@johnmorrisdotca/kazu 1.3.0 → 1.4.0

package/CHANGELOG.md

@@ -6,6 +6,17 @@ All notable changes to this project are written here. The format follows
 
 ## [Unreleased]
 
+## [1.4.0] - 2026-10-05
+
+### Added
+
+- **A 25×25 Sudoku, the Colossus.** `number-place` takes a side of 25 (`KAZU_SPECS["number-place"].sizes` is now 4, 6, 9, 16, 25; boxes of 5×5; `mostCells` 625) at `easy`, `medium` and `hard`, every puzzle with exactly one answer. Its symbols go on from the 16×16's: 1 to 9, then A to P for 10 to 25 (`symbolOf`, `valueOfSymbol`, `decodeCells` and the run and note codes read A to P). Easy yields to singles alone (366 numbers printed), medium to one guess (305), hard to two nested guesses (283). The player's pad has 25 keys and the eraser in three rows, and the keyboard types the letters up to P; because N is the number 23 there, Pencil moves to the slash key on this size (`keysColossus` says so in English and Japanese). Made in a browser's time, over seeds 1 to 50 on a Mac: easy a median 13 ms (slowest 30), medium 81 ms (161), hard 308 ms (590). Hard is the one a phone may take a few seconds over, so a page that deals one for a person should do it in a worker, as the demo's slower generators do.
+- A 25×25 is made and checked by proof, not by counting every answer: `provedByGuessing(grid, layout, guesses)` is what a person's reasoning proves (singles, then guesses at the most constrained cell, each shown wrong or finished by singles), and `countKazuSolutions`, `solveKazu` and `kazuGuessDepth` use singles inside the search from the 25×25 up, which takes a medium or hard 25×25 from minutes to a few milliseconds. Every smaller size is searched exactly as before.
+
+### Fixed
+
+- **Akari never returns the old fixed lattice.** When a level found no random board within its 60 attempts, 1.3.0 returned the fixed rooms of 1.2.0 without saying so: 74% black squares and five full black rows at 14×14, which was about 45% of 14×14 easy seeds (and 17% of 12×12, 35% of 13×13, 65% of 15×15 and 83% of 16×16 easy seeds, and some medium ones at 13×13 and larger). The generator now tries again with more black squares (1.5, 1.8, 2.1 and 2.4 times the usual share, thirty attempts each), which a large board needs to be solvable by its numbers. Every seed that made a random board in 1.3.0 makes the identical one (`src/levels.pins.test.js`, and a comparison over 12×12 to 16×16 at every level); only the seeds that used to return the lattice make a different board, and they make a random one. `src/akariLattice.test.ts` asserts, over every size from 3 to 16 and every level, that no seed returns the lattice, and that the black share and the boards vary. Generation time is unchanged where it was already random (14×14 extra-hard: median 212 ms, slowest 362 ms) and the old lattice cases take a median of 9 ms at 14×14 easy.
+
 ## [1.3.0] - 2026-10-05
 
 ### Added

package/README.md

@@ -1,7 +1,7 @@
 <h1 align="center">Kazu <sub>数</sub></h1>
 
 <p align="center"><strong>Grid number and logic puzzles for JavaScript and TypeScript.</strong><br>
-Sudoku (4×4 to a 16×16 Giant), Jigsaw, Diagonal and Killer Sudoku, Futoshiki, Skyscrapers, Shikaku, Hitori, Nurikabe, Akari, Juosan, Slitherlink, Masyu, Yajilin, Ripple Effect, Kakuro, Fillomino and Heyawake. Dedicated typed engines, independently checked puzzles, SVG drawing, saved progress, and English and Japanese players for touch, mouse and keyboard. No runtime dependencies.</p>
+Sudoku (4×4 to a 25×25 Colossus), Jigsaw, Diagonal and Killer Sudoku, Futoshiki, Skyscrapers, Shikaku, Hitori, Nurikabe, Akari, Juosan, Slitherlink, Masyu, Yajilin, Ripple Effect, Kakuro, Fillomino and Heyawake. Dedicated typed engines, independently checked puzzles, SVG drawing, saved progress, and English and Japanese players for touch, mouse and keyboard. No runtime dependencies.</p>
 
 <p align="center">
   <a href="https://github.com/johnmorrisdotca/kazu/actions/workflows/ci.yml"><img alt="CI" src="https://github.com/johnmorrisdotca/kazu/actions/workflows/ci.yml/badge.svg"></a>
@@ -60,8 +60,8 @@ And in a page, a puzzle to play, by touch, mouse and keyboard, with nothing else
 
 ## Features
 
