cube-model 1.0.3__py3-none-any.whl

cube_model/new_cube.py

@@ -0,0 +1,299 @@
+'''Construct a Cube from explicit corner and edge color sequences.'''
+
+from collections.abc import Sequence
+from random import randrange, shuffle
+
+from .model import (
+  Color,
+  CornerSticker,
+  Cube,
+  EdgeSticker,
+  Side,
+)
+from .utils import even_permutation, rand_elt, to_radix
+
+_OPPOSITE: dict[Color, Color] = {
+  Color.WHITE:  Color.YELLOW,
+  Color.YELLOW: Color.WHITE,
+  Color.RED:    Color.ORANGE,
+  Color.ORANGE: Color.RED,
+  Color.BLUE:   Color.GREEN,
+  Color.GREEN:  Color.BLUE,
+}
+
+def new_cube(
+  corners:     Sequence[tuple[Color, Color, Color]],
+  edges:       Sequence[tuple[Color, Color]],
+  front_color: Color,
+  top_color:   Color,
+  initial:     Cube | None = None,
+) -> Cube:
+  '''Construct a Cube from explicit corner and edge color sequences.
+
+  corners is 8 tuples: the 4 front-face corners starting at home
+  clockwise, then the 4 back-face corners starting at the corner
+  opposite home clockwise when facing the back. The first element
+  of each tuple is the color of the sticker on the front or back
+  face.
+
+  edges is 12 tuples: 4 front-face edges starting just after home
+  clockwise, then 4 middle-layer edges starting next to the home
+  corner then clockwise when facing the front, then 4 back-face
+  edges starting just after the corner opposite home clockwise when
+  facing the back. The first element of each tuple is the color of
+  the sticker touching the front or back face, or the leading
+  sticker for the middle layer.
+
+  If initial is supplied, its sticker objects are reused instead of
+  allocating new ones. Each directed sticker is uniquely identified
+  by (sticker.color, sticker.other.color).
+  '''
+  existing_edges:   dict[tuple[Color, Color], EdgeSticker]
+  existing_corners: dict[tuple[Color, Color], CornerSticker]
+  if initial is not None:
+    existing_edges = {
+      (es.color, es.other.color): es
+      for es in initial.next_corner.keys()
+    }
+    existing_corners = {
+      (cs.color, cs.other.color): cs
+      for cs in initial.next_edge.keys()
+    }
+  else:
+    existing_edges   = {}
+    existing_corners = {}
+
+  edge_stickers: dict[tuple[Color, Color], EdgeSticker] = {}
+  corner_stickers: dict[tuple[Color, Color], CornerSticker] = {}
+
+  def make_edge(a: Color, b: Color) -> None:
+    '''Create or reuse one edge cubie with two stickers.'''
+    if (a, b) in existing_edges:
+      s_ab: EdgeSticker = existing_edges[(a, b)]
+      s_ba: EdgeSticker = existing_edges[(b, a)]
+    else:
+      s_ab = EdgeSticker(a)
+      s_ba = EdgeSticker(b)
+      s_ab._rewire(s_ba)
+      s_ba._rewire(s_ab)
+    edge_stickers[(a, b)] = s_ab
+    edge_stickers[(b, a)] = s_ba
+
+  et: tuple[Color, Color]
+  for et in edges:
+    make_edge(*et)
+
+  next_edge:   dict[CornerSticker, EdgeSticker] = {}
+  next_corner: dict[EdgeSticker, CornerSticker] = {}
+
+  def make_corner(a: Color, b: Color, c: Color) -> CornerSticker:
+    '''Create or reuse a corner cubie with three stickers. Return
+    the first sticker of the cubie.'''
+    if (a, b) in existing_corners:
+      s: tuple[CornerSticker, CornerSticker, CornerSticker] = (
+        existing_corners[(a, b)],
+        existing_corners[(b, c)],
+        existing_corners[(c, a)],
+      )
+    else:
+      s = (
+        CornerSticker(a),
+        CornerSticker(b),
+        CornerSticker(c),
+      )
+      s[0]._rewire(s[1])
+      s[1]._rewire(s[2])
+      s[2]._rewire(s[0])
+    corner_stickers[(a, b)] = s[0]
+    corner_stickers[(b, c)] = s[1]
+    corner_stickers[(c, a)] = s[2]
+    return s[0]
+
+  home: CornerSticker = make_corner(*corners[0])
+  ct: tuple[Color, Color, Color]
+  for ct in corners[1:]:
+    make_corner(*ct)
+
+  cs: CornerSticker
+  es: EdgeSticker
+  i: int
+
+  # wire next links along front face
+  for i in range(4):
+    ct = corners[i]
+    cs = corner_stickers[ct[:2]]
+
+    et = edges[i]
+    es = edge_stickers[et]
+    next_edge[cs] = es
+    next_corner[es.other] = cs.other.other
+
+    et = edges[(i + 3) % 4]
+    es = edge_stickers[et]
+    next_edge[cs.other] = es.other
+    next_corner[es] = cs
+
+    et = edges[i + 4]
+    es = edge_stickers[et]
+    next_edge[cs.other.other] = es
+    next_corner[es.other] = cs.other
+
+  # wire next links along back face
+  for i in range(4, 8):
+    ct = corners[i]
+    cs = corner_stickers[ct[:2]]
+
+    et = edges[i + 4]
+    es = edge_stickers[et]
+    next_edge[cs] = es
+    next_corner[es.other] = cs.other.other
+
+    et = edges[(i + 3) % 4 + 8]
+    es = edge_stickers[et]
+    next_edge[cs.other] = es.other
+    next_corner[es] = cs
+
+    et = edges[3 * i % 4 + 4]
+    es = edge_stickers[et]
+    next_edge[cs.other.other] = es.other
+    next_corner[es] = cs.other
+
+  return Cube(
+    home=home,
+    front_color=front_color,
+    top_color=top_color,
+    next_edge=next_edge,
+    next_corner=next_corner,
+  )
+
+# Solved-state sequences.
+# Corners: front face CW from home, then back face CW facing back
+# from opposite-home. Tuple[0] is the front or back face sticker.
+_SOLVED_CORNERS: list[tuple[Color, Color, Color]] = [
+  (Color.GREEN,  Color.ORANGE, Color.WHITE),
+  (Color.GREEN,  Color.WHITE,  Color.RED),
+  (Color.GREEN,  Color.RED,    Color.YELLOW),
+  (Color.GREEN,  Color.YELLOW, Color.ORANGE),
+  (Color.BLUE,   Color.WHITE,  Color.ORANGE),
+  (Color.BLUE,   Color.ORANGE, Color.YELLOW),
+  (Color.BLUE,   Color.YELLOW, Color.RED),
+  (Color.BLUE,   Color.RED,    Color.WHITE),
+]
+
+# Edges: front face CW after home, middle layer CW facing front from
+# next-to-home, back face CW after opposite-home. Tuple[0] is the
+# front/back sticker or the leading middle-layer sticker.
+_SOLVED_EDGES: list[tuple[Color, Color]] = [
+  (Color.GREEN,  Color.WHITE),
+  (Color.GREEN,  Color.RED),
+  (Color.GREEN,  Color.YELLOW),
+  (Color.GREEN,  Color.ORANGE),
+  (Color.WHITE,  Color.ORANGE),
+  (Color.RED,    Color.WHITE),
+  (Color.YELLOW, Color.RED),
+  (Color.ORANGE, Color.YELLOW),
+  (Color.BLUE,   Color.ORANGE),
+  (Color.BLUE,   Color.YELLOW),
+  (Color.BLUE,   Color.RED),
+  (Color.BLUE,   Color.WHITE),
+]
+
+_ALL_COLORS: list[Color] = list(Color)
+
+_GB: frozenset[Color] = frozenset({Color.GREEN,  Color.BLUE  })
+_OR: frozenset[Color] = frozenset({Color.ORANGE, Color.RED   })
+_WY: frozenset[Color] = frozenset({Color.WHITE,  Color.YELLOW})
+
+def center_parity_even(front_color: Color, top_color: Color) -> bool:
+  '''Return True if the center orientation is an even permutation.
+
+  The center permutation is even when the front and top colors are in
+  one of the three cyclic-neighbor pairs: (GB, WY), (WY, OR), (OR, GB),
+  where GB = {Green, Blue}, WY = {White, Yellow}, OR = {Orange, Red}.
+  '''
+  return (
+       front_color in _GB and top_color in _WY
+    or front_color in _WY and top_color in _OR
+    or front_color in _OR and top_color in _GB)
+
+def solved(initial: Cube | None = None) -> Cube:
+  '''Construct a solved cube.
+
+  If initial is supplied, reuse its sticker objects instead of
+  allocating new ones.
+  '''
+  return new_cube(
+    corners=_SOLVED_CORNERS,
+    edges=_SOLVED_EDGES,
+    front_color=Color.GREEN,
+    top_color=Color.WHITE,
+    initial=initial,
+  )
+
+def shuffled(initial: Cube | None = None) -> Cube:
+  '''Construct a solvable randomly shuffled cube.
+
+  The front color is chosen uniformly at random. To ensure a valid
+  cube, the top color is chosen uniformly at random only from the
+  four colors that are neither the front color nor its opposite.
+
+  Corners and edges are permuted randomly. To ensure solvability, the
+  first two edges are transposed if needed so that the corner, edge,
+  and center permutation parities satisfy the three-way XOR invariant.
+
+  Edge orientations: a random integer in [0, 2**11) determines which
+  of the first 11 edges are flipped. To ensure solvability, the 12th
+  is flipped if needed to keep the total number of flips even.
+
+  Corner orientations: a random integer in [0, 3**7) is interpreted
+  in base 3 to twist the first 7 corners. To ensure solvability,
+  the 8th corner is twisted so that the total twist sum is
+  divisible by 3.
+
+  If initial is supplied, its sticker objects are reused.
+
+  '''
+  front_color: Color = rand_elt(_ALL_COLORS)
+  top_color: Color = rand_elt([c for c in _ALL_COLORS
+    if c is not front_color
+    and c is not _OPPOSITE[front_color]])
+
+  corners: list[tuple[Color, Color, Color]] = list(_SOLVED_CORNERS)
+  edges:   list[tuple[Color, Color]]        = list(_SOLVED_EDGES)
+
+  shuffle(corners)
+  shuffle(edges)
+
+  corner_even: bool = even_permutation(corners, _SOLVED_CORNERS)
+  edge_even: bool = even_permutation(edges, _SOLVED_EDGES)
+  center_even: bool = center_parity_even(front_color, top_color)
+  if not (corner_even ^ edge_even ^ center_even):
+    edges[0], edges[1] = edges[1], edges[0]
+
+  edge_bits: int = randrange(2 ** 11)
+  flips: int = 0
+  for i in range(11):
+    if edge_bits & (1 << i):
+      edges[i] = (edges[i][1], edges[i][0])
+      flips += 1
+  if flips % 2 == 1:
+    edges[11] = (edges[11][1], edges[11][0])
+
+  twists: list[int] = list(to_radix(3, randrange(3 ** 7)))
+  twists.append(2 * sum(twists) % 3)
+  for i, twist in enumerate(twists):
+    match twist:
+      case 1:
+        a, b, c = corners[i]
+        corners[i] = (c, a, b)
+      case 2:
+        a, b, c = corners[i]
+        corners[i] = (b, c, a)
+
+  return new_cube(
+    corners=corners,
+    edges=edges,
+    front_color=front_color,
+    top_color=top_color,
+    initial=initial,
+  )

