cubing 0.22.0 → 0.24.0-pre2

package/src/cubing/search/inside/solve/puzzles/megaminx.ts

@@ -1,51 +0,0 @@
-import type { Alg } from "../../../../alg";
-import type { Transformation } from "../../../../kpuzzle";
-import { mustBeInsideWorker } from "../../inside-worker";
-import type { SGSCachedData } from "../parseSGS";
-import { cachedMegaminxDefWithoutMO } from "./megaminx.sgs.json";
-import { TrembleSolver } from "../tremble";
-
-const TREMBLE_DEPTH = 2;
-
-let cachedTrembleSolver: Promise<TrembleSolver> | null = null;
-async function getCachedTrembleSolver(): Promise<TrembleSolver> {
-  return (
-    cachedTrembleSolver ||
-    (cachedTrembleSolver = (async (): Promise<TrembleSolver> => {
-      const sgs = await import("./megaminx.sgs.json");
-      const json: SGSCachedData = await sgs.cachedSGSDataMegaminx();
-      return new TrembleSolver(await cachedMegaminxDefWithoutMO(), json, [
-        "U",
-        "R",
-        "F",
-        "L",
-        "BR",
-        "BL",
-        "FR",
-        "FL",
-        "DR",
-        "DL",
-        "B",
-        "D",
-      ]);
-    })())
-  );
-}
-
-export async function preInitializeMegaminx(): Promise<void> {
-  await getCachedTrembleSolver();
-}
-
-// TODO: centers
-export async function solveMegaminx(state: Transformation): Promise<Alg> {
-  mustBeInsideWorker();
-  const trembleSolver = await getCachedTrembleSolver();
-  const stateWithoutMO: Transformation = JSON.parse(JSON.stringify(state));
-  stateWithoutMO.CENTERS.orientation = new Array(12).fill(0);
-  const alg = await trembleSolver.solve(
-    stateWithoutMO,
-    TREMBLE_DEPTH,
-    () => 5, // TODO: Attach quantum move order lookup to puzzle.
-  );
-  return alg;
-}

package/src/cubing/search/inside/solve/puzzles/pyraminx.ts

@@ -1,48 +0,0 @@
-import type { Alg } from "../../../../alg";
-import type { Transformation } from "../../../../kpuzzle";
-import { puzzles } from "../../../../puzzles";
-import { mustBeInsideWorker } from "../../inside-worker";
-import type { SGSCachedData } from "../parseSGS";
-import { randomStateFromSGS, TrembleSolver } from "../tremble";
-import { sgsDataPyraminxFixedOrientation } from "./pyraminx.sgs.json";
-
-const TREMBLE_DEPTH = 3;
-
-let cachedTrembleSolver: Promise<TrembleSolver> | null = null;
-async function getCachedTrembleSolver(): Promise<TrembleSolver> {
-  return (
-    cachedTrembleSolver ||
-    (cachedTrembleSolver = (async (): Promise<TrembleSolver> => {
-      const sgs = await import("./pyraminx.sgs.json");
-      const json: SGSCachedData = await sgs.sgsDataPyraminx();
-      return new TrembleSolver(
-        await puzzles.pyraminx.def(),
-        json,
-        "RLUB".split(""),
-      );
-    })())
-  );
-}
-
-export async function preInitializePyraminx(): Promise<void> {
-  await getCachedTrembleSolver();
-}
-
-export async function solvePyraminx(state: Transformation): Promise<Alg> {
-  mustBeInsideWorker();
-  const trembleSolver = await getCachedTrembleSolver();
-  const alg = await trembleSolver.solve(state, TREMBLE_DEPTH, () => 3); // TODO: Attach quantum move order lookup to puzzle.
-  return alg;
-}
-
-export async function randomPyraminxStateFixedOrientation(): Promise<Transformation> {
-  // Note: this sets all center orientations to 0.
-  return randomStateFromSGS(
-    await puzzles.pyraminx.def(),
-    await sgsDataPyraminxFixedOrientation(),
-  );
-}
-
-export async function randomPyraminxScrambleFixedOrientation(): Promise<Alg> {
-  return solvePyraminx(await randomPyraminxStateFixedOrientation());
-}

