@cubingcenter/scrambler 0.6.3 → 0.8.0

package/dist-cjs/puzzles/cube4/reduction/rotation-fix.js

@@ -0,0 +1,216 @@
+"use strict";
+/**
+ * Placement of the whole-cube rotation fix inside a 4x4 solution.
+ *
+ * The reduction ends with the cube solved in some orientation, so the solve
+ * is `P ++ W(R) ++ Q` where `W(R)` are the 2-4 wide moves of the rotation R
+ * (`x` = `Rw Lw'`, ...). A rotation commutes with any move sequence once the
+ * sequence's faces are re-mapped:
+ *
+ *   X ++ W(R)  ≡  W(R) ++ rotateAlgorithm(X, R)
+ *
+ * so the fix can sit at ANY point of the solution (with the moves after it
+ * re-mapped), and a two-rotation fix can be split across two points. The
+ * total is unchanged except at the insertion junctions, where the fix can
+ * cancel against same-axis wide moves (`Uw2 · y2` = `Uw2 · Uw2 Dw2` = `Dw2`).
+ * `placeRotationFix` picks the placement with the shortest simplified total.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ROTATION_WORDS = void 0;
+exports.placeRotationFix = placeRotationFix;
+const moves_js_1 = require("../moves.js");
+const state_js_1 = require("../state.js");
+/** Wide-move words of the 9 single rotations. */
+exports.ROTATION_WORDS = {
+    "x": ["Rw", "Lw'"],
+    "y": ["Uw", "Dw'"],
+    "z": ["Fw", "Bw'"],
+    "x'": ["Rw'", "Lw"],
+    "y'": ["Uw'", "Dw"],
+    "z'": ["Fw'", "Bw"],
+    "x2": ["Rw2", "Lw2"],
+    "y2": ["Uw2", "Dw2"],
+    "z2": ["Fw2", "Bw2"]
+};
+const FACE_MAPS = {
+    "x": { U: "B", R: "R", F: "U", D: "F", L: "L", B: "D" },
+    "x'": { U: "F", R: "R", F: "D", D: "B", L: "L", B: "U" },
+    "y": { U: "U", R: "F", F: "L", D: "D", L: "B", B: "R" },
+    "y'": { U: "U", R: "B", F: "R", D: "D", L: "F", B: "L" },
+    "z": { U: "R", R: "D", F: "F", D: "L", L: "U", B: "B" },
+    "z'": { U: "L", R: "U", F: "F", D: "R", L: "D", B: "B" },
+    "x2": { U: "D", R: "R", F: "B", D: "U", L: "L", B: "F" },
+    "y2": { U: "U", R: "L", F: "B", D: "D", L: "R", B: "F" },
+    "z2": { U: "D", R: "L", F: "F", D: "U", L: "R", B: "B" }
+};
+const FACES = ["U", "R", "F", "D", "L", "B"];
+/** Composite face map of a rotation sequence (applied left to right). */
+function faceMapOf(rotations) {
+    const map = {};
+    for (const face of FACES) {
+        let current = face;
+        for (const rotation of rotations)
+            current = FACE_MAPS[rotation][current];
+        map[face] = current;
+    }
+    return map;
+}
+function remap(moves, map) {
+    const out = new Array(moves.length);
+    for (let i = 0; i < moves.length; i++) {
+        const move = moves[i];
+        out[i] = (map[move[0]] + move.slice(1));
+    }
+    return out;
+}
+const rotationKey = (rotations) => (0, moves_js_1.applyCube4Algorithm)((0, state_js_1.createSolvedCube4State)(), rotations.flatMap((rotation) => exports.ROTATION_WORDS[rotation])).centers.join(",");
+/**
+ * Every factorization of each rotation element into 1 or 2 single rotations
+ * (keyed by the rotated solved cube's centers). Non-minimal ones are kept on
+ * purpose: `x2` as `x · x` costs 4 moves but can cancel at two junctions.
+ */
+const FACTORIZATIONS = (() => {
+    const names = Object.keys(exports.ROTATION_WORDS);
+    const byKey = new Map();
+    const add = (sequence) => {
+        const key = rotationKey(sequence);
+        const list = byKey.get(key);
+        if (!list)
+            byKey.set(key, [sequence]);
+        else
+            list.push(sequence);
+    };
+    for (const a of names)
+        add([a]);
+    for (const a of names)
+        for (const b of names)
+            add([a, b]);
+    return byKey;
+})();
+const AXIS_OF_FACE = { U: 0, D: 0, R: 1, L: 1, F: 2, B: 2 };
+/** Segment boundaries (maximal same-axis runs) of a sequence: 0, ..., n. */
+function runBoundaries(moves) {
+    const bounds = [0];
+    for (let i = 1; i < moves.length; i++) {
+        if (AXIS_OF_FACE[moves[i][0]] !== AXIS_OF_FACE[moves[i - 1][0]])
+            bounds.push(i);
+    }
+    if (moves.length > 0)
+        bounds.push(moves.length);
+    return bounds;
+}
+/** Moves saved by simplifying across one inserted word, judged on a window of 2 runs per side. */
+function junctionSaving(moves, bounds, b, word, leftMap, rightMap) {
+    const lo = bounds[Math.max(0, b - 2)];
+    const hi = bounds[Math.min(bounds.length - 1, b + 2)];
+    const at = bounds[b];
+    const left = moves.slice(lo, at);
+    const window = [...(leftMap ? remap(left, leftMap) : left), ...word, ...remap(moves.slice(at, hi), rightMap)];
+    return window.length - (0, moves_js_1.simplifyCube4Algorithm)(window).length;
+}
+/**
+ * Shortest simplified solution equivalent to `prefix ++ W(rotation) ++
+ * suffix` (same effect on every state), over every run-boundary insertion
+ * point of the fix and every minimal factorization of the rotation. Only
+ * run boundaries matter: the fix can only merge with runs on its own axis,
+ * and re-mapping preserves the run structure of what follows it.
+ */
+function placeRotationFix(prefix, rotation, suffix) {
+    const fixed = (0, moves_js_1.simplifyCube4Algorithm)([
+        ...prefix,
+        ...rotation.flatMap((r) => exports.ROTATION_WORDS[r]),
+        ...suffix
+    ]);
+    if (rotation.length === 0)
+        return fixed;
+    let best = fixed;
+    const consider = (candidate) => {
+        const simplified = (0, moves_js_1.simplifyCube4Algorithm)(candidate);
+        if (simplified.length < best.length)
+            best = simplified;
+    };
+    // A = prefix ++ Q' with W(R) ++ suffix ≡ Q' ++ W(R): Q' = remap(suffix, R⁻¹).
+    const forward = faceMapOf(rotation);
+    const inverseMap = {};
+    for (const face of FACES)
+        inverseMap[forward[face]] = face;
+    const all = (0, moves_js_1.simplifyCube4Algorithm)([...prefix, ...remap(suffix, inverseMap)]);
+    const bounds = runBoundaries(all);
+    const m = bounds.length;
+    const identity = faceMapOf([]);
+    for (const factors of FACTORIZATIONS.get(rotationKey(rotation)) ?? [rotation]) {
+        if (factors.length === 1) {
+            const map = faceMapOf(factors);
+            const word = exports.ROTATION_WORDS[factors[0]];
+            let bestB = -1;
+            let bestSaving = 0;
+            for (let b = 0; b < m; b++) {
+                const saving = junctionSaving(all, bounds, b, word, null, map);
+                if (saving > bestSaving) {
+                    bestSaving = saving;
+                    bestB = b;
+                }
+            }
+            if (bestB >= 0) {
+                const k = bounds[bestB];
+                consider([...all.slice(0, k), ...word, ...remap(all.slice(k), map)]);
+            }
+            continue;
+        }
+        const map1 = faceMapOf([factors[0]]);
+        const map12 = faceMapOf(factors);
+        const word1 = exports.ROTATION_WORDS[factors[0]];
+        const word2 = exports.ROTATION_WORDS[factors[1]];
+        const build = (b1, b2) => {
+            const k1 = bounds[b1];
+            const k2 = bounds[b2];
+            return [
+                ...all.slice(0, k1),
+                ...word1,
+                ...remap(all.slice(k1, k2), map1),
+                ...word2,
+                ...remap(all.slice(k2), map12)
+            ];
+        };
+        // Far-apart junctions save independently: s1 (unmapped | map1) at b1,
+        // s2 (map1 | map12) at b2 >= b1 + 3, combined with a suffix maximum.
+        // Both words at one point (b1 == b2) is a single junction (s12); nearby
+        // pairs interact, so the best few estimates are re-scored exactly.
+        const s1 = new Int32Array(m);
+        const s2 = new Int32Array(m);
+        const word12 = [...word1, ...word2];
+        const shortlist = [];
+        for (let b = 0; b < m; b++) {
+            s1[b] = junctionSaving(all, bounds, b, word1, identity, map1);
+            s2[b] = junctionSaving(all, bounds, b, word2, map1, map12);
+            const s12 = junctionSaving(all, bounds, b, word12, identity, map12);
+            if (s12 > 0)
+                shortlist.push([s12, b, b]);
+        }
+        let suffixBest = -1;
+        for (let b1 = m - 4; b1 >= 0; b1--) {
+            const b2Candidate = b1 + 3;
+            if (suffixBest < 0 || s2[b2Candidate] > s2[suffixBest])
+                suffixBest = b2Candidate;
+            const saving = s1[b1] + s2[suffixBest];
+            if (saving > 0)
+                shortlist.push([saving, b1, suffixBest]);
+            for (let b2 = b1 + 1; b2 < Math.min(m, b1 + 3); b2++) {
+                if (s1[b1] + s2[b2] > 0)
+                    shortlist.push([s1[b1] + s2[b2], b1, b2]);
+            }
+        }
+        shortlist.sort((a, b) => b[0] - a[0] || a[1] - b[1] || a[2] - b[2]);
+        const seen = new Set();
+        for (const [, b1, b2] of shortlist) {
+            if (seen.size >= 4)
+                break;
+            const key = b1 * 256 + b2;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            consider(build(b1, b2));
+        }
+    }
+    return best;
+}