cube_model/reachable.py

@@ -0,0 +1,194 @@
+'''Reachability test for the cube.
+
+A cube position is reachable from the solved position by face moves
+if and only if the three criteria checked here are all satisfied.
+'''
+
+from __future__ import annotations
+
+from collections.abc import Iterator
+
+from .new_cube import solved, center_parity_even
+from .model import (
+  Color,
+  CornerSticker,
+  Cube,
+  EdgeSticker,
+  Side,
+)
+from .navigation import (
+  corner_on_side,
+  side_color,
+  side_corners,
+  sticker_side,
+)
+from .utils import even_permutation
+
+_PRIORITY: list[Color] = [
+  Color.BLUE, Color.GREEN, Color.WHITE, Color.YELLOW,
+]
+
+_WY: frozenset[Color] = frozenset({Color.WHITE, Color.YELLOW})
+
+# Frozenset of the three colors of a corner cubie.
+type _Cubie3 = frozenset[Color]
+# Frozenset of the two colors of an edge cubie.
+type _Cubie2 = frozenset[Color]
+
+def _all_corners(cube: Cube) -> Iterator[CornerSticker]:
+  '''Yield one sticker per corner cubie via navigation.
+
+  Yields the 4 front-face corners followed by the 4 back-face corners.
+  '''
+  yield from side_corners(cube, cube.home)
+  yield from side_corners(cube, corner_on_side(cube, Side.BACK))
+
+def _all_edges(cube: Cube) -> Iterator[EdgeSticker]:
+  '''Yield one sticker per edge cubie via navigation.
+
+  For front-face corners: N gives the 4 front-ring edges,
+  OON gives the 4 middle-layer edges.
+  For back-face corners: N gives the 4 back-ring edges.
+  '''
+  front: list[CornerSticker] = side_corners(cube, cube.home)
+  back: list[CornerSticker] = side_corners(
+    cube, corner_on_side(cube, Side.BACK),
+  )
+  for c in front:
+    yield cube.next_edge[c]
+  for c in front:
+    yield cube.next_edge[c.other.other]
+  for c in back:
+    yield cube.next_edge[c]
+
+def _corner_cubie(cs: CornerSticker) -> _Cubie3:
+  '''Return the frozenset of colors of a corner cubie.'''
+  return frozenset({cs.color, cs.other.color, cs.other.other.color})
+
+def _edge_cubie(es: EdgeSticker) -> _Cubie2:
+  '''Return the frozenset of colors of an edge cubie.'''
+  return frozenset({es.color, es.other.color})
+
+_ref: Cube = solved()
+_SOLVED_CORNERS: list[_Cubie3] = [
+  _corner_cubie(cs) for cs in _all_corners(_ref)
+]
+_SOLVED_EDGES: list[_Cubie2] = [
+  _edge_cubie(es) for es in _all_edges(_ref)
+]
+
+def locations_ok(cube: Cube) -> bool:
+  '''Return True if the corner, edge, and center permutation parities
+  satisfy the reachability invariant.
+
+  Every face move flips all three parities simultaneously, so their
+  XOR is conserved. In the solved state all three are even, so XOR is
+  True; locations_ok checks that the XOR remains True.
+  '''
+  corner_even: bool = even_permutation(
+    [_corner_cubie(cs) for cs in _all_corners(cube)],
+    _SOLVED_CORNERS,
+  )
+  edge_even: bool = even_permutation(
+    [_edge_cubie(es) for es in _all_edges(cube)],
+    _SOLVED_EDGES,
+  )
+  center_even: bool = center_parity_even(cube.front_color, cube.top_color)
+  return corner_even ^ edge_even ^ center_even
+
+def _rep_sticker(es: EdgeSticker) -> EdgeSticker:
+  '''Return the representative sticker of an edge cubie.
+
+  The representative sticker is the one whose color appears earliest
+  in the priority order: blue, green, white, yellow.
+  '''
+  for color in _PRIORITY:
+    if es.color == color:
+      return es
+    if es.other.color == color:
+      return es.other
+  raise ValueError(
+    f'no priority color found in edge cubie: '
+    f'{es.color}, {es.other.color}'
+  )
+
+def _rep_face(cube: Cube, es: EdgeSticker) -> Side:
+  '''Return the representative face of an edge cubie.
+
+  The representative face is the one of the two faces on which the
+  cubie's stickers lie whose center color appears earliest in the
+  priority order: blue, green, white, yellow.
+  '''
+  sides: list[Side] = [
+    sticker_side(cube, es),
+    sticker_side(cube, es.other),
+  ]
+  for color in _PRIORITY:
+    for side in sides:
+      if side_color(cube, side) == color:
+        return side
+  raise ValueError(
+    f'no priority color found among faces of edge cubie: '
+    f'{es.color}, {es.other.color}'
+  )
+
+def edge_flips_ok(cube: Cube) -> bool:
+  '''Return True if the number of flipped edge cubies is even.
+
+  An edge cubie is flipped if its representative sticker is not on
+  its representative face.
+  '''
+  flipped: int = sum(
+    1
+    for es in _all_edges(cube)
+    if sticker_side(cube, _rep_sticker(es)) != _rep_face(cube, es)
+  )
+  return flipped % 2 == 0
+
+def _wy_sticker(cs: CornerSticker) -> CornerSticker:
+  '''Return the white-or-yellow sticker of a corner cubie.'''
+  s: CornerSticker = cs
+  for _ in range(3):
+    if s.color in _WY:
+      return s
+    s = s.other
+  raise ValueError(
+    f'no white/yellow sticker in corner cubie: '
+    f'{cs.color}, {cs.other.color}, {cs.other.other.color}'
+  )
+
+def _corner_rotation(cube: Cube, cs: CornerSticker) -> int:
+  '''Return the rotation number (0, 1, or 2) of a corner cubie.
+
+  Let r be the white-or-yellow sticker of the cubie.
+  If r is on a white/yellow face, rotation is 0.
+  If r.other is on a white/yellow face, rotation is 1.
+  Otherwise rotation is 2.
+  '''
+  r: CornerSticker = _wy_sticker(cs)
+  if side_color(cube, sticker_side(cube, r)) in _WY:
+    return 0
+  if side_color(cube, sticker_side(cube, r.other)) in _WY:
+    return 1
+  return 2
+
+def corner_rotations_ok(cube: Cube) -> bool:
+  '''Return True if the sum of corner rotation numbers is divisible by 3.'''
+  total: int = sum(
+    _corner_rotation(cube, cs) for cs in _all_corners(cube)
+  )
+  return total % 3 == 0
+
+def reachable(cube: Cube) -> bool:
+  '''Return True if the cube is reachable from the solved position by moves.
+
+  A cube is reachable if and only if:
+  - corner and edge permutations have the same parity,
+  - the number of flipped edge cubies is even, and
+  - the sum of corner rotation numbers is divisible by three.
+  '''
+  return (
+    locations_ok(cube)
+    and edge_flips_ok(cube)
+    and corner_rotations_ok(cube)
+  )