package/src/cubing/search/inside/solve/puzzles/sgs-defs.spec.ts

@@ -1,27 +0,0 @@
-import { cachedSGSData3x3x3 } from "./3x3x3-inefficient.sgs.json";
-import { cachedData222 } from "./2x2x2.sgs.json";
-import { cachedSGSDataMegaminx } from "./megaminx.sgs.json";
-import { sgsDataPyraminx } from "./pyraminx.sgs.json";
-import { sgsDataSkewb } from "./skewb.sgs.json";
-
-describe("SGS", () => {
-  it("Parses 2x2x2 SGS", () => {
-    expect(cachedData222).not.toThrow();
-  });
-
-  it("Parses inefficient 3x3x3 SGS", () => {
-    expect(cachedSGSData3x3x3).not.toThrow();
-  });
-
-  it("Parses Megaminx SGS", () => {
-    expect(cachedSGSDataMegaminx).not.toThrow();
-  });
-
-  it("Parses Pyraminx SGS", () => {
-    expect(sgsDataPyraminx).not.toThrow();
-  });
-
-  it("Parses Skewb SGS", () => {
-    expect(sgsDataSkewb).not.toThrow();
-  });
-});

package/src/cubing/search/inside/solve/puzzles/skewb.sgs.json.ts

@@ -1,113 +0,0 @@
-import type { KPuzzleDefinition } from "../../../../kpuzzle";
-import { getPuzzleGeometryByName } from "../../../../puzzle-geometry";
-import { parseSGS, SGSCachedData } from "../parseSGS";
-
-async function skewbDefWithoutMO(): Promise<KPuzzleDefinition> {
-  return getPuzzleGeometryByName("skewb", {
-    allMoves: true,
-    addRotations: true,
-  }).writekpuzzle(true);
-}
-
-// TODO: Implement a general lazy Promise/ Promise cache wrapper
-let defCache: Promise<KPuzzleDefinition> | null = null;
-export async function skewbDefWithoutMOCached(): Promise<KPuzzleDefinition> {
-  return (defCache ??= skewbDefWithoutMO());
-}
-
-let cachedData: Promise<SGSCachedData> | null = null;
-export async function sgsDataSkewb() {
-  return (cachedData ??= uncachedSGSDataSkewb());
-}
-
-export async function sgsDataSkewbFixedCorner(): Promise<SGSCachedData> {
-  return {
-    ordering: (await sgsDataSkewb()).ordering.slice(1),
-  };
-}
-
-// TODO: Reduce info.
-async function uncachedSGSDataSkewb(): Promise<SGSCachedData> {
-  return parseSGS(
-    await skewbDefWithoutMOCached(),
-    `SubgroupSizes 24 6 5 12 9 3 4 9 3 3
-
-Alg y
-Alg y2
-Alg y'
-Alg F
-Alg F'
-Alg y U
-Alg y U'
-Alg y L
-Alg y L'
-Alg y F
-Alg y F'
-Alg y2 U
-Alg y2 U'
-Alg y2 B
-Alg y2 B'
-Alg y' U
-Alg y' F'
-Alg y U L'
-Alg y U B
-Alg y2 U B
-Alg y2 U B'
-Alg y2 U' B
-Alg y2 U' B'
-
-Alg U
-Alg U'
-Alg U L
-Alg U L'
-Alg U' R'
-
-Alg R
-Alg R'
-Alg R B
-Alg R' L'
-
-Alg U B' U
-Alg U' L U
-Alg U' L' U
-Alg U' B U'
-Alg R L R'
-Alg R B' R
-Alg U B L U'
-Alg U B' U B'
-Alg U B' L' U
-Alg U' L B U'
-Alg R' B L' R'
-
-Alg L
-Alg L'
-Alg L B
-Alg L B'
-Alg L B L
-Alg L B L'
-Alg L B' L
-Alg L B' L'
-
-Alg B
-Alg B'
-
-Alg L' B L
-Alg L' B' L
-Alg R' L' B L R
-
-Alg B L' B L B'
-Alg B L' B' L B'
-Alg U L U B U' L' U'
-Alg R L R' B' R L' R'
-Alg U B' R L R' B' U B
-Alg U' B U L U' B' U L'
-Alg L U' B U L' U' B' U
-Alg R B' U R B L U' B
-
-Alg U L U' B' U L' U' B
-Alg U' B L U L B' U' L'
-
-Alg U R' U' L B R' B' R
-Alg R' U' R U B' U' B L`,
-  );
-}

