DEV Community: SEN LLC

Nurimisaki: clue positions the setter never chooses — and half the information lives in the blank cells

SEN LLC — Thu, 13 Aug 2026 23:19:34 +0000

Nurimisaki in the browser with four rule sets inside. Shade some
cells of an n×n grid: the white cells form one connected region, no 2×2
is all white or all black, and a white cell with exactly one white
neighbor is a cape — with the circled cells being exactly the
capes. A number counts the white cells of the straight run leaving its
cape, circle included. Puzzle #38 in the solver series.

Demo: https://sen.ltd/portfolio/nurimisaki/
Repo: https://github.com/sen-ltd/nurimisaki

I picked this puzzle for two reasons, and both live inside the single word
exactly — the clue rule is an iff.

The blank cells are clues

If every cape must be circled, then a cell with nothing printed on it is a
promise: no cape here. Should that cell end up white, at least two of its
neighbors are white too. Part of the puzzle is written in the places where
nothing is written, and for the first time in this series I could measure
how much (spoiler: on 6×6 boards, dropping that promise from the semantics
takes unique boards from 12/60 down to 2/60 and triples the typical
solution count — roughly half the information is negative space).

The setter never places a clue

In every sibling puzzle of this series, the setter finishes a board and
then chooses where the clues go. In Nurimisaki the answer forces them:
circles sit exactly on the capes of the finished shading. Clues cannot be
added or moved — only their numbers can be removed. The board deals its
own clue budget: about 15 capes per 100 cells at every size, with run
lengths averaging 3.0 regardless of size. The demand for information grows
with n²; the budget doesn't. That structural starvation shows up in every
table below.

The configuration space

Strip the numbers and count what a finished board can be (white connected,
no monochrome 2×2 of either color): 12 boards on 2×2, 103 on 3×3, 2,286 on
4×4, by plain exhaustive loops. The white region is a skinny polyomino —
it contains no 2×2 — yet the all-black ban means it must also touch every
2×2 window: thin, but everywhere. The cape histogram comes free: of the
2,286 4×4 boards, 14 have no cape at all (white loops and lone dots), 48
have exactly one (a loop with a tail), and 3 capes is the mode. The two
capeless 3×3 boards — a single center dot, and the ring around it — are
precisely the solutions of the empty puzzle, because a puzzle with no
circles bans capes everywhere.

Four rule sets

level	rule
`cape`	the iff, both halves: enumerate which neighbor of a circle is its single white one (numbered runs lay out their cells and terminator), force what every viable direction agrees on; blank cells must keep two reachable white neighbors or go black
`window`	no monochrome 2×2, either color: three-of-a-kind turns the fourth. A printed rule here — in the siblings the 2×2 pattern was connectivity's emergent shadow
`bridge`	white connectivity made local with one articulation-point DFS: pockets can't be white, bridges must be. The black cells owe nothing — this rule has no black half
`probe`	assume a color on one cell, run the rules below to a fixpoint, drop what contradicts

The law returns — and the uniqueness cliff

300 raw boards per size, every cape numbered (density 1.0 is the natural
baseline: the circle set is forced, numbers are the only dial there is).
Fraction finished by the fixpoint alone:

board	cape	+window	+bridge	+probe	unique in the raw stream
6×6	1.0%	4.0%	14.0%	24.3%	24.3%
8×8	0.3%	0.3%	3.0%	7.0%	7.0%
10×10	0.0%	0.0%	0.7%	1.3%	1.3%

Two things stare back. Probe equals uniqueness at every size — the law
that Kurotto broke last time holds again. Kurotto's ambiguity lived in
paired-cell block rearrangements invisible to single-cell probing;
Nurimisaki's window and connectivity rules apparently drag that kind of
superposition back into a one-cell probe's field of view.

And the uniqueness column is a cliff. Print every number the board can
carry and still only 1.3% of 10×10 boards have one answer. The siblings
could always turn the density dial up to 100%-unique territory. Nurimisaki
has no dial left to turn.

Ablation: zero redundancy, a series first

Full ladder minus one rule; the last column keeps every printed rule and
drops only the blank cells' no-cape promise from the propagator:

board	full	−cape	−window	−bridge	−blank promise
6×6	24.3%	0.0%	6.0%	9.3%	7.7%
8×8	7.0%	0.0%	0.3%	0.7%	1.7%
10×10	1.3%	0.0%	0.0%	0.0%	0.0%

Removing cape collapses everything — the only rule that reads a clue,
same as Cave's −count. But look at the 10×10 row: removing any single
rule collapses the ladder to 0.0%. Kurotto's four rungs were one theorem
poked four ways — you could delete three of them for free. Cave's corner
rule was bridge's perfect shadow. After five straight
redundant-but-not-useless findings, this is the series' first puzzle with
no redundancy at all: four different theorems, all load-bearing at once,
because the boards are too starved to afford spares.

The dial that never reaches

8×8, 150 raw boards per density point, thinning only the numbers:

density	unique	probe-solved	bridge-solved	mean numbers
0.00	0.0%	0.0%	0.0%	0.0
0.50	1.3%	1.3%	0.0%	4.4
1.00	5.3%	5.3%	3.3%	9.3

Probe = unique holds at every point of the dial, and the top of the dial
is 5.3%. Circles alone (density 0) never pinned an 8×8 board in 150 tries —
but small boards manage it almost: the shipped 5×5 probe-grade boards keep
a median of 1 number on their 4 circles. There are boards whose cape
geometry nearly names the answer.

A bank you fish for, not thin down

The siblings generate banks by thinning a generous reveal. Nurimisaki's
full reveal is often not even unique — my test fixtures pin two hand-drawn
boards whose fully numbered puzzles have 4 and 6 solutions, certified by
brute force. So the generator fishes the raw stream for the rare unique
boards, then removes numbers adversarially. A 10×10 probe-grade board
keeps a median of 6 numbers on 17 circles.

The grade lineup is dealt by the board too: past 6×6, cape-graded and
window-graded boards stop existing — zero found in thousands of
attempts. The UI greys out the difficulties your chosen size cannot
produce. Certifying uniqueness takes a median of 6 guesses at 10×10 with
the full ladder propagating; the connectivity-free rungs already explode
at 6×6 (mean 139.5 guesses for cape alone).

Verification

A brute force sharing no code with the ladder — DFS over free cells, pruned only by restatements of the printed rules, leaves scored by a standalone validator — agrees with the propagating search at all four levels on every board it can reach: 560/560 (board, level) pairs, plus 120/120 for the variant engines with the blank-cell promise dropped.
Exhaustive anchors: 12 / 103 / 2,286 circle-free configurations at 2×2 / 3×3 / 4×4, of which 4 / 2 / 14 are capeless — and those capeless boards are exactly what every engine returns as the solutions of the empty puzzle.
Uniqueness is never inferred from solvability: every shipped board is re-checked by the searching engine.

All 40 tests: npm test. TypeScript + Vite, no runtime dependencies.

Takeaways

An iff clue rule makes silence informative: the no-cape promise of blank cells carries roughly half the puzzle's information.
Forced clue positions cap the clue budget at ~15 capes per 100 cells — the most information-starved puzzle in the series (1.3% unique at 10×10 with every number printed).
The probe-equals-uniqueness law is back — and ablation redundancy hit zero for the first time: at 10×10, every rule is a single point of failure.
Difficulty grades are dealt, not designed: no cape- or window-grade boards exist past 6×6.

Repo: https://github.com/sen-ltd/nurimisaki

Kurotto: the puzzle with no global rule — and the first crack in the probe-equals-uniqueness law

SEN LLC — Thu, 13 Aug 2026 00:14:25 +0000

Kurotto in the browser with four rule sets inside. Some cells of
an n×n grid carry a circled number and are never shaded. Shade any of
the remaining cells so that each circled number equals the total size
of the shaded blocks — orthogonally connected groups — sharing an
edge with that circle. That is the whole rule book. Puzzle #37 in the
solver series.

Demo: https://sen.ltd/portfolio/kurotto/
Repo: https://github.com/sen-ltd/kurotto

I picked this puzzle because it has no global rule at all.

The legal boards are… all of them

Strip the circles away and ask what a finished board can look like:
anything. No connectivity rule, no 2×2 ban, no border rule. All 16
shadings of the 2×2 board are valid, all 512 of the 3×3 — checked
exhaustively. The configuration space is the full hypercube, 2^(n²)
boards.

This series has spent entries hunting bijections between legal boards and
samplable objects — Yin-Yang's ridge paths, Cave's lattice cycles. Kurotto
is the degenerate end of the hunt: the bijection is the identity, and a
uniform sample is n² coin flips. The generator needs no theorem.

In exchange, everything the earlier puzzles got for free from
connectivity theorems, Kurotto must buy with arithmetic alone — and the
only global force left in the puzzle is the demand that the answer be
unique.

Four rungs — but not four theorems

A circle's clue is bracketed by two flood fills. The floor: the shaded
cells already attached to it. The ceiling: everything still reachable
through non-white cells (its potential region). The floor only rises,
the ceiling only falls.

level	rule
`sum`	clue at the ceiling → the whole potential region shades; clue at the floor → the frontier seals white (a 0-clue is this with an empty floor)
`door`	a circle below its clue must grow, and every growth shades a frontier cell; one frontier cell means a forced shade
`echo`	assume one color on one cell, re-run every circle's floor/ceiling arithmetic, drop the assumption if some clue falls out of its bracket
`probe`	assume one color on one cell, run the rules below to a fixpoint, drop the assumption on contradiction

Unlike the earlier ladders these are not four different theorems — they
are one theorem probed harder: the same two floods read directly, at
the frontier, under a hypothesis, under a propagated hypothesis. The
ablation table makes this brutally visible.

The law breaks

Measured on 300 raw generator boards per size (circle density 0.8 over the
white cells, unfiltered — fraction finished by the fixpoint alone, no
guessing):

board	sum	+door	+echo	+probe	unique answers in the raw stream
6×6	21.7%	48.7%	56.3%	62.0%	63.3%
8×8	10.7%	33.0%	43.0%	52.0%	52.7%
10×10	2.0%	21.7%	33.0%	42.0%	42.3%

In every earlier puzzle of this series, the probe column equaled the
uniqueness column at every size: a sound fixpoint can't decide a cell two
answers disagree on, so uniqueness is a ceiling — and the ladder always
sat exactly on it.

Kurotto is the first puzzle where it doesn't. 4 of the 190 unique 6×6
boards, 2 of 158 at 8×8, 1 of 127 at 10×10 are unique — yet no chain of
single-cell assumptions finishes them. Confirmed independently: a brute
force that shares no code with the ladder (pruned only by the definitional
floor/ceiling restatement, every leaf scored by a standalone validator)
counts exactly one solution on each gap board, in 906–3,078 nodes
(tools/gapcheck.mts).

Why here? Because block arithmetic can hold two reshuffling ambiguities
in superposition: every single cell survives both hypotheses alone,
and only a pair of assumptions dies. The uniqueness proof lives outside
the world a one-cell probe can see.

Ablation: remove anything, nothing happens

board	full	−sum	−door	−echo
6×6	62.0%	61.7%	62.0%	61.7%
8×8	52.0%	52.0%	52.0%	50.7%
10×10	42.0%	42.0%	42.0%	39.0%

In Cave, removing the one clue-reading rule collapsed everything to 0.0%.
Kurotto has no "only rule that reads the clues" — every rung reads the
same arithmetic, so every rung below probe is nearly redundant against
the rest. Fifth entry in a row with redundant-but-not-useless rules, but
this time it's not one rule — it's the ladder's whole lower half shadowing
itself. The rungs still earn their keep: they define genuine difficulty
grades in the shipped bank, and they are the deductions a human actually
makes, in that order.

Where the ambiguity lives — the oracle needed three certificates

A circle can only speak about its potential region. A free cell outside
every region is a free second solution before a single deduction is made —
so uniqueness first demands full coverage. Then two assassins remain:
silent flips (one cell whose lone flip changes no sum) and — new in
this puzzle — silent pair flips: two cells whose joint flip reshuffles
blocks without any circle noticing.

The uniqueness oracle behind every table reads all three certificates
straight off the drawn solution before it ever searches; only the
nearly-unique survivors go to the counting search. Before the pair-flip
check existed, naive counting stalled for minutes per board — the
measuring instrument itself had to learn the puzzle's ambiguity
structure. Guess-cap overflows across all sections: zero.

Circle density sweep at 10×10, 150 raw boards per point:

density	unique	no-silent-flip ceiling	echo-solved	sum-solved
0.30	0.0%	4.7%	0.0%	0.0%
0.42	0.0%	18.0%	0.0%	0.0%
0.54	2.0%	49.3%	0.0%	0.0%
0.66	11.3%	79.3%	5.3%	0.0%
0.78	36.0%	90.0%	28.0%	0.7%
0.90	67.3%	100.0%	60.7%	20.0%

Two honest surprises. The coverage ceiling never binds: even at
density 0.30, all 150 boards were fully covered — empty-board floods
reach nearly everything, so the "cell no circle can see" assassin only
appears in far cornerier regimes than a random stream produces. And where
Cave's uniqueness hugged its flip ceiling all the way up, Kurotto's
crawls far below it: at density 0.54 the single-flip ceiling allows
49.3% and reality delivers 2.0%. Kurotto's ambiguity is dominated by
multi-cell block reshuffles — the same structure that broke the
probe-equals-uniqueness law. In the series' coordinate system, Kurotto is
Yin-Yang's kind of hunger, taken to the extreme.

Search effort to certify uniqueness

On boards that pass all three certificates (100 per size):

board	rule set	median guesses	mean
6×6	sum	4	29.7
6×6	door	0	8.3
6×6	echo	0	3.1
6×6	probe	0	0.5
10×10	echo	0	2.3
10×10	probe	0	0.0

Once echo propagates, proving uniqueness is barely a search at all — a
median of 0 guesses at 10×10. The weak levels' searches explode with the
free-cell count past 6×6, so they never see the larger stream. The
shipped bank pins a 10×10 board with a median of 27–35 circles, where a
random reveal needs ~48 (density 0.84 over the white cells) for a
coin-flip's chance.

