@johnmorrisdotca/kazu 1.2.0 → 1.3.0

package/dist/fillominoSolve.js

@@ -1,5 +1,7 @@
 import { FILLOMINO_MOST_NODES } from "./fillomino.constants.js";
-import { fillominoNeighbours, isFillominoBoard } from "./fillominoBoard.js";
+import { isFillominoBoard } from "./fillominoBoard.js";
+import { fillominoModel } from "./fillominoLogic.js";
+import { decide, openSlots, solveCsp } from "./csp.js";
 /** Counts completed partitions. `complete` is false when a bound, including the answer limit, stops search. */
 export function solveFillomino(board, entries = board.givens, options = {}) {
     if (!isFillominoBoard(board))
@@ -21,91 +23,16 @@ export function solveFillomino(board, entries = board.givens, options = {}) {
     });
     if (fixed.some(value => value < 0))
         return { count: 0, solution: null, complete: true, nodes: 0 };
-    const resolved = Array(entries.length).fill(0);
-    const state = { nodes: 0, stopped: false };
-    let count = 0;
-    let solution = null;
-    const visit = () => {
-        if (++state.nodes > budget) {
-            state.stopped = true;
-            return;
-        }
-        let anchor = -1;
-        for (let cell = 0; cell < resolved.length; cell += 1) {
-            if (resolved[cell] === 0) {
-                anchor = cell;
-                break;
-            }
-        }
-        if (anchor < 0) {
-            count += 1;
-            solution ?? (solution = [...resolved]);
-            if (count >= limit)
-                state.stopped = true;
-            return;
-        }
-        const choices = fixed[anchor] ? [fixed[anchor]] : Array.from({ length: entries.length }, (_, index) => index + 1);
-        for (const value of choices) {
-            const shapes = regionShapes(board, anchor, value, resolved, fixed, state, budget);
-            if (state.stopped)
-                return;
-            for (const shape of shapes) {
-                for (const cell of shape)
-                    resolved[cell] = value;
-                visit();
-                for (const cell of shape)
-                    resolved[cell] = 0;
-                if (state.stopped)
-                    return;
-            }
-        }
-    };
-    visit();
-    const complete = !state.stopped;
-    return { count, solution, complete, nodes: Math.min(state.nodes, budget) };
-}
-function regionShapes(board, anchor, area, resolved, fixed, state, budget) {
-    if (fixed[anchor] !== 0 && fixed[anchor] !== area)
-        return [];
-    const shapes = [];
-    const seen = new Set();
-    const grow = (cells) => {
-        if (state.stopped)
-            return;
-        if (++state.nodes > budget) {
-            state.stopped = true;
-            return;
-        }
-        const key = [...cells].sort((a, b) => a - b).join(",");
-        if (seen.has(key))
-            return;
-        seen.add(key);
-        if (cells.length === area) {
-            const members = new Set(cells);
-            for (const cell of cells) {
-                for (const next of fillominoNeighbours(board, cell)) {
-                    if (members.has(next))
-                        continue;
-                    if (resolved[next] === area || fixed[next] === area)
-                        return;
-                }
-            }
-            shapes.push([...cells]);
-            return;
-        }
-        const frontier = new Set();
-        for (const cell of cells) {
-            for (const next of fillominoNeighbours(board, cell)) {
-                if (cells.includes(next) || resolved[next] !== 0)
-                    continue;
-                if (fixed[next] !== 0 && fixed[next] !== area)
-                    continue;
-                frontier.add(next);
-            }
-        }
-        for (const next of frontier)
-            grow([...cells, next]);
-    };
-    grow([anchor]);
-    return shapes;
+    const { csp, most } = fillominoModel(board, fixed);
+    const start = openSlots(csp);
+    fixed.forEach((value, cell) => { if (value)
+        decide(csp, start, cell, cell * most + value - 1); });
+    const found = solveCsp(csp, start, limit, budget);
+    const solution = found.solution ? Array.from({ length: fixed.length }, (_, cell) => {
+        for (let v = 0; v < most; v += 1)
+            if (found.solution[cell * most + v])
+                return v + 1;
+        return 0;
+    }) : null;
+    return { count: found.count, solution, complete: !found.exhausted && !found.stopped, nodes: found.nodes };
 }

package/dist/hitori-entry.d.ts

