librarylibs/Eigencube/src/Eigencube.xtl

The 27 integer points of {-1, 0, 1}^3, one per row (x slowest).

The 26 cubelets, each named by its place in the solved cube: every point but the hidden center.

Each cubelet's 1-norm, its number of stickers: 1 center, 2 edge, 3 corner.

Each cubelet's layer in the solved cube: 1 top, 0 middle, -1 bottom.

The 3-by-3 identity.

The solved cube: every cubelet unrotated, a batch of one, 1 26 3 3.

The six faces' outward normals, named U D F B R L: up is +z, front +x, right +y. Faces 2a-1 and 2a share axis a.

The face names, in the order of N.

The move vectors: move 2f-1 turns face f clockwise as seen facing it, move 2f counterclockwise.

Each move's direction: 1 clockwise, -1 counterclockwise.

The cross-product matrices, flattened: row k holds minus the Levi-Civita symbol eps(i, j, k) over (i, j), so that row v of V '+ '× i̲nner E is [v]x, the matrix with [v]x u = v x u.

The twelve rotation matrices, flattened, one per row: a quarter turn clockwise about v (seen from v) is v v^T - [v]x, Rodrigues' formula at -90 degrees; counterclockwise flips the sign of [v]x.

The twelve matrices stacked into one 36 by 3 matrix: rows 3m-2 to 3m are move m's. One product with it turns a batch every way at once.

h:t_urns R: every quarter turn applied to every 3-by-3 matrix of R, a batch of n (n 3 3); the result is 12 n 3 3, turn first. The batch is laid out 3 n 3, so one matrix product with M turns them all.

h:p_os S: where each cubelet of each cube of the batch S (n 26 3 3) sits, R c; the result is n 26 3.

h:c_hildren S: all twelve turns of every cube of the batch S, 12n cubes, move-major: cube r is move 1 + (r - 1) div n of cube 1 + (r - 1) mod n. A cubelet moves when the move vector's dot product with where it sits is positive (one matrix product for every move and cubelet); a moved cubelet's matrix is the turn's matrix times its own (the other product, in h:t_urns).

l:t_urn m S: move m (1 to 12) applied to every cube of the batch S.

      ᵉᶜ⁼u̲se< "Eigencube"

      ᵉᶜsolved m̲atch 4 '{ S → 5 ᵉᶜt̲urn S } p̲ower ᵉᶜsolved
1

l:d_o ms S: the moves ms (a vector of 1 to 12) applied in order to every cube of the batch S.

      ᵉᶜ⁼u̲se< "Eigencube"

      ᵉᶜsolved m̲atch 12 11 10 9 ᵉᶜd̲o 9 10 11 12 ᵉᶜd̲o ᵉᶜsolved
1

Each face's two directions across the page, as a cube net draws it: rightward, then downward, seen from outside the face (U with F below it, D with F above it, the side faces with U above them).

l:s_tickers S: the colors of the cube S (a batch of one) as a 6 by 9 matrix, a row per face (U D F B R L), its cells row by row as the face is seen; a color is the face of the solved cube it belongs to (1 to 6, the order of N). Cubelet k shows a sticker on face v when v . (R c) = 1; the sticker's color is the direction it faced in the solved cube, R^T v, so the colors are one more matrix product.

h:g_row G: the rotations G (flattened rows of 9) and every turn of them, without repeats.

The cube's 24 rotations, flattened, one per row: what the twelve turns reach from the identity (three rounds reach them all).

The turns' Cayley table: row m, column g is the index in G of the rotation that move m makes of rotation g.

h:o_rient S: the index in G of each cubelet's rotation, n 26.

Where each cubelet sits in each rotation, 26 24: the index in pts of G c, from one matrix product of every rotation with every name.

Which points each move turns, 12 27: the dot product of the move vector with the point is positive.

h:n_ext O: h:c_hildren for cubes given by their orientations O (n 26), as orientations (12n 26): the same turns, read from the two tables the matrices made (at, layer and the Cayley table Tm), so the search moves 26 small integers per cube instead of 26 matrices.

h:r_elax d: a table of distances (cubelet by rotation) relaxed along every turn until it stops changing, so d[k; g] becomes the fewest quarter turns that take rotation g to one where cubelet k is done.

h:d_istances done: the distance table from a 26 by 24 table of 1s where the cubelet counts as done in that rotation.

How far column j of each rotation is from e_j, 24 3.