-- **Seven puzzles, three levels.** Sudoku (4×4, 6×6, 9×9 and a 16×16 Giant), Jigsaw, Diagonal and Killer Sudoku, Futoshiki and Skyscrapers, each at `easy`, `medium` and `hard`, named by kebab-case keys.
-- **Six number puzzles, three levels.** Sudoku (4×4, 6×6, 9×9 and a 16×16 Giant), Jigsaw, Diagonal and Killer Sudoku, Futoshiki and Skyscrapers, each at `easy`, `medium` and `hard`, named by kebab-case keys. Shikaku and Juosan use dedicated rectangle and territory models.
+- **Seven puzzles, three levels.** Sudoku (4×4, 6×6, 9×9, a 16×16 Giant and a 25×25 Colossus), Jigsaw, Diagonal and Killer Sudoku, Futoshiki and Skyscrapers, each at `easy`, `medium` and `hard`, named by kebab-case keys.
+- **Six number puzzles, three levels.** Sudoku (4×4, 6×6, 9×9, a 16×16 Giant and a 25×25 Colossus), Jigsaw, Diagonal and Killer Sudoku, Futoshiki and Skyscrapers, each at `easy`, `medium` and `hard`, named by kebab-case keys. Shikaku and Juosan use dedicated rectangle and territory models.
 - **Four levels on the grid puzzles.** Shikaku, Akari, Slitherlink, Hitori, Fillomino and Kakuro each make `easy`, `medium`, `hard` and `extra-hard` boards, at three or more sizes each, every one with exactly one answer and rated by what a person must do to solve it: [Levels of the grid puzzles](#levels-of-the-grid-puzzles).
 - **Exactly one answer.** A generator makes puzzles from a seed, and a solver that counts answers confirms there is one. The same kind, size, level and seed make the same puzzle in every browser and every Node, for ever.
 - **A check a server can trust.** `checkKazu` reads a finished grid in O(cells), with no search, and says the first thing wrong in words.
@@ -177,7 +177,7 @@ exactly one answer. Every kind is named by a kebab-case key.
 
 | Key | Called | In Japanese | Sizes | What it prints | What is new |
 | --- | --- | --- | --- | --- | --- |
-| `number-place` | Sudoku | ナンプレ | 4×4, 6×6, 9×9, 16×16 | numbers | every row, column and box holds each number once; the 16×16 Giant uses 1 to 9 and then A to G |
+| `number-place` | Sudoku | ナンプレ | 4×4, 6×6, 9×9, 16×16, 25×25 | numbers | every row, column and box holds each number once; the 16×16 Giant uses 1 to 9 and then A to G, and the 25×25 Colossus goes on to P |
 | `jigsaw` | Jigsaw Sudoku | 変形ナンプレ | 5×5, 6×6, 7×7, 9×9 | numbers, and the regions | the boxes are irregular regions, each joined and none a row or a column |
 | `diagonal` | Diagonal Sudoku | 対角ナンプレ | 6×6, 9×9 | numbers | the two long diagonals hold each number once too |
 | `sum-cages` | Killer Sudoku | サムナンプレ | 6×6, 9×9 | cages and their sums | next to no numbers: dashed cages each add to a sum, and repeat nothing |
@@ -218,7 +218,7 @@ has always used. It restates the rules rather than reading the solver's mind, so
 A solver and a generator never run on a server unless you ask them to.
 
 A run is kept as short strings the site's own stored runs decode as they are: `encodeRun(entries)` and
-`decodeRun(code, size)` (one character a cell, `.` for empty, A to G past nine), `encodeSteps` and
+`decodeRun(code, size)` (one character a cell, `.` for empty, A to P past nine), `encodeSteps` and
 `decodeSteps` for a step log, `kazuHash(givens)` for a fingerprint of a puzzle, and `encodeNotes` and
 `decodeNotes` for Kazu's own pencil marks.
 
@@ -293,8 +293,8 @@ out of the notes of the cells it shares a group with. **Undo** takes the last ch
 cell to fill next and why, **Check** says how many cells are wrong, never which. A clock starts on the first entry
 and stops when the last cell is right, and waits while the page is hidden.
 
-The keys: the arrows move, a number (1 to 9, and A to G on the 16×16) fills the chosen cell, Shift with a
-number writes it as a pencil mark, Backspace empties the cell, N turns Pencil on or off, Ctrl or Cmd with Z
+The keys: the arrows move, a number (1 to 9, then A to G on the 16×16 and on to P on the 25×25) fills the chosen cell, Shift with a
+number writes it as a pencil mark, Backspace empties the cell, N turns Pencil on or off (the slash key on the 25×25, where N is the number 23), Ctrl or Cmd with Z
 undoes, Escape lets the cell go. The board's box keeps one steady square, and the lines of words under it keep
 the room their longest wording takes, so nothing moves as numbers are written or messages come and go. Nothing
 the player touches can be selected. Its words are English and Japanese and follow the page's `lang`.
@@ -417,10 +417,10 @@ All of these are held by tests, and the ones with a name are exported.
 | --- | --- | --- |
 | Puzzles | the six keys of `KAZU_KINDS` | the table under [The puzzles](#the-puzzles) |
 | Levels | `easy`, `medium`, `hard` | `KAZU_LEVELS` |
-| Sizes | each puzzle's own, 4×4 to 16×16 | `KAZU_SPECS[kind].sizes` |
+| Sizes | each puzzle's own, 4×4 to 25×25 | `KAZU_SPECS[kind].sizes` |
 | A seed | a whole number from 1 to 2,147,483,647 | `KAZU_SEED_MOST`, `isKazuSeed` |
-| Symbols in a grid | `1` to `9`, then `A` to `G` for the 16×16 | `symbolOf`, `valueOfSymbol` |
-| The longest givens code | Sudoku 256 characters, Jigsaw 162, Diagonal 81, Killer Sudoku 286, Futoshiki 133, Skyscrapers 77 | `KAZU_SPECS[kind].mostCells`, for a route that must refuse anything larger |
+| Symbols in a grid | `1` to `9`, then `A` to `G` for the 16×16 and on to `P` for the 25×25 | `symbolOf`, `valueOfSymbol` |
+| The longest givens code | Sudoku 625 characters, Jigsaw 162, Diagonal 81, Killer Sudoku 286, Futoshiki 133, Skyscrapers 77 | `KAZU_SPECS[kind].mostCells`, for a route that must refuse anything larger |
 | Answers counted | two, so that "many" costs no more than "two" | the `limit` argument of `countKazuSolutions` |
 | The solver's work | 2,000,000 steps, then it says it cannot say (`null`) | the `budget` argument of `solveKazu` |
 | A step log | the newest 400 steps | `KAZU_STEPS_KEPT` |
@@ -881,7 +881,7 @@ src/
 ├── kinds.ts            the six puzzles' keys, sizes and levels, and the shape of a puzzle
 ├── random.ts           the seeded random numbers every puzzle is made from
 ├── csp.ts              the one small engine under the six grid kinds: counting answers, and reasoning with and without supposing
-├── cells.ts            a grid of numbers as a string, 1 to 9 and A to G
+├── cells.ts            a grid of numbers as a string, 1 to 9 and A to P
 ├── layout.ts           the groups that must each hold every number once: rows, columns, boxes, regions, diagonals, cages
 ├── groupSolve.ts       the solver for puzzles made of groups: counting, singles, depth
 ├── numberPlace.ts      Sudoku and Diagonal Sudoku: the generator and how givens are carved

package/dist/akari.constants.d.ts

@@ -5,3 +5,10 @@ export declare const AKARI_LEVELS: readonly ["easy", "medium", "hard", "extra-ha
 /** The sides the demo and the site offer for a square board; any side from 2 to `AKARI_MOST_SIDE` can be made. */
 export declare const AKARI_SIZES: readonly [5, 7, 10, 14];
 export declare const AKARI_MOST_ATTEMPTS = 60;
+/**
+ * When a level finds no board in `AKARI_MOST_ATTEMPTS` plain attempts (a large board of an easy level, mostly: one attempt in a
+ * hundred succeeds on a 14×14), the generator tries again with more black squares, each of these multiples of the usual share in
+ * turn, `AKARI_DENSER_ATTEMPTS` attempts at each. Black squares are what make a large board solvable by its numbers.
+ */
+export declare const AKARI_DENSER_CROWDS: readonly [1.5, 1.8, 2.1, 2.4];
+export declare const AKARI_DENSER_ATTEMPTS = 30;

package/dist/akari.constants.js

@@ -5,3 +5,10 @@ export const AKARI_LEVELS = ["easy", "medium", "hard", "extra-hard"];
 /** The sides the demo and the site offer for a square board; any side from 2 to `AKARI_MOST_SIDE` can be made. */
 export const AKARI_SIZES = [5, 7, 10, 14];
 export const AKARI_MOST_ATTEMPTS = 60;
+/**
+ * When a level finds no board in `AKARI_MOST_ATTEMPTS` plain attempts (a large board of an easy level, mostly: one attempt in a
+ * hundred succeeds on a 14×14), the generator tries again with more black squares, each of these multiples of the usual share in
+ * turn, `AKARI_DENSER_ATTEMPTS` attempts at each. Black squares are what make a large board solvable by its numbers.
+ */
+export const AKARI_DENSER_CROWDS = [1.5, 1.8, 2.1, 2.4];
+export const AKARI_DENSER_ATTEMPTS = 30;

package/dist/akariGenerate.d.ts

@@ -5,6 +5,8 @@ import type { AkariLevel, AkariPuzzle } from "./akari.types.ts";
  * the puzzle can still be solved the way the level asks: easy and medium by the rules alone (easy keeps most
  * of its numbers), hard by supposing one square at a time, extra-hard for as long as the answer stays single,
  * which leaves a board that needs more supposing than that. If no board of the level is found within the
- * attempts, the next one down is tried, and the first generator, which cannot fail, is the last.
+ * attempts, the next one down is tried; if none of the levels finds one, the same is tried again with more
+ * black squares, which a large board needs to be solvable at all (see `AKARI_DENSER_CROWDS`). The fixed lattice
+ * of the first generator is only what is left if even that fails, which no seed does at any size offered.
  */
 export declare function generateAkari(width?: number, height?: number, seed?: number, level?: AkariLevel): AkariPuzzle;

package/dist/akariGenerate.js

@@ -1,4 +1,4 @@
-import { AKARI_LEVELS, AKARI_MOST_ATTEMPTS, AKARI_MOST_SIDE } from "./akari.constants.js";
+import { AKARI_DENSER_ATTEMPTS, AKARI_DENSER_CROWDS, AKARI_LEVELS, AKARI_MOST_ATTEMPTS, AKARI_MOST_SIDE } from "./akari.constants.js";
 import { akariNeighbours, akariVisible, checkAkari, isAkariBoard } from "./akariBoard.js";
 import { akariModel } from "./akariLogic.js";
 import { solveAkari } from "./akariSolve.js";
@@ -11,38 +11,51 @@ import { isKazuSeed, seededRandom, shuffled } from "./random.js";
  * the puzzle can still be solved the way the level asks: easy and medium by the rules alone (easy keeps most
  * of its numbers), hard by supposing one square at a time, extra-hard for as long as the answer stays single,
  * which leaves a board that needs more supposing than that. If no board of the level is found within the
- * attempts, the next one down is tried, and the first generator, which cannot fail, is the last.
+ * attempts, the next one down is tried; if none of the levels finds one, the same is tried again with more
+ * black squares, which a large board needs to be solvable at all (see `AKARI_DENSER_CROWDS`). The fixed lattice
+ * of the first generator is only what is left if even that fails, which no seed does at any size offered.
  */
 export function generateAkari(width = 7, height = width, seed = 1, level = "medium") {
     if (![width, height].every(n => Number.isInteger(n) && n >= 2 && n <= AKARI_MOST_SIDE)
         || !isKazuSeed(seed) || !AKARI_LEVELS.includes(level))
         throw new RangeError("Invalid Akari settings");
     const random = seededRandom(seed);
+    // The plain attempts come first, as they always have, so every seed that made a board before makes the same one.
     for (let aim = AKARI_LEVELS.indexOf(level); aim >= 0; aim -= 1) {
-        const aimed = AKARI_LEVELS[aim];
-        // Extra-hard is the hardest of several boards that need supposing: the most suppositions wins.
-        const wanted = aimed === "extra-hard" ? 8 : 1;
-        let best = null, found = 0;
-        for (let attempt = 0; attempt < AKARI_MOST_ATTEMPTS && found < wanted; attempt += 1) {
-            const made = attemptAkari(width, height, aimed, random);
-            if (!made)
-                continue;
-            const proof = solveAkari(made.board, { limit: 2 });
-            if (!proof.complete || proof.count !== 1 || !proof.solution || !checkAkari(made.board, proof.solution).ok)
-                continue;
-            found += 1;
-            if (!best || made.probes > best.probes)
-                best = { board: made.board, probes: made.probes, solution: proof.solution };
-        }
-        if (best)
-            return { ...best.board, seed, level, solution: best.solution };
+        const found = bestAkari(width, height, AKARI_LEVELS[aim], random, 1, AKARI_MOST_ATTEMPTS);
+        if (found)
+            return { ...found.board, seed, level, solution: found.solution };
     }
+    for (const crowd of AKARI_DENSER_CROWDS)
+        for (let aim = AKARI_LEVELS.indexOf(level); aim >= 0; aim -= 1) {
+            const found = bestAkari(width, height, AKARI_LEVELS[aim], random, crowd, AKARI_DENSER_ATTEMPTS);
+            if (found)
+                return { ...found.board, seed, level, solution: found.solution };
+        }
     const fallback = templateAkari(width, height, seed);
     return { ...fallback, level };
 }
-function attemptAkari(width, height, level, random) {
+/** The best board of the level found within `attempts` tries at this share of black squares, with its answer, or null. */
+function bestAkari(width, height, level, random, crowd, attempts) {
+    // Extra-hard is the hardest of several boards that need supposing: the most suppositions wins.
+    const wanted = level === "extra-hard" ? 8 : 1;
+    let best = null, found = 0;
+    for (let attempt = 0; attempt < attempts && found < wanted; attempt += 1) {
+        const made = attemptAkari(width, height, level, random, crowd);
+        if (!made)
+            continue;
+        const proof = solveAkari(made.board, { limit: 2 });
+        if (!proof.complete || proof.count !== 1 || !proof.solution || !checkAkari(made.board, proof.solution).ok)
+            continue;
+        found += 1;
+        if (!best || made.probes > best.probes)
+            best = { board: made.board, probes: made.probes, solution: proof.solution };
+    }
+    return best;
+}
+function attemptAkari(width, height, level, random, crowd) {
     const size = width * height;
-    const density = { easy: .2, medium: .22, hard: .24, "extra-hard": .26 }[level] * (.85 + random() * .3);
+    const density = { easy: .2, medium: .22, hard: .24, "extra-hard": .26 }[level] * (.85 + random() * .3) * crowd;
     const cells = Array.from({ length: size }, () => random() < density ? false : null);
     if (random() < .5)
         for (let y = 0; y < height; y += 1)

package/dist/cells.d.ts

@@ -2,14 +2,14 @@
  * A GRID OF NUMBERS AS A STRING: for an address, a POST body, and a kept run.
  *
  * Row-major, one character per cell: a digit for a value, `.` for an empty cell. Past nine the
- * values are letters, A for 10 up to G for 16, as a 16×16 Sudoku is printed (`symbolOf`), so one
- * character is still one cell. Upper case only in a code, so one grid has one spelling. These are
+ * values are letters, A for 10 up to G for 16 as a 16×16 Sudoku is printed, and on to P for 25 on a
+ * 25×25 (`symbolOf`), so one character is still one cell. Upper case only in a code, so one grid has one spelling. These are
  * the spellings itsutsu.com has always stored, and they decode here unchanged.
  */
 export declare const EMPTY_CELL = ".";
-/** How a value is written, in a code and on a cell: 1–9, then A–G. */
+/** How a value is written, in a code and on a cell: 1–9, then A–P. */
 export declare function symbolOf(value: number): string;
-/** The value a symbol names, or 0 for one that is not 1–9 or A–G (either case). */
+/** The value a symbol names, or 0 for one that is not 1–9 or A–P (either case). */
 export declare function valueOfSymbol(symbol: string): number;
 /** `[0, 3, 0, 1]` → `".3.1"`. */
 export declare function encodeCells(cells: readonly number[]): string;

package/dist/cells.js

@@ -2,18 +2,18 @@
  * A GRID OF NUMBERS AS A STRING: for an address, a POST body, and a kept run.
  *
  * Row-major, one character per cell: a digit for a value, `.` for an empty cell. Past nine the
- * values are letters, A for 10 up to G for 16, as a 16×16 Sudoku is printed (`symbolOf`), so one
- * character is still one cell. Upper case only in a code, so one grid has one spelling. These are
+ * values are letters, A for 10 up to G for 16 as a 16×16 Sudoku is printed, and on to P for 25 on a
+ * 25×25 (`symbolOf`), so one character is still one cell. Upper case only in a code, so one grid has one spelling. These are
  * the spellings itsutsu.com has always stored, and they decode here unchanged.
  */
 export const EMPTY_CELL = ".";
-/** The letters after 9, in order: A is 10, G is 16. */
-const PAST_NINE = "ABCDEFG";
-/** How a value is written, in a code and on a cell: 1–9, then A–G. */
+/** The letters after 9, in order: A is 10, G is 16, P is 25. */
+const PAST_NINE = "ABCDEFGHIJKLMNOP";
+/** How a value is written, in a code and on a cell: 1–9, then A–P. */
 export function symbolOf(value) {
     return value <= 9 ? String(value) : PAST_NINE[value - 10];
 }
-/** The value a symbol names, or 0 for one that is not 1–9 or A–G (either case). */
+/** The value a symbol names, or 0 for one that is not 1–9 or A–P (either case). */
 export function valueOfSymbol(symbol) {
     if (symbol.length !== 1)
         return 0;

package/dist/groupSolve.d.ts

@@ -60,6 +60,15 @@ export declare function applySingles(grid: Grid, layout: Layout): SinglesResult;
  * has no answer. Meant for a grid already known to have exactly one.
  */
 export declare function guessDepth(grid: Grid, layout: Layout): number;
+/**
+ * What reasoning with at most `guesses` guesses proves about a grid: 0 when it proves there is no answer, 1
+ * when it proves there is exactly one, 2 when it proves neither (it could not finish, or there are several).
+ * A guess is made at the most constrained empty cell and every value is tried, each followed by everything
+ * singles find; the grid has one answer when exactly one value leads to one and every other leads to none.
+ * This is a person's proof, and it stops where theirs would, so it costs a bounded few hundred passes of
+ * singles however sparse and large the grid is: counting every answer of a sparse 25×25 grid does not.
+ */
+export declare function provedByGuessing(grid: Grid, layout: Layout, guesses: number): 0 | 1 | 2;
 /**
  * A full grid for this layout, drawn at random, or null when the search runs
  * past `budget` steps — which for a jigsaw means these regions are a poor

package/dist/groupSolve.js

@@ -121,6 +121,8 @@ export function countSolutions(grid, layout, limit = 2) {
  * rather than keeping a browser waiting.
  */
 export function countSolutionsWithin(grid, layout, limit, budget, first) {
+    if (layout.size > LARGEST_SEARCHED_BARE)
+        return countByReasoning(grid, layout, limit, budget, first);
     const work = [...grid];
     const taken = used(work, layout);
     let found = 0;
@@ -150,6 +152,41 @@ export function countSolutionsWithin(grid, layout, limit, budget, first) {
     step();
     return steps > budget && found < limit ? null : found;
 }
+/**
+ * Up to this side the search guesses at the most constrained cell and nothing else, which is how every
+ * 4×4 to 16×16 grid has always been counted. Past it (the 25×25) a sparse grid thrashes that way for
+ * minutes, so a search there lets singles finish whatever they can before each guess.
+ */
+const LARGEST_SEARCHED_BARE = 16;
+/** The same count for a large grid: at every step all the singles are filled in first, and only what they leave is guessed at. */
+function countByReasoning(grid, layout, limit, budget, first) {
+    let found = 0;
+    let steps = 0;
+    const step = (from) => {
+        if (found >= limit || steps > budget)
+            return;
+        steps += 1;
+        const singles = applySingles(from, layout);
+        if (singles.contradiction)
+            return;
+        if (singles.solved) {
+            if (found === 0)
+                first?.([...singles.grid]);
+            found += 1;
+            return;
+        }
+        const { index, mask } = mostConstrained(singles.grid, layout, used(singles.grid, layout));
+        for (let left = mask; left !== 0; left &= left - 1) {
+            const next = [...singles.grid];
+            next[index] = lowestBit(left);
+            step(next);
+            if (found >= limit || steps > budget)
+                return;
+        }
+    };
+    step(grid);
+    return steps > budget && found < limit ? null : found;
+}
 /**
  * THE ANSWER, WORKED OUT FROM THE GIVENS: a finished puzzle kept before its
  * grid was, drawn solved rather than as dealt. Every puzzle made here has
@@ -245,6 +282,35 @@ export function guessDepth(grid, layout) {
     }
     return deepest === Infinity ? Infinity : deepest + 1;
 }
+/**
+ * What reasoning with at most `guesses` guesses proves about a grid: 0 when it proves there is no answer, 1
+ * when it proves there is exactly one, 2 when it proves neither (it could not finish, or there are several).
+ * A guess is made at the most constrained empty cell and every value is tried, each followed by everything
+ * singles find; the grid has one answer when exactly one value leads to one and every other leads to none.
+ * This is a person's proof, and it stops where theirs would, so it costs a bounded few hundred passes of
+ * singles however sparse and large the grid is: counting every answer of a sparse 25×25 grid does not.
+ */
+export function provedByGuessing(grid, layout, guesses) {
+    const singles = applySingles(grid, layout);
+    if (singles.contradiction)
+        return 0;
+    if (singles.solved)
+        return 1;
+    if (guesses < 1)
+        return 2;
+    const work = singles.grid;
+    const { index, mask } = mostConstrained(work, layout, used(work, layout));
+    let ones = 0;
+    for (let left = mask; left !== 0; left &= left - 1) {
+        const next = [...work];
+        next[index] = lowestBit(left);
+        const outcome = provedByGuessing(next, layout, guesses - 1);
+        if (outcome === 2)
+            return 2;
+        ones += outcome;
+    }
+    return ones === 0 ? 0 : ones === 1 ? 1 : 2;
+}
 /**
  * A full grid for this layout, drawn at random, or null when the search runs
  * past `budget` steps — which for a jigsaw means these regions are a poor

package/dist/kinds.js

@@ -10,7 +10,7 @@ export const KAZU_KINDS = ["number-place", "jigsaw", "diagonal", "sum-cages", "m
 /** How hard a puzzle is made: what the solver needed. Easy yields to singles alone, medium to one guess, hard to whatever it takes. */
 export const KAZU_LEVELS = ["easy", "medium", "hard"];
 export const KAZU_SPECS = {
-    "number-place": { sizes: [4, 6, 9, 16], defaultSize: 9, mostCells: 256 },
+    "number-place": { sizes: [4, 6, 9, 16, 25], defaultSize: 9, mostCells: 625 },
     jigsaw: { sizes: [5, 6, 7, 9], defaultSize: 7, mostCells: 162 },
     diagonal: { sizes: [6, 9], defaultSize: 9, mostCells: 81 },
     "sum-cages": { sizes: [6, 9], defaultSize: 9, mostCells: 286 },

package/dist/layout.js

@@ -19,6 +19,7 @@ export const KAZU_BOXES = {
     6: { rows: 2, cols: 3 },
     9: { rows: 3, cols: 3 },
     16: { rows: 4, cols: 4 },
+    25: { rows: 5, cols: 5 },
 };
 /** The box a cell is in, numbered row-major from 0. */
 export function boxOf(size, index) {

package/dist/mount.d.ts

@@ -2,24 +2,6 @@ import { type KazuGame } from "./game.ts";
 import { type KazuHint } from "./hint.ts";
 import type { KazuKind, KazuLevel } from "./kinds.ts";
 import { type KazuLanguage } from "./strings.ts";
-/**
- * A PLAYABLE KAZU BOARD IN ANY PAGE: `mountKazu(host, options)` draws a puzzle into an element and plays
- * it by touch, mouse and keyboard. Tap a cell and tap a number on the pad (or type it); tap the chosen
- * cell again to step it on, 1, 2, 3 … and back to empty; turn Pencil on and the pad writes small notes
- * instead; Undo takes the last change back; Hint says which cell to fill next and why; Check says how
- * many are wrong, never which. A clock starts on the first entry and stops when the last cell is right.
- *
- * The keys: the arrows move, a number (1 to 9, and A to G on the 16×16) fills the chosen cell, Shift
- * with a number writes it as a pencil mark, Backspace empties the cell, N turns Pencil on or off,
- * Ctrl or Cmd with Z undoes, and Escape lets the cell go.
- *
- * What happens is told in events, on the host as DOM events and to the callbacks given: `kazu-change`
- * for every change to the grid, `kazu-hint` for each hint, `kazu-check` for each check, and `kazu-solve`
- * once, with the answer ready for `checkKazu`. Every button is also a method of the returned handle.
- * The rules it plays by are `game.ts`'s, and the drawing is `drawKazu`'s: both are usable alone.
- *
- * Needs a page. Its words are English and Japanese and follow the page's `lang`.
- */
 /** What every event tells of the board. */
 export type KazuEventDetail = {
     kind: KazuKind;

package/dist/mount.js

@@ -7,6 +7,27 @@ import { KAZU_PLAY_STYLE } from "./playStyle.js";
 import { decodeNotes, decodeRun, encodeNotes, encodeRun, notesOf } from "./progress.js";
 import { solveKazu } from "./solve.js";
 import { kazuLanguageOf, kazuNameOf, kazuSay } from "./strings.js";
+/**
+ * A PLAYABLE KAZU BOARD IN ANY PAGE: `mountKazu(host, options)` draws a puzzle into an element and plays
+ * it by touch, mouse and keyboard. Tap a cell and tap a number on the pad (or type it); tap the chosen
+ * cell again to step it on, 1, 2, 3 … and back to empty; turn Pencil on and the pad writes small notes
+ * instead; Undo takes the last change back; Hint says which cell to fill next and why; Check says how
+ * many are wrong, never which. A clock starts on the first entry and stops when the last cell is right.
+ *
+ * The keys: the arrows move, a number (1 to 9, then A to G on the 16×16 and on to P on the 25×25) fills
+ * the chosen cell, Shift with a number writes it as a pencil mark, Backspace empties the cell, N turns
+ * Pencil on or off (the slash key on the 25×25, where N is the number 23), Ctrl or Cmd with Z undoes,
+ * and Escape lets the cell go.
+ *
+ * What happens is told in events, on the host as DOM events and to the callbacks given: `kazu-change`
+ * for every change to the grid, `kazu-hint` for each hint, `kazu-check` for each check, and `kazu-solve`
+ * once, with the answer ready for `checkKazu`. Every button is also a method of the returned handle.
+ * The rules it plays by are `game.ts`'s, and the drawing is `drawKazu`'s: both are usable alone.
+ *
+ * Needs a page. Its words are English and Japanese and follow the page's `lang`.
+ */
+/** From this side up the letter N is a number (A is 10, so N is 23), and Pencil moves to the slash key. */
+const NOTES_KEY_IS_A_NUMBER = 23;
 /** Put the style in the page once: in the document's head, or in the shadow root the host is in. */
 export function ensureKazuPlayStyle(host) {
     const root = host.getRootNode();
@@ -210,7 +231,7 @@ export function mountKazu(host, options) {
         host.dataset.kind = game.kind;
         host.dataset.size = String(game.size);
         box.setAttribute("aria-label", say("board", { name: kazuNameOf(game.kind, language), size: game.size }));
-        keysNote.textContent = say("keys");
+        keysNote.textContent = say(game.size >= NOTES_KEY_IS_A_NUMBER ? "keysColossus" : "keys");
         const counts = numberCounts(game);
         padKeys.forEach((key, at) => {
             const value = at + 1;
@@ -328,13 +349,13 @@ export function mountKazu(host, options) {
             event.preventDefault();
             api.enter(0);
         }
-        else if (event.key.toLowerCase() === "n") {
+        else if (event.key.toLowerCase() === (game.size >= NOTES_KEY_IS_A_NUMBER ? "/" : "n")) {
             event.preventDefault();
             api.pencil();
         }
         else if (event.shiftKey && selected !== null) {
             // Shift with a number is a pencil mark, whatever the keyboard writes for a shifted digit: read the key's place, not its symbol.
-            const code = /^Digit([1-9])$/.exec(event.code)?.[1] ?? /^Key([A-G])$/.exec(event.code)?.[1];
+            const code = /^Digit([1-9])$/.exec(event.code)?.[1] ?? /^Key([A-P])$/.exec(event.code)?.[1];
             const value = code === undefined ? 0 : valueOfSymbol(code);
             if (value >= 1 && value <= game.size) {
                 event.preventDefault();

package/dist/names.js

@@ -11,13 +11,13 @@ export const KAZU_NAMES = {
             en: [
                 "Fill every empty cell with a number from 1 up to the side of the grid, so that each row, each column and each box holds every number exactly once.",
                 "The numbers already printed are the givens. They stay where they are, and every puzzle has exactly one answer that fits them.",
-                "The 16×16 Giant has sixteen symbols: 1 to 9, then A to G for 10 to 16.",
+                "The 16×16 Giant has sixteen symbols: 1 to 9, then A to G for 10 to 16. The 25×25 Colossus has twenty-five: A to P for 10 to 25.",
                 "Easy yields to reasoning alone: every cell can be found from what is already there. Medium and hard ask you to try something and see.",
             ],
             ja: [
                 "空いているマスに、1から盤の一辺の数までの数字を入れます。どの行、列、ブロックにも、同じ数字が一つずつ入ります。",
                 "最初から書かれている数字はそのままです。どの問題も、答えはちょうど一つだけです。",
-                "16×16の「特大」は、1から9までの数字に、10から16までを表すAからGを足した16種類を使います。",
+                "16×16の「特大」は、1から9までの数字に、10から16までを表すAからGを足した16種類を使います。25×25の「巨大」は、10から25までを表すAからPまでを使う25種類です。",
                 "やさしい問題は、推理だけで全部のマスが決まります。ふつうとむずかしい問題では、試してみる場面があります。",
             ],
         },
@@ -154,7 +154,7 @@ export const KAZU_NAMES = {
 };
 /** What each side is for, under its size on a chooser: the quick one, the usual one, the long one. */
 export const KAZU_SIZE_NAMES = {
-    "number-place": { 4: { en: "Quick", ja: "速" }, 6: { en: "Short", ja: "短" }, 9: { en: "Classic", ja: "定番" }, 16: { en: "Giant", ja: "特大" } },
+    "number-place": { 4: { en: "Quick", ja: "速" }, 6: { en: "Short", ja: "短" }, 9: { en: "Classic", ja: "定番" }, 16: { en: "Giant", ja: "特大" }, 25: { en: "Colossus", ja: "巨大" } },
     jigsaw: { 5: { en: "Quick", ja: "速" }, 6: { en: "Short", ja: "短" }, 7: { en: "Standard", ja: "定番" }, 9: { en: "Classic", ja: "本格" } },
     diagonal: { 6: { en: "Short", ja: "短" }, 9: { en: "Classic", ja: "定番" } },
     "sum-cages": { 6: { en: "Short", ja: "短" }, 9: { en: "Classic", ja: "定番" } },

package/dist/numberPlace.d.ts

@@ -8,7 +8,7 @@ import { type Random } from "./random.ts";
  * puzzle on a layout (Sudoku, Diagonal and Jigsaw).
  */
 export declare function carve(solution: Grid, layout: Layout, level: KazuLevel, floor: number, random: Random): Grid;
-/** A Sudoku (Number Place) of this side, level and seed: 4, 6, 9 or 16. */
+/** A Sudoku (Number Place) of this side, level and seed: 4, 6, 9, 16 or 25. */
 export declare function generateNumberPlace(size: number, level: KazuLevel, seed: number): KazuPuzzle;
 /** A Diagonal Sudoku (Sudoku X): Sudoku with the two long diagonals as groups too. 6 or 9. */
 export declare function generateDiagonal(size: number, level: KazuLevel, seed: number): KazuPuzzle;

package/dist/numberPlace.js

@@ -1,5 +1,5 @@
 import { encodeCells } from "./cells.js";
-import { countSolutions, guessDepth } from "./groupSolve.js";
+import { countSolutions, guessDepth, provedByGuessing } from "./groupSolve.js";
 import { boxedLayout } from "./layout.js";
 import { seededRandom, shuffled } from "./random.js";
 /**
@@ -22,10 +22,21 @@ import { seededRandom, shuffled } from "./random.js";
  * hard puzzle would be a medium one with a different label.
  */
 const LEVELS = {
-    easy: { depth: 0, floor: { 4: 9, 6: 20, 9: 40, 16: 150 } },
-    medium: { depth: 1, floor: { 4: 7, 6: 15, 9: 31, 16: 125 } },
-    hard: { depth: Infinity, floor: { 4: 5, 6: 11, 9: 24, 16: 116 } },
+    easy: { depth: 0, floor: { 4: 9, 6: 20, 9: 40, 16: 150, 25: 366 } },
+    medium: { depth: 1, floor: { 4: 7, 6: 15, 9: 31, 16: 125, 25: 305 } },
+    hard: { depth: Infinity, floor: { 4: 5, 6: 11, 9: 24, 16: 116, 25: 283 } },
 };
+/** Past this side the exact count of answers and the exact depth are not asked, only a proof (see `LARGE_GUESSES`). */
+const LARGEST_COUNTED = 16;
+/**
+ * The 25×25 is carved by proof, not by counting. Counting every answer of a sparse 625-cell grid can run for
+ * minutes (a single removal took 20 s), and the exact guess depth of one is as bad. What a person does is
+ * what is asked instead: singles, then at most this many guesses at the most constrained cell, each value
+ * of it either finished by singles or shown wrong by them. A puzzle that passes has exactly one answer, and
+ * the work for each removal is bounded however the grid looks. Hard allows two nested guesses and no more,
+ * so a 25×25 hard puzzle is one a person can finish, and easy is singles alone, as it is at every size.
+ */
+const LARGE_GUESSES = { easy: 0, medium: 1, hard: 2 };
 /**
  * A whole grid, filled cell by cell in reading order with the values tried in a seeded order. The
  * groups come from the layout, so the diagonals are honoured the same way.
@@ -65,7 +76,7 @@ function fillInOrder(layout, random) {
  * into a dead end deep in a 256-cell grid and take seconds to climb out. A grid that is right by
  * construction (each row the one above it shifted a box's width, each band shifted by one), then
  * shuffled in every way that keeps it right (the numbers relabelled, rows within a band, the
- * bands, columns within a stack, the stacks), is as varied and costs nothing. Only 16×16 is made
+ * bands, columns within a stack, the stacks), is as varied and costs nothing. Only 16×16 and 25×25 are made
  * this way, so every smaller grid comes out of its seed exactly as it always has.
  */
 function fillByPattern(size, random) {
@@ -91,7 +102,9 @@ export function carve(solution, layout, level, floor, random) {
             break;
         const value = givens[index];
         givens[index] = 0;
-        const stillOne = countSolutions(givens, layout, 2) === 1 && guessDepth(givens, layout) <= depth;
+        const stillOne = layout.size > LARGEST_COUNTED
+            ? provedByGuessing(givens, layout, LARGE_GUESSES[level]) === 1
+            : countSolutions(givens, layout, 2) === 1 && guessDepth(givens, layout) <= depth;
         if (stillOne)
             left -= 1;
         else
@@ -99,11 +112,11 @@ export function carve(solution, layout, level, floor, random) {
     }
     return givens;
 }
-/** A Sudoku (Number Place) of this side, level and seed: 4, 6, 9 or 16. */
+/** A Sudoku (Number Place) of this side, level and seed: 4, 6, 9, 16 or 25. */
 export function generateNumberPlace(size, level, seed) {
     const random = seededRandom(seed);
     const layout = boxedLayout(size);
-    const solution = size === 16 ? fillByPattern(size, random) : fillInOrder(layout, random);
+    const solution = size >= 16 ? fillByPattern(size, random) : fillInOrder(layout, random);
     const givens = carve(solution, layout, level, LEVELS[level].floor[size], random);
     return { kind: "number-place", size, level, seed, givens: encodeCells(givens), solution: encodeCells(solution) };
 }

package/dist/strings.js

@@ -19,6 +19,7 @@ export const KAZU_STRINGS = {
         tap: "Tap a cell, then a number.",
         tapPencil: "Pencil marks are on: tap a number to note it in the cell.",
         keys: "Arrow keys move, a number fills the cell, Backspace empties it, N turns pencil marks on or off.",
+        keysColossus: "Arrow keys move, a number or a letter from A to P fills the cell, Backspace empties it, the slash key turns pencil marks on or off (N is a number here).",
         undo: "Undo",
         pencil: "Pencil",
         pencilTitle: "Write small notes in a cell instead of a number",
@@ -83,6 +84,7 @@ export const KAZU_STRINGS = {
         tap: "マスをタップして、数字を選びます。",
         tapPencil: "メモがオンです。数字をタップすると、マスにメモします。",
         keys: "矢印キーで移動、数字キーで入力、Backspaceで消去、Nでメモのオンとオフ。",
+        keysColossus: "矢印キーで移動、数字またはAからPのキーで入力、Backspaceで消去、スラッシュキーでメモのオンとオフ（ここではNは数字です）。",
         undo: "元に戻す",
         pencil: "メモ",
         pencilTitle: "数字のかわりに、マスに小さくメモを書きます",

package/dist/version.d.ts

@@ -1,2 +1,2 @@
 /** The package's version. */
-export declare const VERSION = "1.3.0";
+export declare const VERSION = "1.4.0";

package/dist/version.js

@@ -1,2 +1,2 @@
 /** The package's version. */
-export const VERSION = "1.3.0";
+export const VERSION = "1.4.0";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@johnmorrisdotca/kazu",
-  "version": "1.3.0",
-  "description": "Grid number and logic puzzles for JavaScript and TypeScript: Sudoku and its variants, Futoshiki, Skyscrapers, Shikaku, Hitori, Nurikabe, Akari, Juosan, Slitherlink, Masyu, Yajilin, Ripple Effect, Kakuro, Fillomino and Heyawake. Dedicated typed engines, independently checked puzzles, SVG boards and bilingual touch and keyboard players. Zero runtime dependencies.",
+  "version": "1.4.0",
+  "description": "Grid number and logic puzzles for JavaScript and TypeScript: Sudoku (up to 25×25) and its variants, Futoshiki, Skyscrapers, Shikaku, Hitori, Nurikabe, Akari, Juosan, Slitherlink, Masyu, Yajilin, Ripple Effect, Kakuro, Fillomino and Heyawake. Dedicated typed engines, independently checked puzzles, SVG boards and bilingual touch and keyboard players. Zero runtime dependencies.",
   "keywords": [
     "puzzle",
     "sudoku",