@@ -3,4 +3,5 @@ export * from "./hitori.constants.ts";
 export * from "./hitoriBoard.ts";
 export * from "./hitoriSolve.ts";
 export * from "./hitoriGenerate.ts";
+export * from "./hitoriRate.ts";
 export * from "./hitoriGame.ts";

package/dist/hitori-entry.js

@@ -3,4 +3,5 @@ export * from "./hitori.constants.js";
 export * from "./hitoriBoard.js";
 export * from "./hitoriSolve.js";
 export * from "./hitoriGenerate.js";
+export * from "./hitoriRate.js";
 export * from "./hitoriGame.js";

package/dist/hitori.constants.d.ts

@@ -1,2 +1,8 @@
 export declare const HITORI_MAX_NODES = 300000;
-export declare const HITORI_SIZES: readonly [5, 7];
+/** The sides on offer; any side from 4 to `HITORI_MOST_SIDE` is a board `isHitoriBoard` takes. */
+export declare const HITORI_SIZES: readonly [5, 6, 7, 8, 9, 10, 12];
+export declare const HITORI_MOST_SIDE = 12;
+export declare const HITORI_LEAST_SIDE = 4;
+/** How hard a puzzle is made, by what a person must do to solve it; see `rateHitori`. */
+export declare const HITORI_LEVELS: readonly ["easy", "medium", "hard", "extra-hard"];
+export declare const HITORI_MOST_ATTEMPTS = 600;

package/dist/hitori.constants.js

@@ -1,2 +1,8 @@
 export const HITORI_MAX_NODES = 300000;
-export const HITORI_SIZES = [5, 7];
+/** The sides on offer; any side from 4 to `HITORI_MOST_SIDE` is a board `isHitoriBoard` takes. */
+export const HITORI_SIZES = [5, 6, 7, 8, 9, 10, 12];
+export const HITORI_MOST_SIDE = 12;
+export const HITORI_LEAST_SIDE = 4;
+/** How hard a puzzle is made, by what a person must do to solve it; see `rateHitori`. */
+export const HITORI_LEVELS = ["easy", "medium", "hard", "extra-hard"];
+export const HITORI_MOST_ATTEMPTS = 600;

package/dist/hitori.types.d.ts

@@ -1,11 +1,28 @@
 export type HitoriBoard = {
-    size: 5 | 7;
+    size: number;
     numbers: readonly number[];
 };
+export type HitoriLevel = "easy" | "medium" | "hard" | "extra-hard";
 export type HitoriPuzzle = HitoriBoard & {
     seed: number;
+    level: HitoriLevel;
     solution: readonly boolean[];
 };