package/src/cubing/search/inside/solve/puzzles/skewb.ts

@@ -1,65 +0,0 @@
-import type { Alg, QuantumMove } from "../../../../alg";
-import type { Transformation } from "../../../../kpuzzle";
-import { mustBeInsideWorker } from "../../inside-worker";
-import type { SGSCachedData } from "../parseSGS";
-import { randomStateFromSGS, TrembleSolver } from "../tremble";
-import {
-  sgsDataSkewbFixedCorner,
-  skewbDefWithoutMOCached,
-} from "./skewb.sgs.json";
-
-const TREMBLE_DEPTH = 3;
-
-let cachedTrembleSolver: Promise<TrembleSolver> | null = null;
-async function getCachedTrembleSolver(): Promise<TrembleSolver> {
-  return (
-    cachedTrembleSolver ||
-    (cachedTrembleSolver = (async (): Promise<TrembleSolver> => {
-      const sgs = await import("./skewb.sgs.json");
-      const json: SGSCachedData = await sgs.sgsDataSkewb();
-      return new TrembleSolver(
-        await sgs.skewbDefWithoutMOCached(),
-        json,
-        "RLUB".split(""),
-      );
-    })())
-  );
-}
-
-export async function preInitializeSkewb(): Promise<void> {
-  await getCachedTrembleSolver();
-}
-
-function resetCenterOrientation(state: Transformation): Transformation {
-  return {
-    CORNERS: state.CORNERS,
-    CENTERS: {
-      permutation: state.CENTERS.permutation,
-      orientation: new Array(6).fill(0),
-    },
-  };
-}
-
-// TODO: fix def consistency.
-export async function solveSkewb(state: Transformation): Promise<Alg> {
-  mustBeInsideWorker();
-  const trembleSolver = await getCachedTrembleSolver();
-  const alg = await trembleSolver.solve(
-    resetCenterOrientation(state),
-    TREMBLE_DEPTH,
-    (quantumMove: QuantumMove) => (quantumMove.family === "y" ? 4 : 3), // TODO: Attach quantum move order lookup to puzzle.
-  );
-  return alg;
-}
-
-export async function randomSkewbFixedCornerState(): Promise<Transformation> {
-  // Note: this sets all center orientations to 0.
-  return randomStateFromSGS(
-    await skewbDefWithoutMOCached(),
-    await sgsDataSkewbFixedCorner(),
-  );
-}
-
-export async function randomSkewbFixedCornerScramble(): Promise<Alg> {
-  return solveSkewb(await randomSkewbFixedCornerState());
-}

package/src/cubing/search/inside/solve/puzzles/sq1.ts

@@ -1,6 +0,0 @@
-import { Alg } from "../../../../alg";
-import { getRandomSquare1ScrambleString } from "../vendor/sq12phase/scramble_sq1";
-
-export async function getRandomSquare1Scramble(): Promise<Alg> {
-  return Alg.fromString(await getRandomSquare1ScrambleString());
-}

package/src/cubing/search/inside/solve/puzzles/wca-minx.ts

