@cubingcenter/scrambler 0.5.3 → 0.6.0

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

@@ -0,0 +1,258 @@
+"use strict";
+/**
+ * Center1 (phase 1 of the 4x4 reduction solver): reduce the two colors of a
+ * chosen axis (U/D, R/L or F/B) onto a single face-pair.
+ *
+ * Design (simpler than the reference's symmetry-reduced tables, which use a
+ * fragile 48-element non-group of "block-turn symmetries"):
+ *  - coordinate: the raw C(24,8) = 735,471 mask of the positions holding the
+ *    two axis colors — NO symmetry reduction;
+ *  - pruning: the exact BFS distance table from the three face-pair goal
+ *    masks (God's number 9; the 27-move set reaches the whole space);
+ *  - search: greedy descent — any move that decreases the exact distance by
+ *    exactly 1 is on an optimal path, so repeatedly applying the first such
+ *    move reaches the goal in exactly `distance` moves, with zero
+ *    backtracking and no iterative deepening.
+ *
+ * One table serves all three axes (the face-pairs are equivalent goals).
+ * The phase-1 move set: 9 axes [U,R,F,D,L,B,Uw,Rw,Fw] × 3 powers = 27.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CENTER1_GOAL_MASKS = exports.CENTER1_RAW_STATES = exports.CENTER1_MOVES = exports.CENTER1_AXES = void 0;
+exports.center1Mask = center1Mask;
+exports.rankCenter1Mask = rankCenter1Mask;
+exports.unrankCenter1Mask = unrankCenter1Mask;
+exports.buildCenter1MoveMaps = buildCenter1MoveMaps;
+exports.applyCenter1Move = applyCenter1Move;
+exports.generateCenter1Tables = generateCenter1Tables;
+exports.getCenter1Distance = getCenter1Distance;
+exports.solveCenter1 = solveCenter1;
+exports.solveCenter1All = solveCenter1All;
+exports.verifyCenter1 = verifyCenter1;
+const moves_js_1 = require("../moves.js");
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+exports.CENTER1_AXES = [
+    "U", "R", "F", "D", "L", "B", "Uw", "Rw", "Fw"
+];
+exports.CENTER1_MOVES = exports.CENTER1_AXES.flatMap((face) => [face, `${face}2`, `${face}'`]);
+exports.CENTER1_RAW_STATES = 735471;
+// 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;
+})();
+// ---------------------------------------------------------------------------
+// Mask utilities (24-bit integers; bit i = center position i)
+// ---------------------------------------------------------------------------
+/** The mask of the positions holding the two axis colors (colors % 3 == urf). */
+function center1Mask(centers, urf) {
+    let mask = 0;
+    for (let i = 0; i < 24; i++) {
+        if (centers[i] % 3 === urf)
+            mask |= 1 << i;
+    }
+    return mask;
+}
+/** C(24,8) combination rank of a mask. */
+function rankCenter1Mask(mask) {
+    let idx = 0;
+    let r = 8;
+    for (let i = 23; i >= 0; i--) {
+        if ((mask >> i) & 1)
+            idx += CNK[i][r--];
+    }
+    return idx;
+}
+function unrankCenter1Mask(idx) {
+    let mask = 0;
+    let r = 8;
+    for (let i = 23; i >= 0; i--) {
+        if (idx >= CNK[i][r]) {
+            idx -= CNK[i][r];
+            r--;
+            mask |= 1 << i;
+        }
+    }
+    return mask;
+}
+/** The three face-pair goal masks (bit i = center position i, face-major). */
+exports.CENTER1_GOAL_MASKS = {
+    ud: 0xf00f,
+    rl: 0xf00f0,
+    fb: 0xf00f00
+};
+// ---------------------------------------------------------------------------
+// Move bit-permutations
+// ---------------------------------------------------------------------------
+/** The 27 phase-1 moves as bit-permutations of the 24-bit mask. */
+function buildCenter1MoveMaps() {
+    const maps = new Int32Array(exports.CENTER1_MOVES.length * 24);
+    for (let m = 0; m < exports.CENTER1_MOVES.length; m++) {
+        const { face, turns } = (0, moves_js_1.parseMove)(exports.CENTER1_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;
+        }
+        // apply a move: dest bit i takes source bit pos[i]
+        for (let i = 0; i < 24; i++)
+            maps[m * 24 + i] = pos[i];
+    }
+    return maps;
+}
+function applyCenter1Move(mask, moveMap, move) {
+    let out = 0;
+    for (let i = 0; i < 24; i++) {
+        if ((mask >> moveMap[move * 24 + i]) & 1)
+            out |= 1 << i;
+    }
+    return out;
+}
+function generateCenter1Tables() {
+    const moveMaps = buildCenter1MoveMaps();
+    const distance = new Uint8Array(Math.ceil(exports.CENTER1_RAW_STATES / 2)).fill(0xff);
+    const setDistance = (rank, d) => {
+        const byte = rank >> 1;
+        if ((rank & 1) === 0)
+            distance[byte] = (distance[byte] & 0xf0) | (d & 0x0f);
+        else
+            distance[byte] = (distance[byte] & 0x0f) | ((d & 0x0f) << 4);
+    };
+    const getDistance = (rank) => {
+        const byte = distance[rank >> 1];
+        return (rank & 1) === 0 ? byte & 0x0f : byte >> 4;
+    };
+    const isUnset = (rank) => {
+        const byte = distance[rank >> 1];
+        return (rank & 1) === 0 ? (byte & 0x0f) === 0x0f : (byte >> 4) === 0x0f;
+    };
+    // BFS from the three goal masks.
+    for (const goal of [exports.CENTER1_GOAL_MASKS.ud, exports.CENTER1_GOAL_MASKS.rl, exports.CENTER1_GOAL_MASKS.fb]) {
+        setDistance(rankCenter1Mask(goal), 0);
+    }
+    const queue = [
+        rankCenter1Mask(exports.CENTER1_GOAL_MASKS.ud),
+        rankCenter1Mask(exports.CENTER1_GOAL_MASKS.rl),
+        rankCenter1Mask(exports.CENTER1_GOAL_MASKS.fb)
+    ];
+    let head = 0;
+    while (head < queue.length) {
+        const rank = queue[head++];
+        const mask = unrankCenter1Mask(rank);
+        const d = getDistance(rank);
+        for (let m = 0; m < exports.CENTER1_MOVES.length; m++) {
+            const next = applyCenter1Move(mask, moveMaps, m);
+            const nextRank = rankCenter1Mask(next);
+            if (isUnset(nextRank)) {
+                setDistance(nextRank, d + 1);
+                queue.push(nextRank);
+            }
+        }
+    }
+    // verify completeness: every state reached
+    let reached = 0;
+    for (let rank = 0; rank < exports.CENTER1_RAW_STATES; rank++) {
+        if (!isUnset(rank))
+            reached++;
+    }
+    if (reached !== exports.CENTER1_RAW_STATES) {
+        throw new Error(`Center1 BFS incomplete: ${reached}/${exports.CENTER1_RAW_STATES} states reached.`);
+    }
+    return { distance, moveMaps };
+}
+function getCenter1Distance(mask, tables) {
+    const rank = rankCenter1Mask(mask);
+    const byte = tables.distance[rank >> 1];
+    return (rank & 1) === 0 ? byte & 0x0f : byte >> 4;
+}
+/**
+ * Phase-1 greedy descent: bring the axis colors onto some face-pair in
+ * exactly `distance` moves (optimal). Every move that decreases the exact
+ * distance by 1 is on an optimal path, so no backtracking is needed.
+ * Returns null if the state is unreachable (should not happen).
+ */
+function solveCenter1(centers, urf, tables) {
+    const solutions = solveCenter1All(centers, urf, tables, 1);
+    return solutions.length > 0 ? solutions[0] : null;
+}
+/**
+ * Enumerate phase-1 solutions (the optimal descending paths, then longer
+ * alternatives up to `cap`). The phase-1 → phase-3 pipeline needs variety:
+ * the phase-2 gate rate depends strongly on the phase-1 output's wings.
+ */
+function solveCenter1All(centers, urf, tables, cap = 50) {
+    const moveMaps = tables.moveMaps;
+    const solutions = [];
+    const path = [];
+    const maxLength = 30;
+    const dfs = (mask, depth) => {
+        if (solutions.length >= cap)
+            return true;
+        const h = getCenter1Distance(mask, tables);
+        if (h === 0) {
+            solutions.push({ moves: path.slice(0, depth).map((m) => exports.CENTER1_MOVES[m]), length: depth });
+            return false;
+        }
+        if (depth >= maxLength)
+            return false;
+        for (let m = 0; m < exports.CENTER1_MOVES.length; m++) {
+            const next = applyCenter1Move(mask, moveMaps, m);
+            if (getCenter1Distance(next, tables) !== h - 1)
+                continue;
+            path[depth] = m;
+            if (dfs(next, depth + 1))
+                return true;
+        }
+        return false;
+    };
+    dfs(center1Mask(centers, urf), 0);
+    return solutions;
+}
+// ---------------------------------------------------------------------------
+// Verification gates
+// ---------------------------------------------------------------------------
+function verifyCenter1(tables) {
+    const errors = [];
+    if (getCenter1Distance(exports.CENTER1_GOAL_MASKS.ud, tables) !== 0) {
+        errors.push("Goal mask ud must have distance 0.");
+    }
+    if (getCenter1Distance(exports.CENTER1_GOAL_MASKS.rl, tables) !== 0) {
+        errors.push("Goal mask rl must have distance 0.");
+    }
+    if (getCenter1Distance(exports.CENTER1_GOAL_MASKS.fb, tables) !== 0) {
+        errors.push("Goal mask fb must have distance 0.");
+    }
+    // distances must be consistent with the moves
+    let maxDepth = 0;
+    for (let rank = 0; rank < exports.CENTER1_RAW_STATES; rank++) {
+        const mask = unrankCenter1Mask(rank);
+        const d = getCenter1Distance(mask, tables);
+        if (d > maxDepth)
+            maxDepth = d;
+        for (let m = 0; m < exports.CENTER1_MOVES.length; m++) {
+            const next = applyCenter1Move(mask, tables.moveMaps, m);
+            const nd = getCenter1Distance(next, tables);
+            if (nd < d - 1 || nd > d + 1) {
+                errors.push(`Distance inconsistency at rank ${rank} move ${exports.CENTER1_MOVES[m]}: ${d} -> ${nd}.`);
+                break;
+            }
+        }
+    }
+    return errors;
+}