@cubingcenter/scrambler 0.6.3 → 0.8.0

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

@@ -0,0 +1,212 @@
+/**
+ * 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.
+ */
+import { applyCube4Algorithm, simplifyCube4Algorithm } from "../moves.js";
+import { createSolvedCube4State } from "../state.js";
+/** Wide-move words of the 9 single rotations. */
+export const 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) => applyCube4Algorithm(createSolvedCube4State(), rotations.flatMap((rotation) => 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(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 - 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.
+ */
+export function placeRotationFix(prefix, rotation, suffix) {
+    const fixed = simplifyCube4Algorithm([
+        ...prefix,
+        ...rotation.flatMap((r) => ROTATION_WORDS[r]),
+        ...suffix
+    ]);
+    if (rotation.length === 0)
+        return fixed;
+    let best = fixed;
+    const consider = (candidate) => {
+        const simplified = 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 = 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 = 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 = ROTATION_WORDS[factors[0]];
+        const word2 = 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;
+}

package/dist/puzzles/cube4/reduction/solve.d.ts

@@ -7,25 +7,195 @@ import type { Cube4State, Cube4Move } from "../types.js";
 import { type Center1Tables } from "./center1.js";
 import { type Center2Tables } from "./center2.js";
 import { type Center3Tables } from "./center3.js";
+import { type HcDenseTables } from "./hc-pdb.js";
 import { type Edge3Tables } from "./edge3.js";
 import type { Cube3State, Cube3Move } from "../../cube3/types.js";
+import type { Cube3Phase1Tables, Cube3Phase2Tables } from "../../cube3/solver/tables.js";
 export interface Cube4SolveTables {
     center1: Center1Tables;
     center2: Center2Tables;
     center3: Center3Tables;
     edge3: Edge3Tables;
+    cube3Phase1?: Cube3Phase1Tables;
+    /** Phase-2 tables for the optional continuous 3x3 finish. */
+    cube3Phase2?: Cube3Phase2Tables;
+    /** Half-class exact PDB (optional; tightens the phase-3 root bound and node-level pruning). */
+    hc?: HcDenseTables;
+    /** Joint Center3 x Single Pair PDB distances (optional). */
+    c3PairDist?: Uint8Array;
 }
 export interface Cube4SolveResult {
     /** The complete solve sequence (solves the input state). */
     moves: Cube4Move[];
     /** The scramble (the inverted solution). */
     scramble: Cube4Move[];
+    /** Winning reduction breakdown (unsimplified lengths). */
+    phases?: {
+        length12: number;
+        length1: number;
+        length2: number;
+        length3: number;
+        finish: number;
+    };
+    /** Search work: phase-2 DFS nodes + phase-3 IDA* nodes this attempt. */
+    nodes?: {
+        p2: number;
+        p3: number;
+        f3calls: number;
+    };
+    /** Wall-clock split of this solve (reduction search / finish loop / polish). */
+    timings?: {
+        reductionMs: number;
+        f1Ms: number;
+        f2Ms: number;
+        f3Ms: number;
+        finishMs: number;
+        polishMs: number;
+    };
 }
+declare abstract class Cube4SolveError extends Error {
+    abstract readonly code: "cube4-phase2-cap" | "cube4-phase3-cap" | "cube4-finish-cap";
+}
+export declare class Cube4Phase2CapError extends Cube4SolveError {
+    readonly code: "cube4-phase2-cap";
+    constructor(message: string);
+}
+export declare class Cube4Phase3CapError extends Cube4SolveError {
+    readonly code: "cube4-phase3-cap";
+    constructor(message: string);
+}
+export declare class Cube4FinishCapError extends Cube4SolveError {
+    readonly code: "cube4-finish-cap";
+    constructor(message: string);
+}
+export declare function rotateAlgorithm(alg: readonly Cube4Move[], rotSeq: string[]): Cube4Move[];
+/** Physical wide-move sequence implementing a whole-cube rotation. */
+export declare function cubeRotationMoves(rotSeq: readonly string[]): Cube4Move[];
+export declare function invertRotationSequence(rotSeq: readonly string[]): string[];
+export declare function applyCubeRotation(state: Cube4State, rotSeq: string[]): Cube4State;
+export declare const P2_CANCEL: readonly (readonly boolean[])[];
+/** Temporary instrumentation for F2 goal statistics (CUBE4_F2_STATS=1). */
+export declare const f2Stats: {
+    goals: number;
+    transversalPass: number;
+    axisRejects: number;
+    minTransversalL2: number;
+    minChiralL2: number;
+};
+export declare function resetF2Stats(): void;
+/** Trigger rate for the stagnationCut early-stop (checks vs actual cuts). */
+export declare const stagnationStats: {
+    checks: number;
+    cuts: number;
+};
+export declare function resetStagnationStats(): void;
+/**
+ * Temporary instrumentation for the finish-skip bound (CUBE4_FINISH_STATS=1):
+ * `gap = totalEst - finalLen` per finished reduction. A skip
+ * `totalEst - SLACK >= minTotalMoves` is only sound while SLACK covers the
+ * observed gap maximum (junction cancellation + finish-vs-h3 slack).
+ */
+export declare const finishStats: {
+    gapMin: number;
+    gapMax: number;
+    gapSum: number;
+    gapN: number;
+    finishes: number;
+    skipped: number;
+};
+/**
+ * Temporary instrumentation for the rotMoves cost (CUBE4_ROT_STATS=1):
+ * per built reduction records the prep frame rotation, the derived
+ * normalization rotation and the emitted fix length.
+ */
+export declare const rotStats: Array<{
+    totalRot: string;
+    rotToStandard: string;
+    rotLen: number;
+}>;
 /**
  * Solve a 4x4 state with the reduction solver + the cube3 two-phase finish.
  * `solveCube3` is injected (the cube3 solver loads its tables lazily).
+ *
+ * The search is bounded by deterministic work caps (candidate counts, node
+ * budgets and length caps); `timeoutMs` is retained as deprecated API and is
+ * not enforced. Attempt failures mean the
+ * state is outside the solver's horizon, never "ran out of time".
  */
-export declare function solveCube4State(state: Cube4State, tables: Cube4SolveTables, solveCube3: (state: Cube3State) => Promise<{
+export interface Cube4SolveOptions {
+    /** @deprecated No wall-clock timeout is enforced; the search uses work caps. */
+    timeoutMs?: number;
+    /**
+     * Last-resort effort: widens every work cap (phase-2 depth/nodes,
+     * phase-3 budgets/lengths, pool caps). Only the fast path failing
+     * should trigger this — easy states never pay it.
+     */
+    deep?: boolean;
+    /** Phase-4 attempts among valid reductions (default 3, or centersBeam * edgesPerCenter). */
+    finishTries?: number;
+    /** Number of distinct center candidates from phase 2 to explore in phase 3 (default 1). */
+    centersBeam?: number | undefined;
+    /** Maximum number of distinct edge pairings to collect per center candidate in phase 3 (default 5). */
+    edgesPerCenter?: number | undefined;
+    /** Deep multi-candidate polish pass in Phase 3. */
+    deepPolish?: boolean | undefined;
+    /** Prune searches whose reduction exceeds this bound (branch-and-bound). */
+    maxReductionLen?: number | undefined;
+    /**
+     * Phase-2 wide move set: search all 28 center2 moves (adds
+     * Dw2/Lw/Lw2/Lw'/Bw2) with the `pruningWide` table instead of the
+     * default 23. Requires regenerated center2 tables; default false.
+     * (Measured: ~-0.2 moves for ~+15% time; keep opt-in.)
+     */
+    center2Wide?: boolean | undefined;
+    /**
+     * F1 enumeration depth beyond the per-axis optimum (default 3):
+     * collects up to `phase1Cap` F1 solutions of length <= minH + this,
+     * deliberately supra-optimal, to feed diverse F2/F3 candidates.
+     * (Measured: restricting to 0 shows no consistent benefit and
+     * interacts badly with center2Wide; keep the default.)
+     */
+    phase1ExtraDepths?: number | undefined;
+    /** F1 solution collection cap (default 60). */
+    phase1Cap?: number | undefined;
+    /** Phase-2 prep collection cap (default 100, or 160 in deep mode). */
+    prepCap?: number | undefined;
+    /** Max candidates to collect per (prep, length) DFS call (default 64, or 96 in deep mode). */
+    p1CandCap?: number | undefined;
+    /** Early stop when candidate pool has >= CAND_MIN and best value stagnates across 2 lengths. */
+    stagnationCut?: boolean | undefined;
+    /**
+     * Full-pipeline restarts over the SAME state (default 1): each restart
+     * re-runs phases 1-4 with a reshuffled search order (seeded by the state
+     * hash ^ restart index, so results stay deterministic) and the shortest
+     * simplified total wins. Same-state diversity preserves the sampled
+     * state's distribution — unlike bestOf, which samples new states.
+     * `1` keeps the legacy single deterministic pass bit-identical.
+     */
+    restarts?: number | undefined;
+    /**
+     * Maximum whole-cube rotation fix (rotMoves, before placement) accepted
+     * on a phase-3 goal end (default 4 = no filter). The phase-3 goal is
+     * scheme-agnostic (half-class centers): the end's color scheme lands
+     * 0/2/4 wide moves from standard depending on the goal path. Since
+     * `placeRotationFix` cancels most of the fix against the reduction's wide
+     * moves (and totalEst prices the placed fix), filtering no longer pays:
+     * measured 46.13 moves @ 1425 ms at 4 vs 46.31 @ 2009 ms at 2 (cc:0..15).
+     * `0` = only standard-scheme ends (fails on some states).
+     */
+    maxFixMoves?: number | undefined;
+    /**
+     * Two-stage finish (default 0 = off): every candidate reduction is first
+     * finished with the cheap "screen" effort, then the best N by screened
+     * total are re-finished with the "full" effort. Measured with the 1×5
+     * beam (cc:0..31): off 44.97 @ 662 ms vs top-2 45.19 @ 663 ms — with few
+     * finishes per solve, screening only loses quality. 0 = every finish at
+     * full effort.
+     */
+    finishScreenTop?: number | undefined;
+}
+export declare function solveCube4State(state: Cube4State, tables: Cube4SolveTables, solveCube3: (state: Cube3State, effort?: "screen" | "full") => Promise<{
     moves: Cube3Move[];
-}>): Promise<Cube4SolveResult>;
+}>, options?: Cube4SolveOptions): Promise<Cube4SolveResult>;
+export {};
 //# sourceMappingURL=solve.d.ts.map

package/dist/puzzles/cube4/reduction/solve.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"solve.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/cube4/reduction/solve.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAEzD,OAAO,EAKL,KAAK,aAAa,EACnB,MAAM,cAAc,CAAC;AACtB,OAAO,EAML,KAAK,aAAa,EACnB,MAAM,cAAc,CAAC;AACtB,OAAO,EAAiB,KAAK,aAAa,EAAE,MAAM,cAAc,CAAC;AAKjE,OAAO,EAGL,KAAK,WAAW,EACjB,MAAM,YAAY,CAAC;AAGpB,OAAO,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAIlE,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,aAAa,CAAC;IACvB,OAAO,EAAE,aAAa,CAAC;IACvB,OAAO,EAAE,aAAa,CAAC;IACvB,KAAK,EAAE,WAAW,CAAC;CACpB;AAED,MAAM,WAAW,gBAAgB;IAC/B,4DAA4D;IAC5D,KAAK,EAAE,SAAS,EAAE,CAAC;IACnB,4CAA4C;IAC5C,QAAQ,EAAE,SAAS,EAAE,CAAC;CACvB;AAuKD;;;GAGG;AACH,wBAAsB,eAAe,CACnC,KAAK,EAAE,UAAU,EACjB,MAAM,EAAE,gBAAgB,EACxB,UAAU,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAC;IAAE,KAAK,EAAE,SAAS,EAAE,CAAA;CAAE,CAAC,GACjE,OAAO,CAAC,gBAAgB,CAAC,CAqL3B"}
+{"version":3,"file":"solve.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/cube4/reduction/solve.ts"],"names":[],"mappings":"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"}