+/**
+ * How hard a board is, measured by solving it. `depth` 0 means the rules solve it, 1 that somebody has to suppose a
+ * square shaded or white and watch it break, 2 that more than that is needed. `reach` says the rule that the white
+ * squares stay in one piece was needed at depth 0. `probes` is the suppositions depth 1 needed.
+ */
+export type HitoriRating = {
+    depth: 0 | 1 | 2;
+    reach: boolean;
+    probes: number;
+    shaded: number;
+    /** Shaded squares as a share of the board. */
+    shadedShare: number;
+    /** Squares whose number repeats in their row or column, as a share of the board. */
+    repeatShare: number;
+};
 export type HitoriSolve = {
     count: number;
     solution: readonly boolean[] | null;

package/dist/hitoriBoard.js

@@ -1,5 +1,6 @@
+import { HITORI_LEAST_SIDE, HITORI_MOST_SIDE } from "./hitori.constants.js";
 export function isHitoriBoard(board) {
-    return !!board && (board.size === 5 || board.size === 7)
+    return !!board && Number.isInteger(board.size) && board.size >= HITORI_LEAST_SIDE && board.size <= HITORI_MOST_SIDE
         && Array.isArray(board.numbers)
         && board.numbers.length === board.size * board.size
         && board.numbers.every(value => Number.isInteger(value) && value >= 1 && value <= board.size);

package/dist/hitoriBuild.d.ts

@@ -0,0 +1,12 @@
+import type { HitoriBoard, HitoriLevel } from "./hitori.types.ts";
+import type { Random } from "./random.ts";
+export declare const SHARE: Record<HitoriLevel, number>;
+/** A board with one answer, or null when the random choices did not lead to one. How the numbers are chosen leans on the level. */
+export declare function candidateHitori(size: number, level: HitoriLevel, random: Random, base?: readonly number[]): {
+    board: HitoriBoard;
+    shaded: readonly boolean[];
+} | null;
+/** A random Latin square: every number once in each row and column, built row by row with backtracking. */
+export declare function latinSquare(size: number, random: Random): number[] | null;
+/** The same square with its rows, columns and numbers renamed at random: still one of each in every line. */
+export declare function isotope(square: readonly number[], size: number, random: Random): number[];

package/dist/hitoriBuild.js

@@ -0,0 +1,117 @@
+import { hitoriNeighbors } from "./hitoriBoard.js";
+import { hitoriModel } from "./hitoriLogic.js";
+import { countCsp, openSlots } from "./csp.js";
+import { shuffled } from "./random.js";
+export const SHARE = { easy: .26, medium: .27, hard: .28, "extra-hard": .3 };
+/** A board with one answer, or null when the random choices did not lead to one. How the numbers are chosen leans on the level. */
+export function candidateHitori(size, level, random, base = latinSquare(size, random) ?? []) {
+    const total = size * size;
+    if (base.length !== total)
+        return null;
+    const target = Math.round(total * SHARE[level] * (.9 + random() * .2));
+    const shaded = Array(total).fill(false);
+    let count = 0;
+    const around = Array.from({ length: total }, (_, cell) => hitoriNeighbors(size, cell));
+    const mark = new Int32Array(total), stack = new Int32Array(total);
+    let stamp = 0;
+    const connected = () => {
+        const first = shaded.indexOf(false);
+        stamp += 1;
+        let top = 0, reached = 1;
+        stack[top++] = first;
+        mark[first] = stamp;
+        while (top)
+            for (const next of around[stack[--top]])
+                if (!shaded[next] && mark[next] !== stamp) {
+                    mark[next] = stamp;
+                    reached += 1;
+                    stack[top++] = next;
+                }
+        return reached === total - count;
+    };
+    for (const cell of shuffled(Array.from({ length: total }, (_, i) => i), random)) {
+        if (count >= target)
+            break;
+        if (around[cell].some(next => shaded[next]))
+            continue;
+        shaded[cell] = true;
+        count += 1;
+        if (!connected()) {
+            shaded[cell] = false;
+            count -= 1;
+        }
+    }
+    if (count < Math.max(2, target - 2))
+        return null;
+    const numbers = isotope(base, size, random).map((n, cell) => shaded[cell] ? 0 : n);
+    const partnersOf = (cell) => {
+        const x = cell % size, y = Math.floor(cell / size), found = [];
+        for (let k = 0; k < size; k += 1) {
+            if (k !== x && !shaded[y * size + k])
+                found.push(y * size + k);
+            if (k !== y && !shaded[k * size + x])
+                found.push(k * size + x);
+        }
+        return found;
+    };
+    const blacks = shaded.flatMap((on, cell) => on ? [cell] : []);
+    for (const cell of blacks) {
+        const options = partnersOf(cell);
+        if (!options.length)
+            return null;
+        numbers[cell] = numbers[options[Math.floor(random() * options.length)]];
+    }
+    const board = { size, numbers };
+    const { csp } = hitoriModel(board, 2);
+    let proof = countCsp(csp, openSlots(csp), 2, 20000);
+    for (let repair = 0; repair < 60 && proof.count > 1 && !proof.exhausted; repair += 1) {
+        const other = proof.solutions[1].slice(), mine = (alive, cell) => alive[2 * cell + 1] === 1;
+        const candidates = shuffled(blacks.filter(cell => !mine(other, cell)), random);
+        let changed = false;
+        for (const cell of candidates) {
+            const keepers = partnersOf(cell).filter(p => !mine(other, p));
+            if (!keepers.length)
+                continue;
+            numbers[cell] = numbers[keepers[Math.floor(random() * keepers.length)]];
+            changed = true;
+            break;
+        }
+        if (!changed)
+            return null;
+        proof = countCsp(csp, openSlots(csp), 2, 20000);
+    }
+    if (proof.count !== 1 || proof.exhausted)
+        return null;
+    return { board, shaded };
+}
+/** A random Latin square: every number once in each row and column, built row by row with backtracking. */
+export function latinSquare(size, random) {
+    const cells = Array(size * size).fill(0);
+    let steps = 0;
+    const fill = (at) => {
+        if (at === cells.length)
+            return true;
+        if (++steps > 20000)
+            return false;
+        const x = at % size, y = Math.floor(at / size);
+        const used = new Set();
+        for (let k = 0; k < x; k += 1)
+            used.add(cells[y * size + k]);
+        for (let k = 0; k < y; k += 1)
+            used.add(cells[k * size + x]);
+        for (const n of shuffled(Array.from({ length: size }, (_, i) => i + 1).filter(i => !used.has(i)), random)) {
+            cells[at] = n;
+            if (fill(at + 1))
+                return true;
+        }
+        cells[at] = 0;
+        return false;
+    };
+    return fill(0) ? cells : null;
+}
+/** The same square with its rows, columns and numbers renamed at random: still one of each in every line. */
+export function isotope(square, size, random) {
+    const rows = shuffled(Array.from({ length: size }, (_, i) => i), random), cols = shuffled(Array.from({ length: size }, (_, i) => i), random);
+    const names = shuffled(Array.from({ length: size }, (_, i) => i + 1), random);
+    return Array.from({ length: size * size }, (_, cell) => names[square[rows[Math.floor(cell / size)] * size + cols[cell % size]] - 1]);
+}

package/dist/hitoriGenerate.d.ts

@@ -1,3 +1,10 @@
-import type { HitoriPuzzle } from "./hitori.types.ts";
-/** Seeded number relabelings and board symmetries of original layouts, accepted only after a uniqueness proof. */
-export declare function generateHitori(size?: 5 | 7, seed?: number): HitoriPuzzle;
+import type { HitoriLevel, HitoriPuzzle } from "./hitori.types.ts";
+/**
+ * Makes a seeded puzzle and proves its answer is the only one. The shaded squares are chosen first (never touching,
+ * the rest in one piece), the white squares get numbers that repeat nowhere in their row or column, and every shaded
+ * square takes a number that a white square in its row or column already has. Boards with more than one answer are
+ * repaired by renumbering a shaded square so that the other answer repeats a number, and the result is rated:
+ * easy by the plain rules, medium once the whites must stay in one piece, hard by supposing, and extra-hard the
+ * most-supposing of several boards.
+ */
+export declare function generateHitori(size?: number, seed?: number, level?: HitoriLevel): HitoriPuzzle;

package/dist/hitoriGenerate.js

@@ -1,163 +1,65 @@
-import { HITORI_MAX_NODES, HITORI_SIZES } from "./hitori.constants.js";
+import { HITORI_LEAST_SIDE, HITORI_LEVELS, HITORI_MOST_ATTEMPTS, HITORI_MOST_SIDE } from "./hitori.constants.js";
 import { checkHitori } from "./hitoriBoard.js";
+import { candidateHitori, latinSquare } from "./hitoriBuild.js";
+import { hitoriModel } from "./hitoriLogic.js";
 import { solveHitori } from "./hitoriSolve.js";
-import { isKazuSeed, seededRandom, shuffled } from "./random.js";
-const layouts = {
-    5: [
-        {
-            numbers: [
-                1, 3, 3, 1, 5, 2, 3,
-                4, 5, 1, 3, 4, 5, 1,
-                2, 4, 5, 1, 2, 3, 5,
-                1, 2, 3, 4,
-            ],
-            shade: [
-                false, true, false, true, false, ...Array(20).fill(false),
-            ],
-        },
-        {
-            numbers: [
-                1, 2, 3, 4, 5, 2, 3,
-                4, 1, 1, 3, 4, 5, 1,
-                2, 3, 5, 1, 4, 3, 5,
-                1, 2, 3, 4,
-            ],
-            shade: [
-                false, false, false, false, false, false, false,
-                false, true, false, false, false, false, false,
-                false, true, false, false, true, false, false,
-                false, false, false, false,
-            ],
-        },
-        {
-            numbers: [
-                1, 4, 3, 4, 1, 2, 3,
-                4, 5, 1, 3, 4, 5, 1,
-                2, 4, 5, 1, 2, 3, 5,
-                1, 2, 3, 4,
-            ],
-            shade: [
-                false, true, false, false, true, false, false,
-                false, false, false, false, false, false, false,
-                false, false, false, false, false, false, false,
-                false, false, false, false,
-            ],
-        },
-        {
-            numbers: [
-                1, 4, 3, 4, 5, 2, 3,
-                2, 5, 1, 2, 4, 5, 1,
-                2, 4, 5, 1, 2, 3, 5,
-                5, 2, 3, 4,
-            ],
-            shade: [
-                false, true, false, false, false, false, false,
-                true, false, false, true, false, false, false,
-                false, false, false, false, false, false, false,
-                true, false, false, false,
-            ],
-        },
-    ],
-    7: [
-        {
-            numbers: [
-                1, 2, 3, 4, 2, 6, 7,
-                2, 6, 4, 5, 6, 7, 1,
-                3, 4, 5, 6, 1, 1, 1,
-                4, 5, 6, 7, 1, 2, 3,
-                5, 6, 7, 1, 2, 3, 4,
-                6, 7, 1, 2, 3, 4, 5,
-                7, 1, 2, 3, 4, 5, 6,
-            ],
-            shade: [
-                false, false, false, false, true, false, false,
-                false, true, false, false, false, false, false,
-                false, false, false, false, true, false, true,
-                ...Array(28).fill(false),
-            ],
-        },
-        {
-            numbers: [
-                1, 2, 4, 4, 5, 7, 7,
-                2, 3, 4, 5, 5, 7, 1,
-                3, 4, 5, 6, 7, 1, 2,
-                4, 5, 6, 7, 1, 2, 7,
-                5, 6, 7, 1, 2, 3, 4,
-                6, 2, 1, 2, 3, 4, 5,
-                7, 1, 2, 3, 7, 5, 6,
-            ],
-            shade: [
-                false, false, true, false, false, true, false,
-                false, false, false, false, true, false, false,
-                false, false, false, false, false, false, false,
-                false, false, false, false, false, false, true,
-                false, false, false, false, false, false, false,
-                false, true, false, false, false, false, false,
-                false, false, false, false, true, false, false,
-            ],
-        },
-        {
-            numbers: [
-                1, 2, 3, 4, 5, 6, 7,
-                2, 3, 4, 5, 6, 7, 1,
-                3, 4, 5, 6, 1, 1, 6,
-                4, 6, 6, 6, 1, 2, 3,
-                5, 6, 7, 1, 2, 3, 4,
-                6, 7, 1, 2, 3, 4, 5,
-                7, 1, 2, 3, 4, 5, 6,
-            ],
-            shade: [
-                false, false, false, false, false, false, false,
-                false, false, false, false, false, false, false,
-                false, false, false, false, true, false, true,
-                false, true, false, true, false, false, false,
-                false, false, false, false, false, false, false,
-                false, ...Array(13).fill(false),
-            ],
-        },
-        {
-            numbers: [
-                1, 2, 3, 4, 6, 6, 7,
-                2, 2, 4, 5, 6, 2, 1,
-                3, 4, 5, 6, 7, 1, 2,
-                4, 5, 6, 7, 1, 2, 3,
-                5, 6, 7, 1, 2, 3, 4,
-                6, 7, 1, 2, 3, 4, 5,
-                7, 1, 2, 3, 6, 5, 6,
-            ],
-            shade: [
-                false, false, false, false, true, false, false,
-                false, true, false, false, false, true, false,
-                false, false, false, false, false, false, false,
-                false, false, false, false, false, false, false,
-                false, false, false, false, false, false, false,
-                false, false, false, false, false, false, false,
-                false, false, false, false, true, false, false,
-            ],
-        },
-    ],
-};
-/** Seeded number relabelings and board symmetries of original layouts, accepted only after a uniqueness proof. */
-export function generateHitori(size = 5, seed = 1) {
-    if (!HITORI_SIZES.includes(size) || !isKazuSeed(seed))
+import { logicCsp, openSlots } from "./csp.js";
+import { isKazuSeed, seededRandom } from "./random.js";
+/**
+ * Makes a seeded puzzle and proves its answer is the only one. The shaded squares are chosen first (never touching,
+ * the rest in one piece), the white squares get numbers that repeat nowhere in their row or column, and every shaded
+ * square takes a number that a white square in its row or column already has. Boards with more than one answer are
+ * repaired by renumbering a shaded square so that the other answer repeats a number, and the result is rated:
+ * easy by the plain rules, medium once the whites must stay in one piece, hard by supposing, and extra-hard the
+ * most-supposing of several boards.
+ */
+export function generateHitori(size = 5, seed = 1, level = "medium") {
+    if (!Number.isInteger(size) || size < HITORI_LEAST_SIDE || size > HITORI_MOST_SIDE || !isKazuSeed(seed) || !HITORI_LEVELS.includes(level)) {
         throw new RangeError("Invalid Hitori settings");
-    const random = seededRandom(seed), templates = layouts[size];
-    const template = templates[Math.floor(random() * templates.length)];
-    const labels = shuffled(Array.from({ length: size }, (_, index) => index + 1), random);
-    const turns = Math.floor(random() * 4), reflected = random() < 0.5;
-    const numbers = Array(size * size), solution = Array(size * size);
-    for (let y = 0; y < size; y += 1)
-        for (let x = 0; x < size; x += 1) {
-            let tx = reflected ? size - 1 - x : x, ty = y;
-            for (let turn = 0; turn < turns; turn += 1)
-                [tx, ty] = [size - 1 - ty, tx];
-            const source = y * size + x, destination = ty * size + tx;
-            numbers[destination] = labels[template.numbers[source] - 1];
-            solution[destination] = template.shade[source];
+    }
+    const random = seededRandom(seed);
+    const base = latinSquare(size, random);
+    if (!base)
+        throw new Error("No Hitori found within the generation budget; try another seed");
+    for (let aim = HITORI_LEVELS.indexOf(level); aim >= 0; aim -= 1) {
+        const aimed = HITORI_LEVELS[aim];
+        const wanted = aimed === "extra-hard" ? 4 : 1;
+        let best = null, found = 0;
+        for (let attempt = 0; attempt < HITORI_MOST_ATTEMPTS && found < wanted; attempt += 1) {
+            const built = candidateHitori(size, aimed, random, base);
+            const made = built && rated(built.board, built.shaded, aimed);
+            if (!made)
+                continue;
+            found += 1;
+            if (!best || made.score > best.score)
+                best = made;
+        }
+        if (best) {
+            const proof = solveHitori(best.board);
+            if (proof.complete && proof.count === 1 && proof.solution && checkHitori(best.board, proof.solution).ok) {
+                return { ...best.board, seed, level, solution: proof.solution };
+            }
         }
-    const board = { size, numbers }, proof = solveHitori(board, { nodes: HITORI_MAX_NODES });
-    if (!checkHitori(board, solution).ok || !proof.complete || proof.count !== 1 || !proof.solution) {
-        throw new Error("No uniquely solvable Hitori found within the generation budget; try another seed");
     }
-    return { ...board, seed, solution: proof.solution };
+    throw new Error("No uniquely solvable Hitori found within the generation budget; try another seed");
+}
+function rated(board, shaded, level) {
+    const total = board.size * board.size;
+    const solved = (strength, depth) => {
+        const { csp } = hitoriModel(board, strength);
+        const run = logicCsp(csp, openSlots(csp), depth);
+        return run.solved && checkHitori(board, Array.from({ length: total }, (_, cell) => run.alive[2 * cell + 1] === 1)).ok ? run : null;
+    };
+    if (level === "easy")
+        return solved(0, 0) ? { board, shaded, score: 0 } : null;
+    if (solved(0, 0))
+        return null;
+    if (level === "medium")
+        return solved(2, 0) ? { board, shaded, score: 0 } : null;
+    if (solved(2, 0))
+        return null;
+    const probing = solved(2, 1);
+    if (!probing)
+        return level === "extra-hard" ? { board, shaded, score: 1000 } : null;
+    return { board, shaded, score: probing.probes };
 }

package/dist/hitoriLogic.d.ts

@@ -0,0 +1,12 @@
+import type { Csp } from "./csp.ts";
+import type { HitoriBoard } from "./hitori.types.ts";
+/**
+ * Hitori as variables: one per square, slot 0 for left white and slot 1 for shaded.
+ * `strength` is how much of the rules the pruning uses: 0 has the duplicates, the ban on touching shades, the
+ * pair and the sandwich; 1 adds that every white square must stay in reach of the others; 2 adds that a square
+ * whose shading would cut the whites in two must stay white. A finished answer must be one piece, which the
+ * search checks whatever the strength.
+ */
+export declare function hitoriModel(board: HitoriBoard, strength?: 0 | 1 | 2): {
+    csp: Csp;
+};