@cubingcenter/scrambler 0.5.3 → 0.6.0

package/dist-cjs/puzzles/cube4/reduction/center3.js

@@ -0,0 +1,284 @@
+"use strict";
+/**
+ * Center3 (the center part of the phase-3 search): track the center
+ * arrangement through the phase-3 moves (which disturb the solved centers
+ * with the wide doubles) and reach the fully-solved centers.
+ *
+ * Ported from the reference's `Center3` class, adapted to this repo's
+ * layout. The state is three 8-entry arrays of "half-class" bits
+ * ((color / 3) ^ 1) per face-pair, plus a parity bit:
+ *  - ud: the U, D face positions (this repo: U = 0-3, D = 12-15)
+ *  - fb: the F, B face positions (8-11, 20-23)
+ *  - rl: the R, L face positions (4-7, 16-19)
+ *
+ * Coordinate (reference `$getct_0`): C(7,4) ranks of ud and fb vs their 8th
+ * entry (35 each), the rl C(8,4) rank reduced to one of 12 standard values,
+ * then ×2 + parity = 29,400 × 2. The rank-0 pattern is "the first four
+ * entries differ from the last four" — i.e. each face-pair uniform in half
+ * — which is exactly the solved-cube arrangement (verified: the solved cube
+ * encodes to coordinate 0). The parity bit absorbs the wing-pairing parity
+ * XOR the corner parity at the phase-2 → phase-3 bridge and flips on the
+ * wide doubles (`pmove`).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CENTER3_STATES = exports.CENTER3_BFS_MOVES = exports.CENTER3_MOVES = void 0;
+exports.encodeCenter3 = encodeCenter3;
+exports.generateCenter3Tables = generateCenter3Tables;
+exports.verifyCenter3 = verifyCenter3;
+const moves_js_1 = require("../moves.js");
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+exports.CENTER3_MOVES = [
+    "U", "U2", "U'", "R2", "F", "F2", "F'", "D", "D2", "D'",
+    "L2", "B", "B2", "B'", "Uw2", "Rw2", "Fw2", "Dw2", "Lw2", "Bw2"
+];
+/** The 17-move BFS subset (the reference's pruning loop uses m < 17). */
+exports.CENTER3_BFS_MOVES = exports.CENTER3_MOVES.slice(0, 17);
+/** Wide doubles flip the parity bit. */
+const PARITY_FLIP = new Set(["Uw2", "Rw2", "Fw2", "Dw2", "Lw2", "Bw2"]);
+/** Face-pair positions in this repo's numbering. */
+const UD_POS = [0, 1, 2, 3, 12, 13, 14, 15];
+const FB_POS = [8, 9, 10, 11, 20, 21, 22, 23];
+const RL_POS = [4, 5, 6, 7, 16, 17, 18, 19];
+/** The 12 standard rl ranks (reference rl2std). */
+const RL2STD = [0, 9, 14, 23, 27, 28, 41, 42, 46, 55, 60, 69];
+exports.CENTER3_STATES = 29400;
+// Cnk table up to n=24.
+const CNK = (() => {
+    const table = [];
+    for (let n = 0; n <= 24; n++) {
+        table[n] = [];
+        for (let k = 0; k <= 24; k++) {
+            if (k === 0 || k === n)
+                table[n][k] = 1;
+            else if (k > n)
+                table[n][k] = 0;
+            else
+                table[n][k] = table[n - 1][k - 1] + table[n - 1][k];
+        }
+    }
+    return table;
+})();
+// ---------------------------------------------------------------------------
+// Half-class helpers
+// ---------------------------------------------------------------------------
+function halfClass(color) {
+    return (Math.floor(color / 3) ^ 1) & 1;
+}
+/** C(7,4) rank of the entries differing from the last one. */
+function rank7(values) {
+    const last = values[7];
+    let idx = 0;
+    let r = 4;
+    for (let i = 6; i >= 0; i--) {
+        if (values[i] !== last)
+            idx += CNK[i][r--];
+    }
+    return idx;
+}
+/** C(8,4) rank of the entries differing from `check`. */
+function rank8(values, check) {
+    let idx = 0;
+    let r = 4;
+    for (let i = 7; i >= 0; i--) {
+        if (values[i] !== check)
+            idx += CNK[i][r--];
+    }
+    return idx;
+}
+/**
+ * Encode a full cube state to the Center3 coordinate.
+ *
+ * `edgeXorCornerParity` = the $set_6 pairing parity XOR the corner
+ * permutation parity, computed at the phase-2 → phase-3 bridge.
+ */
+function encodeCenter3(state, edgeXorCornerParity) {
+    const colors = state.centers;
+    // reference: parity = (ct[0]%3 > ct[8]%3) ^ (ct[8]%3 > ct[16]%3) ^ (ct[0]%3 > ct[16]%3) ? 0 : 1
+    const a = colors[0] % 3;
+    const b = colors[8] % 3;
+    const c = colors[16] % 3;
+    const xored = (a > b ? 1 : 0) ^ (b > c ? 1 : 0) ^ (a > c ? 1 : 0);
+    const parity = xored === 0 ? 1 : 0;
+    const ud = new Uint8Array(8);
+    const fb = new Uint8Array(8);
+    const rl = new Uint8Array(8);
+    for (let i = 0; i < 8; i++) {
+        ud[i] = halfClass(colors[UD_POS[i]]);
+        fb[i] = halfClass(colors[FB_POS[i]]);
+        rl[i] = halfClass(colors[RL_POS[i]]);
+    }
+    let idx = rank7(ud);
+    idx = idx * 35 + rank7(fb);
+    idx *= 12;
+    const check = fb[7] ^ ud[7];
+    const rlRank = rank8(rl, check);
+    const rlIndex = RL2STD.indexOf(rlRank);
+    const finalParity = (parity ^ edgeXorCornerParity);
+    return {
+        coordinate: finalParity + 2 * (idx + rlIndex),
+        parity: finalParity
+    };
+}
+// ---------------------------------------------------------------------------
+// Move tables + pruning
+// ---------------------------------------------------------------------------
+function buildMovePositionMaps() {
+    const maps = new Int32Array(exports.CENTER3_MOVES.length * 24);
+    for (let m = 0; m < exports.CENTER3_MOVES.length; m++) {
+        const { face, turns } = (0, moves_js_1.parseMove)(exports.CENTER3_MOVES[m]);
+        const effect = moves_js_1.FACE_MOVE_EFFECTS[face];
+        let pos = Array.from({ length: 24 }, (_, i) => i);
+        for (let t = 0; t < turns; t++) {
+            const next = new Array(24);
+            for (let i = 0; i < 24; i++)
+                next[i] = pos[effect.ctperm[i]];
+            pos = next;
+        }
+        for (let i = 0; i < 24; i++)
+            maps[m * 24 + i] = pos[i];
+    }
+    return maps;
+}
+/**
+ * Decode a coordinate to canonical half-class arrays (for the move tables):
+ * the rank-0 pattern is "first four differ from the last four", so the
+ * canonical state is ud = [1,1,1,1,0,0,0,0], fb = [1,1,1,1,0,0,0,0],
+ * rl = [1,1,1,1,0,0,0,0] for coordinate 0.
+ */
+function decodeCenter3(coordinate) {
+    const parity = coordinate & 1;
+    let value = coordinate >> 1;
+    const rlIndex = value % 12;
+    value = Math.floor(value / 12);
+    const fbRank = value % 35;
+    const udRank = Math.floor(value / 35);
+    const ud = new Uint8Array(8);
+    const fb = new Uint8Array(8);
+    const rl = new Uint8Array(8);
+    // unrank C(7,4) patterns
+    let idx = udRank;
+    let r = 4;
+    for (let i = 6; i >= 0; i--) {
+        if (idx >= CNK[i][r]) {
+            idx -= CNK[i][r];
+            r--;
+            ud[i] = 1;
+        }
+    }
+    idx = fbRank;
+    r = 4;
+    for (let i = 6; i >= 0; i--) {
+        if (idx >= CNK[i][r]) {
+            idx -= CNK[i][r];
+            r--;
+            fb[i] = 1;
+        }
+    }
+    // rl: the standard rank from the index
+    const rlRank = RL2STD[rlIndex];
+    idx = rlRank;
+    r = 4;
+    for (let i = 7; i >= 0; i--) {
+        if (idx >= CNK[i][r]) {
+            idx -= CNK[i][r];
+            r--;
+            rl[i] = 1;
+        }
+    }
+    return { ud, fb, rl, parity };
+}
+function generateCenter3Tables() {
+    const moveMaps = buildMovePositionMaps();
+    const moveTable = new Int32Array(exports.CENTER3_STATES * exports.CENTER3_MOVES.length).fill(-1);
+    // canonical full arrangements: half-class bits at the face-pair positions.
+    // The rl array stores the parity-XORed halves, so the decode undoes the XOR
+    // to recover the colors; the move evolution re-extracts the RAW halves and
+    // evolves the parity bit via pmove only (it is NOT re-derived from the
+    // centers, matching the reference's doMoveCenter3).
+    const full = new Uint8Array(24);
+    const moved = new Uint8Array(24);
+    const ud2 = new Uint8Array(8);
+    const fb2 = new Uint8Array(8);
+    const rl2 = new Uint8Array(8);
+    const coordinateOfMoved = (coordinate, m, parity) => {
+        const { ud, fb, rl } = decodeCenter3(coordinate);
+        // the half-class arrays live at the 24 face-pair positions; a move is a
+        // position permutation, so build the 24-array, permute, and re-extract.
+        for (let i = 0; i < 24; i++)
+            full[i] = 0;
+        for (let i = 0; i < 8; i++) {
+            full[UD_POS[i]] = ud[i];
+            full[FB_POS[i]] = fb[i];
+            full[RL_POS[i]] = rl[i];
+        }
+        const map = moveMaps;
+        for (let i = 0; i < 24; i++)
+            moved[i] = full[map[m * 24 + i]];
+        for (let i = 0; i < 8; i++) {
+            ud2[i] = moved[UD_POS[i]];
+            fb2[i] = moved[FB_POS[i]];
+            rl2[i] = moved[RL_POS[i]];
+        }
+        let idx = rank7(ud2);
+        idx = idx * 35 + rank7(fb2);
+        idx *= 12;
+        const check = fb2[7] ^ ud2[7];
+        const rlRank = rank8(rl2, check);
+        const rlIndex = RL2STD.indexOf(rlRank);
+        if (rlIndex < 0)
+            return -1;
+        const nextParity = (parity ^ (PARITY_FLIP.has(exports.CENTER3_MOVES[m]) ? 1 : 0));
+        return nextParity + 2 * (idx + rlIndex);
+    };
+    // BFS from coordinate 0 with the 17 BFS moves, computing the move-table
+    // entries on demand (only the reachable states' transitions are needed).
+    const pruning = new Uint8Array(exports.CENTER3_STATES).fill(0xff);
+    pruning[0] = 0;
+    const queue = [0];
+    let head = 0;
+    while (head < queue.length) {
+        const coord = queue[head++];
+        const d = pruning[coord];
+        for (let m = 0; m < exports.CENTER3_MOVES.length; m++) {
+            const next = coordinateOfMoved(coord, m, coord & 1);
+            if (next < 0)
+                continue;
+            moveTable[coord * exports.CENTER3_MOVES.length + m] = next;
+            if (m < exports.CENTER3_BFS_MOVES.length && pruning[next] === 0xff) {
+                pruning[next] = d + 1;
+                queue.push(next);
+            }
+        }
+    }
+    return { moveTable, pruning };
+}
+// ---------------------------------------------------------------------------
+// Verification gates
+// ---------------------------------------------------------------------------
+function verifyCenter3(tables) {
+    const errors = [];
+    if (tables.pruning[0] !== 0) {
+        errors.push("Goal coordinate must have pruning 0.");
+    }
+    let maxDepth = 0;
+    for (let coord = 0; coord < exports.CENTER3_STATES; coord++) {
+        const d = tables.pruning[coord];
+        if (d === 0xff)
+            continue; // unreachable coordinates have no entries
+        if (d > maxDepth)
+            maxDepth = d;
+        for (let m = 0; m < exports.CENTER3_MOVES.length; m++) {
+            const next = tables.moveTable[coord * exports.CENTER3_MOVES.length + m];
+            if (next < 0)
+                continue;
+            const nd = tables.pruning[next];
+            if (nd === 0xff || nd < d - 1 || nd > d + 1) {
+                errors.push(`Pruning inconsistency at ${coord} move ${exports.CENTER3_MOVES[m]}: ${d} -> ${nd}.`);
+                break;
+            }
+        }
+    }
+    return errors;
+}