@cubingcenter/scrambler 0.5.3 → 0.6.0

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

@@ -0,0 +1,462 @@
+"use strict";
+/**
+ * Center2 (phase 2 of the 4x4 reduction solver): from the phase-1 output
+ * (axis colors on a face-pair), reach the phase-2 goal: the U/D/F/B faces
+ * uniform in color-class and the R/L faces in one of the 6 goal patterns.
+ *
+ * Ported from the reference's `Center2` class, adapted to this repo's layout:
+ *  - ct part: the 16 positions of the U, D, F, B faces, storing color % 3
+ *    (the color-class), ranked as C(15,8) vs ct[15] = 6,435 states;
+ *  - rl part: the 8 positions of the R, L faces, storing the actual colors,
+ *    ranked as C(7,4) vs rl[7] × 2 + wing-parity = 70 states;
+ *  - full coordinate: ct × 70 = 450,450;
+ *  - goal: ct == 0 and rl in the 6 reference goal patterns (even parity);
+ *  - the 28-move set keeps the ct and rl position sets separate, so the move
+ *    tables factor: ctmv (6,435×28) and rlmv (70×28);
+ *  - the search explores the first 23 moves (face moves + Uw2/Rw/Rw2/Rw').
+ *
+ * The phase-1 → phase-2 bridge (alignment + encode) is in `reduction.ts`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CENTER2_STATES = exports.CENTER2_RL_STATES = exports.CENTER2_CT_STATES = exports.CENTER2_GOAL_RL = exports.CENTER2_SEARCH_MOVES = exports.CENTER2_MOVES = void 0;
+exports.wingPermutationParity = wingPermutationParity;
+exports.encodeCenter2 = encodeCenter2;
+exports.isCenter2Goal = isCenter2Goal;
+exports.center2Bridge = center2Bridge;
+exports.generateCenter2Tables = generateCenter2Tables;
+exports.solveCenter2 = solveCenter2;
+exports.solveCenter2All = solveCenter2All;
+exports.solveCenter2GatedLength = solveCenter2GatedLength;
+exports.solveCenter2Gated = solveCenter2Gated;
+exports.verifyCenter2 = verifyCenter2;
+const moves_js_1 = require("../moves.js");
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+/** The phase-2 move set (28 real moves + the reference's trailing no-op). */
+exports.CENTER2_MOVES = [
+    "U", "U2", "U'", "R", "R2", "R'", "F", "F2", "F'", "D", "D2", "D'",
+    "L", "L2", "L'", "B", "B2", "B'",
+    "Uw2", "Rw", "Rw2", "Rw'", "Fw2", "Dw2", "Lw", "Lw2", "Lw'", "Bw2"
+];
+/** The search's exploration set (the first 23 of CENTER2_MOVES). */
+exports.CENTER2_SEARCH_MOVES = exports.CENTER2_MOVES.slice(0, 23);
+/** The 6 reference goal rl patterns (full 70-space values, even parity). */
+exports.CENTER2_GOAL_RL = [0, 18, 28, 46, 54, 56];
+exports.CENTER2_CT_STATES = 6435;
+exports.CENTER2_RL_STATES = 70;
+exports.CENTER2_STATES = exports.CENTER2_CT_STATES * exports.CENTER2_RL_STATES;
+// ct positions: U(0-3), D(12-15), F(8-11), B(20-23) — the reference's face
+// order {U, D, F, B}, in this repo's face-major numbering.
+const CT_POS = [0, 1, 2, 3, 12, 13, 14, 15, 8, 9, 10, 11, 20, 21, 22, 23];
+// rl positions: R(4-7), L(16-19).
+const RL_POS = [4, 5, 6, 7, 16, 17, 18, 19];
+/** Wide quarter turns flip the wing permutation parity. */
+const PARITY_FLIP = new Set(["Rw", "Rw'", "Lw", "Lw'"]);
+// 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;
+})();
+function rankVsLast(values, size, ones) {
+    const last = values[size - 1];
+    let idx = 0;
+    let r = ones;
+    for (let i = size - 2; i >= 0; i--) {
+        if (values[i] !== last)
+            idx += CNK[i][r--];
+    }
+    return idx;
+}
+function wingPermutationParity(wp) {
+    let parity = 0;
+    const seen = new Array(24).fill(false);
+    for (let start = 0; start < 24; start++) {
+        if (seen[start] || wp[start] === start)
+            continue;
+        let length = 0;
+        let current = start;
+        while (!seen[current]) {
+            seen[current] = true;
+            current = wp[current];
+            length++;
+        }
+        parity ^= (length - 1) & 1;
+    }
+    return parity;
+}
+/** Encode a full 4x4 state to the (ct, rl) coordinate (0..450,449). */
+function encodeCenter2(state) {
+    const ct = new Uint8Array(16);
+    const rl = new Uint8Array(8);
+    for (let i = 0; i < 16; i++)
+        ct[i] = state.centers[CT_POS[i]] % 3;
+    for (let i = 0; i < 8; i++)
+        rl[i] = state.centers[RL_POS[i]];
+    const ctRank = rankVsLast(ct, 16, 8);
+    const rlRank = rankVsLast(rl, 8, 4) * 2 + wingPermutationParity(state.wp);
+    return { ct: ctRank, rl: rlRank };
+}
+function isCenter2Goal(ct, rl) {
+    return ct === 0 && exports.CENTER2_GOAL_RL.includes(rl);
+}
+/**
+ * The phase-2 coordinate is only valid for states where exactly 8 of the
+ * first 15 ct entries differ from ct[15] and exactly 4 of the first 7 rl
+ * entries differ from rl[7]. Phase-1 outputs don't always satisfy this; the
+ * phase-1 → phase-2 bridge applies a short alignment sequence (0-2 moves)
+ * that re-categorizes the axis colors onto the R/L face-pair, which is
+ * always invariant (verified over random states).
+ */
+const ALIGNMENT_CANDIDATES = [
+    [],
+    ["Fw", "Bw'"],
+    ["Uw", "Dw'"]
+];
+function center2InvariantDiffs(centers) {
+    let ctDiff = 0;
+    let rlDiff = 0;
+    for (let i = 0; i < 15; i++) {
+        if (centers[CT_POS[i]] % 3 !== centers[CT_POS[15]] % 3)
+            ctDiff++;
+    }
+    for (let i = 0; i < 7; i++) {
+        if (centers[RL_POS[i]] !== centers[RL_POS[7]])
+            rlDiff++;
+    }
+    return { ctDiff, rlDiff };
+}
+/**
+ * Phase-1 → phase-2 bridge: apply the shortest alignment candidate that
+ * makes the state coordinate-invariant, then encode.
+ */
+function center2Bridge(state) {
+    for (const alignment of ALIGNMENT_CANDIDATES) {
+        const aligned = alignment.length === 0
+            ? state
+            : (0, moves_js_1.applyCube4Algorithm)(state, alignment);
+        const { ctDiff, rlDiff } = center2InvariantDiffs(aligned.centers);
+        if (ctDiff === 8 && rlDiff === 4) {
+            return {
+                alignment: [...alignment],
+                state: aligned,
+                encoded: encodeCenter2(aligned)
+            };
+        }
+    }
+    return null;
+}
+// ---------------------------------------------------------------------------
+// Move tables
+// ---------------------------------------------------------------------------
+function buildMovePositionMaps() {
+    const maps = new Int32Array(exports.CENTER2_MOVES.length * 24);
+    for (let m = 0; m < exports.CENTER2_MOVES.length; m++) {
+        const { face, turns } = (0, moves_js_1.parseMove)(exports.CENTER2_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;
+}
+function unrankVsLast(idx, size, ones) {
+    const values = new Uint8Array(size);
+    let r = ones;
+    for (let i = size - 2; i >= 0; i--) {
+        if (idx >= CNK[i][r]) {
+            idx -= CNK[i][r];
+            r--;
+            values[i] = 1;
+        }
+    }
+    return values;
+}
+function generateCenter2Tables() {
+    const moveMaps = buildMovePositionMaps();
+    const ctMove = new Int32Array(exports.CENTER2_CT_STATES * exports.CENTER2_MOVES.length);
+    const rlMove = new Int32Array(exports.CENTER2_RL_STATES * exports.CENTER2_MOVES.length);
+    // canonical full arrangements: ct classes {0,1} (ct[15]=0), rl colors {0,1} (rl[7]=0)
+    const full = new Uint8Array(24);
+    const moved = new Uint8Array(24);
+    for (let ctRank = 0; ctRank < exports.CENTER2_CT_STATES; ctRank++) {
+        const pattern = unrankVsLast(ctRank, 16, 8);
+        for (let i = 0; i < 24; i++)
+            full[i] = 0;
+        for (let i = 0; i < 16; i++) {
+            if (pattern[i] === 1)
+                full[CT_POS[i]] = 1;
+        }
+        for (let m = 0; m < exports.CENTER2_MOVES.length; m++) {
+            const map = moveMaps;
+            for (let i = 0; i < 24; i++)
+                moved[i] = full[map[m * 24 + i]];
+            const ct = new Uint8Array(16);
+            for (let i = 0; i < 16; i++)
+                ct[i] = moved[CT_POS[i]] % 3;
+            ctMove[ctRank * exports.CENTER2_MOVES.length + m] = rankVsLast(ct, 16, 8);
+        }
+    }
+    for (let rlRankBase = 0; rlRankBase < 35; rlRankBase++) {
+        for (const parity of [0, 1]) {
+            const rlRank = rlRankBase * 2 + parity;
+            const pattern = unrankVsLast(rlRankBase, 8, 4);
+            for (let i = 0; i < 24; i++)
+                full[i] = 0;
+            for (let i = 0; i < 8; i++) {
+                if (pattern[i] === 1)
+                    full[RL_POS[i]] = 1;
+            }
+            for (let m = 0; m < exports.CENTER2_MOVES.length; m++) {
+                const map = moveMaps;
+                for (let i = 0; i < 24; i++)
+                    moved[i] = full[map[m * 24 + i]];
+                const rl = new Uint8Array(8);
+                for (let i = 0; i < 8; i++)
+                    rl[i] = moved[RL_POS[i]];
+                const nextParity = (parity ^ (PARITY_FLIP.has(exports.CENTER2_MOVES[m]) ? 1 : 0));
+                rlMove[rlRank * exports.CENTER2_MOVES.length + m] = rankVsLast(rl, 8, 4) * 2 + nextParity;
+            }
+        }
+    }
+    // pruning BFS from the 6 goal states, with the 23 exploration moves
+    const pruning = new Uint8Array(exports.CENTER2_STATES).fill(0xff);
+    const queue = [];
+    for (const rl of exports.CENTER2_GOAL_RL) {
+        pruning[rl] = 0; // ct == 0 → index == rl
+        queue.push(rl);
+    }
+    let head = 0;
+    while (head < queue.length) {
+        const idx = queue[head++];
+        const ct = Math.floor(idx / exports.CENTER2_RL_STATES);
+        const rl = idx % exports.CENTER2_RL_STATES;
+        const d = pruning[idx];
+        for (let m = 0; m < exports.CENTER2_SEARCH_MOVES.length; m++) {
+            const nextCt = ctMove[ct * exports.CENTER2_MOVES.length + m];
+            const nextRl = rlMove[rl * exports.CENTER2_MOVES.length + m];
+            const next = nextCt * exports.CENTER2_RL_STATES + nextRl;
+            if (pruning[next] === 0xff) {
+                pruning[next] = d + 1;
+                queue.push(next);
+            }
+        }
+    }
+    return { ctMove, rlMove, pruning };
+}
+// The reference's cancellation rule (ckmv over move2std): skip the same base
+// move, or the same axis-class when the previous move's standard index is
+// larger than the current's.
+const STANDARD_ORDER = [
+    "U", "U2", "U'", "R", "R2", "R'", "F", "F2", "F'", "D", "D2", "D'",
+    "L", "L2", "L'", "B", "B2", "B'",
+    "Uw", "Uw2", "Uw'", "Rw", "Rw2", "Rw'", "Fw", "Fw2", "Fw'",
+    "Dw", "Dw2", "Dw'", "Lw", "Lw2", "Lw'", "Bw", "Bw2", "Bw'"
+];
+const STD_INDEX = new Map(STANDARD_ORDER.map((m, i) => [m, i]));
+function baseOf(move) {
+    return move.replace(/[2']$/, "");
+}
+function axisClass(base) {
+    return { U: 0, D: 0, R: 1, L: 1, F: 2, B: 2 }[base];
+}
+function isCancelled(previous, current) {
+    const pb = baseOf(previous);
+    const cb = baseOf(current);
+    if (pb === cb)
+        return true;
+    if (axisClass(pb) === axisClass(cb)) {
+        return STD_INDEX.get(previous) > STD_INDEX.get(current);
+    }
+    return false;
+}
+function solveCenter2(startCt, startRl, tables, maxLength = 40) {
+    const solutions = solveCenter2All(startCt, startRl, tables, maxLength, 1);
+    return solutions.length > 0 ? solutions[0] : null;
+}
+/**
+ * Enumerate phase-2 solutions (shortest first). The phase-2 → phase-3 bridge
+ * needs multiple candidates: the reference filters them by the pairing gate
+ * (transversal + even wing permutation), which most states fail.
+ */
+function solveCenter2All(startCt, startRl, tables, maxLength = 40, cap = 200) {
+    const solutions = [];
+    const moveLog = new Array(maxLength);
+    for (let length = tables.pruning[startCt * exports.CENTER2_RL_STATES + startRl]; length <= maxLength; length++) {
+        if (search(startCt, startRl, length, -1, 0))
+            break;
+    }
+    return solutions;
+    function search(c, r, maxl, lm, depth) {
+        if (isCenter2Goal(c, r)) {
+            if (maxl === 0) {
+                solutions.push({
+                    moves: moveLog.slice(0, depth).map((m) => exports.CENTER2_MOVES[m]),
+                    ct: c,
+                    rl: r
+                });
+                return solutions.length >= cap;
+            }
+            return false;
+        }
+        for (let m = 0; m < exports.CENTER2_SEARCH_MOVES.length; m++) {
+            if (lm >= 0 && isCancelled(exports.CENTER2_SEARCH_MOVES[lm], exports.CENTER2_SEARCH_MOVES[m])) {
+                continue;
+            }
+            const nc = tables.ctMove[c * exports.CENTER2_MOVES.length + m];
+            const nr = tables.rlMove[r * exports.CENTER2_MOVES.length + m];
+            const prun = tables.pruning[nc * exports.CENTER2_RL_STATES + nr];
+            if (prun >= maxl)
+                continue;
+            moveLog[depth] = m;
+            if (search(nc, nr, maxl - 1, m, depth + 1))
+                return true;
+        }
+        return false;
+    }
+}
+let cachedWingMaps = null;
+function getWingMoveMaps() {
+    if (!cachedWingMaps) {
+        cachedWingMaps = buildWingMoveMaps();
+    }
+    return cachedWingMaps;
+}
+const tempWpPool = Array.from({ length: 5 }, () => new Uint8Array(24));
+function replayWp(startWp, moves, depth, wingMaps, outWp) {
+    outWp.set(startWp);
+    const temp = tempWpPool[0];
+    for (let d = 0; d < depth; d++) {
+        const m = moves[d];
+        temp.set(outWp);
+        for (let i = 0; i < 24; i++) {
+            outWp[i] = temp[wingMaps[m * 24 + i]];
+        }
+    }
+}
+/**
+ * Solve Center 2 gated for an exact target length.
+ */
+function solveCenter2GatedLength(startCt, startRl, startWp, tables, isGateEligible, targetLength, moveLog = new Array(targetLength)) {
+    const wingMaps = getWingMoveMaps();
+    let finalWp = null;
+    let finalCt = -1;
+    let finalRl = -1;
+    if (search(startCt, startRl, targetLength, -1, 0)) {
+        return {
+            moves: moveLog.slice(0, targetLength).map((m) => exports.CENTER2_MOVES[m]),
+            ct: finalCt,
+            rl: finalRl,
+            wp: finalWp
+        };
+    }
+    return null;
+    function search(c, r, maxl, lm, depth) {
+        if (isCenter2Goal(c, r)) {
+            if (maxl === 0) {
+                replayWp(startWp, moveLog, depth, wingMaps, tempWpPool[1]);
+                if (isGateEligible(tempWpPool[1])) {
+                    finalWp = tempWpPool[1].slice();
+                    finalCt = c;
+                    finalRl = r;
+                    return true;
+                }
+            }
+            return false;
+        }
+        if (maxl === 0)
+            return false;
+        for (let m = 0; m < exports.CENTER2_SEARCH_MOVES.length; m++) {
+            if (lm >= 0 && isCancelled(exports.CENTER2_SEARCH_MOVES[lm], exports.CENTER2_SEARCH_MOVES[m])) {
+                continue;
+            }
+            const nc = tables.ctMove[c * exports.CENTER2_MOVES.length + m];
+            const nr = tables.rlMove[r * exports.CENTER2_MOVES.length + m];
+            const prun = tables.pruning[nc * exports.CENTER2_RL_STATES + nr];
+            if (prun >= maxl)
+                continue;
+            moveLog[depth] = m;
+            if (search(nc, nr, maxl - 1, m, depth + 1))
+                return true;
+        }
+        return false;
+    }
+}
+/**
+ * Phase-2 search that tracks the wing permutation alongside the (ct, rl)
+ * coordinate and only accepts goal states whose wings satisfy the pairing
+ * transversal (the phase-3 entry gate).
+ */
+function solveCenter2Gated(startCt, startRl, startWp, tables, isGateEligible, maxLength = 40) {
+    const moveLog = new Array(maxLength);
+    const minLength = tables.pruning[startCt * exports.CENTER2_RL_STATES + startRl];
+    for (let length = minLength; length <= maxLength; length++) {
+        const result = solveCenter2GatedLength(startCt, startRl, startWp, tables, isGateEligible, length, moveLog);
+        if (result)
+            return result;
+    }
+    return null;
+}
+function buildWingMoveMaps() {
+    const maps = new Int32Array(exports.CENTER2_MOVES.length * 24);
+    for (let m = 0; m < exports.CENTER2_MOVES.length; m++) {
+        const { face, turns } = (0, moves_js_1.parseMove)(exports.CENTER2_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.wperm[i]];
+            pos = next;
+        }
+        for (let i = 0; i < 24; i++)
+            maps[m * 24 + i] = pos[i];
+    }
+    return maps;
+}
+// ---------------------------------------------------------------------------
+// Verification gates
+// ---------------------------------------------------------------------------
+function verifyCenter2(tables) {
+    const errors = [];
+    for (const rl of exports.CENTER2_GOAL_RL) {
+        if (tables.pruning[rl] !== 0) {
+            errors.push(`Goal rl ${rl} must have pruning 0.`);
+        }
+    }
+    let maxDepth = 0;
+    for (let idx = 0; idx < exports.CENTER2_STATES; idx++) {
+        const d = tables.pruning[idx];
+        if (d > maxDepth)
+            maxDepth = d;
+        const ct = Math.floor(idx / exports.CENTER2_RL_STATES);
+        const rl = idx % exports.CENTER2_RL_STATES;
+        for (let m = 0; m < exports.CENTER2_SEARCH_MOVES.length; m++) {
+            const nc = tables.ctMove[ct * exports.CENTER2_MOVES.length + m];
+            const nr = tables.rlMove[rl * exports.CENTER2_MOVES.length + m];
+            const nd = tables.pruning[nc * exports.CENTER2_RL_STATES + nr];
+            if (nd < d - 1 || nd > d + 1) {
+                errors.push(`Pruning inconsistency at ${idx} move ${exports.CENTER2_MOVES[m]}: ${d} -> ${nd}.`);
+                break;
+            }
+        }
+    }
+    return errors;
+}