cube_model/rotate.py

@@ -0,0 +1,104 @@
+'''Rigid rotation of the cube.'''
+
+from .new_cube import solved
+from .model import (
+    Color,
+    Cube,
+    Side,
+    opp_side,
+    shallow_copy,
+)
+from .move import Move, Multiplicity, invert
+from .navigation import (
+    Nav,
+    nav_cc,
+    parse_navs,
+    side_color,
+)
+
+HOME_TRANSITIONS: dict[Move, list[Nav]] = {
+    Move(Side.FRONT, Multiplicity.CW):  parse_navs('ONNO'),
+    Move(Side.FRONT, Multiplicity.CCW): parse_navs('NN'),
+    Move(Side.FRONT, Multiplicity.TWO): parse_navs('NNNN'),
+    Move(Side.RIGHT, Multiplicity.CW):  parse_navs('ONNOO'),
+    Move(Side.RIGHT, Multiplicity.CCW): parse_navs('OONN'),
+    Move(Side.RIGHT, Multiplicity.TWO): parse_navs('ONNNNOO'),
+    Move(Side.TOP, Multiplicity.CW):    parse_navs('NNOO'),
+    Move(Side.TOP, Multiplicity.CCW):   parse_navs('OONNO'),
+    Move(Side.TOP, Multiplicity.TWO):   parse_navs('OONNNNO'),
+}
+
+for _side in (Side.LEFT, Side.BOTTOM, Side.BACK):
+    for _mult in Multiplicity:
+        HOME_TRANSITIONS[Move(_side, _mult)] = HOME_TRANSITIONS[
+            Move(opp_side[_side], invert[_mult])
+        ]
+
+COLOR_TRANSITIONS: dict[tuple[Move, Color, Color], tuple[Color, Color]] = {}
+
+def _build_color_transitions() -> None:
+    '''Populate COLOR_TRANSITIONS dynamically using side_color.'''
+    dummy: Cube = solved()
+    opp_color: dict[Color, Color] = {
+        side_color(dummy, side): side_color(dummy, opp)
+        for side, opp in opp_side.items()
+    }
+    m_f_cw  = Move(Side.FRONT, Multiplicity.CW)
+    m_f_ccw = Move(Side.FRONT, Multiplicity.CCW)
+    m_f_two = Move(Side.FRONT, Multiplicity.TWO)
+    m_r_cw  = Move(Side.RIGHT, Multiplicity.CW)
+    m_r_ccw = Move(Side.RIGHT, Multiplicity.CCW)
+    m_r_two = Move(Side.RIGHT, Multiplicity.TWO)
+    m_t_cw  = Move(Side.TOP, Multiplicity.CW)
+    m_t_ccw = Move(Side.TOP, Multiplicity.CCW)
+    m_t_two = Move(Side.TOP, Multiplicity.TWO)
+    for f in Color:
+        for t in Color:
+            if f == t or t == opp_color[f]:
+                continue
+            dummy.front_color = f
+            dummy.top_color = t
+            left_c:   Color = side_color(dummy, Side.LEFT)
+            right_c:  Color = side_color(dummy, Side.RIGHT)
+            bottom_c: Color = side_color(dummy, Side.BOTTOM)
+            back_c:   Color = side_color(dummy, Side.BACK)
+            COLOR_TRANSITIONS[(m_f_cw,  f, t)] = (f, left_c)
+            COLOR_TRANSITIONS[(m_f_ccw, f, t)] = (f, right_c)
+            COLOR_TRANSITIONS[(m_f_two, f, t)] = (f, bottom_c)
+            COLOR_TRANSITIONS[(m_r_cw,  f, t)] = (bottom_c, f)
+            COLOR_TRANSITIONS[(m_r_ccw, f, t)] = (t, back_c)
+            COLOR_TRANSITIONS[(m_r_two, f, t)] = (back_c, bottom_c)
+            COLOR_TRANSITIONS[(m_t_cw,  f, t)] = (right_c, t)
+            COLOR_TRANSITIONS[(m_t_ccw, f, t)] = (left_c, t)
+            COLOR_TRANSITIONS[(m_t_two, f, t)] = (back_c, t)
+    for side in (Side.LEFT, Side.BOTTOM, Side.BACK):
+        for mult in Multiplicity:
+            opp: Side = opp_side[side]
+            inv: Multiplicity = invert[mult]
+            for f in Color:
+                for t in Color:
+                    if f == t or t == opp_color[f]:
+                        continue
+                    m: Move = Move(side, mult)
+                    opp_m: Move = Move(opp, inv)
+                    COLOR_TRANSITIONS[(m, f, t)] = (
+                        COLOR_TRANSITIONS[(opp_m, f, t)]
+                    )
+
+_build_color_transitions()
+
+def rotate(move: Move, cube: Cube) -> None:
+    '''Rotate the cube rigidly in-place.'''
+    steps: list[Nav] = HOME_TRANSITIONS[move]
+    cube.home = nav_cc(steps, cube, cube.home)
+    new_f, new_t = COLOR_TRANSITIONS[
+        (move, cube.front_color, cube.top_color)
+    ]
+    cube.front_color = new_f
+    cube.top_color = new_t
+
+def rotated(move: Move, cube: Cube) -> Cube:
+    '''Return a new cube after rotating it rigidly.'''
+    new_cube: Cube = shallow_copy(cube)
+    rotate(move, new_cube)
+    return new_cube