@@ -1,32 +0,0 @@
-import { randomUIntBelowFactory } from "../vendor/random-uint-below";
-
-const randomUIntBelowPromise = randomUIntBelowFactory();
-
-const suffixes = ["++", "--"];
-
-export async function randomMegaminxScrambleString(): Promise<string> {
-  const randomUIntBelow = await randomUIntBelowPromise;
-
-  function rdPair(): string {
-    return `R${suffixes[randomUIntBelow(2)]} D${suffixes[randomUIntBelow(2)]}`;
-  }
-
-  function randomU(): string {
-    return `U${["", "'"][randomUIntBelow(2)]}`;
-  }
-
-  function row(): string {
-    const chunks = [];
-    for (let i = 0; i < 5; i++) {
-      chunks.push(rdPair());
-    }
-    chunks.push(randomU());
-    return chunks.join(" ");
-  }
-
-  const chunks = [];
-  for (let i = 0; i < 6; i++) {
-    chunks.push(row());
-  }
-  return chunks.join("\n");
-}

package/src/cubing/search/inside/solve/tremble.ts

@@ -1,212 +0,0 @@
-import { Alg, AlgBuilder, Move, QuantumMove } from "../../../alg";
-import {
-  areStatesEquivalent,
-  combineTransformations,
-  identityTransformation,
-  invertTransformation,
-  KPuzzle,
-  KPuzzleDefinition,
-  Transformation,
-} from "../../../kpuzzle";
-import { countMoves } from "../../../notation";
-import type { SGSAction, SGSCachedData } from "./parseSGS";
-import { randomChoiceFactory } from "./vendor/random-uint-below";
-
-const DEFAULT_STAGE1_DEPTH_LIMIT = 2; // Moderately performant default.
-
-const DOUBLECHECK_PLACED_PIECES = true;
-const DEBUG = false;
-
-// TODO: Take moves instead of move names?
-function calculateMoves(
-  def: KPuzzleDefinition,
-  moveNames: string[],
-): {
-  move: Move;
-  transformation: Transformation;
-}[] {
-  const searchMoves: {
-    move: Move;
-    transformation: Transformation;
-  }[] = [];
-  // const identity = identityTransformation(def); // TODO
-  const kpuzzle = new KPuzzle(def);
-  // TODO: Make it easy to filter moves.
-  moveNames.forEach(function (moveName) {
-    const rootMove = new Move(moveName);
-    if (rootMove.amount !== 1) {
-      throw new Error(
-        "SGS cannot handle def moves with an amount other than 1 yet.",
-      );
-    }
-    kpuzzle.reset();
-    // eslint-disable-next-line no-constant-condition
-    for (let i = 1; true; i++) {
-      kpuzzle.applyMove(rootMove);
-      // console.log(kpuzzle.state, identityTransformation(def));
-      if (
-        // TODO: Use cached identity.
-        areStatesEquivalent(def, kpuzzle.state, identityTransformation(def))
-      ) {
-        break;
-      }
-      searchMoves.push({
-        move: rootMove.modified({ amount: i }),
-        transformation: kpuzzle.state, // TODO: make this safe through the KPuzzle API
-      });
-    }
-  });
-  return searchMoves;
-}
-
-// function badRandomMoves(moves: string[], ksp: KSolvePuzzle): KSolvePuzzleState {
-//   // var sum = 0;
-//   var scramble = "";
-//   for (var i = 0; i < 1000; i++) {
-//     scramble = scramble + " " + moves[Math.floor(moves.length * Math.random())];
-//   }
-//   // var sol = "";
-//   const indexer = new TreeAlgIndexer(ksp, Alg.fromString(scramble));
-//   return indexer.transformAtIndex(indexer.numMoves()) as any; // TODO
-// }
-
-export class TrembleSolver {
-  private searchMoves: {
-    move: Move;
-    transformation: Transformation;
-  }[];
-
-  constructor(
-    private def: KPuzzleDefinition,
-    private sgs: SGSCachedData,
-    trembleMoveNames?: string[],
-  ) {
-    this.searchMoves = calculateMoves(
-      this.def,
-      trembleMoveNames ?? Object.keys(this.def.moves),
-    );
-  }
-
-  // public badRandomMoves(): KSolvePuzzleState {
-  //   return badRandomMoves(this.moves, this.ksp);
-  // }
-
-  public async solve(
-    state: Transformation,
-    stage1DepthLimit: number = DEFAULT_STAGE1_DEPTH_LIMIT,
-    quantumMoveOrder?: (quantumMove: QuantumMove) => number,
-  ): Promise<Alg> {
-    let bestAlg: Alg | null = null;
-    let bestLen = 1000000;
-    const recur = (
-      recursiveState: Transformation,
-      togo: number,
-      sofar: Alg,
-    ) => {
-      // console.log("recur");
-      if (togo === 0) {
-        const sgsAlg = this.sgsPhaseSolve(recursiveState, bestLen);
-        if (!sgsAlg) {
-          return;
-        }
-        // console.log("sgs done!", sofar.toString(), "|", sgsAlg.toString());
-        const newAlg = sofar
-          .concat(sgsAlg)
-          .simplify({ collapseMoves: true, quantumMoveOrder });
-
-        const len = countMoves(newAlg);
-        if (bestAlg === null || len < bestLen) {
-          if (DEBUG) {
-            console.log(`New best (${len} moves): ${newAlg.toString()}`);
-            console.log(`Tremble moves are: ${sofar.toString()}`);
-          }
-          bestAlg = newAlg;
-          bestLen = len;
-        }
-        return;
-      }
-      for (const searchMove of this.searchMoves) {
-        recur(
-          combineTransformations(
-            this.def,
-            recursiveState,
-            searchMove.transformation,
-          ),
-          togo - 1,
-          sofar.concat([searchMove.move]),
-        );
-      }
-    };
-    for (let d = 0; d <= stage1DepthLimit; d++) {
-      recur(state, d, new Alg());
-    }
-    if (bestAlg === null) {
-      throw new Error("SGS search failed.");
-    }
-    return bestAlg;
-  }
-
-  private sgsPhaseSolve(
-    initialState: Transformation,
-    bestLenSofar: number,
-  ): Alg | null {
-    // const pieceNames = "UFR URB UBL ULF DRF DFL DLB DBR".split(" ");
-
-    // function loggo(s: string) {
-    //   // console.warn(s);
-    //   // document.body.appendChild(document.createElement("div")).textContent = s;
-    // }
-
-    // console.log("sgsPhaseSolve");
-    const algBuilder = new AlgBuilder();
-    let state = initialState;
-    for (const step of this.sgs.ordering) {
-      const cubieSeq = step.pieceOrdering;
-      let key = "";
-      const inverseState = invertTransformation(this.def, state);
-      for (let i = 0; i < cubieSeq.length; i++) {
-        const loc = cubieSeq[i];
-        const orbitName = loc.orbitName;
-        const idx = loc.permutationIdx;
-        key += ` ${inverseState[orbitName].permutation[idx]} ${inverseState[orbitName].orientation[idx]}`;
-      }
-      const info = step.lookup[key];
-      if (!info) {
-        throw new Error("Missing algorithm in sgs or esgs?");
-      }
-      algBuilder.experimentalPushAlg(info.alg);
-      if (algBuilder.experimentalNumUnits() >= bestLenSofar) {
-        return null;
-      }
-      state = combineTransformations(this.def, state, info.transformation);
-      if (DOUBLECHECK_PLACED_PIECES) {
-        for (let i = 0; i < cubieSeq.length; i++) {
-          const location = cubieSeq[i];
-          const orbitName = location.orbitName;
-          const idx = location.permutationIdx;
-          if (
-            state[orbitName].permutation[idx] !== idx ||
-            state[orbitName].orientation[idx] !== 0
-          ) {
-            throw new Error("bad SGS :-(");
-          }
-        }
-      }
-    }
-    return algBuilder.toAlg();
-  }
-}
-
-export async function randomStateFromSGS(
-  def: KPuzzleDefinition,
-  sgs: SGSCachedData,
-): Promise<Transformation> {
-  const randomChoice = await randomChoiceFactory<SGSAction>(); // TODO: make this sync by putting the factory into a TLA
-
-  let state = identityTransformation(def);
-  for (const step of sgs.ordering) {
-    const sgsAction = randomChoice(Object.values(step.lookup));
-    state = combineTransformations(def, state, sgsAction.transformation);
-  }
-  return state;
-}