Solved distances, 26 24 (eigencube.py's min_moves_to_solved): a cubelet is solved when its rotation fixes each axis it has stickers on, the nonzero coordinates of its name.

l:s_olved? S: whether every cubelet of the cube S (a batch of one) is solved (eigencube.py's is_cube_solved): a center may still be turned about its own axis, which no sticker shows.

      ᵉᶜ⁼u̲se< "Eigencube"

      (ᵉᶜs̲olved? ᵉᶜsolved) c̲at ᵉᶜs̲olved? 1 ᵉᶜt̲urn ᵉᶜsolved
1 0

How far each rotation moves each home point, 24 26.

Place distances, 26 24 (eigencube.py's min_moves_to_position): a cubelet is in place when R c = c, its stickers perhaps twisted.

Whether each rotation keeps the bottom face (yellow) down: R fixes z.

The cubelet sets the stages count over, one per row: 1 none, 2 top edges, 3 top layer, 4 top and middle layers, 5 bottom edges, 6 bottom corners, 7 middle layer, 8 bottom layer but its corners, 9 all but the bottom corners.

h:s_pec s: stage s (1 to 29) as 7 rows of 3. A goal is three counts at least their thresholds: count c is how many cubelets of set row1[c] are solved, plus of set row2[c] have yellow down, plus of set row3[c] are in place; row 6 holds the thresholds. The heuristic is a sum of three terms, term t (sum of sqrt d)^2 / row7[t], the sum over set row4[t] of solved distances and over set row5[t] of place distances (eigencube.py's p-norms with p = 1/2). Stages 1-17 solve the top and middle layers a cubelet at a time, 18-25 the bottom edges (yellow down, then solved), 26-29 put the bottom corners in place.

h:o_f r spec: the cubelet sets named by row r of a stage's spec, as the columns of a 26 by 3 matrix of 1s and 0s.

h:r_elevant spec: the cubelets a stage looks at, 1s and 0s over the 26: those of every set its goal and heuristic name (rows 1 to 5).

h:p_roject rel O: the orientations O with every cubelet the stage does not look at (rel 0) set to 1, the identity. A turn moves each cubelet by its own position and rotation alone, never by the others, so cubes that differ only there are one state to the stage's search.

h:s_core spec O: each cube's search score, from its cubelets' orientations O (n 26, h:o_rient): -1 for a cube that meets the stage's goal, else its heuristic, a Float per cube.

How many of the best open cubes each step of the search expands.

How much more the heuristic weighs than the moves made (weighted A*).

l:i_nverse m: the move that undoes move m (0, no move, has none).

h:f_ace m: the face move m turns, 1 to 6 (0 for no move).

h:c_ubes O: the cubes whose cubelets' orientations are O (n 26), their rotation matrices looked up in G, n 26 3 3.

h:k_ey O: each cube's key, n 2: its 26 orientations (1 to 24) as two 13-digit numbers in base 24, so one i_ndexOf finds a cube.

The macros: the solver's moves for the middle and bottom layers, each a fixed sequence of turns. 1 to 3: D, D' and D2. 4 to 8: the classic sequences for the last layer, mirrored from the top to the bottom (U and D swap, R and L swap): F L D L' D' F' flips two bottom edges, Sune (L D L' D L D2 L') and its mirror cycle edges and twist corners, D L D' R' D L' D' R and its inverse cycle three bottom corners. 9 to 16: a middle edge brought up from the bottom into each of the four slots, from either side (U R U' R' U' F' U F and its mirror, mirrored the same way and turned about the vertical axis). Each keeps the top layer whole, and each of 1 to 8 the top two layers, so a search over them builds on what is solved (as the endgame's twist does in eigencube.py).

The macros the middle layer's stages search over: D turns and the insertions.

The macros the bottom layer's stages search over: D turns and the last-layer sequences.

h:a_ctions hybrid s: what stage s searches over: none for the twelve turns (all stages when hybrid is 0, eigencube.py's search alone; the top layer always), else the middle or the bottom layer's macros.

h:a_long ms O: the moves ms applied in order to the cubes O (n 26), as orientations.

h:m_acros set O: every macro of the set (indices into macros) applied to every cube of O, macro-major as h:n_ext orders the turns.

h:e_xpand set O: the cubes one action from O: the twelve turns for an empty set, else the set's macros.

h:f_latten acts: macros (indices into macros) as the moves they make.

h:s_tep spec table: one step of the search. The table holds every cube found, a row each: its key, its orientations, the cube it was reached from, the move, its moves from the start g and its priority g + greed * h; then the open cubes, best first. A step takes the best batch open cubes, turns each every way at once, drops a move that undoes the last one or turns two opposite faces out of order (they commute; eigencube.py prunes the same two), and adds the cubes not found before. It stops on a cube that meets the goal, giving the moves to it.

h:t_race (par, mv) i: the moves from the start (cube 1) to cube i, by following each cube back to the one it was reached from.

h:s_earch (spec, set) S: the moves taking the cube S (a batch of one) to the stage's goal, found by h:s_tep from a table holding S alone, over the twelve turns or the set's macros.

h:s_tage hybrid (S, ms, lens): the next search stage run on the cube S, its moves added to the moves so far ms and its length to the stage lengths (h:a_ctions says what it searches over).

The endgame's twist: L' U' L U, twice (eigencube.py's routine).

The bottom turn eigencube.py makes between corners, D' here.

h:o_riented? S: whether the corner at front-left-bottom, (1 -1 -1), has its yellow sticker down, so that turns of the bottom alone solve it (eigencube.py's is_corner_oriented): its rotation fixes z.

h:c_orner (S, ms): twist the front-left-bottom corner until it is oriented, then turn the bottom to bring the next corner there.

h:f_inish (S, ms): turn the bottom until the cube is solved.

l:s_olve hybrid S: a solution of the cube S (a batch of one), after eigencube.py's solve: 29 search stages (the top and middle layers a cubelet at a time, then the bottom edges and the bottom corners' places), then the endgame's corner twists. With hybrid 1 the middle and bottom stages search over macros, as a person solving by hand uses known sequences (seconds); with 0 every stage searches the twelve turns, eigencube.py's search alone (minutes in X_eTaL). The moves, each stage's length, and the endgame's length.

l:n_ame ms: moves as text in the usual notation, U for the top face clockwise, U' counterclockwise, separated by spaces.

ec:p_arse t: moves written in the usual notation as numbers: each letter of ec:faces is a move, counterclockwise when a ' follows it; anything else between moves is ignored. The inverse of ec:n_ame.

      ᵉᶜ⁼u̲se< "Eigencube"

      ᵉᶜp̲arse "U R' F B'"
1 10 5 8

      (ᵉᶜp̲arse ᵉᶜn̲ame 3 12 7) m̲atch 3 12 7
1