cube_model/utils.py

@@ -0,0 +1,58 @@
+'''Permutation utilities for cube analysis.'''
+
+from __future__ import annotations
+
+from collections.abc import Hashable, Iterator, Sequence
+from random import randrange
+
+def permutation_cycles[T: Hashable](
+  start: Sequence[T],
+  end: Sequence[T],
+) -> list[list[T]]:
+  '''Return the cycle decomposition of the permutation from start to end.
+
+  Both sequences must contain the same set of distinct elements.
+  The returned cycles are disjoint and cover all elements that move.
+  Fixed points are omitted.
+  '''
+  index: dict[T, int] = {v: i for i, v in enumerate(end)}
+  visited: set[int] = set()
+  cycles: list[list[T]] = []
+  for i, v in enumerate(start):
+    if i in visited:
+      continue
+    j: int = index[v]
+    if i == j:
+      visited.add(i)
+      continue
+    cycle: list[T] = []
+    k: int = i
+    while k not in visited:
+      visited.add(k)
+      cycle.append(start[k])
+      k = index[start[k]]
+    cycles.append(cycle)
+  return cycles
+
+def even_permutation[T: Hashable](
+  start: Sequence[T],
+  end: Sequence[T],
+) -> bool:
+  '''Return True if the permutation from start to end is even.
+
+  A permutation is even if the number of cycles of even length is even.
+  '''
+  cycles: list[list[T]] = permutation_cycles(start, end)
+  even_count: int = sum(
+    1 for c in cycles if len(c) % 2 == 0
+  )
+  return even_count % 2 == 0
+
+def to_radix(base: int, n: int) -> Iterator[int]:
+  '''Little-endian representation of n in the given base'''
+  while n > 0:
+    yield n % base
+    n //= base
+
+def rand_elt[T](seq: Sequence[T]) -> T:
+  return seq[randrange(len(seq))]