Verification

Solution counts. Brute force vs propagating search at each of the four rule levels, on every board where the brute force is feasible: 520/520 (board, level) pairs agree.
Exhaustive anchors. 16/16 shadings of the circle-free 2×2 validate, 512/512 of the 3×3 — there really is no hidden rule. A hand-enumerated corner circle splits its 8 completions 2/2/3/1 by sum; the brute force reproduces it.
The gap. Every probe-stuck unique board behind the headline claim is re-counted by the brute force.

All 26 tests: npm test.

Play it

The Hint button fills in the first cell the selected level can prove, one
deduction at a time. Every shaded block of two or more wears its current
size in the corner — the number a Kurotto player keeps recounting.
Circles turn green when exactly satisfied and sealed, red when they can no
longer be met.

Next up: another puzzle with a solver inside.

SEN LLC — software development experiments, shipped in public.
More: https://sen.ltd/portfolio/

Cave: every answer is a hole-free polyomino — counted as lattice cycles, generated with a 3 3 stamp

SEN LLC — Wed, 12 Aug 2026 14:38:29 +0000

Cave (also sold as Corral or Bag) in the browser with four rule
sets inside. Shade some cells of an n×n grid. The unshaded cells — the
cave — form one orthogonally connected group, every shaded wall
connects through walls to the border, and each number sits in the cave
and counts the cave cells it sees in the four directions, itself
included, before a wall or the edge stops the view. Puzzle #36 in the
solver series.

Demo: https://sen.ltd/portfolio/cave/
Repo: https://github.com/sen-ltd/cave

I picked this one because the answer space has a name of its own.

The answers are the hole-free polyominoes

Strip the numbers away and ask what a finished board can look like. The
cave is connected; every wall reaches the border — and the second rule is
just "no pocket of walls sealed inside the cave", i.e. no holes. So a
valid configuration is exactly a hole-free polyomino, and its boundary
— the grid edges between a cave cell and a wall or the outside — is a
single closed non-crossing loop on the lattice points.

The correspondence is a bijection: one valid board per simple cycle of the
(n+1)×(n+1) grid graph. That is why the same puzzle ships under two names —
shade the cells and it's Cave, draw the fence and it's Corral. Same object.

Counted, both ways. Exhaustive enumeration of clue-free boards: 13 on
2×2, 213 on 3×3, 9,349 on 4×4. An independently written
simple-cycle counter on the lattice — it knows nothing about polyominoes —
returns 13 / 213 / 9,349. All three match OEIS A140517, the cycle
counts of the grid graph.

The pattern no rule mentions

A checkered 2×2 — cave on one diagonal, wall on the other — never survives,
though no stated rule bans it. The cave path joining the two cave corners
closes into a curve that fences one of the wall cells away from the
border. In boundary-loop language, a checkered window is a pinch
point, where the loop touches itself. It is connectivity's local shadow,
and it does a full rule set's worth of work in the solver.

The generator: a 3×3 stamp from digital image topology

How do you sample hole-free polyominoes? Backtracking over shadings fights
the structure instead of using it. Digital image processing already has the
right tool: a cell whose flip preserves the topology of the picture is
called a simple point, and it is recognized locally.

Read the 8 cells around a candidate in a circle (off-grid counts as wall).
The flip is safe exactly when:

the circle changes color exactly twice — one cave arc, one wall arc;
an orthogonal neighbor already has the flip's new color.

Consecutive ring cells are orthogonal neighbors of each other, so an arc is
automatically connected; two changes mean both sides of the flip stay in
one piece, and the arc condition keeps the pinch — the checkered 2×2 — out.

Seed one random cell, grow, then mix with thousands of random safe flips.
Every intermediate picture is a valid configuration, no global
connectivity check ever runs, and no backtracking exists to be needed.
Verified on 1,500 generated configurations: one boundary component, zero
pinch points, V = E (closed), 1,500/1,500.

Four rule sets

level	rule
`count`	the clue arithmetic, made exact: a clue v splits as 1 + four ray extents; an extent claims its cells cave and its stopper wall; convolve the four feasible-extent sets as sum bitmasks and force what every completion agrees on
`corner`	a 2×2 admits 14 of its 16 shadings — only the two checkered ones die, and only connectivity says so
`bridge`	both connectivity rules made local, one articulation-point DFS each: cave cells stay mutually reachable through (cave ∪ free); walls stay reachable from a virtual outside node through (wall ∪ free); sealed-off cells take the other color, cut vertices take the color they carry
`probe`	assume one color on one cell, run the rules below to a fixpoint, drop the assumption if that alone is a contradiction

Incremental vs ablation — the cleanest split yet

Measured on 300 raw generator boards per size (85% of the cave cells
clued; unfiltered by uniqueness or difficulty, so the numbers aren't shaped
by the property they measure — fraction finished by the fixpoint alone, no
guessing):

board	count	+corner	+bridge	+probe	unique answers in the raw stream
6×6	16.0%	44.0%	72.7%	73.3%	73.3%
8×8	6.3%	29.0%	55.3%	55.7%	55.7%
10×10	2.3%	23.0%	52.0%	53.0%	53.0%

The incremental table credits corner with 21–28 points — a solid
supporting role. Then run the ablation (full ladder minus one rule):

board	full	−count	−corner	−bridge
6×6	73.3%	0.0%	73.3%	44.0%
8×8	55.7%	0.0%	55.7%	29.3%
10×10	53.0%	0.0%	53.0%	23.7%

Removing corner costs 0.0 points at every size — not one board.
Corner is the shadow of connectivity, and once bridge — connectivity
itself — enters the room, the shadow vanishes. Removing count drops
everything to 0.0%: it is the only rule that reads the clues at all.
That's the fourth puzzle in a row where a rule is redundant but not
useless: corner still defines a genuine difficulty grade in the shipped
bank, and it is the pattern a human actually spots.

Probe's solve rate = the uniqueness rate, again

At every size the probe column equals the uniqueness column exactly. A
sound fixpoint cannot decide a cell that two answers disagree on, so the
uniqueness rate is a ceiling — and the ladder sits on it.

Cave's ambiguity lives in single-cell flips

Cave is starving for clues under random reveals — clues can only sit on
cave cells, so every wall is a free cell forever. But it starves in the
opposite way from Yin-Yang.

Call a flip silent when it keeps the board valid and leaves every clue
count unchanged. Each silent flip is a free second solution, so
P(unique) ≤ P(no silent flip). 10×10, 150 raw boards per point:

density	unique	no-silent-flip ceiling	bridge-solved	count-solved
0.50	1.3%	3.3%	1.3%	0.0%
0.60	6.0%	12.0%	6.0%	0.0%
0.70	20.7%	26.0%	20.7%	0.0%
0.80	38.0%	47.3%	37.3%	2.0%
0.90	65.3%	72.7%	64.7%	1.3%
1.00	100.0%	100.0%	100.0%	2.0%

Yin-Yang's measured uniqueness crawled far below its flip ceiling — its
ambiguity lived in multi-cell reroutes of the curve. Cave's uniqueness
hugs the ceiling all the way up. As bare configurations the space is
loose (a random 10×10 board has ~50 flippable cells), but the sight-line
arithmetic silences almost all of them, and what ambiguity survives is
almost entirely single silent flips.

Two columns deserve a stare. Clue every cave cell (density 1.00) and the
board is always unique — yet count alone still finishes only 2% of
them. The numbers pin the answer without being able to reach it: only
connectivity knows the cave is one room and the walls have doors. And once
connectivity propagates, proving uniqueness stops being a search: a median
of 0 guesses with bridge at 10×10 (mean 1.0) — while the
connectivity-free levels already explode at 6×6, riding the never-clued
free walls.

The shipped bank's boards, thinned adversarially instead of randomly, pin a
10×10 board with a median of 23–27 clues — half the budget a random reveal
needs for a coin-flip's chance.

Verification

Every claim is counted two independent ways. One engine searches with the
rule ladder propagating at each of the four levels. The other is a brute
force sharing no code with any of them: row-major DFS over free cells,
pruned only by the three definitional rules (clue min/max brackets,
cave reachability, wall-to-border reachability), every leaf scored by a
standalone validator. On every board the brute force can reach, all levels
must agree on the solution count: 400/400 (board, level) pairs.

Exhaustive anchors: clue-free 2×2 / 3×3 / 4×4 boards number 13 / 213 /
9,349, matching the independent lattice-cycle counter on all three
(A140517). The boundary-loop theorem is verified not just on generator
output (that would be circular) but on every valid board up to 4×4. And
every flip the 3×3 stamp accepts is re-checked by the standalone validator
— never a broken board. All 25 tests.

Play it

The Hint button proves one cell at a time at the selected level; the rule
selector doubles as the difficulty dial, and the bank only serves boards
that first become guess-free at that level. The cave's boundary is drawn
live in purple — you can watch it close into a single fence as the board
finishes. The moment it closes, you have also solved the Corral.

Next up: probably another puzzle with a solver inside.

SEN LLC — software development experiments, shipped in public.
More portfolio: https://sen.ltd/portfolio/

Yin-Yang: two global rules force one unbroken curve — every solved board is literally a yin-yang symbol

SEN LLC — Tue, 11 Aug 2026 00:03:18 +0000

Yin-Yang (Shiromaru-Kuromaru) in the browser with four rule sets
inside. Color every cell of an n×n grid black or white. Two rules only:
each color forms one orthogonally connected group, and no 2×2
square is a single color. Puzzle #35 in the solver series.

Demo: https://sen.ltd/portfolio/yin-yang/
Repo: https://github.com/sen-ltd/yin-yang

I picked this one because the name is a theorem.

The name is a theorem

Read the frontier — the set of grid edges separating a black cell from a
white one — as a curve on the lattice points. The two rules translate
directly into properties of that curve:

a monochrome 2×2 is an interior lattice point the curve misses: the four cells around a point agree exactly when no frontier edge touches it;
a checkered 2×2 is a point where the curve crosses itself — and it's forbidden even though no rule says so: the diagonal black pair and the diagonal white pair would each need a connecting path, and two disjoint paths between opposite corners of a square cannot avoid crossing in a planar grid. Connectivity's local shadow;
a second frontier component would cut the board into three or more monochrome regions, two of which share a color they cannot reach.

So in every legal board the frontier is a single non-crossing curve
through every interior lattice point — a Hamiltonian path on the
(n−1)×(n−1) interior grid, extended one edge to the border at each end.
Rarely it closes into a Hamiltonian cycle instead, and one color becomes
landlocked.

Sanity check at 2×2: one interior point, the curve just passes through it,
C(4,2) = 6 ways to pick its two edges, times two colorings — 12 boards.
Exhaustive enumeration also says 12. The 3×3 count is 34 (2 of them
landlocked: a lone stone in the center — the purest yin-yang symbols), the
4×4 count is 96. Six counting engines agree on all of these.

Across 1,500 generated boards: frontier components always 1, crossings
always 0, border color changes always 0 or 2. Zero exceptions — which is
why the demo's win message says so.

The generator runs the theorem backwards

The first generator was naive: place random colors on random cells,
propagate, backtrack on contradiction. 6×6 took 3ms per board. 10×10 took
5.6 seconds — scattered placements plant connectivity failures that only
surface deep in the search.

So use the theorem instead. Valid board ⟺ Hamiltonian path, so draw the
curve, not the coloring:

start from a serpentine Hamiltonian path over the interior lattice;
mix it with backbite moves (reattach an endpoint to a random neighbor and reverse the tail — the standard Markov chain for random Hamiltonian paths on grids);
keep mixing until both endpoints sit on the interior's edge, extend each to the border;
flood the two sides of the curve with the two colors.

Zero backtracking, 0.6ms per 10×10 board — about 9,000× faster. The
generator benefits from the theorem before the solver ever does.

Four rule sets

The solver whittles per-cell candidates cand[k] ∈ {black, white, both}.

level	rule
`window`	enumerate the 12 legal colorings of a 2×2 (16 minus 2 monochrome minus 2 checkered) consistent with the current cells; fix what every survivor agrees on
`border`	the border cells form a cycle and each color may occupy at most one arc of it — decided border cells may never show more than 2 color changes around the ring
`bridge`	connectivity made local: placed cells of a color must stay mutually reachable through (that color ∪ free); a free cell sealed off from a color can't take it, a free cut vertex between two placed cells must. One Tarjan articulation-point pass per color, O(V+E)
`probe`	assume one color on one cell, run the rules below to a fixpoint, drop the assumption if that alone is a contradiction

Only half of the window rule is stated in the puzzle. The checkered ban
and the border-arc rule are both cheap local shadows of the one expensive
global rule. The independent validator doesn't know about either — it
checks the two definitional rules only, and the shadows have to emerge.

Incremental vs ablation — they disagree again, harder than ever

Three sizes × 300 boards from the raw generator stream, unfiltered by
uniqueness or difficulty (so the numbers aren't shaped by the property they
measure). Clue density 0.8, fraction finished by the fixpoint alone:

board	window	+border	+bridge	+probe	unique in the raw stream
6×6	2.3%	16.7%	57.3%	57.3%	57.3%
8×8	0.0%	2.7%	39.3%	39.3%	39.3%
10×10	0.0%	0.0%	16.7%	17.0%	17.0%

Ablation — full ladder minus one rule:

board	full	−window	−border	−bridge
6×6	57.3%	15.3%	57.3%	16.7%
8×8	39.3%	2.3%	39.3%	2.7%
10×10	17.0%	0.0%	17.0%	0.0%

Incrementally, border looks like a supporting actor: +14.4pt at 6×6.
Ablate it and nothing drops, at any size — window+bridge+probe catch
every board it would have caught. Remove window or bridge instead and
10×10 collapses to 0.0%. This series keeps finding incremental/ablation
disagreements; this is the most extreme one yet.

Border still earns its keep, though: it defines a real difficulty grade —
its bank boards (median 11 clues at 6×6) sit exactly between window's (20)
and bridge's (8) clue budgets — and it's the rule human solvers actually
play with. Redundant is not the same as useless, third time running.