cube_model-1.0.3.dist-info/METADATA

@@ -0,0 +1,45 @@
+Metadata-Version: 2.4
+Name: cube-model
+Version: 1.0.3
+Summary: Orientation-independent cube model in strictly typed Python
+Author: Yitzchak Gale
+Author-email: gale@sefer.org
+Requires-Python: >=3.13,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Project-URL: Homepage, https://github.com/ygale/cube-model
+Project-URL: Repository, https://github.com/ygale/cube-model
+Description-Content-Type: text/markdown
+
+# cube-model
+
+An orientation-independent cube model in strictly typed Python.
+
+## Highlights
+
+- Strict typing (`mypy --strict`)
+- Orientation-independent cube state
+- `Color` and `Side` are enums
+- `CornerSticker` objects form circular linked lists of size 3
+- `EdgeSticker` objects form circular linked lists of size 2
+- `Cube.next_edge` and `Cube.next_corner` encode clockwise sticker order on faces
+
+## Install
+
+```bash
+pip install cube-model
+```
+
+## Example
+
+```python
+from cube_model import Color, Move, Multiplicity, Side, solved, move
+
+cube = solved()
+assert cube.front_color is Color.GREEN
+
+move(Move(Side.FRONT, Multiplicity.CW), cube)
+```
+
+