Certifying uniqueness (solution count = 1) on 100 raw 10×10 boards needs a
median of 527 search guesses with window alone, 21 with border, 2 with
bridge. The moment connectivity enters the propagation, uniqueness
checking almost stops being a search.

Probe's solve rate = the uniqueness rate, again

The probe column equals the uniqueness column at every size. A sound
fixpoint cannot decide a cell that two answers disagree on, so the
uniqueness rate is a ceiling — and the ladder sits on it, at every size and
every density point below.

Yin-Yang is starving for clues

The density sweep, 10×10, 150 boards per point:

density	unique	flip ceiling E[d^flips]	bridge-solved	window-solved
0.50	0.0%	80.0%	0.0%	0.0%
0.70	2.7%	88.5%	2.7%	0.0%
0.80	16.7%	91.1%	16.7%	0.0%
0.90	60.7%	95.1%	60.7%	1.3%
0.95	88.7%	97.5%	88.7%	8.7%
1.00	100.0%	100.0%	100.0%	100.0%

Reveal 90% of the board at random and 4 boards in 10 still have more than
one answer. Far worse than Slant's threshold (50% unique at density 0.75).

To find out why, I counted flippable cells: cells whose lone color flip
keeps the whole board valid. Any flippable cell left unclued is a free
second solution, so P(unique) ≤ E[density^flips]. But random boards average
only 0.4 flippable cells at 10×10, so that ceiling is high — and the
measured curve sits far below it everywhere short of 1.0. The gap is the
finding: Yin-Yang's ambiguity lives in multi-cell reroutes of the curve,
not single-cell flips. Where the frontier crosses a clue-free region, many
paths fit, and one clue kills only one of them.

The shipped bank is thinned adversarially instead (start from the full
reveal, delete clues while the target level still finishes without
guessing): a probe-grade 10×10 board pins the answer with a median of 24
clues — certainty that a random reveal of 90 cells still fails to buy 40%
of the time. A clue is only worth something where it pins the curve.

Landlocked boards have a parity

Boards whose frontier closes into a loop — one color never touching the
border — exist, but they're rare and they carry a parity. Exhaustively:
exactly 2 at 3×3, none at 4×4 or 6×6 (full enumeration of all interior
subsets), and explicit constructions at 5×5 and 7×7 (they're in the tests).
On even boards the corner 2×2 windows pin interior stones into a monochrome
square. In 1,500 random configurations: zero closed curves.

Verification

Every claim is counted two independent ways: a propagating search at each
of the four rule levels, and a brute force that shares no code with any of
them — row-major DFS over free cells, pruned only by the two definitional
rules (a completed monochrome 2×2 is dead; placed cells of a color must
stay mutually reachable), every leaf scored by a standalone validator.
Wherever the brute force is feasible, all levels must agree on the solution
count: 360/360 (board, level) pairs.

Exact anchors: the clue-free 2×2 / 3×3 / 4×4 boards count 12 / 34 / 96,
and the frontier theorem is verified over all valid boards up to 4×4 —
not just generated ones, which would be circular, since the generator draws
boards from curves. All 33 tests.

Play it

The Hint button proves one cell at a time at the selected level; the rule
selector doubles as the difficulty dial, and the bank only serves boards
that first become guess-free at that level. The black–white frontier is
drawn live in purple — you can watch it join up into a single curve as the
board closes.

Next up: probably another puzzle with a solver inside.

SEN LLC — software development experiments, shipped in public.
More portfolio: https://sen.ltd/portfolio/

Gokigen Naname (Slant): the no-loop rule is a counting theorem — every board is a forest with exactly 2n+1 trees

SEN LLC — Sun, 09 Aug 2026 23:22:51 +0000

Gokigen Naname (Slant) in the browser with four rule sets inside.
Fill every cell of an n×n grid with one diagonal — / or \**. A circled
number on a lattice point counts the diagonals whose tip touches it, and
the diagonals must **never close a loop. Puzzle #34 in the solver series.

Demo: https://sen.ltd/portfolio/gokigen-naname/
Repo: https://github.com/sen-ltd/gokigen-naname

I picked this one because the rule that looks topological — no loops — turns
out to be arithmetic.

The no-loop rule is V − E

Every cell adds exactly one edge to a graph on the (n+1)×(n+1) lattice
points: \ joins the cell's top-left and bottom-right corners, / joins the
other two. Either way, one edge. A finished board is therefore n² edges on
(n+1)² vertices.

A graph with no cycle has exactly V − E connected components, and
(n+1)² − n² = 2n+1. Every legal Slant board is a spanning forest with
exactly 2n+1 trees, whatever the clues say. The component count is not a
degree of freedom. Measured over 1,500 generated boards: 2n+1 trees, zero
exceptions — which is why the demo's win message says so.

export function edgeOf(k: number, orient: number, n: number): [number, number] {
  const [tl, tr, bl, br] = cornersOf(k, n);
  return orient === BACK ? [tl, br] : [tr, bl];
}

The whole puzzle is a paraphrase of that function, and every rule in the
solver is a sentence about it.

The four rule sets

The solver prunes a candidate array cand[k] ∈ {/, \, both}.

level	rule
`count`	one clue at a time: placed diagonals reach the number → the rest turn away; the undecided cells are exactly the missing ones → they all turn in
`cycle`	a union-find over the lattice points; an orientation that would join two already-connected points is dead
`duet`	two orthogonally adjacent clues read as one constraint: enumerate the ≤64 joint assignments of their ≤6 cells, keep only what every survivor agrees on
`probe`	assume one diagonal, run the rules below to a fixpoint, drop the assumption if that alone is a contradiction

duet swallows the textbook tricks whole. "Adjacent 3s force the four outer
diagonals in", "adjacent 1s make their flanking cells equal" — special cases
of the enumeration.

The second of those hides a trap. What the textbook rule actually
concludes about the two cells flanking adjacent 1s is "A and B point the same
way" — the output is not a cell value but an equality between two cells.
A unary propagator cannot write that down, and the enumeration confirms it:
both A=B=/ and A=B=\ survive, so no cell is forced. Try to translate classic
techniques into propagators one-for-one and you discover some of them output
relations, not values. duet extracts the unary part; the leftover equality
fires through count the moment one side decides; whatever still escapes is
probe's job. The test for adjacent 3s shows exactly this shape — four outer
cells forced, the two middle cells still open as an XOR:

expect(c2[cellId(1, 1, 5)]).toBe(BACK); // outer: forced by duet
expect(c2[cellId(1, 2, 5)]).toBe(BOTH); // middle: only a relation survives

Incremental and ablation tell different stories

300 raw generator boards per size, clue density 0.75, unfiltered by
uniqueness or difficulty — so the numbers are not shaped by the property they
measure. Fraction finished by the fixpoint alone:

board	count	+cycle	+duet	+probe	unique answers in the raw stream
5×5	78.7%	82.0%	82.7%	83.3%	83.3%
7×7	56.3%	62.7%	66.7%	68.3%	68.3%
10×10	31.7%	42.7%	52.7%	55.0%	55.0%

Now the same rules ranked by ablation — full ladder minus one rule, same
boards:

board	full	−count	−cycle	−duet
5×5	83.3%	71.7%	79.3%	83.3%
7×7	68.3%	55.7%	60.3%	68.3%
10×10	55.0%	39.0%	40.7%	55.0%

Incrementally, duet looks like the hero of 10×10: +10.0 points. Ablate it
and not a single board is lost — the probe behind it catches every board
it would have caught. Remove cycle instead and the full ladder drops 14.3
points: probe cannot substitute for it. Same "measured against the bench"
problem as the last two puzzles in the series. But redundant is not useless:
what duet buys is finishing boards without guessing that cycle alone
cannot — precisely what a difficulty grade measures, so the shipped bank's
four grades include a duet tier, and every (size, grade) bucket is full.

The −count column is my favourite: delete the fundamental rule and the
ladder still solves 39% of 10×10 boards, because duet quietly re-derives
counting for every clue that has an orthogonal neighbour. At density 0.75
most clues do; only the isolated ones go completely invisible.

Probe = uniqueness, again

In the first table the probe column equals the unique-answer column at
every size — and across all eleven points of the density sweep below, too.
A sound fixpoint can never finish a board with two answers, so "solved by
rules" is capped by the uniqueness rate. The ladder sits exactly on that
ceiling.

Slant is clue-hungry

Sweeping clue density on 10×10 boards, 150 per point:

density	unique	probe	count
0.55	1.3%	1.3%	0.0%
0.65	11.3%	11.3%	2.0%
0.75	50.7%	50.7%	28.0%
0.85	90.7%	90.7%	85.3%
0.95	100%	100%	100%

The threshold is sharp: nearly nothing decides at 0.55, everything at 0.95.
One clue is a weak constraint — a number 0–4 over at most four cells —
against n² bits of board freedom. Published Slant puzzles put numbers on more
than half the lattice points, and that is not a stylistic choice; it is
information-theoretic necessity. (Degree distribution of the raw stream at
10×10: 0/1/2/3/4 = 8.6 / 38.5 / 34.8 / 15.1 / 2.9% — clue 4s are rare by
statistics, not by design.)

Certifying uniqueness barely needs search at the top of the ladder: over 100
raw 10×10 boards, the median number of branchings to confirm the solution
count was 1 for count, 1 for cycle, and 0 for both duet and
probe.

Checking it

Two independent counters score every board: a propagating search run at each
of the four rule levels, and a brute force that shares none of their code —
row-major cell order, nothing but degree arithmetic and a rollback
union-find, every leaf judged by a standalone validator. All levels must
agree with the brute force on the number of solutions of every board — a
sound rule set cannot change how many solutions a board has.

One exact anchor: a clueless 2×2 board has 15 fillings — 2⁴ = 16
assignments minus the single diamond loop around the centre point. All five
counters agree on 15. 27 tests.

Play it

The Hint button fills one provable cell at the selected level; the rules
selector doubles as difficulty, and the bank only serves boards that first
become guess-free at that level. A probe-grade 10×10 needs an assumption even
after count, cycle and duet have all had their say.

Next up: another puzzle with the solver built in.

SEN LLC — public experiments in software.
More of the portfolio: https://sen.ltd/portfolio/

Tentai Show: one mirror map is the whole puzzle, and every deduction happens twice or not at all

SEN LLC — Sat, 08 Aug 2026 23:30:04 +0000

Tentai Show (Spiral Galaxies) in the browser with four rule sets
inside. Divide the grid into regions, one per dot, so that every region
contains its dot, is connected, and maps onto itself under a 180° turn
about that dot. Dots sit on cell centres, edge midpoints, or lattice
points. Puzzle #33 in the solver series.

Demo: https://sen.ltd/portfolio/tentai-show/
Repo: https://github.com/sen-ltd/tentai-show

I picked this one because the whole puzzle folds into a single map. The rules
say three things — contains its dot, connected, 180°-symmetric — and once you
start implementing, two and a half of those turn out to be sentences about one
one-line function.

Doubled coordinates and the three kinds of dot

A dot can sit on a cell centre, an edge midpoint, or a lattice point. That
looks like a case analysis until you double the coordinates. Put the centre of
cell (r, c) at (2r+1, 2c+1); a dot position (cy, cx) with integers in
[1, 2n−1] is a cell centre when both are odd, an edge when exactly one is
even, a lattice point when both are even. And the mirror of cell k through dot
g is:

export function mirrorOf(k: number, g: Galaxy, n: number): number {
  const r = g.cy - rowOf(k, n) - 1;
  const c = g.cx - colOf(k, n) - 1;
  return r >= 0 && r < n && c >= 0 && c < n ? r * n + c : -1;
}

2·cy − (2r+1) is odd whatever the parity of cy, so the mirror of a cell is
always exactly one cell, for every kind of dot. The case analysis only ever
resurfaces when enumerating the 1, 2 or 4 cells a dot physically touches.

The four-rule ladder

The solver prunes a candidate array cand[g][k] — "galaxy g can still own
cell k".

level	rule
`mirror`	a cell and its twin stand or fall together — in both directions: a dead twin kills the cell, and a pinned cell pins its twin
`reach`	a region is connected and contains its dot, so g dies wherever a cell cannot walk home to the dot through surviving candidates
`bridge`	a cell pinned to g must stay connected to its dot; a cell on the only remaining corridor is taken
`probe`	assume one pairing, run the rules below to a fixpoint, drop the pairing if that alone is a contradiction

The pair theorem — every deduction happens twice

One invariant falls out of the construction: each galaxy's candidate set
stays 180°-symmetric about its dot through the entire ladder.

Each rule commutes with the rotation. The mirror closure is symmetric by
definition. The reach BFS walks a symmetric set from symmetric sources (the
cells the dot touches), so the reached set is symmetric. If a corridor cell
forced by bridge is an articulation point, so is its twin. A probe
contradiction replays verbatim on the mirrored side. So prune a candidate on
one side of a dot and the twin falls in the same round. Deductions happen
twice or not at all.

This is measurable: 3 sizes × 300 boards × 4 levels = 3,600 fixpoints,
zero asymmetric candidate sets.

A corollary comes free. A galaxy whose dot sits on an edge or corner covers an
even number of cells; a centre dot covers an odd number. That parity rule
looks worth implementing — and it can never fire. Under the symmetric
closure, undecided cells arrive in twins, and a twin contributes zero or two
cells: every parity the rule could check is already correct. A rule that
cannot fire is a theorem of the rules below it.

The trap I stepped in — writing half of the mirror rule

My first mirror said: "if g is dead at the twin, kill it here". That
transfers candidate death. But the definition of symmetry is stronger — if
a cell is in g's region, so is its twin. The information "this cell's
candidates collapsed to g" never reaches the twin through death-transfer
alone.

// Ownership transfers too: a cell pinned to g pins its twin through g.
for (let k = 0; k < nc; k++) {
  const g = assignedAt(model, cand, k);
  if (g === -1) continue;
  const m = model.mirror[g * nc + k];
  for (let h = 0; h < model.galaxies.length; h++) {
    if (h !== g && cand[h * nc + m]) cand[h * nc + m] = 0;
  }
}

With that half missing, grading boards by the weakest level that finishes them
collapsed to {mirror, probe}: all sixteen 7×7 bank boards graded probe.
Pinned cells never propagated, so every deduction the middle rules should have
made was swallowed by probe. With both directions in, the same generator and
seeds spread the 7×7 bank to mirror 9 / reach 6 / bridge 1. Before measuring
how strong your rule sets are, check that each rule uses all of its own
definition.

The connectivity cliff

300 raw boards per size, unfiltered — filtering the population by the
property you measure makes the column meaningless. Fraction finished by the
fixpoint alone:

board	mirror	+reach	+bridge	+probe	unique answers in the raw stream
5×5	94.3%	97.7%	98.0%	98.0%	98.0%
7×7	63.3%	93.3%	95.3%	95.3%	95.3%
10×10	2.7%	87.3%	92.3%	93.0%	93.0%

mirror falls off a cliff, from 94.3% on 5×5 to 2.7% on 10×10. Mirrors
preserve distance, so "the twin is off the board" prunes less and less as
boards grow — and mirror never once asks whether a cell can still walk
home. reach asks exactly that and lifts 10×10 back to 87.3%. Connectivity
is the rule that pays.

Ablation measured "value relative to the bench", again

Same boards, all four rules minus one:

board	full	−mirror	−reach	−bridge	−probe
5×5	98.0%	5.3%	95.0%	98.0%	98.0%
7×7	95.3%	0.0%	74.0%	95.3%	95.3%
10×10	93.0%	0.0%	31.0%	92.7%	92.3%

Incrementally (the +bridge column of the ladder), bridge looks like
+5.0 points on 10×10. In the ablation it is worth −0.3 points — take
it out and probe picks up nearly every ball it drops. This is the same lesson
the previous puzzle in this series taught: a propagator has no intrinsic
contribution, only a contribution relative to a particular bench. Publish the
incremental ladder and the ablation, because either one alone will lie.

The solve rate is capped by uniqueness — and the ladder hits the cap

Look at the table again: the solve rate at probe equals the unique-answer
rate of the raw stream, to the decimal, at all three sizes (98.0 / 95.3 /
93.0%). Not a coincidence. Sound propagation can never kill a true solution,
so a fixpoint can never finish a board that has two answers. "Solved by
rules" is bounded above by "unique", and this ladder reaches the bound
exactly. Every unsolved board in those columns is a multi-solution board,
where no sound rule could ever help.

That 93–98% of the raw stream is unique at all is this puzzle's own
personality: the mirror constraint is brutal on its own. Even a brute force
with no candidate arrays — walk cells row-major, assign twin pairs in one
stroke, never look at connectivity until a leaf hands the finished division to
an independent flood-fill validator — enumerates all solutions of a 5×5 in a
median of 5 nodes. The uniqueness check on a 10×10 needs a median of 142.5
guesses at mirror, and 0 once reach is in.

Verification

Count agreement: the propagating search at all four levels and the brute force above count the same number of solutions on random small boards. A sound rule set cannot change the count, so one level disagreeing would convict that rule.
Independent validator: shares no code with the model or the rules; flood-fills every region at every leaf and every solver exit.
Soundness: the generator's own division survives the probe-level fixpoint with zero candidates lost, on random boards.
The pair theorem: symmetry of every candidate set audited after every fixpoint (the 3,600-run version of the same check).

27 tests.

Takeaways

Doubled coordinates collapse three kinds of dot into one one-line mirror map
Candidate sets stay 180°-symmetric through the whole ladder (3,600 fixpoints, zero violations): deductions happen twice or not at all
The parity rule cannot fire — it is a theorem of the mirror closure. Knowing which rules you don't have to write is also a payoff
The mirror rule has two directions, death and ownership; write half of it and your difficulty grades quietly collapse
mirror drops to 2.7% on 10×10; connectivity brings back 87.3%
bridge: +5.0pt incremental, −0.3pt in ablation — publish both numbers
A sound fixpoint's solve rate is capped by the uniqueness rate, and this ladder hits the cap at every size

SEN LLC builds small, well-measured software and writes up what it learns.
More at sen.ltd/portfolio.

Shakashaka: the rule is about whole regions, and it is exactly a rule about one lattice point

SEN LLC — Fri, 07 Aug 2026 23:37:55 +0000

Shakashaka in the browser with five rule sets inside. Drop black
triangles into the white cells — each fills half a cell, right angle in one
of the four corners — so that every piece of white left over is a
rectangle, upright or turned 45°. A number on a black cell says how many of
the four cells around it hold a triangle. Puzzle #32 in the solver series.

Demo: https://sen.ltd/portfolio/shakashaka/
Repo: https://github.com/sen-ltd/shakashaka

I picked this one because its main rule is stated in the worst possible shape
for a solver. "Every white region is a rectangle" is a sentence about connected
components: you cannot ask it anything until the last cell is filled, and once
you finally can, answering it costs a flood fill. Every other puzzle in this
series hands you something local to propagate. This one hands you a region.

Except it does not, quite. The rule turns out to be exactly equivalent to a
condition on the white angle at a single lattice point — eight bits and a table
lookup, no regions anywhere — and that changes what a solver can be.

Three findings:

The global rule is local, and provably so. Every maximal run of white 45° sectors around a lattice point must be 90°, 180° or 360°. I checked that against a flood-fill oracle on 12.5 million configurations, including every picture on every 3×3 board. Zero disagreements.
The obvious local rule is wrong in both directions at once. "The white angle at a point is a multiple of 90°" accepts 13 958 pictures on an empty 4×4 board where only 23 are legal — while rejecting 21 of those 23.
Adding a redundant propagator moved another propagator's ablation score by 27 points. Same rule, same boards, same metric. A propagator does not have a contribution; it has a contribution relative to a set.

The rule that will not propagate

Here is the whole puzzle. Cells are black (given, sometimes numbered) or white.
In a white cell you may place one black right triangle filling half the cell,
right angle in one of the four corners, or leave the cell alone. So each white
cell has five states.

export const E = 0;    // no triangle: white to the edges
export const TNW = 1;  // right angle at the NW corner
export const TNE = 2;
export const TSE = 3;
export const TSW = 4;

And then: the white area left over must be a disjoint set of rectangles,
upright or turned 45°.

A search wants to hear no as early as possible. This rule says nothing at all
until every cell is decided, at which point a flood fill tells you whether the
last five hours were wasted. That is a leaf test, and a leaf-only search over
84 white cells has 5^84 ≈ 10^59 states to walk.

Eight bits around a point

Stand on a lattice point — a corner of the grid, not a cell. Four cells meet
there. Each one contributes a white angle of 0°, 45° or 90°, and nothing else
about the board is visible from where you are standing.

Chop the full turn into eight 45° sectors, numbered clockwise from north:

sectors 0,1 → the cell NE of the point      2,3 → SE
        4,5 → SW                            6,7 → NW

Each cell state fills two of those bits. A black or off-board cell fills none.
An empty white cell fills both of its quadrant's bits. A triangle fills both if
its right angle is in the far corner, none if it is in the near corner, and one
of the two otherwise:

export const PAT: number[][] = [
  // q0: the cell NE of the point; the point is that cell's SW corner.
  //     E     TNW   TNE   TSE   TSW
  [0b11, 0b10, 0b11, 0b01, 0b00],
  [0b11, 0b00, 0b10, 0b11, 0b01],  // q1: SE
  [0b11, 0b01, 0b00, 0b10, 0b11],  // q2: SW
  [0b11, 0b11, 0b01, 0b00, 0b10],  // q3: NW
];

Now the claim. Take the maximal unbroken cyclic runs of white sectors around
the point. Then:

The white area is a disjoint set of rectangles ⟺ every run is 2, 4 or 8
sectors long.

90°, 180° or 360°. A corner, a straight edge, or the inside of something.

Why that is enough: every vertex of the white boundary sits on a lattice point
(triangle hypotenuses go corner to corner), so the boundary of a white region
is a polygon with lattice-point corners. A run of 4 is a straight point, a run
of 8 is an interior point, and a run of 2 is a corner turning 90°. Rule out
everything else and a region's boundary is a simple polygon whose every corner
turns 90° in the same direction — which has exactly four corners, because the
turns must sum to 360°. Four corners, all right angles: a rectangle. And the
edges are cell sides or cell diagonals, so consecutive perpendicular edges are
either both axis-aligned or both diagonal. Upright or 45°, nothing in between.

Runs of 6 are the reflex corners that make an L an L. Odd runs are 45° wedges —
the tip of a lone triangle. Both are exactly what the rule forbids, and there
is no third failure to rule out.

So the entire rule is a 256-entry table:

export const VALID_FULL = table((arcs) => arcs.every((L) => L === 2 || L === 4 || L === 8));

Runs, not the total — and this is where I would have shipped a bug

The version you write first is "the white angle at each point adds up to 0°,
90°, 180° or 360°". One popcount, no arc decomposition, obviously the same
thing.

It is not the same thing, and it is not even a safe approximation. It is wrong
in both directions:

board	legal	naive says legal	legal ones it rejects	illegal ones it accepts
empty 2×2	2	13	0 (0%)	11
empty 3×3	3	1	2 (67%)	0
empty 4×4	23	13958	21 (91%)	13956

On an empty 4×4 there are 23 legal pictures. The naive rule accepts 13 958 of
them and agrees with reality on two.

Both failures come from one fact: two rectangles may touch at a single
point. Two white 1×1 squares on a diagonal, with black cells on the other
diagonal, is the most ordinary picture in the puzzle. At the shared corner that
is 180° of white — but split into two separate right angles. Sum the angle and
you cannot tell it from a straight edge, so:

45° + 45° in opposite quadrants sums to 90° and gets accepted, though it is two illegal wedges;
180° + 90° as two separate runs sums to 270° and gets rejected, though it is a perfectly legal edge next to a perfectly legal corner.

The temptation is to file this under "edge case". It is not. Counting the
lattice points of the answers shipped with the demo:

board	lattice points	empty	one corner	one edge	interior	two arcs
6×6	784	10%	38%	16%	11%	25% (on 16/16 boards)
8×8	1296	8%	35%	16%	13%	28% (on 16/16 boards)
10×10	1936	5%	33%	13%	13%	35% (on 16/16 boards)

A third of the lattice points on a 10×10 answer are places where two separate
pieces of white touch at a point. The naive rule is wrong on every board there
is.

How do you test a claim like that?

An equivalence between a global property and a local one is not something a
unit test can assert directly. What you can do is build the other reading —
properly, independently — and run both on everything.

The literal reading needed to avoid every concept the local rule uses: no
angles, no corners, no sectors. Here is what I landed on.

Cut every cell into four quarter triangles with both diagonals. Every legal
half-cell triangle is a union of two of them, so the quarters are the atoms of
the picture:

black corner NW → black quarters N, W      NE → N, E
             SE → S, E                     SW → S, W

Flood fill the white quarters — edge adjacency only, so two regions touching at
a point stay two regions. Then, for each region, the rectangle test is areas:

// A quarter triangle has area 1 in doubled coordinates.
const upright = (Xmax - Xmin) * (Ymax - Ymin);
const tilted = (Umax - Umin) * (Vmax - Vmin);   // = 2 × the tilted box area
if (count !== upright && 2 * count !== tilted) { /* not a rectangle */ }

where U = X + Y and V = X − Y. A region always fits inside its own bounding
box, so if the areas are equal the region is the box — no shape comparison
needed, and it is exact integer arithmetic because doubling the coordinates
puts cell corners on even numbers and cell centres on odd ones. Upright
rectangles are boxes in (x, y); 45° ones are boxes in (x+y, x−y). There is
no third orientation to worry about.

Then run both readings on everything I could afford:

configurations	source	legal ones among them
625	every picture on an empty 2×2	2
1,953,125	every picture on an empty 3×3	3
46,656	every picture on every 2×3 board, black cells and all	46
10,077,696	every picture on every 3×3 board, black cells and all	328
400,000	random pictures on crowded random 5×5 boards	1
75,264	every one- and two-cell edit of every answer in the bank	232

That fourth row is 6^9: nine cells, each of them black or one of five states.
Every Shakashaka board of that size, and every picture on it.

The last row is the one that matters, though. Look at the "legal" column on the
random 5×5 sweep: one legal picture in 400 000. Random boards only exercise
the easy side of the claim — both readings say no, loudly, for unrelated
reasons. Boards that are one or two cells away from a real answer are the ones
sitting on the boundary, and 232 of those 75 264 are legal. That is the sweep I
would trust if I had to pick one.

A separate test pins the table itself to the geometry: for all 1296 ways four
cells can meet at a point, step a hair away from the point in the middle of
each of the eight sectors and ask the actual picture — x + y > 1, y > x —
whether that spot is white. If PAT had one bit wrong, everything above would
be a self-consistent verification of the wrong thing.

What it buys

The local rule is a constraint over four cells with five values each, so it is
an arc-consistency propagator. Each cell's domain collapses to at most four
distinct 2-bit patterns, which makes the whole constraint 16 bits in, 16 bits
out, memoised:

const packed = supported(rules.valid, key);
for (let q = 0; q < 4; q++) {
  const next = dom[cells[q]] & STATESET[q][(packed >> (4 * q)) & 15];
  if (next === 0) return false;
  ...
}

Same search, same boards, same answers — the only difference is whether the
rules may look before the leaves:

board	white cells	answers	nodes, propagating	nodes, leaf checks only	ratio
3×3	6	0	0	19,531	19,531×
3×3	8	2	3	488,281	162,760×
4×4	11	1	1	61,035,156	61,035,156×

And on the boards the demo ships, the right-hand column stops being a number
you can print:

board	white cells	nodes to settle it	states without pruning
6×6	30	1 (median)	5^30 ≈ 10^21
8×8	54	1.5 (median)	5^54 ≈ 10^38
10×10	84	1 (median)	5^84 ≈ 10^59

A median of one node. On the shipped boards, arc consistency over the lattice
points settles the entire answer without a single guess.

The per-test speed is the boring half of the win and it is there too — 10.5 µs
for the flood fill against 3.2 µs for the table lookups on the same finished
boards — but three times faster is not the point. Being askable at all, on a
board that is one tenth filled, is the point.

Two ways to score a propagator, and they disagree

The full rule splits into two independent local rules: tips (no odd runs —
no 45° wedges) and reflex (no runs of 6 — no corner bending the wrong way).
Their intersection is the whole thing, which is a nice test to have:

expect(Array.from(intersect(VALID_TIPS, VALID_REFLEX))).toEqual(Array.from(VALID_FULL));

I added a fourth, deliberately: parity — the white angle at a point must be
a whole number of right angles, never mind where the sectors sit. That is one
popcount instead of an arc decomposition, it is implied by tips, and it is
exactly the kind of cheap approximation someone reaches for.

Climbing the ladder — what can this rule do that the weaker ones cannot:

board	rule set	reduction	finished
10×10	(nothing)	0.0%	0%
10×10	clues	5.3%	0%
10×10	clues + parity	24.0%	0%
10×10	clues + parity + tips	74.7%	0%
10×10	clues + parity + tips + reflex	93.8%	27%

Leave one out — what can this rule do that the stronger set cannot:

board	dropped	reduction	finished	vs. full set
10×10	(nothing)	93.8%	27%	—
10×10	clues	68.8%	0%	−25.0% reduction, −27 boards
10×10	parity	93.8%	27%	−0.0% reduction, −0 boards
10×10	tips	32.9%	0%	−60.9% reduction, −27 boards
10×10	reflex	74.7%	0%	−19.1% reduction, −27 boards

Incrementally parity is the second-biggest jump on the ladder — it more than
four-times the reduction over clues alone. By ablation it is worth zero, to
the last decimal, at every board size. That much I expected; it is redundant by
construction, and it is the same shape of result I got out of the previous
puzzle in this series.

What I did not expect was the other direction. Score tips by ablation against
two different sets:

board	set	without `tips`	drop in reduction
10×10	clues + tips + reflex	6.1%	−87.7%
10×10	clues + parity + tips + reflex	32.9%	−60.9%

Same rule. Same boards. Same metric. The number moved by 27 points because a
different rule — one that is worth nothing on its own showing — was standing
behind it to catch what it dropped. Ablation does not measure a propagator. It
measures a propagator against a particular bench of substitutes, and adding a
redundant rule to the set quietly deflates the ablation score of the rule it
duplicates.

Which is the honest version of a thing I already believed: a propagator has no
contribution of its own. Report both directions or you are stating a
preference.

Who actually makes the answer unique

Take boards with exactly one answer, switch off one rule, count again:

board	boards	clues dropped: still unique	shape rule down to `tips`: still unique
6×6	60	5 (8%), median 6.5 answers	20 (33%)
8×8	60	0 (0%), median 52.5 answers	4 (7%)
10×10	36	0 (0%), median 335 answers	0 (0%)

Both halves load-bearing, and the shape rule is the bigger one — which is why
these boards carry so few numbers. The generator numbers every black cell from
the answer and then takes numbers away for as long as the answer survives:

board	black cells	numbers kept	share	which digits
6×6	6.0	1.7	28%	0:6% 1:37% 2:40% 3:16% 4:0%
8×8	10.0	3.3	33%	0:9% 1:25% 2:45% 3:16% 4:5%
10×10	16.0	5.5	35%	0:6% 1:29% 2:41% 3:21% 4:2%

Two thirds of the numbers are things the geometry already knew. A 10×10 board
here ships with about five numbers on it and one answer.

Cross-checking

Every count is produced three ways, and the tests fail if they disagree:

Propagating search — smallest-domain-first backtracking driven by arc consistency over the lattice points and the clues.
The same search with the propagators unplugged — assign cells in row-major order, test the rules only at the leaves. Same answers, up to 61 million times the nodes.
Brute force through validate — enumerate every assignment and re-read the rule book from the top: clue arithmetic, then flood fill and bounding boxes. The only pruning it is allowed is counting to four, so the thing under test stays untouched.

The rung labels are checked too, not just believed: for a generated board the
test takes the difficulty label, runs that rung, and asserts the domains it
reaches are the intended answer cell by cell. And a soundness test asserts that
every rung, on every board, keeps every real solution inside its domains —
which is the property that makes a propagator a propagator rather than a guess.

26 tests. TypeScript, no runtime dependencies.

Repo: https://github.com/sen-ltd/shakashaka
Demo: https://sen.ltd/portfolio/shakashaka/

Tatamibari: three of the four rules are an exact-cover matrix, and the fourth is the one that matters

SEN LLC — Thu, 06 Aug 2026 23:25:04 +0000

Tatamibari in the browser with five rule sets inside. Cut the grid
into rectangles so that every rectangle holds exactly one clue, and the clue
says what shape it is: + a square, - wider than tall, | taller than
wide. And one more rule, which belongs to no rectangle in particular:
no four rectangles may meet at a point. Puzzle #31 in the solver series.

Demo: https://sen.ltd/portfolio/tatamibari/
Repo: https://github.com/sen-ltd/tatamibari

I picked this puzzle because the first three rules are exact cover written
out verbatim — a rare thing, and a good excuse to write dancing links. What I
did not expect was how much of the puzzle turned out to live in the one rule
that would not go in the matrix.

Three findings:

The fourth rule cannot be a column, and it is the rule that makes the answer unique. Switch it off on 10×10 boards that have exactly one solution, and only 17% of them still do. One went to 1953.
Incremental reach and ablation gave me opposite verdicts on the same rule. One propagator looks like the second-biggest contributor climbing the ladder and is worth literally zero removed from the top.
The rule that does not fit does not help the search either. It costs 5–20% more nodes, because it has no column, so the column-choice heuristic cannot see it.

Three rules are a matrix

"Every cell belongs to exactly one rectangle" plus "every clue gets exactly one
rectangle, of the shape it asks for" is exact
cover with nothing left over. One
column per cell, one row per candidate rectangle, hand it to Algorithm X.

The pleasant surprise is what you don't need. My first sketch had n²
columns for the cells plus one column per clue, to force one rectangle per
clue. That second block is redundant. A candidate rectangle only exists if it
contains exactly one clue — a rectangle swallowing two clues is not a legal
piece — so the column for that clue's own cell already forces exactly one
rectangle per clue. The matrix is n² columns wide and that is all of it.

Generating the candidates is the whole model:

for (let r0 = 0; r0 <= cr; r0++) {
  for (let r1 = cr; r1 < n; r1++) {
    const h = r1 - r0 + 1;
    for (let c0 = 0; c0 <= cc; c0++) {
      for (let c1 = cc; c1 < n; c1++) {
        const w = c1 - c0 + 1;
        if (cl.type === '+' && w !== h) continue;
        if (cl.type === '-' && w <= h) continue;
        if (cl.type === '|' && h <= w) continue;
        if (clueCount(r0, c0, r1, c1) !== 1) continue;   // ← the load-bearing filter
        ...

clueCount is a 2-D prefix sum, so "how many clues does this rectangle
contain" is four array reads. It matters: a centre cell on a 10×10 board sits
inside 900 rectangles, and almost every large one swallows a second clue.

The fourth rule is not a column

No four rectangles may meet at a point.

This is not a statement about a cell being covered once. It is a statement
about a lattice point being cornered at most three times. Exact cover
speaks "exactly one" (primary columns) and, with Knuth's secondary columns,
"at most one". There is no way to write "at most three".

So it rides along the search as an incremental counter. Every rectangle knows
which interior lattice points it corners at, and when dancing links offers a
row, those counters get bumped:

for (let i = D[best]; i !== best; i = D[i]) {
  const a = ROW[i];
  // The one rule that is not a column.
  let bad = false;
  if (useCorners) {
    const cs = cands[a].corners;
    let t = 0;
    for (; t < cs.length; t++) {
      if (++cornerCount[cs[t].p] === 4) { bad = true; t++; break; }
    }
    if (bad) for (let u = 0; u < t; u++) cornerCount[cs[u].p]--;
  }
  if (!bad) { /* ...cover, recurse, uncover... */ }
}

Everything else in the function is textbook Algorithm X. The one rule I could
not express is fifteen lines bolted to the side of it.

Getting the corner predicate right is fiddly enough that I gave it its own
tests. A lattice point (lr, lc) has four cells around it, and a rectangle
owning the north-west one corners there only if it stops exactly at lr-1,
lc-1:

export function cornersAt(rect: Rect, lr: number, lc: number, q: number): boolean {
  switch (q) {
    case 0: return rect.r1 === lr - 1 && rect.c1 === lc - 1;  // NW cell
    case 1: return rect.r1 === lr - 1 && rect.c0 === lc;      // NE cell
    case 2: return rect.r0 === lr     && rect.c1 === lc - 1;  // SW cell
    default: return rect.r0 === lr    && rect.c0 === lc;      // SE cell
  }
}

There is a small lemma hiding in there that the propagator leans on: no
single rectangle can corner at two quadrants of the same point. NW wants
c1 = lc-1, NE wants c0 = lc, and c0 > c1 is not a rectangle. So "all four
cells corner here" really does imply "four distinct rectangles", which is what
lets the propagator work in terms of cornering rather than in terms of
identity. There is a randomised test asserting exactly this over 500 rectangles
× 25 points, because I did not want to find out later that I had been assuming
it.

And it is the rule that makes the answer unique

Here is the measurement I did not see coming. Take boards with exactly one
solution under all four rules. Switch off the one rule that would not fit in
the matrix. Count again. 60 freshly generated boards per size:

board	boards	still unique	solutions without it: median	mean	max
6×6	60	31 (52%)	1	2.2	15
8×8	60	24 (40%)	2	3.2	16
10×10	60	10 (17%)	5.5	66.4	1953

At 10×10, five out of six well-posed puzzles stop being puzzles. The matrix on
its own hands you a median of five and a half answers, and one board in the
sample had 1953.

The trend is the point. On 6×6 the corner rule is close to decorative — you
could nearly drop it and still ship. By 10×10 it is carrying the puzzle. The
part of the problem that fits the framework beautifully is not the part that
makes the problem well-posed, and the gap widens with size.

Most tilings are dead before a clue is written

The same rule does the same work one level up, on the generator. Draw random
rectangle tilings — no clues, nothing solved — and just ask how many are legal.
4000 draws per row, maxSide capping how long a piece may get:

board	maxSide	rectangles (mean)	four rectangles meet	survivors
6×6	2	18.8	100%	0%
6×6	4	10.7	60%	40%
6×6	6	7.6	29%	71%
8×8	2	32.7	100%	0%
8×8	4	17.9	84%	16%
8×8	6	13.4	60%	40%
10×10	2	50.5	100%	0%
10×10	3	34.8	100%	0%
10×10	4	27.3	95%	5%
10×10	6	19.8	76%	24%

Cap the pieces at 2×2 and not one tiling in four thousand survives, at any
board size. That is not a near miss, it is structural: a fine tiling by small
rectangles is made of points where four pieces meet. You need long pieces to
get away with it, which is exactly why real Tatamibari boards look the way they
do.

Useful going up, worthless coming down

The solver has five rule sets, each adding one propagator: shape (a clue with
one rectangle left is placed), cover (a cell only one clue can reach must be
inside that clue's rectangle), disjoint (a rectangle overlapping every
remaining rectangle of some other clue cannot be chosen), corners, probe.

Climbing the ladder, on 60 unique boards per size — share of surplus
candidates eliminated / share of boards finished outright:

board	shape	cover	disjoint	corners	probe
6×6	5% / 0%	76% / 28%	88% / 48%	99% / 97%	100% / 100%
8×8	3% / 0%	67% / 12%	87% / 32%	98% / 87%	100% / 100%
10×10	4% / 0%	54% / 2%	81% / 12%	96% / 82%	100% / 100%

disjoint looks indispensable. It takes 10×10 from 54% to 81% of candidates
cut and from 2% to 12% of boards finished — the biggest jump on the board
except for corners. I was pleased with it. It is the one rule in there I had
to think about.

Now drop one propagator from the full set instead. Same 60 boards, same
code:

dropped	6×6 cut / done	8×8 cut / done	10×10 cut / done
nothing	100% / 60	100% / 60	100% / 60
`shape`	100% / 60	100% / 60	100% / 60
`cover`	72% / 1	70% / 0	69% / 0
`disjoint`	100% / 60	100% / 60	100% / 60
`corners`	93% / 31	96% / 24	93% / 10
`probe`	99% / 58	98% / 52	96% / 49

disjoint is worth exactly nothing. Not "a percentage point" — zero, at
every size, on both measures. So is shape. Anything they can prove, cover
and corners prove anyway.

Two tables, same boards, same code, opposite verdicts. They are answering
different questions:

Incremental reach asks "what can this rule do that the weaker ones cannot?"
Ablation asks "what can this rule do that the stronger ones cannot?"

A rule sitting in the middle of a ladder answers the first question loudly and
the second one not at all. And the natural way to build a hint ladder — switch
propagators on one at a time and watch the numbers climb — measures only the
first. I would have shipped disjoint as a headline result on the strength of
that first table alone, and it would have been a headline about a rule that does
nothing.

This is the second time in this series I have gone looking for what a rule is
worth and got a different answer depending on where I stood. Last time
(Ripple Effect)
it was the solver-vs-generator split: a rule worth almost nothing to the solver
was deciding which boards existed at all. This time it is inside the solver:
the same rule, on the same boards, measured two defensible ways, comes out
essential and worthless. A propagator does not have "a" contribution. It has a
contribution relative to a set, and if you only ever report one set you are
reporting a preference, not a measurement.

They stay in the codebase, by the way — a hint ladder needs rungs a player can
reason with, and "that rectangle blocks that clue entirely" is an explanation,
not just an elimination. But they are not there to make the solver stronger,
because they don't.

corners is the only rule here load-bearing in both directions. Drop it and
10×10 goes from 60 boards finished to 10.

The rule that does not fit does not help the search either

The corner check cannot inform Knuth's column-choice heuristic. It has no
column, so it has no size, so S cannot see it. All it can do is reject a row
after the matrix has already offered one. DLX nodes to the first solution,
summed over the shipped bank:

board	boards	nodes with the check	nodes without	ratio
6×6	16	291	238	1.22×
8×8	16	291	277	1.05×
10×10	16	746	626	1.19×

5–20% more nodes. Which is the honest shape of the whole thing: the rule that
makes these puzzles well-posed is the rule the machinery cannot help with, and
it pays for its own enforcement.

I am not sure there is a fix, only a trade. You could encode "at most three of
these four" with auxiliary rows and secondary columns, at which point the
heuristic can see it — and you have added (n-1)² structures to a matrix
that was n² columns of pure signal. I did not try it. The counter is fifteen
lines and it is correct.

Where the clue sits inside its rectangle

There is no "prune the redundant givens" step in this generator, which is
unusual for the series. The clue count is fixed the moment the tiling is drawn
— one per rectangle. The only free variable left is where inside its rectangle
each clue sits.

That turns out to matter enormously, and for a reason specific to this puzzle:
a rectangle that would swallow a second clue is not a candidate at all. Move
one dot and the candidate sets of every clue near it change. Fix a tiling,
redraw only the clue positions, 16 layouts each:

board	tilings	unique layouts	tilings with ≥1 unique layout
6×6	120	27%	64%
8×8	120	5%	15%
10×10	60	0%	0%

At 10×10 not one of 960 randomly placed layouts was unique. The generator still
finds them — 5247 layouts over 10127 tilings for sixteen boards — but roughly
one draw in three hundred lands.

One more small thing, from the same run. Mean candidate rectangles kept per
clue:

| board | + (square) | - (wide) | \| (tall) |
|---|---|---|---|
| 6×6 | 2.3 | 5.6 | 5.4 |
| 8×8 | 3.7 | 12.8 | 11.2 |
| 10×10 | 3.7 | 15.3 | 12.3 |

A + pins both dimensions at once; - and | only put them in order. Same
symbol size, four times the information — and + barely grows with the board
(2.3 → 3.7) while - triples, because a square anchored at a cell has O(n)
shapes and an oblong has O(n²).

Cross-checking

Every shipped board is counted by two solvers that enumerate the problem in
opposite directions, and they have to agree:

dancing links over the cell columns, choosing the column with the fewest live rows;
an anchored brute force, keyed on the observation that the first uncovered cell in row-major order is necessarily the top-left corner of whichever rectangle owns it. Branching factor is "candidates anchored exactly here", and the enumeration order shares nothing with the matrix.

A third counter runs the rule sets to a fixpoint and branches on the clue with
the fewest survivors. The tests check all three agree, with the corner rule on
and off — the "off" case matters, because a corner-rule bug that only fires
when the rule is on would otherwise hide behind agreement.

And validate re-reads all four rules from scratch against a proposed tiling,
sharing no code with the model or any solver: it builds its own cell→rectangle
owner map and reads the corner rule straight off it. That is the one that would
catch a subtly wrong cornersAt.

One test failure was worth the trip. I had asserted that on an unsolvable board
the propagators either report a contradiction or leave the board unfinished.
They report the contradiction — and isSolved still returned true, because a
fixpoint that aborts half-way leaves an array where every clue happens to have
one candidate left. The contract was fine (every caller already guards on ok);
my assertion was not. It is now a documented precondition rather than a thing
you find out about.

36 tests. TypeScript, no runtime dependencies.

Repo: https://github.com/sen-ltd/tatamibari
Demo: https://sen.ltd/portfolio/tatamibari/

Ripple Effect: the rule that matters most never shows up in the difficulty rating

SEN LLC — Thu, 06 Aug 2026 15:11:38 +0000

Ripple Effect (also sold as Hakyuu and 波及効果) in the browser with
five rule sets inside. Every outlined region of s cells holds 1 to s,
each exactly once. And the rule it is named for: if the same value k shows up
twice in one row or one column, the two cells must be more than k apart — a
1 needs one clear cell between them, a 5 needs five. Puzzle #30 in the solver
series.

Demo: https://sen.ltd/portfolio/ripple-effect/
Repo: https://github.com/sen-ltd/ripple-effect

Three things came out of this one, and only the first was on the plan.

A row is not one constraint graph. It is a different graph for every value you might place in it.
Most boards do not exist. 87% of randomly drawn region partitions have no solution at all, before a single number is written.
The rule I was proudest of never appears in a difficulty rating. It is worth one percentage point to the solver and everything to the generator.

A row is not one graph, it is one graph per value

In Sudoku a row is an all-different clique. Nine cells, all mutually exclusive,
and that stays true whichever digit you happen to be holding. Every propagator
you write can take "the row" as a fixed object.

Here the row is a different object for every value. Two equal values k must sit
more than k apart, so the row splits into overlapping windows of width k+1 —
and the window depends on k. The conflict graph for 1s is just the grid's own
adjacency graph. The graph for 5s is eleven cells wide. They share no edges
beyond the trivial ones. One board carries as many line-conflict graphs as it has
distinct values.

So the reach function takes the value as an argument, and this is the entire
puzzle in six lines:

export function rippleReach(k: number, v: number, n: number): number[] {
  const r = rowOf(k, n), c = colOf(k, n);
  const out: number[] = [];
  for (let d = 1; d <= v; d++) {
    if (c - d >= 0) out.push(k - d);
    if (c + d < n) out.push(k + d);
    if (r - d >= 0) out.push(k - d * n);
    if (r + d < n) out.push(k + d * n);
  }
  return out;
}

There is no such thing as "the cells k conflicts with". Only "the cells k
conflicts with when it holds a 4".

Measured on an empty board — the mean number of cells a single placed v
forbids, against how many v's the whole board can hold at once:

board	v=1	v=2	v=3	v=4	v=5
6×6	deg 3.3, room 18	deg 6.0, room 12	deg 8.0, room 12	deg 9.3, room 12	deg 10.0, room 6
8×8	deg 3.5, room 32	deg 6.5, room 24	deg 9.0, room 16	deg 11.0, room 16	deg 12.5, room 16
10×10	deg 3.6, room 50	deg 6.8, room 40	deg 9.6, room 30	deg 12.0, room 20	deg 14.0, room 20

The two halves pull opposite ways, and the tension between them is where the
puzzle lives. A big value reaches far but turns up rarely — only a region of size
v or more ever holds a v. A 1 barely reaches at all, but every region
owns one, so 1s are the most crowded thing on the board.

Where the counting arguments can and cannot live

I wrote this in the header of the solver on day one:

Every counting argument here is region-scoped, because a region must hold
each of 1..s while a row promises nothing at all.

The first half is right. A region of size s has to contain a 3 if s ≥ 3, so
"only one cell in this region can still take a 3" pins that cell — the ordinary
hidden single. A row has no such duty. A row of a Ripple Effect board need not
contain a 3 anywhere, so there is no line-scoped hidden single, and I concluded
there was nothing to count along a line.

That is wrong, and the region partition is what makes it wrong.

A region that lies entirely inside one row promises that row a 1, and a 2, and
so on up to its size. Trapped regions are disjoint, so their demands add. On
the supply side, the ripple rule caps how many v's fit in n cells at
⌈n/(v+1)⌉. Demand against capacity, per line, per value — a line-scoped counting
argument after all, and the only place where the region-scoped "must contain" and
the line-scoped "must be far apart" ever meet.

It prunes, too, not just refutes. If a line owes need copies of v, then a
cell that cannot be part of any packing of at least need copies cannot hold v:

for (const i of spots) {
  let best = 1;
  const left: number[] = [], right: number[] = [];
  for (const j of spots) {
    if (i - j > v) left.push(j);
    else if (j - i > v) right.push(j);
  }
  best += maxPacked(left, v) + maxPacked(right, v);
  if (best < need && !strike(b, line.cells[i], v)) return false;
}

maxPacked is greedy left-to-right, which is optimal here for the usual
interval-scheduling reason. A worked case, with no givens on the board at all:
row 0 holds two 1×3 regions, so it owes two 3s, and a row of 6 has room for
exactly two — they must sit four apart. Columns 2 and 3 are in no such pair, so
neither can hold a 3, and the rule says so from an empty grid.

Most boards do not exist

Take the same argument global. Every region of size ≥ v spends exactly one v,
those regions are disjoint, and each of the n rows holds at most ⌈n/(v+1)⌉ of
them. Cut a 6×6 board into eighteen dominoes and it is over: eighteen regions
want a 2 and the board has room for twelve. No numbers, no givens, no solution.

The smallest case in the whole family is prettier still — two size-1 regions
sitting orthogonally adjacent. A size-1 region is a forced 1, so that is two 1s
one step apart, and 1s need a gap.

Which made me wonder how often a random partition survives any of this. The
answer is: rarely. The solver is the ground truth here, and I brute-force
verified a sample of the verdicts with a counter that enumerates region
permutations, because "most of your boards are impossible" is exactly the kind of
claim that is usually a bug.

board	size-1 share	dead	adjacent singletons	board capacity	line rule	any of them
6×6	5%	85%	31%	0%	8%	33%
6×6	12%	87%	56%	0%	13%	62%
6×6	25%	100%	90%	10%	48%	93%
6×6	40%	100%	98%	32%	67%	98%
8×8	12%	88%	66%	0%	4%	66%
8×8	40%	100%	100%	10%	60%	100%
10×10	12%	93%	84%	0%	0%	84%

Read the middle 6×6 row: 87% of partitions are dead; the adjacent-singleton test
explains 56% of the corpses, the line rule another handful, and 38% of them are
dead for reasons no static test I have catches. Across every row, the cheap
tests never once killed a partition that had a solution.

At 10×10 it is worse: 93% dead, and the counting tests stop explaining any of it.

This is a genuinely different shape from the other puzzles in this series. In
Kurodoko or Yajilin you paint a legal board first and the skeleton comes along
for free. Here the skeleton is chosen blind and is usually a corpse, and the
generator's real job is drawing skeletons until one is alive.

The prefilter that made things slower

Obvious next move: the solver is expensive, the counting tests are arithmetic, so
skip the solver on partitions that are obviously hopeless. Free speed.

It is not free. Median of 5 trials, order alternated to cancel warm-up:

board	live / drawn	solver only	with prefilter	speedup
6×6	40 / 396	35 ms	44 ms	0.80×
8×8	20 / 312	753 ms	760 ms	0.99×

Slower at 6×6, indistinguishable at 8×8. The premise was wrong. A dead partition is dead for reasons the ordinary
propagators hit within a round or two, so the solver refutes it almost
immediately — there is no expensive search to skip. Meanwhile the "cheap" test
rebuilds the line structures for every candidate, which is the most expensive
thing in the loop.

There is a second lesson buried in that table, and it cost me an hour. The first
version of this measurement took one sample per configuration, and on two
consecutive runs it read 0.4× and 2.4× — the second one while a test suite was
running on the same machine. I had already written the "it is negative" paragraph
around the first sample. A timing claim from a single shot is not a measurement;
it now takes five, alternates the order, and reports a median, and the honest
answer turns out to be "no difference worth having" rather than the more dramatic
thing I nearly published.

So the prefilter came out of the generator. looksDead stays in the codebase
because it answers a different question — it says why a partition is dead, one
named reason at a time, which is what the mortality table above is made of. It is
not there to save time, because it doesn't.

The strongest rule never shows up in a difficulty rating

Five rule sets, each strictly containing the one below:

name	what it adds
`region`	a region of size s holds 1..s, once each
`ripple`	a placed v erases v within v steps along the row and column
`hidden`	a value with only one seat left in its region takes it
`lines`	demand from trapped regions against the line's capacity
`probe`	singleton consistency: assume a value, propagate, watch it die

Reach, measured on boards carrying the same number of givens as the shipped banks
but never filtered for solvability, so the last column is not circular. Each
cell reads surplus candidates eliminated / boards finished outright:

board	region	ripple	hidden	lines	probe
6×6 (N=40)	15% / 0%	52% / 0%	63% / 5%	63% / 5%	82% / 13%
8×8 (N=25)	18% / 0%	56% / 0%	64% / 0%	64% / 0%	81% / 0%

lines adds nothing. Not "a little" — the columns are identical. The ablation
says the same thing from the other direction, dropping one propagator at a time
from the strongest fixpoint over 30 solvable 6×6 boards:

dropped	candidates eliminated	boards finished
nothing	100%	30/30
region	97%	27/30
ripple	16%	0/30
hidden	67%	10/30
lines	99%	29/30

One percentage point and one board. And not a single board in the shipped bank of
48 is labelled lines — they come out as ripple or hidden, every time.

The rule with the sharpest argument behind it, the one that took the most care to
get right, is dead weight to the solver. Its entire contribution is upstream, on
the skeleton, deciding which boards get to exist at all. By the time a board has
givens on it, the cheaper rules have already been everywhere it would go.

The lesson I am taking from it: a difficulty rating measures the solver, and a
solver is only one of the two consumers of a rule. A rule can be load-bearing
for the generator and worthless for the player, and nothing in the difficulty
column will ever tell you which. If I had only ever measured rule sets the usual
way — reach on finished boards — I would have deleted lines as dead code and
never found out that it is the thing that explains why most boards do not exist.

Meanwhile the eponymous rule is exactly as important as the name suggests:
without ripple the solver eliminates 16% of the candidates and finishes nothing
at all.

Generation: one monotone knob and one that isn't

The givens are the pleasant half. A given is written on a cell whose value the
intended solution already fixes, so adding one cannot change the solution — it
can only remove rivals. Termination is free: in the worst case every cell becomes
a given and the board is pinned by construction. Size-1 regions are kept out of
the pool, since a given there would only repeat what the partition already says.

Then the walk runs backwards and drops every given that is not pulling its weight.
The test is not "is it still unique" but "can the rule set still finish it", which
is strictly stronger — every propagator here is sound, so a rule set that decides
every cell has also proved the board unique. The sweep removes 43–48% of them.

The partition has no such courtesy. It is monotone in nothing, it is usually
dead, and the only thing to do with a dead one is throw it away whole.

Cross-checking

Three counters, and any unsound propagator shows up as a disagreement:

by cells — walk the grid in row-major order, trying every value a cell could hold
by regions — hand each region a permutation of 1..s at a time
with propagation — the rule sets plus search

The first two enumerate opposite halves of the problem and share nothing but the
geometry helpers. validate re-reads the distance rule from scratch by brute
force over every ordered pair in every line, and shares no code with the
propagators at all. The soundness tests take boards with known solutions, run each
propagator, and insist the solution's value survived in every cell — which is the
property that makes "finished without search" a uniqueness certificate rather than
a guess that happened to work.

34 tests. Puzzle #30 in the solver series.

npm install
npm run dev        # demo at http://localhost:5173
npm test
npm run generate   # rebuild the bank
npm run stats      # every number in this post

MIT. No runtime dependencies.

Solving Kurodoko: whether a rule looks useless depends on where you measure it

SEN LLC — Thu, 06 Aug 2026 00:41:58 +0000

Kurodoko (also sold as Kuromasu and 黒マスはどこだ) in the browser with
four rule sets inside. Blacken some cells. A numbered cell is always
white, and its number is how many white cells it can see — itself, plus
the unbroken runs of white in all four directions, each stopping at the first
black cell or the edge. No two black cells touch, and all the white
cells form one connected group. Puzzle #29 in the solver series.

Demo: https://sen.ltd/portfolio/kurodoko/
Repo: https://github.com/sen-ltd/kurodoko

Two measurement stories this time.

The cross-check caught an unsound propagator — one that looked obviously correct while I was writing it.
The same rule looked worthless and then decisive, with nothing changing but where I measured it.

The variable is not the cell

A clue with number k says

1 + up + right + down + left == k

where each term is the length of an unbroken white run with a hard geometric
cap. Four bounded integers summing to a constant is a shape a solver
already knows what to do with: a direction's run is at least the total minus
what the other three could contribute at their most generous, and at most the
total minus what they must contribute at their meanest. Plain interval
propagation.

How much smaller does that make the problem? Measuring the size of one clue's
domain — the compositions of k−1 into four capped parts:

board	mean compositions per clue	largest	raw cell space
6×6	9.9	28	2³⁶ ≈ 6.9e10
8×8	19.0	60	2⁶⁴ ≈ 1.8e19
10×10	35.2	100	2¹⁰⁰ ≈ 1.3e30

Thirty-five options at 10×10, against a raw cell space of 2¹⁰⁰.

And the reach of each rule set, measured on boards carrying the same number of
clues as the shipped banks but never filtered for solvability, so the last
column is not circular:

board	cells	rays	connect	probe
6×6 cells decided	8%	25%	25%	74%
8×8 cells decided	8%	34%	35%	86%

Reading each clue on its own gets 8%. Lifting it to four integers gets 25–34%.

The rule that looked obviously right and wasn't

Once a direction's run is pinned to [lo, hi], two conclusions seem to follow:

the run is at least lo, so the first lo cells of that ray are white
the run is at most hi, so the cell at hi is black

The first is sound. The second is not.

"At most hi" does not put a black cell at index hi. If the run stops short,
the cell at hi sits beyond the stopping cell — outside this clue's view
entirely — and is completely free. The step is only justified once the whole
prefix is already known white, which pins the run at exactly hi.

That rule shipped into the first working version, and the boards it generated
looked perfectly fine. What caught it was the counters disagreeing:

6x6 #0: byCells=1 byRays=1 byRules=0   <- only the propagation-backed counter
                                           says there are no solutions

Propagation was killing the real solution, which is exactly what an unsound
propagator does. Fixing it re-labelled the difficulty of the whole bank — the
weaker rule sets had been "solving" boards by smuggling in the answer.

The two brute-force counters are deliberately written to enumerate opposite
halves of the problem:

by cells — walk the grid row-major, pruning on clue bounds
by rays — walk the clues, choosing each one's four ray lengths from the compositions of k−1, and paint the consequences

They share no logic with the propagators and none with each other, so one
mistake cannot show up identically in both.

Whether a rule looks useless depends on where you measure it

This was the interesting part.

Drop one propagator from the strongest fixpoint and count again (6×6, 30
boards):

dropped	free cells still decided
nothing	35%
shaded-adjacency	26%
plain per-clue counting	35% (no change — the lifting subsumes it)
the ray lifting	7%
connectivity	34%

The lifting is load-bearing: 35% collapses to 7% without it. Expected.

And connectivity moves the number by one point. On that table alone the
conclusion writes itself: dead weight. It looks exactly like the checkerboard
colouring argument from the previous entry,
which stayed at 78% whether you kept it or not.

It isn't. Measure the same rule inside singleton consistency — assume a
cell, propagate, see whether the board dies:

	free cells decided	boards finished
probe with connectivity	100%	25/25
probe without connectivity	90%	8/25

Same propagator. Same boards. Opposite verdict.

The two measurements ask the rule to do different jobs. At fixpoint, the job is
decide a cell on your own — and connectivity almost never can, because
early on there are too few known white cells for an articulation point to
separate any of them.

Inside singleton consistency the job is refute an assumption. The moment
you assume a cell is black, the board becomes far more constrained: more whites
are forced, more blacks are forced, and severing the white region becomes a
real possibility. As a decider it is powerless; as a refuter it is the
difference between finishing 8 boards and finishing 25.

I called Yajilin's colouring argument "true and worthless" last time, and that
verdict holds — it was worthless at fixpoint and inside probing, refuting 1
wrong guess in 1090. This one is not the same situation, and the lesson is:
before concluding a rule does nothing, measure it in both of the jobs a
propagator can hold.

Adding a clue never changes the answer

The generator has exactly the opposite character to the last one.

In Yajilin a clue cell is off the loop, so adding a clue pulls a cell out of
the solution and changes it — and routing ambiguity could not be fixed by
clues at any price.

In Kurodoko a clue cell is just a white cell carrying a number, and it was
white already. So:

Adding a clue cannot change the solution. It can only remove rivals.

That makes the whole pipeline monotone and termination free. Paint a legal
board, then keep adding clues until nothing else solves it — in the worst case
every white cell becomes a clue and the board is pinned by construction. Then
run it backwards and drop every clue that turns out not to be pulling its
weight:

board	clues when the walk stopped	after the sweep	removed
6×6	7.8	6.2	21%
8×8	12.5	10.0	20%
10×10	18.1	15.1	17%

The test for keeping a clue is not "is the board still unique" but "can the
rule set still finish it" — which is strictly stronger, because a rule set
that decides every cell has proved uniqueness (every propagator is sound). A
board that is unique but unreachable by propagation leaves the demo's hint
button with nothing to say.

I got that distinction wrong first, pruned for uniqueness only, and then
rejected every board because its post-sweep difficulty came back null. Two
hundred attempts, zero output.

One Tarjan pass instead of a flood fill per candidate

The connectivity propagator asks which still-open cells would strand a white
cell if blackened. The obvious implementation blanks each candidate and redoes
the flood fill — O(cells²) per pass. And it sits inside singleton
consistency, so that factor gets cubed and a 10×10 board simply stops
finishing.

One Tarjan pass answers it for every cell at once: an articulation point of the
not-black graph separates whites exactly when some child subtree holds a white
cell and at least one white cell lies outside it.

board	blunt	Tarjan	speedup	disagreements
6×6, 200 partial boards	11ms	2ms	5.5×	0
10×10, 200 partial boards	52ms	5ms	10.4×	0

The blunt version stays in the test suite as the reference the fast one is
checked against — on 60 random partial boards, with an assertion that at least
one of them actually forced a cell, so the comparison cannot pass by testing
nothing.

Takeaways

Lift a clue to four bounded integers summing to k−1 and a whole-board counting rule becomes ordinary interval propagation: 8% of cells decided becomes 25–34%.
"The run is at most hi, so cells[hi] is black" is unsound — the run can stop short and leave that cell outside the clue's view. Found by two independent counters disagreeing with a third.
Whether a rule looks useless depends on where you measure it. Connectivity is worth one point at fixpoint and takes probing from 8/25 to 25/25 boards finished. Measure a propagator as a refuter, not only as a decider.
A clue cell here is already white, so adding clues never changes the answer — generation is monotone and terminates for free. The redundancy sweep then removes 17–21% of them.
Prune against "can the rule set still finish it", not "is it still unique". The former implies the latter and keeps the boards playable.
Articulation points: one Tarjan pass, not a flood fill per candidate (5.5–10.4×, zero disagreements).

27 tests. Puzzle #29 in the solver series.

Solving Yajilin: clues can pin the shading, but they can never steer the loop

SEN LLC — Wed, 05 Aug 2026 23:54:38 +0000

Yajilin in the browser with four rule sets inside. Shade some cells,
then run one closed loop through every cell you did not shade. No two
shaded cells touch. Each black clue sits outside the loop, and its arrow
counts the shaded cells in that direction, all the way to the edge of the
board. Puzzle #28 in the solver series.

Demo: https://sen.ltd/portfolio/yajilin/
Repo: https://github.com/sen-ltd/yajilin

This is also the entry where the idea I built the whole thing around turned
out to be worthless, and I have the measurements to prove it. Both results up
front:

What worked was noticing an asymmetry. Clues can pin the shading down; they can never steer the loop's routing. So routing uniqueness cannot be repaired after the fact — it decides the entire design of the generator.
What did not work was the checkerboard colouring argument. It is true, it is free, it is pretty. Measured, it decides zero extra cells on 0 of 40 boards and refutes 1 wrong guess in 1090.

Two puzzles tangled together — but not symmetrically

In Yajilin a cell is shaded exactly when the loop misses it, so every deduction
about one is a deduction about the other. That much is familiar from
Norinori and
LITS earlier in this series.

What is different here is that the tangle is not symmetric, and it took a
badly behaved generator to make me see it.

A clue cell is off the loop by definition. So adding a clue can take a
cell off the loop. That is the only thing it can do to the loop. It can
never steer the routing.

That has teeth. If the set of cells the loop covers admits two different
Hamiltonian circuits, the board has two solutions — and no amount of extra
clues will ever fix it. Shading ambiguity is fixable by clues. Routing
ambiguity is not. A new clue changes which cells are available, but you cannot
aim it at one circuit and kill it.

Which means routing uniqueness has to be designed into the loop's shape
before a single clue exists.

I did not start there. The first generator did the obvious thing — grow a loop,
split the leftover cells into shaded cells and clues, then add clues until the
board is unique — and it produced 8×8 boards with 24 clues and zero shaded
cells. It was converting shaded cells into clues, over and over, trying to
kill an ambiguity that clues cannot touch, until there was nothing left to
shade.

Growing a loop by inflation

The loop needs to be a random closed circuit. I grow it by inflation: start
from a 2×2 square, the smallest legal loop, then repeatedly take one edge and
push it out into the neighbouring 2×2, replacing that edge with a three-edge
detour through two fresh cells.

 x───y         x       y
               └───┐
 p   q         p───q      (x-y becomes x-p-q-y; p and q join the loop)

This move always leaves one closed circuit. No connectivity check, no
rejection, and the loop grows by exactly two cells each time. Whatever the loop
misses becomes either a shaded cell (a greedy independent subset, since shaded
cells may not touch) or a clue, and the arrow numbers are read straight off the
finished shading.

A freely grown loop essentially never has a unique routing

Grown to 62% coverage, then counting the Hamiltonian circuits the cell set
admits:

board	loops with a unique circuit	median rival circuits
6×6	7/40 (18%)	3
8×8	0/40	52
10×10	0/40	60+ (counting cap)

Zero at 8×8 and above, with a median of 52 rival circuits. No wonder the first
generator ate all the shading: it was fighting an ambiguity it had no weapon
against.

Two attempts to ban it locally, both failed

If the ambiguity has a shape, ban the shape. The obvious culprit is a 2×2
square whose four cells are all on the loop and which the loop enters by two
parallel edges — swap that pair for the other pair and every degree stays at
two, so you may well have a second circuit.

Attempt 1: ban the shape outright during growth. Uniqueness went to 100% —
40/40 at every size. But growth stalls: against a 62% target it reached
21–43%. That leaves most of the board off-loop, and most of that becomes
clues. A 10×10 with 38 clues is not a puzzle. Useless.

Attempt 2: ban only the swaps that really produce a rival. Do the swap, and
if the result is still a single circuit it is a genuine rival; if it splits the
circuit in two it is harmless. Sharper condition, checked at every move. Result
at 8×8: 0/40. It did nothing at all.

The reason is that the property is not monotone. A square whose swap splits
the circuit today becomes a genuine rival after two more inflations somewhere
else. A test applied at move time is worthless by the time the loop is
finished. The shape ban is monotone but kills growth; the effect ban preserves
growth but does not hold. Local conditions do not reach.

Descending the shape itself

That leaves the only honest objective: how many Hamiltonian circuits the cell
set admits, counted for real.

To change the shape without changing the size, pair a deflation with an
inflation. Deflation is exactly the inverse of the growth step: where the
loop runs x-p-q-y and x is adjacent to y, drop p and q and join x
to y. It also preserves the single circuit.

deflate:  x-p-q-y  ->  x-y      (two cells smaller)
inflate:  x-y      ->  x-p-q-y  (two cells larger)

Take a random deflation and a random inflation, keep the pair if the circuit
count did not go up, roll back otherwise. That is the whole thing.

board	reached target size with exactly one circuit	time
6×6	40/40	54ms
8×8	40/40	952ms
10×10	40/40	17.9s

0/40 to 40/40, at the target size. Norinori's generator taught me that
hill-climbing on solution count oscillates and never converges; this
objective behaves because it depends only on the loop's shape, with no shading
or clues entangled in it.

Adding clues by looking at the counterexample

With the routing pinned, the only ambiguity left is in the shading — and
clues can fix that.

The first version picked at random: if the board has more than one solution,
turn some random shaded cell into a clue. It works, but it is wasteful, and it
strips the board of nearly all its shading before it happens to hit the cells
that were actually ambiguous.

The fix is to ask the solver for one rival solution and look at the
disagreement. Pick a cell that our solution shades and the rival does not, and
convert that one. The move is guaranteed on both sides:

it kills this rival — nobody can shade that cell any more
it leaves our solution standing — the cell was off-loop already, so the loop is untouched

At 8×8 the random version converged on 24 clues and 0 shaded cells. The
counterexample version gives 12–18 clues and 6–12 shaded cells; at 10×10,
21–28 clues and 10–17 shaded. Those are Yajilin-shaped boards.

And now the pretty argument that does nothing

This is the part I most wanted to write.

A grid graph is bipartite. Colour it like a checkerboard and every pair of
adjacent cells differs in colour, so a closed loop alternates colours and
must cover equally many of each.

With W, B the non-clue cells of each colour and sw, sb the shaded counts,
the loop covers W - sw white cells and B - sb black ones, so

W - sw == B - sb    <=>    sw - sb == W - B

and the right-hand side is a constant fixed by the clue positions alone —
known before you shade a cell or draw an edge. A whole-board constraint, for one
O(cells) pass, that no amount of local arrow-counting can see.

I was sure this would carry the entry. Measured:

boards where colouring decided more than the arrows:   0 / 40
mean gap:                                             +0.0 cells
wrong guesses the arrows accept and colouring refutes:  1 / 1090  (0%)

Nothing. Drop it from the strongest rule set and the fixpoint stays at 78%,
unchanged to the point. Look at rule-set reach and arrows and parity are
identical: 30%/30% at 6×6, 32%/32% at 8×8.

Why it does nothing

The algebra shows it. Write the unknown cells that will end up shaded as xw
(0 to uw) on white and xb (0 to ub) on black, and the identity becomes

xw - xb == T        (T a constant fixed by the board)

whose left side ranges over [-ub, uw]. This constraint forces something
only when T sits at one end of that interval — T == uw means every unknown
white cell is shaded and every unknown black one is on the loop, and T == -ub
is the mirror image.

And the interval stays wide until the board is nearly solved. Twenty unknown
cells means an interval about twenty wide, and T landing exactly on an
endpoint is rare. As a contradiction detector it is the same story: one wrong
cell moves T by one, which almost never pushes it outside a wide interval.

True, free, and never tight. That is what 0/40 and 1/1090 are saying.

I locked the result into a test — parity must decide exactly as many cells as
arrows — so that a future change to the propagator in either direction breaks
the build instead of quietly invalidating this article. And it ships in the demo
as the rule set that loses; switch the hint level between arrows and parity
and watch nothing change.

What actually carries the load

Drop one propagator at a time from the strongest fixpoint (6×6, 30 boards):

dropped	free cells still decided
nothing	78%
the arrow counting	47%
shaded-adjacency	62%
the colouring argument	78% (no change)
the loop's structure	39%

It is the loop structure — degrees, dead ends, circuits that would close too
early, cells stranded in an unreachable component. Drop it and 78% falls to 39%.
The puzzle is named after its arrows, but the loop is what breaks it open.

Rule-set reach, measured on boards generated with the uniqueness filter
switched off (filtering by solvability and then reporting solvability is
circular — a trap this series has fallen into before):

board	arrows	parity	loop	probe
6×6 cells decided	30%	30%	67%	100%
8×8 cells decided	32%	32%	66%	100%

Soundness: three counters, and one external sequence

Two brute-force counters share no logic with the propagators:

shading first — enumerate the shadings, then count Hamiltonian circuits on whatever cells are left
loop first — enumerate the circuit edge by edge, read the shading off as the complement

Plus a propagation-backed counter and an independent validator that re-derives
every rule from scratch. All of them must agree on solution counts.

But agreement between counters I wrote myself does not rule out being wrong in
the same way twice. So the circuit counter is pinned to an external source:
the number of Hamiltonian cycles in an n×n grid graph is published as
OEIS A003763 — 1, 6, 1072 — and the counter
reproduces it exactly. That single test did more for my confidence than the
other twenty-nine combined.

30 tests.

Takeaways

Clues pin the shading; they can never steer the routing, because a clue cell is off the loop by definition. Routing ambiguity has no post-hoc repair, so it must be built into the loop's shape.
Freely grown loops are unique 0% of the time at 8×8 and above (median 52 rivals). Two attempts to ban the ambiguity locally both failed — the blunt ban stalls growth at 21–43% coverage, and the sharp one is not monotone.
Deflate + inflate descent on the real circuit count: 0/40 to 40/40, at target size.
Add clues by walking counterexamples, not at random: degenerate 0-shaded boards became boards with 6–12 shaded cells.
The checkerboard colouring argument is correct and worthless: 0/40 boards, 1/1090 refutations, 0% change when removed. It only bites at the ends of an interval that stays wide. Pinned by a test; shipped as the losing rival.
Pin at least one counter to a published sequence, not just to another counter you wrote.

Puzzle #28 in the solver series.

Solving Fillomino: the third rule isn't a rule — it's why the puzzle can be printed with no borders

SEN LLC — Mon, 03 Aug 2026 23:50:23 +0000

Fillomino in the browser with three rule sets inside. It is normally
stated in three clauses: cut the grid into polyomino regions; a region of
N cells is written N everywhere; and two regions of the same size may not
share an edge. That third clause is where this build starts. Read a filled
grid the only way a grid of numbers can be read — a region is a maximal
connected run of equal numbers — and the third clause becomes impossible to
break: two touching regions of size two are, on the page, one run of four 2s,
and 4 ≠ 2, which clause 2 already rejects. Fillomino has one rule.
Puzzle #28 in the solver-included series.

🌐 Live demo: https://sen.ltd/portfolio/fillomino/
📦 GitHub: https://github.com/sen-ltd/fillomino

The rules, in one sentence

Every connected run of equal numbers is exactly that many cells.

A run of 3s is three cells. A run of 5s is five. That is all. The engine checks
that one sentence and nothing else — it never asks whether same-size regions
touch.

So what is the third rule doing?

Saying "rule 3 is redundant" is only half right. Precisely:

Formulate the puzzle over pictures (grids of numbers) and clause 3 is not expressible as a separate constraint. It is already implied.
Formulate it over partitions (a cut into regions, plus labels) and clause 3 is a real constraint. Drop it and the solutions multiply.

So clause 3 does not narrow the answer. It guarantees the answer can be
written down. That is what makes Fillomino visually unique among the region
puzzles in this series — Heyawake, Norinori, LITS, Shikaku all have to print
their region walls, because numbers alone would not locate them. A Fillomino
prints nothing but numbers, and rule 3 is exactly the condition under which the
picture gives the partition back.

The demo makes the point literally: the borders are not in the data. As you
write numbers, a wall is drawn wherever two adjacent cells disagree, and the
region map appears out of nowhere as the grid fills.

Counting the theorem

If the claim is true, two independent enumerators must agree on every board.

countByRegions walks regions: take the first blank cell, try every polyomino that could be its region, and check clause 3 out loud.
countByCells walks cells in reading order: write a number, then check only that the run through that cell has not outgrown its number and can still reach it. It has never heard of clause 3.

They share no code. On empty grids (npm run stats):

grid	pictures (region walk)	pictures (cell walk)	partitions, rule 3 dropped
1×1	1	1	1
2×2	5	5	12
3×3	445	445	1,434
4×4	259,728	259,728	1,691,690

The two middle columns agree exactly, on every board, which is the theorem.
The third column is the same region walk with clause 3 switched off: it counts
cuts rather than pictures, and by 4×4 it is counting each answer
6.51 times over. That factor is the ambiguity clause 3 removes.

On real boards the ablation is brutal. Of the sixteen 6×6 boards this repo
ships, 16/16 are unique as pictures — and only 2/16 are unique as
partitions once clause 3 is dropped. The median board admits 20 different
ways to cut it up; the worst admits 12,244. Every one of them writes the
same numbers.

The 2×2 case is small enough to check by hand: all-4s (one way), or a lone
corner 1 with an L-tromino of 3s (four ways). Five. Cutting it into two
dominoes of 2 dies as a picture — four 2s in a row, and 4 ≠ 2.

The variable is the cell; the domain is a set of sizes

Every other region puzzle hands you the regions and asks what goes inside.
Fillomino hands you nothing: the regions are the answer. So a cell's domain
is not "which colour" but "how big is the region I end up in", and every
propagator becomes a statement about how a run can still grow.

`local` — never past the frontier

// a run that has reached its number is finished: nothing beside it may join
if (comp.length === v) {
  for (const c of comp) for (const u of nb[c]) {
    if (state[u] === UNKNOWN) dropValue(d, u, v);
  }
  continue;
}
// a run still short of its number must grow — one way out means that cell is in
const exits = new Set<number>();
for (const c of comp) for (const u of nb[c]) {
  if (state[u] === UNKNOWN && hasValue(d, u, v)) exits.add(u);
}
if (exits.size === 0) return -1;
if (exits.size === 1) state[[...exits][0]] = v;

Look at the first half. "A finished run blocks its own number next door" is
clause 3 — derived from the one-sentence formulation without ever naming it.

`region` — the two rules that need the whole board

reach. A region of size v is v connected cells that can all hold v.
So a cell keeps v only while it sits inside a v-capable component of at
least v cells — and a component of exactly v cells that already
contains a v is the region, in full.

if (mem.length < v) {
  for (const c of mem) { if (state[c] === v) return -1; dropValue(d, c, v); }
} else if (mem.length === v && mem.some((c) => state[c] === v)) {
  for (const c of mem) if (state[c] === UNKNOWN) state[c] = v;  // component = region
}

cut. For a run still short of its number, delete one cell and re-flood. If
what remains can no longer reach the number, no legal region avoids that cell,
so the cell is in it. Articulation reasoning — and the rule that feels closest
to how people actually play.

const room = reachable(comp, v, d, n);
if (room.length < v) return -1;
for (const x of room) {
  if (reachable(comp, v, d, n, x).length < v) { state[x] = v; return 1; }
}

`probe` — singleton consistency

Assume a number in a cell, run the region rules, and if the board dies the
number is gone. Restricted to the frontier (cells that already touch something
known) as a budget — and a budget that prunes less can never cost you
soundness.

How far does each rule set reach? (measured without circularity)

Generate only boards a rule set can solve, then measure how often that rule set
solves them, and you will discover it solves 100%. So these boards are
generated with no solvability filter at all — clues are peeled while
brute force still says "unique", and only then is the rule set asked:

size	local	region	probe	clues
5×5	0%	10%	95%	9.6 / 25
6×6	0%	4%	96%	13.5 / 36

The local rules finish nothing. The region rules finish about one board in
ten. Probing — still no search — gets to 95%, and the last few percent need
real backtracking whatever you do. From 900 random positions, the region rules
decided more cells than the local rules in 818 of them, +6.4 cells on
average, and the local rules never once won.

Since every propagator is sound, a rule set that finishes a board with no
search is also a uniqueness certificate.

Generation: most regions are never mentioned

Generation is a randomised region packing — grow a region, refuse to touch a
same-size neighbour, backtrack when stuck — followed by peeling clues off the
solved grid one at a time for as long as a rule set still finishes the board.

What is left over is the surprising part: 9–14% of the regions in a shipped
board carry no clue at all. Nothing printed says they exist. Their size,
shape and position are forced entirely by their neighbours.

And they are the small ones: a silent region averages 1.3–1.8 cells against
2.7–2.8 for regions in general. Roughly half of all lone 1s are never
printed — fenced in by bigger runs on all four sides, a 1 often has nowhere
else to be.

Per cell, that is the entire economics of a Fillomino clue. The share of cells
that end up clued falls steadily with region size — on the shipped 6×6 bank,
1:0.51 2:0.50 3:0.35 4:0.36 5:0.28, and on 8×8, 1:0.80 2:0.46 3:0.40 4:0.29 5:0.31. One clue buys more grid the bigger the region it lands in,
which is why a board covered in 1s and 2s is a board covered in clues.

One invariant falls straight out of the one rule and is checked on every board:
the grid holds a whole number of size-v regions, so the count of cells
labelled v is always a multiple of *v*.

The cap is a promise, not a crutch

These boards declare "no region is bigger than five cells", which keeps a
cell's domain at five values instead of a hundred and is what makes probing
affordable in a tab. It buys speed, not solutions: re-count the shipped 6×6
boards with the cap lifted to the whole grid and all 16 are still unique.
At 8×8 the same re-count re-proves 12 of 16, and the remaining 4 exhaust the
node budget — reported as budget exhaustion rather than quietly counted as
passes.

And how much is probing actually worth, in clues? Peel the same twenty solved
6×6 grids twice: stop while the region rules still finish and you leave 15.1
clues on average; let probe carry the board and you get to 13.8 (min 12,
max 17). The whole difficulty ladder is about 1.3 clues wide.

Soundness

Two enumerators that share no code with the propagators — one walking regions,
one walking cells — plus a validator that re-reads every region from scratch.
All of them must agree on solution counts across randomly generated boards; a
disagreement is how an unsound propagator gets caught. 72 tests.

Takeaways

Fillomino's third clause is not a constraint on the answer — it is the guarantee that the answer can be printed. Over pictures, the puzzle is one sentence.
Verified by two independent exhaustive enumerators (259,728 legal 4×4 boards, counted both ways). Drop the clause and the same answer is counted 6.51 times over; on real boards uniqueness collapses from 16/16 to 2/16.
The variable is the cell and the domain is a set of region sizes, so every propagator is about growth: finished runs block, unreachable numbers die, articulation cells are forced.
Rule-set reach measured on boards nobody filtered for solvability: local 0%, region 4–10%, probe 95–96%.
After peeling, 9–14% of regions carry no clue at all — their existence is forced by their neighbours.

🌐 Live demo: https://sen.ltd/portfolio/fillomino/
📦 GitHub: https://github.com/sen-ltd/fillomino