DEV Community: SEN LLC

Heteromino: when the clues are holes, local reasoning dies completely

Sashigane: which end the arrow goes on is not a matter of taste

Numberlink: colour the grid and the clues are constrained before you draw a single line

Stostone: the rule says drop the stones — and nothing ever has to move

Choco Banana: the half of the rule that can only say no is six times the more expensive half

Yajisan-Kazusan: everything the solver learns first, it learns from a liar

Statue Park: the no-touching rule isn't a rule, and the circle that names nothing costs 60% more

Country Road: contract the countries and it is a Hamiltonian cycle — and that is the easy half

Creek: a puzzle with a closed form, and why the numbers on the edge of the paper are the ones to erase

Numbrix: one number colours the whole board, and the ruler rung that provably pays nothing

Kojun: the clue you draw before you write a digit, and two walls where boards stop existing

Magnets: a clue that can't see half the board, and a generator that cannot dead-end

DEV Community: SEN LLC

Heteromino: when the clues are holes, local reasoning dies completely

Sashigane: which end the arrow goes on is not a matter of taste

Numberlink: colour the grid and the clues are constrained before you draw a single line

Stostone: the rule says drop the stones — and nothing ever has to move

Choco Banana: the half of the rule that can only say no is six times the more expensive half

Yajisan-Kazusan: everything the solver learns first, it learns from a liar

Statue Park: the no-touching rule isn't a rule, and the circle that names nothing costs 60% more

Rules

For the first time in this series, the clue is not a written thing

1. The blank board — one-row strips are almost all dead

2. Two rows, and the answer is a power of two

3. Clue space is thin — and small enough to enumerate

4. A setter cannot scatter clues

5. The main result — the ladder is flat, then falls off a cliff

6. Dropping each half of the rule

7. Two things I expected and did not get

8. The bug the second engine caught

Implementation

Rules

1. The blank board is not always solvable

2. Print every number and the puzzle stops being one

3. Take the numbers away and the arrow end starts to matter

4. The arrow end is the only choice the setter has, and it is worth 2.6×

5. The numbers really are nearly free

6. Which clause is load-bearing — position beats direction ten to one

7. The ladder, and how much of it never fires

8. A size budget that needs no search at all

9. The bug the second engine caught

Takeaways

Rules

The identity that only mentions the clues

Necessary, and not sufficient. The witness is 2×3

The convention turns out to be nearly all of the uniqueness

Four rungs, and one of them never fires

Dropping "every cell is used" changes almost nothing

Generation: answer first, then repair

Counting the grids themselves

The bug that inverted a conclusion

Two engines

Takeaways

Rules

The counting half

The rest of it

The corollary you can see

Counting is necessary and is not sufficient

The half that cannot open a board is the half you cannot do without

The clue language, and what it cannot say

Generation runs backwards

What the answers look like

Cross-checks

The bug the cross-check caught

Running it

Rules

The two directions are not equivalent as inference

A number is a factorisation, not a quantity

Some answers no clue set can pin down

Both clue dialects are incomplete

`probe` is sound here, but not complete

External ledgers

Three engines

The five rungs

Generation

Try it

Rules

The contrapositive is the engine

A clue set always exists

An all-liar clue set works exactly on maximal answers

The honest dialect is the weaker one

Four clues in ten are liars, and not one of them is spare

`probe` and uniqueness agree exactly

Ablation: the row that argues with the headline

How far away is the second answer

External ledgers

The five rungs

Generation

Tests

Layout

The rules

The most famous rule is not a rule

Theorem: black circles alone always suffice, and so do white circles alone

Measurement: white circles cost about 60% more

Five rungs

Ambiguity is not one piece sliding over

How much is the park rule actually worth?

The generator never guesses at a bank

Soundness

The implementation lesson

The rules

Contract the countries and this is a Hamiltonian cycle problem

What each rung reaches

Ablation: drop one rung from the full ladder

And then the Hamiltonian cycle turns out to be the easy half

The partition can be a wall, so don't start from one

Three engines, and a number from outside the repository

One debugging lesson

This puzzle has a closed form

The ink on the edge of the paper is the ink you can throw away

The kernel is enormous and almost entirely illegal

The rule ladder

The dials on the answer's side

The generator cannot dead-end

The census, checked against formulas rather than against itself

In short

One number colours the whole board

The ruler rung that pays nothing

What survives the argument is distinctness

One load-bearing rung, three accelerators

Ink, spent well and spent badly

Reading a second answer off the answer

Sampling an answer without ever searching for one

The external ledger

probe ⇔ unique

Takeaways

The first clue is drawn, not written

Regions that cannot coexist — a soft wall of granularity

The verticality dial ends in a second wall

Random givens are nearly worthless

One roof over the ladder — and on naked boards, even the roof goes quiet

The multinomial census

A second solution read straight off the answer — 98–100% explained

Takeaways

The difference clue is blind to half the board

Turn the tiling sideways and the same 32 numbers say nothing

A generator that cannot dead-end — as a theorem

Two incomparable rungs under one roof

The √2 census

Reading a second solution straight off the answer

Takeaways

Rules

For the first time in this series, the clue is not a written thing

1. The blank board — one-row strips are almost all dead

2. Two rows, and the answer is a power of two

3. Clue space is thin — and small enough to enumerate

4. A setter cannot scatter clues

5. The main result — the ladder is flat, then falls off a cliff

6. Dropping each half of the rule

7. Two things I expected and did not get

8. The bug the second engine caught

Implementation

Rules

1. The blank board is not always solvable

2. Print every number and the puzzle stops being one

3. Take the numbers away and the arrow end starts to matter

4. The arrow end is the only choice the setter has, and it is worth 2.6×

5. The numbers really are nearly free

6. Which clause is load-bearing — position beats direction ten to one

7. The ladder, and how much of it never fires

8. A size budget that needs no search at all

9. The bug the second engine caught

Takeaways

Rules

The identity that only mentions the clues

Necessary, and not sufficient. The witness is 2×3

The convention turns out to be nearly all of the uniqueness

Four rungs, and one of them never fires

Dropping "every cell is used" changes almost nothing

Generation: answer first, then repair

Counting the grids themselves

The bug that inverted a conclusion

Two engines

Takeaways

Rules

The counting half

The rest of it

The corollary you can see

Counting is necessary and is not sufficient

The half that cannot open a board is the half you cannot do without

The clue language, and what it cannot say

Generation runs backwards

What the answers look like

Cross-checks

The bug the cross-check caught

Running it

Rules

The two directions are not equivalent as inference

A number is a factorisation, not a quantity

Some answers no clue set can pin down

Both clue dialects are incomplete

probe is sound here, but not complete

External ledgers

Three engines

The five rungs

Generation

Try it

Rules

The contrapositive is the engine

A clue set always exists

An all-liar clue set works exactly on maximal answers

The honest dialect is the weaker one

Four clues in ten are liars, and not one of them is spare

probe and uniqueness agree exactly

Ablation: the row that argues with the headline

How far away is the second answer

External ledgers

The five rungs

Generation

Tests

Layout

`probe` is sound here, but not complete

`probe` and uniqueness agree exactly

Why

As rules rather than as inferences, both halves are load-bearing

Incremental: nothing below `probe` ever finishes a board

Ablation: all four rungs are load-bearing

A cut vertex is a proof of impossibility

"Two border crossings per country" is a 2-factor, not a Hamiltonian cycle

Ablation: only the non-linear rung changes anything

Two incomparable rungs with the same finish line

Why

As rules rather than as inferences, both halves are load-bearing

Incremental: nothing below `probe` ever finishes a board

SEN LLC — Sun, 06 Sep 2026 00:39:36 +0000

Heteromino in the browser with a four-rung solver. This puzzle has no
numbers. No arrows, no region boundaries, no circles. The only thing a setter
can hand you is which cells are black — the clue language is a subset of
cells. Two things fell out of that. First, a black cell does two jobs at
once: it removes a cell from the tiling, and it stands between pieces so
that same-shaped neighbours become legal. 65 of the 72 shipped boards depend on
the second job. Second, and more interesting: if nothing is written on the
board then there is nothing to propagate from. The bottom three rungs
settle 2.1% of an untouched 8×8 and then stop. One level of lookahead takes
it to 100%. Puzzle #56 in the solver series.

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

Cut every white cell of the board into trominoes — three-cell pieces, so either a straight bar or an L.
Two pieces of the same shape may not share an edge.
"Shape" means shape as drawn. Rotate an L a quarter turn and it counts as a different piece, so there are six shapes (2 bars + 4 Ls).

That is all of it. There is not a single number anywhere.

Rule 3 — distinguishing rotations — is the hinge. Later I compare it against the
LITS convention, which merges rotations. Spoiler: merging them leaves all 72
shipped boards with no answer at all.

Numberlink prints numbers. Sashigane prints circles and arrows. Heyawake prints
regions and numbers. Every puzzle in this series has a setter who writes
something on the board. Heteromino's setter writes nothing. They delete
cells.

What makes that more than a subset-picking exercise is that one black cell does
two jobs, and you cannot buy one without the other:

The hole job. That cell drops out of the tiling.
The wall job. Pieces on opposite sides of it do not share an edge, so two pieces of the same shape become legal there.

Job 2, measured. I walked the answers to all 72 shipped boards and counted pairs
of same-shaped pieces facing each other across a single black cell:


boards with at least one such pair	65 / 72 (90.3%)
total pairs	263
total pieces	1,968
median / max per board	3 / 11

Take that one black cell away and those two pieces are touching twins, in
violation. The wall job is not decoration.

With no clues at all: how many ways does an empty h×w grid fall into
heterominoes? Exhaustively counted. Rectangles whose cell count is not divisible
by three are disqualified before we start, marked ·.

	1	2	3	4	5	6	7	8	9	10	11	12
1×n	·	·	1	·	·	0	·	·	0	·	·	0
2×n	·	·	2	·	·	4	·	·	8	·	·	16
3×n	1	2	8	14	28	70	144	304	688	1476	3168	6956
4×n	·	·	14	·	·	130	·	·	1414	·	·	14894
5×n	·	·	28	·	·	686	·	·	20077	·	·	584442
6×n	0	4	70	130	686	4552	15218	70654	372124	1525273	6893222	10887414*
7×n	·	·	144	·	·	15218	·	·	2001412	·	·	5375356*

* is a lower bound — the count hit its node budget. Everything else is
exact, and the small entries are recomputed from scratch on every test run.

The first row is the whole rule in miniature. A 1×n strip has no tiling for any
n except 3. In a single row the only piece that fits is the horizontal bar, and
two horizontal bars in one row always share an edge. So a strip holds one piece
and never two.

Which also means 1×3 is the only board in this puzzle that is a legal puzzle
with zero clues: exactly one answer, nothing printed on it.

None of 3×n, 4×n, 5×n or 6×n returns anything from OEIS.

The second row is not a mess either.

tilings of a blank 2 × 3m strip = 2^m

Matched through m = 9 (2×27 = 512). But the count is the least interesting part
of that claim — numeric agreement can be coincidence, so the test suite checks
the structure behind it instead. That is the bottom two rows: across every one of
those tilings, no bar is ever used and no piece ever crosses a three-column
boundary.

So a two-row strip is not a strip. It is a row of independent 2×3 blocks, each
cuttable by two Ls in two ways, and 2^m is just the product.

The argument is short enough to do by hand. Put a bar in the top row of the
leftmost three columns. The cell directly beneath it still needs a piece. Every L
that could take that cell wants a top-row cell, and the bar already has them all.
The only thing left is the bar directly underneath — same shape, touching, and so
illegal. No bar can start at the left edge, and the same trap propagates
rightwards.

This is the rule doing it, not the shape inventory: switch the same-shape rule off
and a blank 2×6 has more than four tilings again, bars included. That check is in
the test suite too.

Because a clue set is nothing but a subset of cells, "how good is this as a clue
language" is a question you can answer by brute force. For small boards I
walked every black-cell set of every legal size and counted the answers each
one admits.

board	black cells	clue sets	no answer	many answers	exactly one
3×4	3	220	37.3%	20.0%	42.7%
3×4	6	924	79.7%	1.6%	18.7%
3×5	3	455	34.3%	42.9%	22.9%
3×6	3	816	28.2%	54.2%	17.6%
3×6	9	48,620	91.8%	1.1%	7.1%
4×5	2	190	2.1%	90.5%	7.4%
4×5	5	15,504	57.9%	20.0%	22.1%
4×6	6	134,596	65.6%	18.8%	15.6%
4×6	9	1,307,504	89.5%	3.3%	7.2%
5×6	3	4,060	4.6%	93.5%	1.9%
5×6	6	593,775	48.2%	40.1%	11.7%
6×6	3	7,140	2.6%	97.0%	0.3%
6×6	6	1,947,792	33.7%	58.7%	7.6%

(An excerpt; the complete table is on the demo page.)

Two things read off it.

Unique boards are rare everywhere. The best cell in the entire census is a 3×4
with 3 clues, and even there only 42.7% of clue sets work.

And the failure mode flips. With few black cells, boards fail by having too
many answers. With many, they fail by having none — because the black cells have
chopped the grid into regions whose sizes are not multiples of three. Uniqueness
lives in a narrow band between "hasn't said enough" and "has said something
impossible", and the band narrows as the board grows.

Since the census is exhaustive, the minimum clue count is an exact bound, not a
search result:

board	cells	sparsest clue set that pins an answer	density
3×4	12	3	25.0%
3×5	15	3	20.0%
4×4	16	4	25.0%
3×6	18	3	16.7%
4×5	20	2	10.0%
4×6	24	3	12.5%
5×5	25	4	16.0%
5×6	30	3	10.0%
6×6	36	3	8.3%

Smallest by count is 4×5 with 2 — a twenty-cell board pinned by two black
cells. Smallest by density is 6×6 at 8.3%. (4×4 and 5×5 need 4 only because
their cell counts are 1 mod 3, so the legal clue counts are 1, 4, 7, … and 1 is
not enough.)

Scale up and sample, and the band closes fast. Random black-cell placements, with
the peak unique rate over all legal clue counts:

board	samples per clue count	best clue count	unique rate there
6×6	4,000	9	8.1%
8×8	1,500	13	1.5%
10×10	600	22	0.7%
12×12	300	—	0%

On 12×12: 17 legal clue counts × 300 draws = 5,100 boards, and not one of them
had exactly one answer.

So the generator does not sample. And here is where generating this puzzle
diverges from every other one in the series.

The other generators all have the same shape: draw an answer, read the clues
off it, then erase clues one at a time while the board stays unique. Heteromino
permits none of that.

The clues are not a function of the answer. Blacking a cell in or out changes which cells even need covering.
The number of white cells must stay a multiple of three, so black cells cannot be added or removed one at a time at all.

There is no legal single-step edit that removes a clue, so a minimisation phase
cannot be written. What is left is: scatter k black cells, count the answers,
and walk the black cells around the board one move at a time.

There was one implementation trap here. Scoring naively by solution count
cannot move. As the census shows, in the interesting density band most random
placements have no answer rather than too many, so most of the search space is a
flat plateau of "zero solutions". I gave unsolvable boards a secondary gradient —
how many open regions have a size that is not a multiple of three. That is a
necessary condition for solvability and never a sufficient one, but it is a
usable slope out of the impossible region.

What the search reaches inside a fixed budget:

board	sparsest clue set reached	density
6×6	3	8.3%
8×8	7	10.9%
10×10	13	13.0%
12×12	24	16.7%

That is a bound on the search, not on the puzzle. The exhaustive table above
is the one that says what exists.

Branch points needed to prove the shipped boards unique, summed per rung:

	`fit`	`region`	`hetero`	`probe`
8×8, 40 boards	7,046	6,547	6,537	0
12×12, 32 boards	103,060	78,098	77,459	39

That is a strange-looking ladder. region — "an open region has a multiple of
three cells", which sounds like it should carry the puzzle — takes 7.1% off fit
at 8×8 and 24.2% at 12×12. hetero, the rung that encodes the puzzle's own
rule, takes off another 0.2% and 0.8%. Then probe takes 8×8 to 0 and
12×12 to 39. Almost flat, then a cliff.

Asking what each rung can prove from an untouched board makes the reason
plain (this is exactly what the checkbox on the demo page displays):

cells proved before any guess	`fit`	`region`	`hetero`	`probe`
8×8	2.1%	2.1%	2.1%	100%
12×12	3.9%	3.9%	4.2%	88.1%

There is nothing to propagate from. Every other puzzle in this series prints
something — a number, an arrow, a region edge — that pins a cell or two locally
and gives the fixpoint computation somewhere to start. Heteromino prints holes.
Each open cell begins with 9.5 candidate pieces on average and no local rule
eliminates a single one of them. The bottom three rungs between them settle 2.1%
and 4.2% of the board and stop.

Add one level of lookahead — assume a piece, propagate, kill it if that
contradicts — and it goes to 100% and 88.1%. Heteromino is, to a good
approximation, exactly singleton-consistency-hard: nothing below probe works,
and probe needs almost no search on top of it.

The hetero rung is still the interesting inference, because it reasons about a
piece it has not identified yet: if every surviving candidate for some cell has
the same shape, then whoever ends up owning that cell has that shape, whichever
one it turns out to be — so every piece of that shape touching that cell is
already dead. It just turns out that on a board with no numbers, that inference
has almost nothing to fire on until a guess has been made.

rule set	boards that stop being unique	of those, boards left with no answer
nothing removed	0 / 72	0
no same-shape rule (pure tromino packing)	72 / 72	0
rotations count as the same shape (LITS convention)	72 / 72	72

The same-shape rule is not a garnish on a packing puzzle; it is structural for
every board.

The other direction is the interesting one. Tightening the rule — merging
rotations, as LITS does — does not make boards more constrained and more unique.
It makes them unsolvable, all 72 of them, because the intended answer itself
stops being legal.

Bars are barely suppressed. A bar has one long flat side, and a long flat side
is a lot of edge on which to run into a twin, so the rule ought to punish it.

	I—	I\|	L┌	L┐	L└	L┘	bars
shipped answers	16.1%	15.5%	16.5%	16.5%	17.7%	17.7%	31.6%
every tiling of a blank 6×6	14.9%	14.9%	17.5%	17.5%	17.5%	17.5%	29.9%
every tiling of a blank 2×12	0%	0%	25%	25%	25%	25%	0%

An unweighted shape set would give 33.3%. Measured: 31.6% and 29.9%. Two or
three points. Recorded as a null result rather than quietly dropped.

The exception is the one place the effect is not statistical at all: in a blank
2×12, bars are 0% — the two-row strip cannot use one, as shown above. Where
the geometry is tight enough the rule excludes bars outright; where it is not, it
barely leans on them.

Every clue is load-bearing — more than I wanted. Move a single black cell on a
shipped board to a random empty cell, leaving the clue count untouched:

board	single-clue moves tried	still exactly one answer	no answer at all
8×8	1,440	6.2%	30.8%
12×12	3,888	3.4%	41.0%

Almost every move destroys the puzzle, and the dominant failure is not "ambiguous"
but "unsolvable" — the same asymmetry the exhaustive census shows, seen from
inside a board that works.

There are two engines and they share no code. The first makes each cell a variable
whose domain is the trominoes that could still cover it, and propagates the four
rungs to a fixpoint. The second builds no domain at all: it walks the grid and, at
the first uncovered cell, tries every piece that would cover it, checking legality
directly against the pieces already down.

The search branches on "which piece owns this cell". That partitions the answer
space, so the subtrees are disjoint and nothing needs excluding between them.
The first version excluded each tried candidate from the parent state anyway and
re-propagated — it looks like a tidy optimisation.

It breaks. After excluding a candidate and propagating, propagation can commit a
later candidate to that same cell. Then when that candidate's own branch comes
up, commit finds the cell already owned, returns false, and the branch is
skipped in silence. No error. Just fewer answers.

The propagator reported 5 tilings of a blank 3×4. The scanner reported 14.

Nothing about the propagator looked wrong on its own. It took a second engine
sharing no code with it to say so.

The test suite carries a soundness property for this: any cell the propagator
assigns an owner to must have that same owner in every answer the scanner
finds.

TypeScript + Vite, no runtime dependencies, plain arrays in the solver.

src/heteromino.ts    rules, candidate generation, the four rungs, engine 1
src/brute.ts         engine 2 — shares no code
src/generate.ts      the clue-walking generator
src/ledger.json      blank-board tiling counts  (npm run ledger)
src/stats.json       every figure in this article (npm run stats)
tools/notes.mts      generates the demo page's notes from stats.json

Every number on the demo page is generated by tools/notes.mts out of
src/stats.json, so not one figure there is transcribed by hand — re-run the
measurements and the prose follows them. 39 tests.

Puzzle #56 in the solver series.

SEN LLC — Fri, 04 Sep 2026 23:48:08 +0000

Sashigane (さしがね, "carpenter's square") in the browser with a
four-rung solver. This one has a property most Nikoli puzzles do not:
every circle is given. A circle always sits on a piece's bend, so the
circles printed on the board are the set of corners — you know how many
pieces there are and where every corner is before you place a single square.
The only unknown is how far the arms reach. So what are the clues doing? I
measured it, and the load-bearing part is which cell the arrow sits on;
which way it points is worth about a tenth of that. And the one freedom a
setter has left — which of two ends the arrow goes on — swings the odds of the
board being a puzzle at all between 11.3% and 29.8% on a 12×12. Puzzle #55 in
the solver series.

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

Cut the board into L-shaped pieces of width one — two straight arms of at least one cell each, meeting at a right angle. The smallest piece is three cells.
Every piece holds exactly one circle, on the bend.
Every piece holds exactly one arrow, on one of its two far ends, pointing back along its arm at the bend.
A number inside a circle is that piece's cell count. Circles may be bare.

Rule 2 does a lot of work. Every piece has a circle and it is always on the bend,
so the printed circles are exactly the corners of the answer. Piece count and
corner positions come free.

And the arrow has a property that most puzzle arrows do not. It is on an end
and it points home, which means it fixes one whole arm outright: the arm runs
in the reverse of the arrow's direction, and its length is the distance from the
arrow to the bend. The arrow is not one bit of directional information — it is a
complete specification of one arm.

Put those together and the shape of the problem is clear. Every corner is known;
one arm of every piece is known. All that is left is which of two perpendicular
sides the other arm falls on, and how far it goes.

Before any clue, count how many ways an empty grid falls into L-shapes at all.

On a one-cell-wide strip, none — an L needs two dimensions. On 2×2, none. And on
3×3, none: nine cells would have to split as 3+3+3 or 4+5 (the largest L that
fits in a 3×3 is five cells), and neither can be done. It is the only square
that fails, and it sits between 2×3, which works two ways, and 3×4, which works
twenty.


2×n	0	2	2	2	6	10	14	26	46	74	126	218	366
3×n	2	0	20	64	234	664	2220	7476	25882
4×n	2	20	110	752	4522	27380	167078
5×n	2	64	752	7720	84846	908020
6×n	6	234	4522	84846	1557970

The strip has a linear recurrence. Every term past the third satisfies

a(n) = a(n−1) + 2·a(n−3)

which is OEIS A052537, generating function
(1−x)/(1−x−2x³). I have no bijective proof, so it lives in the repository as an
identity re-checked against every computed term on every test run. None of the
other rows, and not the square diagonal 0, 0, 0, 110, 7720, 1557970, returns
anything from OEIS (searched 2026-09-05). Every value past 4×6 is cross-checked
by computing the transpose, which the scanner walks in a completely different
order.

Pieces are at least three cells, so a board carries at most ⌊h·w/3⌋ circles —
and that ceiling is reached: 4×6 admits partitions into all eight pieces.

The arrow already fixes one arm. Add the number and the other arm's length is
fixed too. The only thing left is which side it falls on.

So a fully clued circle has at most two shapes. Over 136,576 fully clued
circles drawn from every partition of 3×5, 4×4 and 4×5, 80.3% had exactly one
shape and 19.7% had two. Never three.

And the tiling always picks between them. Cross every partition of a board with
every one of the 2^k ways to place the arrows, with all numbers printed:

board	(partition, arrow-mask) pairs	with exactly one answer
2×6	72	100.0%
3×4	192	100.0%
3×5	896	100.0%
3×6	6,432	100.0%
4×4	1,888	100.0%
4×5	24,416	100.0%

33,896 boards, not one ambiguous, plus a random search from 5×5 up to 10×10
that also found none. I have no proof, so this is a measurement and not a
theorem — but what it says is that the interesting Sashigane board is the one
with the numbers taken off, which is why this generator erases as many as it
can.

The same exhaustion with the circles left bare:

board	pairs	unique	answers no arrow placement can pin
2×6	72	100.0%	0 of 6
3×4	192	87.5%	0 of 20
3×5	896	81.3%	0 of 64
3×6	6,432	73.5%	0 of 234
4×4	1,888	87.3%	0 of 110
4×5	24,416	74.8%	0 of 752
4×6	284,000	70.9%	0 of 4,522

The last column is the reassuring one: no answer is unprintable. Every
partition counted here has at least one arrow placement that pins it. But more
than a quarter of the choices are wrong, and the setter has to find a right one.

Circles are forced onto the bends and the numbers get erased, so the only thing a
Sashigane setter really decides is which of a piece's two ends carries the
arrow — a choice that is completely invisible in the answer. Take the same
random answers and draw each of them three ways: every arrow on its piece's
longer arm, every arrow on the shorter arm, and one coin flip per piece.

board	pieces	all on the long arm	all on the short arm	coin flip
6×6	median 6	57.9%	49.8%	49.9%
8×8	median 9	41.8%	44.8%	30.4%
12×12	median 14	20.8%	29.8%	11.3%

The first two columns are 1200, 1200 and 400 answers; the coin-flip column is
eight independent masks per answer, so 9,600, 9,600 and 3,200 boards.

Two things come out, and only one of them is what I expected.

A consistent convention beats an inconsistent one, every time. At 12×12 the
short-arm convention pins the answer 29.8% of the time and a coin flip 11.3% —
same answers, same circles, same number of arrows, differing only in which end
each arrow went on. I do not have a mechanism for it. Ambiguity is a property of
the printed board alone and the solver never learns the convention, so all a
convention can do is change which boards you land on. Apparently it lands on
better ones.

And which convention is better flips with the board size. Long arm wins at
6×6 by eight points; short arm wins at 12×12 by nine. At 8×8 they are within a
couple of points, which is inside the sampling error here. So there is no rule of
thumb to hand a setter — only the fact that guessing is the one thing that is
reliably wrong.

The generator prints every number, confirms uniqueness, then erases numbers one
at a time and keeps every erasure that survives. Very little survives:

bank	pieces	numbers left	unique with no numbers
8×8, 40 boards	median 9	0–2, median 0	22 of 40
12×12, 32 boards	median 17	0–4, median 1	10 of 32

More than half the 8×8 boards shipped here carry no number anywhere. The circles
and the arrows are the puzzle.

Each clause switched off in turn, over all 72 shipped boards:

rule removed	boards that stop being unique	median answers when they do	branch points
nothing	0 / 72	—	0
the arrow points home	5 / 72	2	12
the arrow sits at an end	52 / 72	6	1,006
the circle sits on the bend	22 / 72	2.5	146
a number equals the piece size	40 / 72	5	386

The arrow's position is worth ten times the arrow's direction. That is the
opposite of where the rule puts its weight. "An arrow at an end pointing at the
circle" reads like one clue whose content is the direction, with the position as
the peg it hangs on. It is the other way round: knowing which cell is an end is
nearly all of it, and knowing which way it points adds a little on top.

The last row is a self-check rather than a finding — the numbers were minimised,
so every surviving number is load-bearing by construction, and exactly the 40
boards that still carry one lose uniqueness when the size rule goes.

rung	what it does
`fit`	build each circle's candidate list: an L is admissible if it holds this circle at its bend, no other circle, exactly one arrow, at an end, pointing home, and the right cell count
`cover`	every cell has exactly one owner. If only one circle can reach a cell, its piece takes it. If every survivor of a circle covers a cell, nobody else may
`area`	sizes add to `h·w`, so a candidate whose size leaves the rest an impossible remainder dies
`probe`	force each survivor in turn and run the rungs below

Branch points needed to prove the answer unique, summed over the shipped boards:

	`fit`	`cover`	`area`	`probe`
8×8, 40 boards	4,053,280*	0	0	0
12×12, 32 boards	9,600,032*	0	0	0

* five 8×8 boards and every 12×12 board hit a 300,000-branch cap, so those two
cells are lower bounds.

cover finishes every board on this bank without a guess, so area and probe
never fire in anger. They stay because area is what rejects a board whose
numbers cannot add up, and probe is what the generator leans on while deciding
whether a draft is unique.

fit alone — pure exact cover with no propagation — settles 94.4% of an 8×8 by
construction and then needs millions of branch points for the rest. One rung
buys the last 5.6% and all of the search.

The pieces cover the board, so their sizes add to h·w. Every printed number
takes its share off the top. Every piece without a number needs at least 3 cells
and can hold at most h+w−1. So the leftover has to land inside

[3 · anon, (h+w−1) · anon]

and if it does not, the board has no answer — no partial solution, nothing to
unwind. budgetOf in src/sashigane.ts is the whole implementation, and it runs
live in the panel beside the demo board.

There are two solvers and they share no code. One turns each circle into a
variable whose domain is the L-shapes it could still be, and propagates coverage
and area to a fixpoint. The other never mentions a circle: it walks the grid in
row-major order and, at every unclaimed cell, tries each L-shape that would cover
it.

They disagreed on a board the generator had just produced — the propagator said
one answer, the scanner said two. The cause was a stale index. The cover
rung builds a table of how many of each circle's survivors reach each cell, then
sweeps the cells killing candidates, and the first version kept sweeping on the
table it had built before the kills. A stale count compared against a fresh
survivor count reads as "every survivor of this circle covers this cell" when it
no longer does, which evicts other circles from a cell they were entitled to and
silently deletes real answers. The rung now returns the moment it kills anything,
so the caller rebuilds the table.

The test suite keeps a soundness property for it: for random boards, every cell
the propagator pins to an owner must really have that owner in every answer the
scanner finds.

Every circle is given and every circle is a bend, so the unknown in Sashigane is only how far the arms reach.
The arrow sits at an end and points home, so it specifies one whole arm. Add the number and the candidate set collapses to at most two shapes.
A board with every number printed was unique in all 33,896 exhaustive cases and in every random case up to 10×10. Erasing the numbers is what makes it a puzzle.
In the ablation, the arrow's position outweighs its direction ten to one — the opposite of where the rule statement puts its emphasis.
The setter's only remaining freedom, which end each arrow goes on, moves the uniqueness rate from 11.3% to 29.8% on a 12×12. A consistent convention always beats a coin flip; which convention is best flips with the board size.
The blank 3×3 cannot be cut into L-shapes at all. The 2×n counts are OEIS A052537.

TypeScript, no runtime dependencies, 68 tests. Every number here is reproducible
with npm run stats.

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

SEN LLC — Fri, 04 Sep 2026 00:17:08 +0000

Numberlink in the browser with a four-rung solver. What I look for in
this series is something you can read off the board without solving it. This
time it turned up in the clue placement itself: checkerboard-colour the grid
and one pass over the numbers tells you whether the board can have an answer
at all. Puzzle #54 in the solver series.

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

Join each pair of equal numbers with a path of orthogonally adjacent cells.
No two paths share a cell, and no path crosses itself.
Every cell of the grid is used.

Rule 3 is Nikoli's, and a lot of connect-the-dots games drop it. There is also a
convention that no path ever runs alongside itself — two cells of one path
that touch on the grid are consecutive on that path. That one is normally
presented as a matter of taste. I measured it. It is not a matter of taste.

Colour the grid like a checkerboard: cell (r, c) is dark when r + c is even.

A path steps one cell at a time, so it alternates colours. For a path of m
cells:

the path's two ends	length	dark − light
both dark	odd	+1
both light	odd	−1
different colours	even	0

In a solution the paths cover every cell of the grid. So summing those ±1s
over all the paths has to give the board's own imbalance — and what is left is
an equation that never mentions a path:

#(pairs with both ends dark) − #(pairs with both ends light) =
(dark cells) − (light cells)

The right-hand side is fixed by h and w alone: 0 when the area is even,
1 when it is odd. So:

On any even-area board, the numbers whose two ends share the dark colour must
be exactly as many as those sharing the light colour.

You check that in one pass over the clues. No search, no partial solution,
nothing to back out of. The implementation is about twenty lines (parityOf in
src/numberlink.ts), and the demo page runs the tally live in a panel next to
the board.

The test suite verifies the identity against every partition of the 3×4 and
4×4 grids — 102,749 of them, zero violations — on every run. npm run stats
extends it to 2×3, 3×3 and 3×5 for 137,789 in total.

. 1 .
. 1 .

The two 1s are on cells of different colours, so the count balances. There is
still no answer. Whichever way you leave the top middle cell you strand a
corner, and a corner has only two neighbours, so it cannot be an interior cell
of any path — interior cells need degree two and a stranded corner is a dead
end.

Give a board exactly one pair and the puzzle collapses into a classical
question:

Is there a Hamiltonian path between these two cells?

One path using every cell is a Hamiltonian path, and the colour count above is
exactly the classical colour condition on grid graphs. Enumerating every
single-pair placement:

board	balance, solvable	balance, no answer
2×2	4	0
2×3	8	1
2×4	14	2
2×5	22	3
3×3	10	0
3×4	29	7
3×5	28	0
4×4	64	0

The interesting part is that it is not monotone. 2×3 has a witness and 3×3
has none; 3×4 has seven and both 3×5 and 4×4 have none. The gap is a function of
the board's shape, not its size.

Generation in this series runs backwards: cut the grid into paths first, then
write a number on each path's two ends. Every board produced that way
already has an answer by construction — the only question is whether it has
more than one.

So I sampled partitions and measured how often the board is unique:

board	partitions sampled	drawn without the convention	with it
7×7	800 each	0.0% unique	72.8% unique
9×9	300 each	0.0% unique	58.7% unique

Zero out of 800, against 583 out of 800.

There is a confound, and it is worth naming rather than hiding: taut paths grow
less far, so they are shorter, so a taut partition leaves more pairs — and
boards with more pairs are easier to pin down. So I bucketed by pair count and
compared inside each bucket:

pairs	loose	taut
5	0.1% of 1274	40.0% of 55
6	0.0% of 1079	54.8% of 301
7	0.4% of 571	72.4% of 909
8	0.9% of 229	85.3% of 1153
9	1.3% of 77	89.9% of 936

The effect survives intact. This is also the only reason a 9×9 bank exists in
this repository at all: before the sampler enforced tautness, four thousand
draws produced zero unique boards.

The solver does not think in paths. It assigns ON / OFF / undecided to the
h(w−1) + (h−1)w segments between cells, which splits the puzzle into two
constraints that look nothing alike:

degree — a numbered cell has exactly one ON segment, every other cell exactly two.
shape — the ON subgraph is a forest of paths, and each path's two ends carry the same number.

Rule 3 — "every cell is used" — disappears entirely into the degree line. A cell
with degree two is on somebody's path by construction. Collapsing the rule that
defines the puzzle into one clause was the nicest part of the build.

The rungs:

deg — degree counting only.
chain — union-find over the ON components; turn off any segment that would close a loop or weld two different numbers onto one path.
reach — connectivity: both ends of every number must still be able to meet, and no region may be sealed off with no complete pair inside it.
probe — try each undecided segment both ways, keep whichever survives.

Decided from a blank slate:

board	`deg`	`chain`	`reach`	`probe`
7×7	8.4%	76.7%	76.7%	100%
9×9	4.5%	53.6%	53.6%	100%

Branch points to prove uniqueness, summed over the bank:

board	`deg`	`chain`	`reach`	`probe`
7×7, 40 boards	3,306,784 *	172	172	0
9×9, 36 boards	10,800,036 *	2,827	2,827	0

* one 7×7 board and all 36 9×9 boards hit a 300,000-branch cap, so the deg
row is a lower bound.

Look at the reach column. It is identical to chain — same decided
fraction, same branch count, digit for digit. Across 2,488 comparisons
(blank slates, partly-drawn boards, shipped boards, random boards) reach has
never once reached a different conclusion than chain.

I added reach because it looked obviously useful. It is not. I have no proof
that degree counting plus loop avoidance implies connectivity here, so this goes
in as a measurement rather than a theorem — and the rung stays in the ladder and
in the demo's dropdown, because a rung that never fires is part of the result.

Rule 3 is what makes Numberlink a puzzle rather than a maze, so removing it
ought to blow the answer count up. It does not:

board	still unique without rule 3	median routings
7×7	36 / 40	1
9×9	31 / 36	1

Nine boards in ten are already unique when read as "just join the pairs, empty
cells are fine". The rule that defines the puzzle is nearly redundant by the
time these particular boards reach you.

That is a fact about the generator, not about Numberlink. Boards grown from taut
partitions are heavily over-determined; they are nowhere near the edge of
uniqueness. It is the 0%-versus-72.8% result seen from the other side. A board
that only just manages to be unique under the full rules would fall apart the
moment you dropped rule 3.

Cutting the grid into taut paths first means an illegal board is unreachable —
"every cell is used" is precisely what a partition is. No rule ever needs
checking afterwards. Only uniqueness needs a search.

And Numberlink has no "add a hint" move. The clues are the path ends, so
adding a number means changing the shape of the answer. When a board comes out
ambiguous the generator therefore does not resample. It repairs:

take two answers;
list the cells where they disagree;
cut the path running through one of them in two — which adds exactly one pair;
repeat until unique.

Aiming the cut at the disagreement kills the intruder without scattering extra
numbers across the board.

Forget the numbers: how many ways does an h × w grid fall apart into paths of
two or more cells?

2xn: 1, 6, 26, 118, 528, 2364, 10580, 47352, 211928, 948504, 4245120, 18999440
3xn: 1, 26, 242, 3113, 34772, 412016, 4758383
4xn: 2, 118, 3113, 99636, 2993923

None of the three is in OEIS (searched 2026-09-04). The 2×n row satisfies

a(n) = 5a(n−1) − 2a(n−2) − 2a(n−3) + 2a(n−4)

for every term computed. It was fitted on four terms, so four of the eight
checks are genuine predictions — but there is no proof here, only the fit.

The scariest bug in the build was in the routine that counts routings with rule
3 switched off. It pulled its four-element neighbour buffer from a pool indexed
by path length:

const b = buf[path.length];   // ← here
const m = neighbors(g, cur, b);
for (let i = 0; i < m; i++) { ... }

When one pair finishes, the next pair restarts at length 1 — and overwrites
buf[1] while an ancestor frame (the first pair, back when it was at length 1)
is still iterating over it. Routings get skipped.

Measured with that bug in place, the first numbers said 6 of 40 boards were
unique without rule 3, with a median of 14.5 routings. That is the exact
opposite of the section above: it said the fill rule was carrying the
uniqueness. A whole section of this article was written backwards and had to be
thrown away.

No puzzle-level test catches this. Does the board solve? Yes. Is the answer
unique? Yes. What caught it was the most boring assertion in the suite, the one
I nearly did not bother writing:

it('is at least as generous as the full puzzle', () => {
  // every answer with the fill rule is also an answer without it
  expect(without).toBeGreaterThanOrEqual(withFill);
});

Removing a constraint reduced the number of solutions. Allocating a fresh
four-element array per frame fixed it.

Everything above is cross-checked by two solvers that share no code. One assigns
ON/OFF to segments and propagates degrees and connectivity. The other never
mentions a segment: it cuts the grid into paths directly, anchoring on the
lowest free cell, and keeps the cuts whose pieces happen to be numbered
correctly. They agree on the answer count for 400 random boards on 3×3 through
4×4, and on which parity-impossible placements have no answer at all.

The checkerboard argument gives an identity that closes on the clue placement alone — board feasibility without any search.
Necessary, not sufficient; the witness is 2×3, and a one-pair board is exactly a Hamiltonian path problem.
The "no path runs alongside itself" convention decides almost all of the uniqueness — 0% against 72.8%, and it survives fixing the pair count.
The connectivity rung never fired in 2,488 comparisons. No proof, so it ships as a measurement.
"Every cell is used" is nearly redundant on these boards — which says more about the generator than about the puzzle.
74 tests, and the boring inequality test is the one that earned its keep.

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

SEN LLC — Thu, 03 Sep 2026 00:16:47 +0000

Stostone in the browser with a five-rung solver. The headline rule is
written as physics — drop the stones, they must fill the bottom half — and it
is not physics at all. It is a per-column count plus one invariant, and both
can be checked without moving anything. Puzzle #53 in the solver series.

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

The board is H×W with H even, and it is cut into regions.

Shade some cells. The shaded cells of each region form exactly one connected group — a stone — and every region has one.
Two stones may not touch.
A number in a region gives the size of that region's stone.
Drop the stones straight down, each one rigid. They must come to rest exactly filling the bottom half of the board.

Rule 4 is the reason the puzzle exists. It is also the only rule in this whole
series of genre implementations that is stated as a process: do a thing, then
look at the result. Every other pencil puzzle states a property of the grid in
front of you. So the first question is whether the process is really necessary.

It is not.

Falling moves cells vertically. It cannot change how many shaded cells a column
holds. And "the bottom half is exactly full" says every column ends with
H/2 shaded cells. Therefore:

Every column starts with exactly H/2 shaded cells.

A statement about a configuration nobody has computed yet is really a local
count on the one in front of you. That is one line of code and it is the whole
col rung of the solver.

Number the shaded cells of a column from the bottom. The one with b blanks
under it has to land on row H−1−b, so it wants to travel H−1−b−r. A stone
is rigid — every one of its cells travels the same distance — so:

blankBelow(r, c) is the same for every cell of a stone, and that common
value is exactly how far the stone falls.

That is the entirety of rule 4, with no simulation in it:

export function packsByRank(h: number, w: number, cells: Int8Array): boolean {
  if (!columnsBalanced(h, w, cells)) return false;
  const below = new Int32Array(h * w);
  for (let c = 0; c < w; c++) {
    let seen = 0;
    for (let r = h - 1; r >= 0; r--) {
      below[r * w + c] = seen;
      if (cells[r * w + c] === BLACK) seen++;
    }
  }
  for (const comp of blackComponents(h, w, cells)) {
    let key = -1;
    for (const k of comp) {
      const v = Math.floor(k / w) + below[k];
      if (key === -1) key = v;
      else if (v !== key) return false;
    }
  }
  return true;
}

There is a second thing hiding here, which is that "drop the stones" is not
obviously well defined at all. Which stone falls first? Does the answer depend
on the order? It does not, and the reason is worth stating: two stones sharing a
column impose d_i − d_j ≤ gap on their displacements, a system of difference
constraints is closed under componentwise maximum, so a unique maximal solution
exists and any greedy schedule reaches it. The repository simulates the fall
twice on two different schedules — one row at a time for everything at once, one
stone at a time all the way down — and checks both against the invariant that
does not simulate it. On every grid the tests can enumerate exhaustively, all
three agree.

Apply the invariant to two cells of one stone in the same column, r < r'. With
B shaded cells strictly between them, blankBelow(r,c) = blankBelow(r',c) + (r' − r − 1 − B), and the invariant forces B = r' − r − 1 — all of them. So:

A stone never has a vertical hole.

That gives three nested readings of rule 4:

count: every column carries H/2.
convex: that, plus no stone has a vertical hole.
exact: the real thing.

All three ship as switchable rule sets, which is what makes the next section
possible.

The smallest witness is 4×3. Every column carries 2 of 4, neither stone has a
vertical hole, and the arch still comes to rest one row high, because its middle
prong lands on the cell underneath:

# . #        . . .
# # #   ↓    # . #
. . .        # # #
. # .        . # .

Counting the region-free grids — no regions, no numbers, just the shadings an
H×W board admits — puts numbers on the gap. count has the closed form
C(H, H/2)^W; the other two were enumerated by walking only the balanced grids.

board	`exact`	`convex`	`count`	exact/count
2×n	2ⁿ	2ⁿ	2ⁿ	100.0%
4×2	28	36	36	77.8%
4×4	640	1,296	1,296	49.4%
4×10	7,618,204	60,466,176	60,466,176	12.6%
6×2	226	376	400	56.5%
6×4	31,820	133,760	160,000	19.9%
6×6	4,482,592	47,582,864	64,000,000	7.0%
8×2	1,940	4,248	4,900	39.6%
8×4	1,717,396	15,963,452	24,010,000	7.2%

Two edges of that table are provable and both come out right. On a two-row
board the three readings coincide: a stone straddling a gap would need three
shaded cells in a column and there are only two, so exact = 2^W exactly. A
single column packs whenever it is balanced, so exact = C(H, H/2). Column
convexity is likewise vacuous at four rows — the convex and count columns
are identical for every 4×n — and only starts costing anything at six rows.

The 4×n counts are 6, 28, 134, 640, 3058, 14612, 69822, 333640, 1594282,

They are not in OEIS. They do satisfy

a(n) = 6·a(n−1) − 5·a(n−2) − 4·a(n−3)

for every term computed — fitted from the first three and confirmed by the next
seven. A transfer matrix of that width would be the proof; this repository does
not have one, and the README says so.

The solver is a five-rung ladder: col (the counting half of rule 4), clue
(the numbers, one stone per region, stones apart, reachability), fit (list
every way a region's stone could still be drawn and keep what they agree on),
drop (the invariant and its corollary), probe (singleton consistency).

Run each rung on its own, cumulatively, from an empty grid, over the 77 shipped
boards:

size	`col`	`clue`	`fit`	`drop`	`probe`
6×6	0.0%	37.9%	75.4%	78.5%	100.0%
8×8	0.0%	11.7%	26.2%	28.5%	100.0%

col settles nothing. It is pure saturation — it can finish a column, and
at the start no column is finished either way. It cannot open a board. But
attribute every cell the full stack writes to the rung that wrote it:

size	boards	`col`	`clue`	`fit`	`drop`	`probe`
6×6	44	19.5%	37.8%	31.1%	5.5%	6.1%
8×8	33	14.6%	29.2%	22.1%	7.9%	26.2%

Give it one cell from anywhere else and it writes about a sixth of the board.
And take each rung out of the full stack:

variant	settled	finish without guessing	assumptions
all rungs	100.0%	77/77	0
− `col`	48.8%	1/77	350,027
− `clue`	98.6%	75/77	4
− `fit`	90.1%	67/77	47
− `drop`	76.1%	36/77	4,917

Without probing on top the same order holds: 593,084 assumptions without col,
14,306 without drop. The half of rule 4 that cannot open a board is 71 times
the more expensive half to do without.

Now ablate rule 4 as a rule of the puzzle instead of as an inference, and the
picture turns over. Here the arithmetic half is the one that is not enough:

size	`exact`	`convex`	`count`	`none`
6×6	44/44	34/44	34/44	0/44
8×8	33/33	2/33	2/33	0/33

At 6×6, weakening the real rule to counting costs 10 of the 44 boards their
unique answer — and adding convexity back buys none of them; exactly the same 10
fall either way. At 8×8, 31 of the 33 lose uniqueness under both, with a median
of 37 answers where there had been one. On the shipped 6×6 region maps, counting
alone admits 8,081 answers where the real rule admits 2,870: 35.5%.

So the two halves are not two smaller versions of the same rule. One does almost
all of the deducing and none of the disambiguating; the other does almost none
of the deducing and all of the disambiguating.

A number lives in a region and gives that region's stone size, so the entire
clue language is the vector region ↦ size. The strongest clue set that exists
is a number in every region. So an answer can be pinned down iff it is the
only legal grid with its size vector — and that fails a lot:

board	stones aimed at	pinned by every number	median answers
6×6	2	57.1%	1
6×6	3	32.7%	2
6×6	4	20.6%	3
8×8	3	50.0%	1.5
8×8	4	33.3%	4

Fewer, larger stones means fewer regions means a shorter vector, and the vector
runs out of things to say. This is the one measurement here that the shipped
boards cannot provide, because the generator draws the stones first and the
region map second, and simply redraws the map until the full number set does pin
the answer. Measuring the rate on the boards it kept would be measuring its own
filter. So it is measured separately with the filter switched off, and the
README says which is which.

Once a board is pinnable, very few numbers are needed: 2.6 of 9.5 regions at
6×6, 5.3 of 11.5 at 8×8.

Every legal position is a bottom half packed solid, cut into connected pieces,
and lifted. That is the invariant read right to left, so the generator never has
to reject an answer for failing rule 4:

Fill the bottom H/2 rows — what the stones must look like once they have landed.
Cut that block into connected pieces.
Lift each piece. Two pieces sharing a column must keep their order, so the upper lifts at least as far as the lower; those constraints form a DAG, and the occasional cycle just means the two pieces would have to interleave and the draw is thrown away.
Refuse a lift that leaves two pieces touching — that fuses them into one stone whose cells disagree about how far they want to fall.
Grow the regions outwards from the stones, then buy numbers adversarially.

The one thing that is a search rather than a formula is step 4. The packed block
is solid, so every pair of neighbouring pieces starts out touching and only the
lift can separate them, and on a crowded 8×8 board most random lifts fail. So
step 3 backtracks over lift values.

size	stones	mean stone	mean fall	stones that never move
6×6	418	1.89	1.50	21.5%
8×8	381	2.77	2.03	17.1%

About a fifth of all stones are already resting where they will end up. Those
are free information: a stone with a blank under it in any column has a nonzero
fall distance, and one that touches the floor pins its entire column below every
one of its cells.

Three engines that share no code have to agree: the propagating search, an
enumerator that treats a grid as an integer and tries all of them, and one that
picks each region's stone out of that region's connected subsets. Over 60 random
4×4 region maps they agree on all 503 answers, and under every one of the four
settings of rule 4.

probe is sound but not complete. Over 876 clue prefixes it never once claimed
to finish a board with more than one answer; three times a board had exactly one
answer and it still needed a guess. The gap only ever points one way, as it has
in every genre in this series.

The interesting failure was not in the puzzle logic. It was in the second
simulation of the fall — the one that drops one stone all the way before moving
to the next. It mixed two coordinate systems: the stone's cells were being
updated in place as it fell, while the collision test still added the cumulative
drop offset on top of them. On a board with one stone it is invisible. It only
diverges when a stone lands on another stone, which is exactly the case the
whole puzzle is about.

Nothing in the puzzle-side tests would have caught it, because the puzzle side
never calls it. It was caught by the property test that asserts the two
schedules reach the same fixpoint — which exists because "the fall is
order-independent" is a claim this repository makes, and a claim like that is
worth a test whether or not you expect it to fail.

npm install
npm run dev      # the demo on localhost
npm test         # 70 tests
npm run build

MIT.

SEN LLC — Wed, 02 Sep 2026 00:18:54 +0000

Choco Banana in the browser with five rule sets inside. Every group of
shaded cells must be a rectangle; every group of unshaded cells must not be.
The same predicate, affirmed once and denied once — and the denied half turns
out to be the one you cannot afford to lose. Puzzle #52 in the solver series.

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

Shade some cells of an H×W grid.

Every orthogonally connected group of shaded cells is a rectangle — a chocolate bar.
Every orthogonally connected group of unshaded cells is not a rectangle — a banana.
A number in a cell gives the size of the group that cell belongs to, and says nothing at all about which colour that group is.

Rules 1 and 2 are the same predicate, affirmed once and denied once. Rule 3 hands
you an area and withholds the colour. Those two asymmetries are the whole puzzle,
and they are what this repository measures.

"Is a rectangle" is closed under bounding boxes. Any set of shaded cells
known to be in one group drags its entire bounding box in with it, so two shaded
cells can fill a block. It pushes.

"Is not a rectangle" is closed under nothing. A banana that happens to be a
rectangle right now is not yet illegal. It only becomes illegal once it is sealed
shut and can no longer grow. So the rule cannot advance a position — it can only
reject one, and only at the very last moment.

Which makes the denied half look like the cheap half.

It is not.

Attribute every cell the solver writes to the rung that wrote it, over the 68
shipped boards:

size	boards	`value`	`rect`	`size`	`anti`	`probe`
6×6	38	19.8%	5.5%	62.6%	4.2%	7.9%
8×8	30	15.3%	3.5%	67.4%	4.5%	9.2%

The two halves of the rectangle predicate write about the same number of cells,
and both are dwarfed by the group-size arithmetic. But now drop one rung at a
time out of the full stack:

variant	settled	finishes with no guessing	assumptions
all rungs	100.0%	68/68	0
− `value`	86.7%	50/68	332
− `rect`	97.2%	54/68	498
− `anti`	89.8%	36/68	11,686
− `size`	23.5%	8/68	3,623,318

Without probing sitting on top, − rect costs 17,452 assumptions across the set
and − anti costs 103,958. The rule that can only say no is six times more
expensive to do without than the rule that can say yes.

The affirmed half has already moved house.

Its real work is happening inside the size rung. A clued chocolate bar of area
v gets matched against the set of area-v rectangles that still fit around the
cell without swallowing a known banana; cells common to every survivor are shaded,
and cells touching the group but inside no survivor are banana. That is "is a
rectangle" — with a number attached. By the time you get to rect standing on
its own, there is almost nothing left for it to do.

The denied half has no second home. Nothing else in the solver knows that a
sealed rectangle of unshaded cells is illegal, so when you delete it, that
knowledge is simply gone and the search pays for it.

(The unique column is worth a footnote: with size removed the search blows
past its 60,000-node ablation budget on 58 of the 68 boards, so it can only
confirm uniqueness on 10 of them. The answer counts did not change — the
budget did. That is itself a measurement of the cost.)

Uniqueness is a property of the rule set, not of the solver. So ablate the two
halves as rules of the puzzle and re-count the answers:

size	boards	full rules	without "banana ≠ rectangle"	without "chocolate = rectangle"
6×6	38	38/38	12/38	21/38
8×8	30	30/30	12/30	9/30

Delete "a banana is not a rectangle" and 26 of the 38 6×6 boards and 18 of the 30
8×8 boards stop having a unique answer, the median board picking up 2 and 4.5
answers respectively. Delete the other half and at 8×8 it is worse — only 9 of
30 survive.

So as constraints the two halves are comparable; the asymmetry lives entirely on
the inference side, and it points the opposite way from the intuition.

The clue gives a size and withholds the colour, so reading it is an arithmetic
question.

A connected set of 1 or 2 cells is a rectangle however you draw it. So 1 and 2 are always chocolate.
A chocolate bar of area v exists on an H×W board only if v = a·b with a ≤ H and b ≤ W. A number outside that multiplication table is always banana — on a 6×6 board that is 7, 11, 13, 14, 17, 19, 21, 22, 23, 26….

And a banana of area v exists exactly when 3 ≤ v ≤ H·W − 1 (with H, W ≥ 2).
The two ends are precisely the cases that force a rectangle, and everything
strictly between is constructible: take ⌊v/W⌋ full rows plus the remainder, and
when the remainder is zero, shave one cell off the last full row and hang it
below instead.

So the value rung never looks at the grid at all. The number and the board
dimensions are enough.

v	6×6	8×8	10×10
1, 2	chocolate	chocolate	chocolate
7	banana	either	either
11, 13	banana	banana	banana
14	banana	either	either

More than half of all possible group sizes name their own colour on sight: 21 of
36 on a 6×6 board (58.3%), 37 of 64 on an 8×8 (57.8%), 61 of 100 on a 10×10
(61.0%). On the shipped 6×6 boards, 271 of the 388 clues (69.8%) are of that
kind — 195 of them because they are a 1 or a 2, 76 because they are off the
times table.

The number of areas a bar may have on an n×n board is exactly
OEIS A027424: 1, 3, 6, 9, 14, 18, 25, 30, 36, 42.

The clue language of Choco Banana is precisely the map cell → size of its
group. So the strongest clue set that can exist is a number in every cell, and a
one-line theorem falls out:

An answer can be made unique if and only if it is the only legal grid with
its size map.

(⇐) If it is the only one, write every size and it is pinned. (⇒) If another
answer B has the same size map, then B satisfies every clue A satisfies, so
no clue set on earth can exclude it.

And the right-hand side is not always true. On a 3×4 board, a 2×3 chocolate bar
in any of the four corners leaves six banana cells in an L — and all four grids
read 6 in every single cell.

###.     .###     ....     ....
###.     .###     ###.     .###
....     ....     ###.     .###

Write all twelve numbers and four answers still stand.

Exhaustively, over every legal grid on small boards:

board	answers	distinct size maps	answers in a tied group	biggest tie
2×2 … 3×3	5 … 121	all distinct	0 (0.0%)	1
3×4	599	596	4 (0.7%)	4
3×5	3057	3055	4 (0.1%)	2
4×4	4835	4831	8 (0.2%)	2
4×5	40899	40875	48 (0.1%)	2

Not one pair exists up to 3×3; they appear at 3×4 and then sit at around 0.1%.
The generator has to detect them and walk away — its adversarial clue-buying loop
returns null the moment it cannot find a single cell where the two answers
disagree about a size.

Restrict clue buying to numbers that name their own colour, then to numbers that
do not:

size	boards	unrestricted	forcing only	silent only	price (median)
6×6	38	38	19	15	6.0 / 7.0 / 8.0

Unrestricted, all 38 answers can be pinned. With only self-naming numbers, 19.
With only silent ones, 15. The price — the median size of the minimal clue set —
barely moves (6 / 7 / 8), so what each dialect loses is not cost but reach.

In the previous puzzle in this series, "singleton consistency finishes the grid"
and "the board has exactly one answer" agreed on all 718 clue prefixes tested.
Not here.

clue prefixes tested: 581
agreement: 525 (90.4%)
unique but probe stalls: 56
probe finishes but the board is not unique: 0

The gap only points one way. Not once did probe claim to have finished a
board that turned out to have a second answer — if it had, that would be a
soundness bug, not a statistic. But 56 times a board had exactly one answer and
probe still needed a guess to find it. Difficulty and search strength come
apart here in a way they did not last time.

Every shipped clue set is minimal in the strict sense: removing any one of the
518 uniqueness clues, one at a time, left 0 of them still unique, and the
median board grew to 26 answers.

Answers on a board with no clues at all, agreed by all engines:

grid	legal grids
`n×n`, n = 1…5	1, 5, 121, 4835, 584931
`1×n`	1, 1, 1, 1, 1, 1, 1, 1
`2×n`, n = 1…10	1, 5, 19, 57, 171, 509, 1505, 4441, 13105, 38689
`3×n`, n = 1…8	1, 19, 121, 599, 3057, 15525, 78781, 399575

None of those is in OEIS as of 2026-09. The 1×n row is not a coincidence and
not a bug: every connected piece of a strip is a rectangle, so no banana can live
on one at all, and the only legal grid is all-chocolate for every n.

The one number that does reach outside the repository is the multiplication
table, A027424 above.

Three implementations that share no code have to agree on every board:

solveCtx — the propagating search
bruteByMask — treats the grid as an integer and tries all of them
bruteByCells — walks cells in raster order and closes each group the moment its last neighbour is coloured, checking rectangularity and clue sizes there and then

67/67 on the shipped boards for solver vs cell enumerator, 100/100 on random
clued boards small enough for all three. 72 tests.

That cross-check earned its keep during development. The anti rung was built
the obvious way: collect the list of unshaded components, then loop over it. But
a write inside that loop can merge two bananas, which makes every later entry
in the list stale — and a stale component is a subset of the real one, so it can
look like it has no way out, i.e. like a sealed rectangle. The solver was
rejecting correct answers as contradictions. The cell enumerator caught it on one
4×4 board with solver=0, brute=1. The fix is one line — return 'changed' the
instant you write, and let the outer loop rebuild the list — and there is a
regression test with the minimal 4×4 case that reproduces it.

rung	what it is
`value`	the number alone names the colour: `1`/`2` are chocolate, an area off the `H×W` times table is banana
`rect`	every chocolate bar fills its bounding box
`size`	a clued group is exactly that big: lower bound (what it holds) and upper bound (what it can reach), both saturating, plus the intersection of the surviving rectangle placements
`anti`	a banana may not be a rectangle: a sealed rectangular banana is a contradiction, one with a single way out must take it, and a cell walled in on four sides is chocolate
`probe`	singleton consistency on top

Cumulatively on 6×6 they settle 19.8% → 34.4% → 69.7% → 79.8% → 100%.

Answer first. Step one finds a legal grid by running the solver on a board with
no clues, with the branching order shuffled and the colour order biased, so every
answer is legal by construction. Step two buys clues adversarially: while a second
answer exists, find a cell where the two grids put a differently sized group and
write that size there. It stops when uniqueness is reached, or gives up when no
such cell exists — which, as above, genuinely happens.

Then the clue set is minimised twice: once down to a uniqueness-minimal set, and
once down to a set that also lets the target rung finish without guessing. The
median 6×6 board needs 6 clues to be unique and 11 to be guess-free; at 8×8 it is
10 and 16.5.

git clone https://github.com/sen-ltd/choco-banana
cd choco-banana && npm install
npm run dev
npm test

?board=8-3&fill=size opens a specific board with one rung already run, so a
link can point at exactly the position being discussed.

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

SEN LLC — Sun, 30 Aug 2026 23:52:56 +0000

Yajisan-Kazusan in the browser with five rule sets inside. An arrow
clue only has to be true when its own cell is unshaded. Shade the clue's cell
and the number may say anything at all — a clue is allowed to lie. Puzzle #51
in the solver series.

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

Shade some cells of an H×W grid.

No two shaded cells are orthogonally adjacent.
The unshaded cells form one connected region.
Every clue is an arrow and a number written inside a cell. If that cell is unshaded, the number must equal how many shaded cells lie beyond it in the arrow's direction, out to the edge. If the cell is shaded, the clue is exempt — it may say anything.

Rule 3 is the whole puzzle. A clue is not an assertion about the grid; it is an
assertion conditional on one of the unknowns, namely its own cell. So a clue
can lie, provided it pays for the privilege by standing on a shaded cell.

Put differently, a Yajisan-Kazusan clue is a disjunction:

I am shaded, or my number is right.

The useful half of a disjunction is what happens when the right-hand side dies.

A line of L cells can hold at most ⌈L/2⌉ shaded cells, because they may not
touch. So a clue whose number is bigger than that can never be true, and:

A clue carrying an unsayable number has confessed that its own cell is
shaded.

That is not a lemma, it is the solver's second rung. Measured on the shipped
boards — what fraction of the grid each rung's fixpoint settles:

size	boards	`adj`	`cap`	`ray`	`white`	`probe`
6×6	40	0.0%	32.4%	52.9%	59.6%	100.0%
8×8	40	0.0%	37.7%	58.0%	67.1%	100.0%
10×10	30	0.0%	34.2%	59.7%	64.3%	100.0%

adj — "shaded cells never touch" — settles 0.0%, and of course it does:
nothing is shaded yet, so the adjacency rule has nothing to work from. The very
next rung, which does nothing whatsoever except catch clues lying, goes straight
to a third of the board.

So in this puzzle, everything the solver learns first, it learns from a
liar. The honest clues cannot start work until a liar has shaded a cell for
them.

The foundation first. For any legal answer there is always a clue set that pins
it down, and the proof is a two-case split that is literally the generator's
code.

Let A be the intended answer and B a rival answer we want to kill.

Case 1: some cell c is shaded in A and unshaded in B.
Put a clue in c. In A it is exempt, so its number is free. In B it is
binding, so any number other than B's actual count kills B.

Case 2: no such cell — i.e. A's shaded set is a proper subset of B's.
Take d, the last cell in raster order where the two disagree; it is shaded in
B, unshaded in A. Its right neighbour (or, at the row's end, its neighbour
below) is unshaded in B by rule 1, and it comes after d, so A and B agree
there — it is unshaded in both. Point an arrow from it back through d. Every
cell on that line other than d is a cell the two answers agree on, so the two
counts differ by exactly one. Write A's honest number and B dies.

Case 2 depends on rule 1, which is the interesting part. Without "shaded
cells never touch", there is no guarantee of a cell next to the disagreement that
is unshaded in both answers.

Existence settled, now restrict the alphabet.

Liar dialect: clues only on cells that end up shaded. Every clue is exempt.
Honest dialect: clues only on cells that end up unshaded. Every clue is binding.

The liar dialect has a clean, exact answer.

Write an unsayable number on every shaded cell of the answer. Each one confesses,
so all those cells are forced shaded; nothing else is said at all. The answers to
that puzzle are therefore precisely the legal shadings that contain the
intended one. So:

If no cell can be added to the answer while staying legal — the answer is ⊆-maximal — nothing else contains it, and it is unique.
If a cell can be added, the bigger shading is a legal answer too, and every clue sits on a cell that the bigger answer also shades, where every clue is exempt. It survives. And this is not a fact about that clue set: a liar-only clue set can only ever live on the answer's shaded cells, so no liar-only clue set can work.

A liar-only clue set exists if and only if the answer is ⊆-maximal.

Both directions, on 540 answers:

size	density	answers	maximal	of those, unique	non-maximal
5×5	0.18	60	0	0	60
5×5	0.24	60	7	7	53
5×5	packed	60	60	60	0
6×6	0.18	60	0	0	60
6×6	0.24	60	10	10	50
6×6	packed	60	60	60	0
7×7	0.18	60	0	0	60
7×7	0.24	60	4	4	56
7×7	packed	60	60	60	0

All 201 maximal answers unique, none of the 339 non-maximal ones. No exceptions.

Same greedy purchase, only the legal locations change.

Sparse answers (~20% shaded; at this density essentially none are maximal)

size	boards	maximal	free-choice clues	liar-only works	honest-only works	honest-only clues
6×6	40	0.0%	11.9	0.0%	22.5%	14.1
8×8	40	0.0%	21.1	0.0%	10.0%	23.0

Packed answers (nothing more fits, so all maximal)

size	boards	maximal	free choice	liar-only works	liar-only clues	honest-only works	honest-only clues
6×6	40	100%	10.4	100%	10.4	57.5%	11.1
8×8	30	100%	17.5	100%	18.3	16.7%	18.6

Read it like this:

Where the liar dialect works at all, it costs the same as a free choice (10.4 vs 10.4 on 6×6, 18.3 vs 17.5 on 8×8). The restriction is nearly free.
The honest dialect frequently does not work at all. On packed 8×8 answers it succeeds on 5 boards out of 30. That is not a price problem, it is an existence problem.

Earlier puzzles in this series kept landing on "both clue colours always exist,
the only question is the price". Yajisan-Kazusan breaks the pattern. The liars
are the expressive half of this puzzle's vocabulary; the honest clues are an
incomplete dialect.

Back from existence to measurement. Build the minimal clue set that buys
uniqueness, then count how many of those clues end up exempt in the answer:

size	boards	clues	exempt	exempt share	unsayable	share	exempt but accidentally true
6×6	40	478	217	45.4%	90	18.8%	20
8×8	40	842	366	43.5%	184	21.9%	26
10×10	30	931	379	40.7%	206	22.1%	25

Just over four in ten are liars, and about half of those carry a number the
line could never show — the confessions cap catches on pass one. The rest are
"sayable, but wrong here". And 7–9% of the exempt clues are accidentally
honest: nobody checks them, but their number happens to be right anyway.

Now minimality does the work. A minimal set means every clue is load-bearing, so
pull the liars out one at a time:

size	exempt clues tried	answers after the drop (median)	max
6×6	217	8	200+
8×8	366	10	200+
10×10	378	11	200+

961 liars removed one at a time, and not once did the board stay unique; the
median board sprouts 8–11 answers. A lying clue is not decoration. Removing one
collapses the board.

Look at it from the grid's side and the same thing shows up: only about a fifth
of the cells are shaded, but four tenths of the clues are sitting on them. Left
to itself, the adversarial buyer over-selects liars.

Two quantities this series measures every time:

clues needed for uniqueness (unique-min)
clues needed to be solvable without search (solve-min)

Previous entries showed a step of about 1.08×. Here:

size	boards	unique-min	solve-min	ratio	grade histogram of the unique-min board
6×6	40	11.9	11.9	1.00	probe:35 white:5
8×8	40	21.1	21.1	1.00	probe:32 white:8
10×10	30	31.0	31.0	1.00	probe:26 white:4

No step at all. The moment a board becomes unique, singleton consistency can
finish it without a single guess.

The other direction, swept over 718 clue prefixes:

size	prefixes	`probe` completes	unique	agree	probe not unique	unique not probe
6×6	358	40	40	100.0%	0	0
8×8	360	40	40	100.0%	0	0

Zero disagreements in either direction, against 98.0% / 98.9% in the previous
entry. My guess at why is that this puzzle's constraints all fire from a single
cell — shade one cell and cap immediately provokes a confession, while adj
and white both propagate outward from one cell — but that is a guess, and I am
only claiming the observation.

Take the full stack and drop exactly one rung.

size	variant	fixpoint bits	boards moved	probes	search assumptions	over budget
6×6	full	1440	0	436	0	0
6×6	−adj	127	40	3892	2,387,173	39
6×6	−cap	1421	1	2040	4	0
6×6	−ray	1339	6	2210	28	0
6×6	−white	1106	37	1652	4854	0
6×6	−probe	858	35	0	426	0
8×8	full	2560	0	800	0	0
8×8	−adj	244	40	7358	2,400,558	40
8×8	−cap	2492	2	3828	10	0
8×8	−ray	2324	8	4110	208	0
8×8	−white	2072	38	2512	23,674	0
8×8	−probe	1717	32	0	2244	0
10×10	full	3000	0	840	0	0
10×10	−adj	252	30	8476	1,800,166	30
10×10	−cap	2957	1	4642	2	0
10×10	−ray	2474	20	6510	790	0
10×10	−white	2661	25	2328	22,448	0
10×10	−probe	1928	26	0	7478	0

(The −adj rows exhaust the 60,000-node search budget on almost every board —
39 of 40 on 6×6, all of them on 8×8 and 10×10 — so those counts only mean "at
least this much".)

There is a row here that points the opposite way from this article's headline.
Dropping cap breaks almost nothing. On 6×6 the fixpoint goes from 1440 bits
to 1421, exactly one board out of forty moves, and search assumptions go from 0
to 4. On 10×10, one board.

It is not a contradiction. The ladder table measures each rung stacked from the
bottom, where cap is the only source of information there is. The ablation
measures dropping a rung from the top, with probe still switched on — and
singleton consistency rediscovers cap by itself, because "assume this cell is
unshaded → its arrow must be true → contradiction" is a single-cell probe.

So cap is a cheap shortcut, not a necessary axiom — and the cost shows up
in the probe counter rather than in the answer: dropping cap sends probe
invocations from 436 to 2040 on 6×6 and from 800 to 3828 on 8×8, about 4.7×. The
same conclusion, bought back at five times the price.

Dropping adj, on the other hand, is a collapse, and it should be: adj is what
supports the ⌈L/2⌉ bound cap rests on and the in-line adjacency the ray DP
respects. Every deduction in this puzzle is built on rule 1.

Every entry in this series asks whether a second answer is explained by a small,
search-free certificate. Drop one clue from a minimal board to make it ambiguous,
then count how many cells the impostor moves:

size	ambiguous boards	cells moved (avg)	≤2	3–4	≥5	of those cells, on a clue
6×6	40	3.13	45.0%	37.5%	17.5%	40.8%
8×8	40	5.53	25.0%	22.5%	52.5%	38.9%
10×10	30	4.17	43.3%	23.3%	33.3%	31.2%

On 6×6, 45% of impostors move two cells or fewer; on 8×8, over half move five or
more. The bigger the board, the less a second answer looks like a local
swap.

And a third to two fifths of the moved cells are clue cells themselves, which
falls straight out of the exemption mechanic: flip a clue cell between shaded and
unshaded and you flip whether that clue is checked at all. Second answers are
usually built by switching clues on and off.

Internal consistency proves nothing, so the counts are nailed to numbers that
exist outside the repository. Switch off rule 2 (connectivity) and drop every
clue, and what is left is just "shade without touching" — the independent sets of
the grid graph:

grid	counts	OEIS
n×n, n=1..5	2, 7, 63, 1234, 55447	A006506, non-attacking princes
2×n, n=1..8	3, 7, 17, 41, 99, 239, 577, 1393	A001333, Pell–Lucas
3×n, n=1..7	5, 17, 63, 227, 827, 2999, 10897	A051736

Three engines produce those numbers and they share no code. bruteByRows stacks
row bitmasks and never looks at a cell. bruteByCells walks cells in raster
order and never builds a mask. independentSetCount does not enumerate at all —
it is a transfer matrix, so it still answers for 7×7 (1,280,128,950) long after
the enumerators have given up.

Switch connectivity back on and the n×n diagonal becomes 1, 5, 39, 562,
20297, which is not in OEIS as of 2026-08. That absence is not a claim about
anything, but the values are baked into the tests.

The 1×n strip has a closed form you can do by hand: on a strip, "the unshaded
cells are connected" means they are one run, so only the two ends can be shaded,
and (for n ≥ 3) the ends do not touch each other. That gives {}, {left},
{right}, {both} — 4 for every n ≥ 3 (1 for n=1, 3 for n=2). Both
enumerators and the solver agree at every n.

rung	what it is
`adj`	the four neighbours of a shaded cell are unshaded
`cap`	a number the line could never show means the clue's own cell is shaded
`ray`	once a clue cell is known unshaded its arrow is honest: a DP along the line
`white`	connectivity of the unshaded region — unreachable cells and cut cells
`probe`	singleton consistency

Only ray needs code shown. For a line r_1..r_L, run a DP that keeps the set of
reachable totals as a bitmask while respecting adjacency inside the line:

export function rayTotals(cells, rr, work, force = -1, forceVal = WHITE): number {
  let d0 = 1; // reachable totals with the previous cell unshaded
  let d1 = 0; // ... with the previous cell shaded
  for (let i = 0; i < rr.length; i++) {
    const s = i === force ? forceVal : cells[rr[i]];
    let n0 = 0, n1 = 0;
    if (s !== SHADED) n0 = d0 | d1;                 // leave it unshaded
    if (s !== WHITE)  n1 = (d0 << 1) & 0x7fffffff;  // shade it: previous must be unshaded
    d0 = n0; d1 = n1;
    if (d0 === 0 && d1 === 0) return 0;
  }
  return d0 | d1;
}

One function, three uses:

cap — assume the clue's cell is unshaded and run it. If the number is not in the reachable set, the assumption is false: the cell is shaded.
ray — with the clue cell known unshaded, pin each undecided line cell both ways with force. If only one way can still reach the number, write it.
It ignores adjacency outside the line, which makes it a relaxation: it never rules out anything real, and it sharpens as the grid fills in.

The ⌈L/2⌉ bound is not implemented as a separate constant anywhere. Run
rayTotals on an empty line and the largest reachable total is ⌈L/2⌉; the
tests check that for L = 0..10. The bound is a corollary of the DP's first
pass, not a rule of its own.

Answer-first. Walk the cells in random order and shade one whenever that keeps
both "no touching" and "the unshaded cells stay connected". No rejection, no
retry — by the time you stop, you already have a legal answer. Set the density
parameter to 1 and it packs until nothing more fits (which needs a fixpoint, not
one pass), and that gives the maximal answers the liar theorem needs.

Clues are then bought adversarially by enumerating exactly the two cases from the
existence proof, then minimised by shuffling and dropping one at a time. Every
clue on a shipped board is load-bearing, and a test removes each one to prove it.

Vary the density and the price runs the opposite way to intuition:

size	density	avg shaded	maximal	answers with no clues	clues for uniqueness
6×6	0.14	5.0	0.0%	1,646,096	12.8
6×6	0.18	6.0	0.0%	1,646,096	12.9
6×6	0.22	8.0	0.0%	1,646,096	11.8
6×6	packed	10.3	100%	1,646,096	10.3

Twice as many shaded cells, fewer clues needed. More shaded cells means more
exempt seats to write a clue into, and a clue in an exempt seat has a free
choice of number — which is the maximum possible freedom to kill a rival. The
more places an answer lets a clue lie, the cheaper it is to make unique.

61 of them: the line DP against brute force for every length 0–10; the asymmetry
of rule 3 (rewrite an exempt clue's number to anything and the answer survives;
move a binding clue's number by one and it dies); monotonicity in both senses
(more clues never adds answers, a stronger rung never decides less); propagation
never writing a cell the answer disagrees with; three engines agreeing on both
counts and answer sets; the external ledgers; both directions of the liar
theorem; and the shipped bank being unique, honestly graded and free of spare
clues.

src/yajisan-kazusan.ts   model, five rule sets, propagation, search, referee
src/brute.ts             two enumerators sharing no code with the solver, plus a transfer matrix
src/generate.ts          answer-first generation and adversarial clue buying
tools/stats.mts          every table in this article

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

SEN LLC — Sun, 30 Aug 2026 00:55:06 +0000

Statue Park in the browser with five rule sets inside. The clue is a
bag of polyominoes: shade cells so the shaded groups are exactly that bag, and
keep the unshaded cells — the park — in one piece. Puzzle #50 in the solver
series.

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

Shade some cells of an H×W grid.

The shaded cells fall into orthogonally connected groups. The multiset of their shapes, up to rotation and reflection, must equal the given bank — every piece used exactly once.
The unshaded cells — the park — form one orthogonally connected region.
A black circle must be shaded. A white circle must not be.

There is not a single number anywhere. The clue is the bag, plus the circles.

Every write-up of Statue Park lists "two pieces may not touch" among the
rules. It isn't one.

A maximal connected group of shaded cells is never orthogonally adjacent to
another maximal group — that is what maximal means. So the moment you take the
answer to be a shading rather than an assignment of placements to pieces, the
non-touching rule is free.

What is left over is that the rulebook's model names its pieces, and the name
is unobservable. Therefore:

Two banks with the same shape multiset give the same shadings, and the
labelled count = the shading count × ∏ mₜ!, one factorial per repeated
shape.

This is not an interpretation, it is a measurable claim. The repo ships two brute
force engines that share no code with the propagators. On 5×5:

bank	shadings	labelled	ratio
2 × the same tetromino	48	96	2 = 2!
3 × the same tetromino	16	96	6 = 3!
one A + two B	152	304	2 = 2!

Two practical payoffs. No symmetry breaking anywhere — the trick you would
otherwise need to stop equal pieces permuting simply does not exist in the
shading model. And two answers always differ as sets of cells, which is what
the next section stands on.

Two answers to the same bank shade the same number of cells, because the bank
fixes the total area. So if two answers differ, then

there is a cell shaded in A and not in B, and
there is a cell shaded in B and not in A.

(Equal totals, so it cannot be one-sided.)

Print a black circle on the first and B dies. Print a white circle on the second
and B dies. So a black-only clue set exists and a white-only clue set exists,
for every puzzle.

Existence is settled. What is left is the price.

Same greedy chooser (look at the second answer, pick a cell where it disagrees
with the intended one, print a circle there), same minimisation afterwards. Only
the alphabet changes:

size  n   mixed  black-only  white-only   black share of mixed   shaded share of board
6x6  40     6.0         5.1         8.1                  55.2%                   36.2%
8x8  23    13.0        11.3        18.6                  63.0%                   34.7%

White-only needs 18.6 circles at 8×8 where black-only needs 11.3. The explanation
is available after the fact: a white circle only says "no statue here", which
kills placements one at a time; a black circle says "a statue passes through
here", which is a claim about a whole piece, and it kills every placement of
every piece that cannot cover that cell.

The interesting column is the third one. Restricting the greedy chooser to black
circles beats letting it choose freely (11.3 vs 13.0 at 8×8). The chooser picks
uniformly among the disagreeing cells, so left alone it keeps buying cheap white
circles. Adding a constraint made it better — a clean example of that.

Corroborating: in the freely-chosen sets, 55–63% of the surviving circles are
black, while only 35–36% of the board is shaded. Minimisation keeps black
circles at nearly twice their base rate.

rung	what it may know
`clue`	the circles, plus the head count — the bank fixes how many cells are shaded
`place`	the catalogue of legal placements; a placement dies when one of its cells is known park, or a cell touching it is known shaded
`fit`	a shaded cell belongs to exactly one piece, so a neighbour that no surviving placement joins to it is park
`white`	the park stays connected, including the cut vertices that would strand part of it
`probe`	singleton consistency over everything above

Every rung is sound (its fixpoint never disagrees with the answer — asserted in
the tests) and monotone (a stronger rung never decides fewer cells).

Fixpoint on the board an editor would print — the minimal circle set that buys
uniqueness:

size  n      clue   place     fit   white   probe   completions
6x6  40    16.7%   18.8%   25.3%   29.1%   74.0%   clue:0 place:0 fit:0 white:0 probe:26
8x8  24    20.5%   22.6%   25.7%   29.2%   48.9%   clue:0 place:0 fit:0 white:0 probe:5

The bottom four rungs all stall under 30% and probe jumps. There are no
clue-, place-, fit- or white-graded puzzles at all. If you want a
difficulty ladder in the shipped bank you have to buy it, by adding circles until
a weaker rung can finish. That turns out to be nearly free:

size  n   unique-min  solve-min   ratio
6x6  40         6.0        6.5    1.08
8x8  24        13.1       14.3    1.09

Ten percent more circles than uniqueness needs, and the board no longer needs a
search at all. Uniqueness drags search-freeness along almost for nothing.

Same boards, full stack minus one rung:

size  variant   fixpoint-bits  boards moved  probe assumptions  search assumptions
6x6  full              1440             0               3098                   0
6x6  −count            1426             1               3385                   2
6x6  −place             736            35               5461                2136
6x6  −fit               834            25               6368                 122
6x6  −white             629            36               4289                1002
8x8  full              1536             0               4274                   0
8x8  −count            1404             6               4543                  28
8x8  −place             845            24               6122               23790
8x8  −fit               807            21               7804                 254
8x8  −white             528            24               4741                5700

The row worth staring at is count. The head count is nearly free at the
fixpoint — it moves one board in forty at 6×6, fourteen bits across all forty —
and it is not free in the search (0 → 28 assumptions at 8×8). Incremental
numbers alone would have called it dead weight. In the other direction, dropping
place at 8×8 makes the search buy 23,790 assumptions.

Peel circles off until a board goes ambiguous, then compare the second answer to
the intended one, component by component:

size  ambiguous  one piece moved  two    three or more   avg pieces moved
6x6         40            17.5% 42.5%           40.0%               2.23
8x8         24            16.7% 25.0%           58.3%               3.13

In earlier entries of this series a cheap search-free certificate — a two-cell
swap, a 2-opt reversal, a whole row sliding — explained 90%+ of second answers.
Statue Park does not do that. The second answer moves two or three pieces on
average and only one board in six moves exactly one. There is no cheap local
certificate here, and given that the bank is an inherently global clue (where
one piece can go depends on where all the others went), that is probably the
honest picture rather than a gap in the analysis.

Count answers to the bank constraint alone, then again with the park rule on, no
circles either way:

config          boards  with park  without park   killed
6x6 2x size4/5      30        833          1399    40.4%
6x6 3x size4        30       5730         15149    62.2%
6x6 3x size5        30        704          4431    84.1%
7x7 3x size5        30      18744         57546    67.4%

The bigger the pieces the bigger the connectivity rule's share — pentominoes cut
the park more easily, so at three pentominoes on 6×6 it is throwing away 84% of
the answer space on its own. Give the same three pentominoes more room (7×7) and
its share drops to 67%: the rule bites hardest when the board is tight.

No "draw a partition, print clues, pray a solution exists". Answer first:

Drop pieces one at a time at a random legal spot, never touching an existing piece.
After every drop, check the park is still connected, and refuse placements that would cut it.
When the last piece lands, that already is a legal answer — so the bank is read off it rather than guessed at.

Legality is structural, so only uniqueness has to be bought: look at the second
answer, print a circle where it disagrees, then minimise the set.

Three engines agree. The propagating search, a placement-first brute force, and a cells-first brute force that never names a piece. Solution counts agree on 80 clue sets at 6×6, zero disagreements — and the count does not change across the rungs of the ladder either.
External ledger. Give the bank k monominoes and switch the park rule off, and an answer is exactly a k-element independent set in the grid graph. Summed over k that has to be 2, 7, 63, 1234, 55447 — OEIS A006506. The tests check it per k against a separate independent-set counter, and check the totals.
Closed form on a 1×m strip. The park is connected only if the unshaded cells are contiguous, so the shaded cells are a prefix plus a suffix; with monominoes each end holds at most one, giving 1, 2, 1 (for m ≥ 3), 0 for k = 0,1,2,3. The tests reproduce it for every m.
probe ⇔ unique. Sweeping 300 clue prefixes at 6×6 and 364 at 8×8: zero boards where probe finished but the answer was not unique. The other direction happens — six and four boards are unique without probe seeing it — for 98.0% and 98.9% agreement. probe never lies; it just does not see everything.

69 tests.

The thing that cost the most time was the brute force engine that does not name
its pieces. It walks the cells in reading order, shades or doesn't, and whenever
a shaded group is sealed off — every neighbour decided — it charges that
shape against the bank.

The bug: sealed groups were recomputed from scratch at every step. A group sealed
at step i is still sealed at step i+1, so the same piece was charged to the
bank twice. It only misbehaves on banks with a repeated shape, and it only ever
loses answers — the quiet kind of wrong.

The fix was one array of "cells already charged", rolled back on backtrack. The
lesson has the usual shape: you write the brute force engine to check that the
fast implementation is right, and the brute force engine is the thing that breaks
most quietly. Which is why the soundness claim cannot rest on one engine — the
placement-first engine cannot make this mistake structurally (each placement is
handed to exactly one bank slot, so double-charging has nowhere to happen), so
agreement between the two is the detector.

src/statue-park.ts   model, shapes, placement catalogue, five rungs, referee
src/brute.ts         two engines sharing no code with the propagators
src/generate.ts      answer-first layout and the circle-buying loop
tools/stats.mts      every table above

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

SEN LLC — Sat, 29 Aug 2026 15:07:10 +0000

Country Road in the browser with five rule sets inside. The grid is
cut into countries; one closed loop visits every country exactly once; a
number says how many of that country's cells the loop uses; and two cells
facing each other across a border may not both be empty. Puzzle #49 in the
solver series.

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

The grid is cut into countries. Draw one closed loop through cell
centres, orthogonally, never crossing itself. Then:

The loop visits every country exactly once.
A number in a country says how many of its cells the loop uses. Unnumbered countries are unconstrained.
Two orthogonally adjacent cells in different countries may not both be off the loop. (Two empty cells inside one country are fine.)

Shrink each country to a single node; join two nodes when their countries share
a border. Rule 1 then says the loop's country order is a cyclic sequence hitting
every node exactly once:

The loop induces a Hamiltonian cycle on the region adjacency graph.

Two consequences, and the whole solver is built around them.

Every Hamiltonian graph is 2-connected. So a partition whose region graph has
a cut vertex or a bridge admits no solution at all — for any numbers
whatsoever.

The cleanest counterexample is the strip partition. Make every row a country and
the region graph is a path, so everything but the two ends is a cut vertex:

  n×n cut into rows: cut vertex true, Hamiltonian false, solutions 0   (n = 4, 5, 6)

hasCutVertex is Hopcroft–Tarjan, O(V+E), and it rejects the board without
looking at a single number. The brute-force counter, which knows nothing about
graphs, independently returns 0.

The loop enters a country once and leaves once, so exactly two of its border
edges are used. As a relaxation that is degree-two on every node of the region
graph — a 2-factor — and the gap between a 2-factor and a Hamiltonian cycle
is exactly the subtour that TSP practitioners spend their lives eliminating.

The ladder is that structure, one rung at a time:

rung	what it knows
`region`	cell-level bookkeeping: an empty cell carries no road, a used edge puts both ends on the road, two empty cells may not face each other across a border, and a number bounds how many cells are used
`once`	every country exactly once: exactly two border edges used, at least one cell on the road, the same border never crossed twice, and a country's road cells connected inside the country
`loop`	the loop's own structure: degree two, dead ends, cycles that close too early or skip a country, road cells stranded out of reach
`macro`	Hamiltonicity of the region graph. Every Hamiltonian cycle is enumerated once per puzzle into a bitmask catalogue; propagating is then set arithmetic — keep the cycles containing every crossed border and avoiding every closed one, then read the union (a border on no cycle dies) and the intersection (a border on every cycle is forced)
`probe`	singleton consistency, on cells and on edges — a board can have every cell decided and still two ways to thread the road through them

macro is the subtour elimination. Every propagator is sound, so a rung
that finishes a board without guessing is also a proof that the board has
exactly one solution.

Share of the board's bits — every cell and every grid edge — decided at the
rung's fixpoint, starting from a board with every country numbered:

size	boards	region	once	loop	macro	probe
6×6	80	14.9%	15.1%	18.3%	30.5%	63.4%
8×8	80	18.1%	18.2%	20.5%	33.4%	77.8%
10×10	40	18.3%	18.4%	19.8%	30.1%	72.8%

Nothing below probe finishes boards to speak of — macro completes 1.3% at
6×6 and 0.0% above it. The shipped bank agrees: the weakest grade it could find
is loop at 6×6, macro at 8×8, probe at 10×10. No board at any size falls
to region or once alone.

size	drop	bits lost at the fixpoint	boards moved	probe assumptions
6×6	−region	889	40/40	+31.6%
6×6	−once	71	9/40	+9.4%
6×6	−loop	482	36/40	+28.5%
6×6	−macro	607	32/40	+39.2%
8×8	−region	1240	30/30	+110.9%
8×8	−once	59	10/30	+46.5%
8×8	−loop	458	30/30	+116.8%
8×8	−macro	591	25/30	+57.8%

once is the row worth staring at. It is nearly free at the fixpoint — 59 bits
across 30 boards at 8×8, and it moves only a third of them — and yet removing it
makes the search buy the same facts back at 46.5% more assumptions.
Incremental reach and ablation point in opposite directions about it, so both
get reported.

The framing above makes the macro problem sound like the hard part. It is not,
and finding out is one measurement: take the ambiguous boards and ask what the
second solution changes.

size	ambiguous boards	second solution walks the same country order	a different one
6×6	51	92.2%	7.8%
8×8	34	85.3%	14.7%

Nearly all ambiguity is micro: same countries, same order, different cells used
inside them. Which is precisely the job of the numbers — and the numbers mostly
do not do it. With every country numbered, only 18.0% of 6×6 boards and
10.0% of 8×8 boards are unique.

The correlation even runs backwards:

Hamiltonian cycles in the region graph	6×6 boards	unique
exactly 1	28	7.1%
2–4	45	17.8%
5–16	26	30.8%

A board with no macro freedom at all is the least likely to be unique. The
confound is country size: small countries make the region graph dense (many
macro cycles) and leave no room to route inside a country. Turn that dial
directly and the whole effect is size's:

size	avg country	unique	median macro cycles	ladder reach
6×6	2.5	40.0%	7	41.6%
6×6	3.5	20.0%	4	33.3%
6×6	4.5	6.7%	2	27.7%
6×6	6.0	3.3%	1	21.3%
8×8	2.5	18.3%	54	34.6%
8×8	6.0	1.7%	4	22.7%

Partition-first generation is a trap, and the trap is measurable. Random
partitions, before a single number exists:

size	countries	cut vertex	region graph Hamiltonian	board solvable
6×6	4	13.3%	86.7%	83.3%
6×6	6	11.7%	88.3%	74.2%
6×6	8	4.2%	95.8%	84.2%
6×6	12	0.0%	100.0%	90.0%

Hamiltonicity of the region graph is necessary but not sufficient: the gap
between the last two columns is the micro problem refusing to route.

So the generator runs the other way, and cannot dead-end:

Inflate one closed loop. Start from a 2×2 square, repeatedly push an edge out into the neighbouring 2×2 and replace it with a three-edge detour. The result is a single closed circuit by construction — no rejection, no connectivity check.
Cut the loop into consecutive arcs. Each arc seeds one country, so the loop already visits every country once and the arc order is a Hamiltonian cycle on the region graph. The macro problem is solved before the board exists.
Hand every connected blob of off-loop cells to one country whole — which is exactly rule 3.

Legality is structural. Only uniqueness has to be bought, by erasing numbers for
as long as the ladder still finishes:

size	countries	numbers kept (adversarial)	numbers kept (random erasure)
6×6	6.7	2.9	5.4
8×8	11.3	4.7	10.1

Every board is counted three ways that share only the geometry helpers: a
propagating search, a cells-first brute force (fix the cells, count the
routings), and a loops-first brute force (enumerate every simple cycle of the
grid, read the empty cells off as the complement). They agree on 60/60
boards.

And the whole thing is pinned to a count that exists outside this repo. Give
every cell its own country and rule 1 becomes "visit every cell exactly
once", so a clue-free board has as many solutions as the grid graph has
Hamiltonian cycles — OEIS A003763:

  2×2 singletons: 1      4×4: 6      6×6: 1072
  2×m strips:     1, for every m from 3 to 8

"Finished without search ⇔ unique" is checked against brute force in both
directions on 120 boards: 0 finished-but-ambiguous, 0 unique-but-stalled. 37
tests in all.

The bug that cost the most time was in loop's premature-closure test. It
compared the size of a closed component against the number of cells known to
be on the road — and within a single pass an edge can be forced after its
endpoint was last looked at. One cell that is on the road by its edges but still
blank in the cell array makes a finished loop look one cell too long, and a
sound-looking propagator kills the correct solution.

The way it surfaced is the standard harness for this series: every rung's
fixpoint must agree, bit for bit, with every solution brute force returns. If
one propagator is unsound, "finished without search" stops being a uniqueness
proof, and everything built on top of it — the grades, the bank, the ablation
tables — is quietly wrong.

src/country-road.ts   rules, geometry, five rungs, referee, region-graph theorems
src/brute.ts          two brute-force counters sharing nothing but geometry
src/generate.ts       loop-first generation, partitions, clue erosion
tools/stats.mts       every table in this article

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

SEN LLC — Thu, 27 Aug 2026 23:31:17 +0000

Creek in the browser with five rule sets inside. The numbers are not
in the cells — they sit on the corners of the grid, and each one counts
the shaded cells among the (at most) four squares that touch it. Every
unshaded cell must join one connected creek. Puzzle #48 in the solver
series.

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

A corner of the paper touches exactly one cell, so it names that cell
outright. An edge corner touches two, an interior corner four. Writing
C(i,j) for the number on corner (i,j):

C(i,j) = x[i−1][j−1] + x[i−1][j] + x[i][j−1] + x[i][j]   (out-of-range terms dropped)

That is the mixed second difference of the board, and inclusion–exclusion
inverts it:

x[r][c] = Σ_{i≤r, j≤c} (−1)^((r−i)+(c−j)) · C(i,j)

The answer is the chequerboard-signed running total of the clues.
solveByScan in the repo is that formula in six lines.

Measured on 600 random fully clued answers at each of 6×6, 8×8 and 10×10: the
closed form reproduces the answer 100% of the time, the board is unique
100% of the time, and count — the weakest rung in the ladder, which
does nothing but tally one corner — finishes 100% of them. Repeatedly
counting a corner that has one unknown cell left is that triangular scan.

So there is no puzzle in a fully clued board. Everything difficult about
Creek lives in the numbers the setter rubbed out.

numbers kept (8×8, of 81)	unique	finished by `count`	finished by the whole ladder
81 (100%)	100.0%	100.0%	100.0%
73 (90%)	99.2%	98.5%	99.2%
65 (80%)	89.0%	82.7%	89.0%
57 (70%)	56.5%	42.3%	56.5%
49 (60%)	19.5%	10.0%	19.5%
41 (50%)	2.3%	0.5%	2.3%

The corner clue is the most powerful number on the board — it names a cell
with no reasoning at all — and it is the one to erase. Take an answer and
delete either (a) the whole border ring of corners, or (b) the same number of
corners drawn from the interior:

board	erase the ring	erase the same count from the interior
6×6 (24 numbers)	unique 92.5%, dof left 11.00	unique 0.0%, dof left 15.00
8×8 (32 numbers)	unique 97.2%, dof left 15.00	unique 0.0%, dof left 19.00
10×10 (40 numbers)	unique 99.7%, dof left 19.00	unique 1.0%, dof left 23.03

The same number of equations goes away, and the rank barely moves — four
extra degrees of freedom out of a hundred variables. Uniqueness goes from
~100% to ~0%.

The collapse is not about how big the kernel is. It is about what shape it
is.

Erase the border ring and only genuine 2×2 windows remain. If two boards
agree on every 2×2 sum, their difference d has a chequerboard twist
e[i][j] = (−1)^(i+j) d[i][j] with vanishing mixed second difference, hence

e[i][j] = u_i + v_j

and the kernel has dimension exactly w+h−1 (checked against the row
reduction at eight different shapes).

Now restrict d to {−1,0,+1}, since both boards are 0/1 matrices. The
catalogue collapses to three shapes:

row — one whole row flipped in chequerboard alternation,
col — one whole column, likewise,
cross — row r and column c with opposite signs, crossing cell untouched.

There is no small ambiguity in a border-erased Creek board. The cheapest
second solution costs an entire row. Which is why:

board	kernel dimension	±1 sign patterns	still unique	has a legal flip
6×6	11	2,048	93.2%	6.5% (row 23, col 15, cross 1)
8×8	15	32,768	98.2%	1.8% (row 5, col 6, cross 0)
10×10	19	524,288	100.0%	0.0%

findFlipCertificate walks that catalogue with no search at all. It explains
98.1% of ambiguous border-erased boards at 6×6 (107 of them) and 100%
at 8×8 (30), with zero false positives on unique boards. On randomly
erased boards, where interior windows are missing and the theorem no longer
applies, it explains 0.3% and 0.1%. The certificate works exactly
where its proof does, and the measurement says so.

rung	what it reads
`count`	one corner: a cardinality constraint on ≤4 cells, already GAC at that scope
`linear`	the whole clue system, row-reduced once at build time, then bound-propagated
`pair`	two corners one step apart share a domino — enumerate their ≤6 cells exactly
`connect`	the creek is one piece: dead components go black, cut vertices stay white
`probe`	assume a colour, run the sub-ladder, drop it on explosion

Drop one rung, run to a fixpoint, compare bit for bit against the full ladder
on 120 random boards per size:

dropped	fixpoint moved	boards completed	probe assumptions
−`count`	0/120, 0/120, 1/120	61→61, 29→29, 7→7	+0.8%, +6.2%, +3.9%
−`linear`	0/120, 0/120, 0/120	61→61, 29→29, 7→7	+0.0%, +0.4%, +2.6%
−`pair`	0/120, 0/120, 0/120	61→61, 29→29, 7→7	+7.2%, +5.8%, +9.2%
−`connect`	37/120, 52/120, 64/120	61→42, 29→16, 7→5	+16.8%, +8.4%, −6.4%

(6×6, 8×8, 10×10.) The three linear rungs are mutually redundant:
remove any one and the surviving two rebuild its fixpoint to the bit. They
are not free, though — dropping pair costs the prober 6–9% more
assumptions, dropping count 1–6%. Only connect, the one rule in the
ladder that is not linear algebra, moves the answer.

The incremental reading points the other way, as it always does: count
34.2% → linear 35.0% → pair 35.0% → connect 45.0% → probe 50.8% at
6×6. Read increments alone and every rung looks essential; read the ablation
alone and three of them look like decoration. Both tables ship.

linear reasons about the whole board over the rationals. pair looks at six
cells but is allowed to know they are integers. Neither contains the
other. On 9,000 random boards:

bits linear finds that pair does not: 756
bits pair finds that linear does not: 1,947
boards where their fixpoints differ at all: 742
boards one finishes and the other does not: 0 — in either direction

And yet the shipped bank does contain pair-graded boards, because thinning
a board to a locally minimal clue set drives it onto precisely the frontier
where the two rungs separate; that happens 1.7% of the time. The null result
was a statement about where you sample, not about the rules.

Shading density. A thin creek in a big bank is easy, a wide one is hard
(8×8, keeping 60% of the numbers at random):

shaded	unique	adversarially minimal numbers
20%	8.7%	32 of 81
40%	13.3%	29 of 81
60%	24.7%	22 of 81
70%	42.7%	18 of 81

Creek shape. Hold the area fixed and change only the shoreline, by
growing towards cells with fewer white neighbours:

growth	shoreline (edges)	0s printed	4s printed	unique
blob (t=1)	26.5	35.6%	10.3%	25.3%
t=2	40.4	25.1%	6.6%	16.7%
t=4	51.2	18.2%	4.0%	15.3%
tendrils (t=8)	55.9	15.3%	3.1%	14.7%

Same size, same white area, same number of printed numbers — and the
uniqueness rate halves. The mechanism is in the histogram: a 0 or a 4
decides four cells on its own, and a winding creek prints far fewer of
them. Doubling the shoreline trades the extremes for 1s.

Adversarial ink against random ink. A locally minimal clue set needs
16 / 29 / 43 numbers at 6×6 / 8×8 / 10×10 — about 35% of the lattice,
remarkably flat across sizes. Random disclosure needs 2.0× as many.

A Creek answer is any shading whose unshaded cells are connected, so the
generator builds the creek instead of searching for one: seed a cell, then
absorb frontier cells one at a time. The frontier is non-empty until the white
set is the whole board, so growth never rejects, never restarts and never
fails.

1×m boards — the white cells are one interval, so m(m+1)/2 + 1: 2, 4, 7, 11, 16, 22, 29, 37 — matched exactly by exhaustive enumeration.
2×m boards — the two cells of a column are adjacent, so legal boards are exactly those whose white columns form a run with consecutive columns overlapping. The transfer matrix gives 4, 14, 41, 109, 276, 682, 1665, 4041, 9780, 23638 — matched exactly — and continues 57097, 137877, 332900, …
n×n boards — 2, 14, 219, 11507.
Injectivity of the full clue map — exhaustively at 3×3, 4×3, 4×4: 512 → 512, 4,096 → 4,096, 65,536 → 65,536 distinct clue fields. No two boards ever print the same numbers.
Kernel dimension — predicted w+h−1, confirmed by row reduction at eight shapes.

Engine agreement: 300 small boards × five rule levels, 100% agreement with
a raw engine that shares no rule, no candidate array and no row reduction
with the ladder.

One more identity, about the ladder rather than the board: on 9,000 boards
across three sizes and five erasure rates, probe finishes a board if and
only if the board is unique — 0 exceptions in either direction.

The numbers live on the corners, and the clue field is the board's mixed second difference — so a fully clued board has a closed form and no puzzle in it; count alone finishes 100% of them
Erasing the 24-corner border ring of a 6×6 leaves 92.5% of boards unique; erasing 24 interior corners leaves 0.0% — same equation count, four degrees of freedom apart. Shape of the kernel, not size
That kernel is exactly (−1)^(i+j)(u_i + v_j), dimension w+h−1, and at ±1 it is three shapes: row, column, cross. The cheapest ambiguity costs a whole row, which is why a 19-dimensional kernel leaves 0% of 10×10 boards ambiguous
The certificate explains 98–100% of border-erased ambiguity with no search and 0.1–0.3% of randomly-erased ambiguity — it works exactly where its proof does
Ablation: the three linear rungs are bit-identical replacements for each other; only connect moves any fixpoint. Increments say the opposite, and both ship
linear and pair are incomparable (756 vs 1,947 bits) yet separated 0/9,000 boards at the finish line — until thinning drives boards onto the frontier, where they separate 1.7% of the time
Doubling the shoreline at constant area halves the uniqueness rate, because 0s and 4s are the only numbers that decide four cells at once

30 tests. TypeScript, zero runtime dependencies.

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

SEN LLC — Thu, 27 Aug 2026 02:14:32 +0000

Numbrix in the browser with five rule sets inside. Fill the grid
with 1 … n so that consecutive numbers share an edge. Strip the
labels and the answer is a Hamiltonian path of the grid graph — the
numbers only record the order you walked it in. Puzzle #47 in the solver
series.

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

Colour the grid like a chessboard. The walk changes colour at every step, so
the colour of the cell holding v is the colour of the cell holding 1,
flipped v−1 times: value parity and cell colour are locked together,
globally. Print a single number anywhere and every other number on the board
learns which half of the grid it lives in.

This is the cheapest and widest clue this series has measured. On random 8×8
answers, counting surviving cell×number pairs:

board	numbers printed	after `pin`	after `link`	cells pinned
8×8	0	100.0%	100.0%	0.0%
8×8	1	96.9%	43.0%	1.6%
8×8	2	93.9%	36.9%	3.3%
8×8	4	88.0%	27.7%	6.8%
8×8	8	76.8%	13.5%	17.5%
10×10	1	98.0%	44.4%	1.0%
10×10	8	84.7%	19.5%	9.8%

Plain bookkeeping (pin) removes one printed number from 63 other cells and
stops. Turning the same clue into a global statement is the chain rule's
doing. And the first clue takes more than half; every clue after it is
suddenly cheap — the chessboard is only bought once.

The solver hard-codes none of this. The value chain 1—2—…—n is a
tree-shaped constraint network, arc consistency on a tree is exact, and the
chessboard falls out as a consequence rather than a rule.

Two corollaries, both checked on 1,400 sampled answers:

value parity ≡ cell colour (1,400 / 1,400)
an odd cell count puts both ends of the walk on the same colour, an even one puts them on opposite colours (600 odd boards and 800 even boards, no exceptions)

For a puzzle about consecutive numbers, everybody's second rule is a ruler.
Walking from u to v takes exactly |v−u| steps and no walk beats the grid
distance, so a cell far from every home of u loses a whole interval of
numbers around u. It is sound, it is cheap, and it is the technique
humans actually use.

It is also provably worthless after link. The value chain is a path, arc
consistency on it is exact, so every candidate link leaves standing takes
part in some complete walk — and that walk is itself the witness for the
distance bound. Anything you can prove with a ruler, the chain has already
proved.

To keep the claim measurable rather than rhetorical, ruleSpan still ships,
unused by the ladder. On 160 random boards:

board	boards	bits after `pin` alone	pinned by pin+ruler	pinned by pin+link
4×4	40	2,851	55.8%	57.3%
6×6	40	20,904	63.3%	64.9%
8×8	40	75,417	56.4%	57.8%
10×10	40	196,219	59.4%	61.2%

Not a weak rule — a redundant one. On its own it does very nearly the chain's
job (1.4–1.8 points less reach). After the chain it deletes nothing at all.

The relaxation the chain solves exactly is a walk: it may step on its own
tail. Everything the real puzzle knows beyond that says the walk is a path —
that it uses distinct cells. There are two ways to say it.

block, the pigeonhole. The values a…b need b−a+1 distinct cells, all from the union of their surviving homes. A smaller union kills the board; a union of exactly that size is a tight set whose cells belong to the block and lose everything else. Read from the cells instead of the values ("if b−a+1 cells have nothing left but a…b, every other cell loses a…b") it prunes the other direction. Both halves of Hall's condition.
edge, the degree count. Forget numbers; look at the drawing. Every cell has path-degree 2 except the two ends. A cell with exactly two possible edges must use both; forced edges glue into runs whose labels are consecutive by construction; a run may never close a cycle; and what survives must keep the board connected.

Stacking rungs from the bottom (cells pinned, random reveals):

board	reveal	`pin`	`link`	`block`	`edge`	`probe`
8×8	20%	20.9%	43.3%	47.5%	53.5%	74.7%
8×8	30%	30.7%	71.9%	74.5%	84.6%	88.8%
8×8	40%	40.6%	86.6%	87.4%	94.1%	96.9%
10×10	20%	21.0%	47.0%	50.7%	61.5%	77.8%
10×10	30%	31.5%	78.8%	80.2%	88.6%	93.4%
10×10	40%	41.4%	90.6%	91.3%	97.3%	97.9%

That table adds rungs from the bottom. Deleting one from the top says
something different, and you need both to avoid lying to yourself:

10×10, variant	cells pinned	boards whose fixpoint moved	pin scans	link scans	edge runs	probes
full	84.9%	—	496,439	471,796	4,484	1,763
−pin	84.9%	0 / 12	0	556,574	5,250	1,763
−link	37.3%	12 / 12	26,300	0	263	72
−block	84.9%	1 / 12	714,182	687,840	6,726	2,015
−edge	84.9%	1 / 12	703,965	660,469	0	2,520
−probe	74.3%	9 / 12	11,300	11,300	113	0

Only link carries reach. Everything else is speed. Dropping the degree
count leaves the same cells pinned on 11 of 12 boards — while raising the
bookkeeping bill by 42% and the probe count by 43%, because the probe
has to re-derive by contradiction what the drawing said for free. What edge
looked like it was earning in the incremental table was really "work the
probe didn't have to do".

A Numbrix clue set is small — but only if the setter picks it. The left
column is the irredundant set an adversary finds (reveal until the level
finishes, then take back every number it can do without); the right is what
the same board needs when numbers are revealed in random order until the
answer becomes unique.

board	adversarial, `edge` level	as % of cells	random reveal until unique (median)	ratio
4×4	3	18.8%	31%	1.7×
6×6	6	16.7%	22%	1.3×
8×8	10	15.6%	30%	1.9×
10×10	15	15.0%	49%	3.3×

The adversarial share falls as the board grows — 15% of a 10×10 is enough —
while random ink wants half the board. Give the probe the same job and 10×10
drops to 12 numbers.

At the bottom of the ladder there is a wall rather than a curve. With only the
bijection to reason from, a cell becomes pinned exactly when it is printed or
when it is the last unclaimed one, so pin cannot finish any board that is
not already printed in full. Measured: 15 of 16 numbers on a 4×4 and
35 of 36 on a 6×6, every single time. The bank has no pin grade because
no such puzzle exists.

A Numbrix answer is a walk, so the cheapest way to build a different answer
out of one you have is the classic 2-opt reversal: pick two positions on
the path whose cells happen to be grid neighbours, and walk the stretch
between them backwards. It needs one extra edge at each end of the window and
no printed number inside it. Scanning every pair is O(n²) with O(1) work
each — a second answer read straight off the first, with no search.

board	ambiguous boards	explained by one reversal	false alarms on unique boards
4×4	60	83.3%	0 of 35
6×6	60	70.0%	0 of 24
8×8	60	63.3%	0 of 3
10×10	60	58.3%	—

The false-alarm column thins out on the big boards because that stream was
deliberately under-clued to produce ambiguity — so the shipped bank does the
same job at full strength: all 64 boards are unique and not one carries
a certificate. That the explained share falls with board size is the honest
reading: on a big grid a second answer can be a re-route the walk never comes
back from.

The move below a reversal does not exist. A single cell can never change its
number quietly — it would appear twice and another would vanish — and the
tests check that exhaustively over every cell and every alternative on 4×4.

A rectangle always has a Hamiltonian path — the boustrophedon one, snaking row
by row — so a Numbrix answer can never fail to exist. The problem is the
opposite: that answer is far too regular to print, and rejection-sampling
random walks until one covers the board is hopeless past 5×5.

So the generator moves between answers instead of drawing one. The
backbite move takes a Hamiltonian path, picks one of its two ends, picks a
random grid neighbour u of that end, and — if u is not already the next
cell along — adds the edge (end, u) and deletes the edge that used to enter
u from the far side. The result is another Hamiltonian path of the same
grid. Always. No rejection, no restart, no failure mode.

board	moves per cell	accepted	turns in the answer	distinct answers in 200 draws
10×10	0 (the snake)	—	18.0	1
10×10	1	69.8%	33.1	200
10×10	4	71.7%	50.9	200
10×10	16	71.8%	55.9	200
10×10	60 (shipped)	72.0%	55.4	200

The snake has 2(n−1) = 18 turns and exactly one form. Sixteen moves per cell
triples the turn count and the sampler has stopped moving — 200 draws, 200
different answers, about seven moves in ten accepted at every size.

The raw engine shares no candidate machinery with the ladder: it walks, and
scores completed walks with the rule text. Switch the printed numbers off and
it becomes a census machine — and these are published combinatorics, not
something this repository can quietly agree with itself about.

board	directed Hamiltonian paths, engine	published
3×3	40	40 — OEIS A096969
4×4	552	552
5×5	8,648	8,648
6×6	458,696	458,696

board	Hamiltonian cycles, engine	published / proved
4×4	6	6 — OEIS A003763
6×6	1,072	1,072
3×3, 5×5	0	0 — theorem: a cycle alternates colours, an odd cell count cannot

And one identity proved rather than looked up. On the 2×m ladder a walk can
only leave a column through its own rung, so it sweeps the columns
monotonically from each end and is fixed by its turning column — giving
m² − m + 2 undirected Hamiltonian paths. The engine, which knows nothing
about ladders, produced 4, 8, 14, 22, 32, 44, 58 for m = 2…8. Exactly.

The two engines agreed on every solution count they both finished. And
probe-completion ⇔ uniqueness held on 160 boards in both directions with
zero disagreements:

board	boards	probe finishes & unique	probe stalls & ambiguous
4×4	40	21	19
6×6	40	16	24
8×8	40	7	33
10×10	40	6	34

Every one of the 64 shipped boards was re-proved unique by both engines before
shipping.

One printed number colours the whole board. Surviving cell×number pairs on an 8×8 go 100% → 43.0% with one clue; a second only reaches 36.9%. The chessboard is bought once. The solver hard-codes none of it — arc consistency on the path-shaped value chain rediscovers it
Corollaries, no exceptions on 1,400 answers: value parity ≡ cell colour, and an odd cell count puts both ends of the walk on the same colour
The ruler rung deletes 0 bits after link (160 boards). Not weak — redundant: on its own it deletes 2,851–196,219 bits and comes within 1.4–1.8 points of the chain's reach. Anything a distance argument can prove, an exact arc consistency on a tree has already proved
What survives the argument is distinctness: block (both halves of Hall's condition) and edge (degree and connectivity) are the two ways to say the walk is a path
The incremental table and the ablation table disagree, and both are true: only link carries reach (84.9% → 37.3% without it), while dropping edge leaves 11 of 12 fixpoints bit-identical and raises the bookkeeping bill 42% and the probe count 43%
Adversarial ink: 15 numbers on a 10×10 (15%) against 49% revealed at random — 3.3×. pin provably needs n−1, so no pin-grade puzzle exists
The 2-opt reversal certificate explains 58–83% of ambiguous boards with no search and 0 false alarms; a single cell can never change alone
Generation is backbite — moving between answers, never searching for one. 16 moves per cell gives 200 distinct answers in 200 draws
External ledger: 40 / 552 / 8,648 / 458,696 directed Hamiltonian paths (A096969), 6 / 1,072 cycles (A003763), 0 on odd boards (theorem), and a self-proved m² − m + 2 for the 2×m ladder, every term

33 tests. TypeScript, zero runtime dependencies.

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

SEN LLC — Wed, 26 Aug 2026 15:11:29 +0000

Kojun in the browser with five rule sets inside. The grid is
divided into regions; a region of k cells holds each of 1…k exactly
once, two cells sharing an edge never hold equal digits — across region
borders too — and of two vertically adjacent cells in the same region,
the upper one is larger. Puzzle #46 in the solver series.

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

Every clue this series has measured so far was a printed number. Kojun has
printed givens too — but before a single digit hits the paper, the setter
has already committed a clue: the partition itself.

A region's outline says three things. The digit range (size k means 1…k),
the internal slope (every in-region vertical edge points downhill), and
sometimes the entire content: a region shaped like a column of height k
reads k, k−1, …, 1 from the top — the chain of interval bounds "upper
exceeds the lower cell's minimum" resolves every cell with zero givens.

On the default partition stream (region sizes 4–7), the shapes alone pin
9–11% of every board's cells before the first given is revealed — and
almost all of that work belongs to order, the interval rule on vertical
edges:

n	`neigh`	`once`	`order`	`region`	probe
6×6	1.6%	1.7%	9.3%	9.3%	9.9%
10×10	1.6%	1.6%	11.1%	11.1%	11.5%

Try to make the partition a stronger clue and the puzzle resists in a
strange way: the board itself stops existing.

In a finished grid, the set of all cells holding v is a global
independent set — equal digits never share an edge, whatever region they
belong to — and every region of size ≥ v contains a v. So small regions
pack the board with 1s and 2s until those classes no longer embed. The
all-singletons partition is the limiting theorem: every cell must hold 1,
two of them always touch, so no legal board exists at any size ≥ 2.

Measured, the collapse starts far above the theorem. One partition, one
fill attempt, nothing redrawn:

8×8, region sizes	admits a board	mean region size	pinned by shape alone (`order`)
1–1 (all singletons)	0.0%	1.00	—
2–3	0.0%	2.40	—
2–5	2.5%	3.26	56.3%
3–6	28.8%	4.00	24.2%
4–7 (the default)	51.3%	4.70	11.4%
5–9	75.0%	5.91	7.0%

The tension runs against the setter: the shapes that say the most (56%
of cells pinned at sizes 2–5) are exactly the shapes that barely exist.

The vertical rule reads only in-region vertical edges, so the same
4–7-cell budget per region says more laid tall than laid flat. Sweeping
the growth bias:

8×8, vbias	admits a board	cells in column regions	pinned by shape (`order`)	median givens to buy a `region`-level finish (6×6)
0.00 (flat)	98.8%	0.7%	0.9%	18
0.50	60.0%	6.9%	10.8%	12
0.75	25.0%	24.5%	25.2%	9
1.00 (tall)	0.0%	74.6%	—	3

The pinning power climbs 0.9% → 25% — and then the boards vanish. The
culprit is self-solvingness itself: two column regions of height k side
by side are both forced to k…1, and their equal digits touch. A shape
that solves itself cannot sit next to another one.

The last column is the price of ink. A unique region-grade board costs a
median 18 givens on flat 6×6 partitions — half the board — and 3 on the
tall partitions that survive. You can pay for most of the puzzle with
outline instead of digits; the fee is that such partitions almost never
exist.

The givens have their own lesson. Revealing 30% of all cells at random
leaves 6×6 boards unique 0.0% of the time (50% reveals: 6%; at 8×8
even 50% gives 0%). Meanwhile the generator's adversarial reveal —
grow-until-solved, then greedily delete — buys uniqueness with a median of
12 givens. Where a given lands matters almost infinitely more than how
many there are. The lesson from Nanro (#326), where 19 adversarial hints
did what 19 random ones failed to do in 30 of 30 tries, survives in a
puzzle where the setter fully owns hint placement.

The ladder: neigh (a pinned grid neighbour erases its digit here),
once (the region as a permutation: pinned cells erase, lone homes pin),
order (interval bounds on vertical edges), region (enumerate every
complete assignment of one region and keep exactly the supported values),
probe (assume, propagate, delete on contradiction).

once (a census of homes per digit) and order (a geometry of edges) are
incomparable middle rungs. But every deletion the three cheap rules can
justify lives inside a single region, or crosses one boundary edge to a
pinned cell — exactly what region's enumeration checks. The roof
subsumes all three, as a theorem; ablation confirms it in bits:

10×10	cells pinned	fixpoints moved	region assignments	probes
full	12.7%	—	8,196	706
−neigh	12.7%	0 of 20	11,129	706
−once	12.7%	0 of 20	9,914	706
−order	12.7%	0 of 20	9,413	706
−region	12.7%	0 of 20	975	706
−probe	11.7%	18 of 20	975	0

Dropping any cheap rule leaves the fixpoint bit-for-bit identical at every
size; what moves is the bill (−neigh raises the roof's enumeration work
by a third). That much is familiar from this series. The fifth row is the
new part: on this stream, removing the roof changes nothing either. On
naked boards every deletion the roof can make, the probe re-derives — the
whole ladder above order falls silent.

The middle wakes up when givens arrive. The shipped bank (80 boards)
fills all five grades at every size: printed digits separate the rungs
that the naked stream collapses. A bare partition flattens the ladder to
two levels; givens unfold it back to five.

Soundness is pinned by an independent engine that shares no machinery with
the ladder: it deals whole regions one at a time — the search space is
literally Π kᵢ! — checking placed digits only against the raw rule text,
and scoring every leaf with the validator. It agreed with the propagating
search on 482/482 solution counts.

It also faces an external identity. An isolated p×q rectangular region (p
rows, q columns, no givens) is constrained only in its columns, each
strictly decreasing downward — so the count of fillings must be the
multinomial:

(pq)! / (p!)^q   — choose each column's digits; their order inside is forced

The engine, which knows nothing about multinomials, landed on every term
asked: 1×5 = 120, 3×2 = 20, 4×2 = 70, 3×3 = 1,680, 2×5 = 113,400 — and
k×1 = 1, the counting-theory version of "a column is its own solution."

A single cell can never change value silently: its region would gain a
duplicate and lose a digit (the tests prove this exhaustively over every
cell and every alternative value). So the cheapest ambiguity is a swap —
two ungiven cells of one region trading digits with every law intact — and
one scan of the finished grid finds it, no search at all:

n	non-unique boards	explained by one swap
4×4	296	291 (98.3%)
6×6	200	200 (100.0%)
8×8	240	240 (100.0%)

Magnets (#328) got 37–47% out of its pair certificate. Kojun's ambiguity
is almost entirely confined inside single regions — the small bijections
lock digits so tightly that multi-region rearrangements are almost never
the cheapest second solution. And the probe ladder agreed with true
uniqueness on all 680 stream boards, in both directions.

Kojun's first clue is the partition: column regions solve themselves with zero givens, and default shapes pin 9–11% of all cells on their own (nearly all of it order's work)
Digit classes are board-wide independent sets, so small regions are the most informative and the least existent: at 8×8, sizes 2–3 admit 0% of boards, 5–9 admit 75%; the all-singletons partition is empty by theorem
The verticality dial raises shape-pinning 0.9% → 25% while existence falls 98.8% → 0% — self-solving shapes cannot sit next to each other. Ink cost: 18 givens flat, 3 tall
Random givens are nearly worthless (30% reveals: 0% unique); 12 adversarial ones do the job
The region roof provably subsumes the three cheap rules — ablation is bit-identical everywhere — and on naked boards the roof itself is redundant; only givens wake the ladder's middle (the bank still fills all five grades at every size)
The independent Π kᵢ! engine matched 482/482 counts and reproduced the multinomial census (pq)!/(p!)^q on every rectangle asked
The in-region swap certificate explains 98–100% of non-unique boards with zero false alarms; probe ⇔ unique held on all 680 boards

27 tests. TypeScript, zero runtime dependencies.

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

SEN LLC — Mon, 24 Aug 2026 23:32:40 +0000

Magnets in the browser with five rule sets inside. The board is
pre-tiled into dominoes; each domino either becomes a magnet — a +
pole on one half, a − pole on the other — or stays neutral. Two
cells sharing an edge may never hold the same pole, and the margins count
every row and column's + cells and − cells. Puzzle #45 in the solver
series.

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

Each line (row or column) carries two numbers: its + count and its −
count. The useful way to read them is as a sum and a difference.

The sum counts magnetised cells and cannot tell + from −. The
difference can — but it cannot see any domino lying inside the line.
A domino tucked horizontally into a row contributes one + and one − if
it is a magnet, and nothing if it is neutral; either way it cancels out of
the difference. What survives is exactly the cells whose domino crosses
the line, one half in, one half out:

plusClue − minusClue = Σ over crossing cells of σ,   σ ∈ {+1, −1, 0}

The difference clue is a signed flux through the line's boundary, and
the in-line dominoes drop out of that integral identically. A Kakuro sum
talks about every cell in its scope; a Magnets difference is structurally
unable to mention half of its own line.

The solver's third rung, flux, reasons from that identity alone: interval
bounds on the sum of σ terms, plus one parity fact — when every other
crossing cell is known magnetised, the remainder's parity is forced.

The identity has a measurable consequence. Give the tiling generator a
horizontal bias hbias and sweep it, keeping the clue count fixed at 32
numbers per 8×8 board:

hbias	crossing cells per row	rows with difference 0	pinned by `flux`	pinned by probe	exactly one answer
0.00 (all vertical)	8.00	28.4%	1.6%	3.8%	0.0%
0.25	6.16	33.0%	10.8%	71.7%	23.8%
0.50	4.51	39.8%	20.4%	87.3%	50.0%
0.75	2.74	46.6%	15.7%	80.1%	35.0%
1.00 (all horizontal)	0.00	100.0%	2.7%	7.7%	0.0%

At hbias = 1 every domino lies inside its row, so every row's
difference clue is identically zero — it carries no bits at all. The
information moves wholesale into the columns… and the puzzle dies anyway:
uniqueness collapses from 50% in the isotropic middle to 0% at both ends.

The culprit is the certificate below. Parallel dominoes stacked on the same
two tracks are precisely the configuration that can trade states silently,
and an anisotropic tiling mass-produces it. An isotropic tiling keeps both
readings of the clue pair alive; an anisotropic one kills one reading and
paves the board with silent pairs.

Every generator in this series has claimed "no search, no rejection", but
always as a measurement. Magnets is stronger: the filling phase provably
cannot fail.

Drawing an answer takes two steps. The tiling is laid scan-order with a
bounded restart. The filling then visits dominoes in random order and gives
each a state that is legal right now — and since a neutral domino
conflicts with nothing, the set of legal states is never empty. Neutral
is a structural escape hatch:

// Both magnet orientations may be blocked by neighbours — neutral never is.
if (legalPole(a, PLUS) && legalPole(b, MINUS)) options.push([PLUS, MINUS]);
if (legalPole(a, MINUS) && legalPole(b, PLUS)) options.push([MINUS, PLUS]);
// options may be empty; grid[a] = grid[b] = NEUTRAL always advances.

The price of the guarantee is a density dial, and both of its ends are
easy:

8×8, magnetise	mean magnetisation	`count` finishes	probe finishes	exactly one answer
0.0	0.0%	100.0%	100.0%	100.0%
0.4	36.6%	8.3%	41.7%	41.7%
0.8	65.7%	0.0%	56.7%	56.7%
1.0	75.7%	0.0%	50.0%	50.0%

An all-neutral board is trivially unique (every clue is 0); a packed board
is rigid again because adjacency dictates. Ambiguity lives in the middle,
at the density where the adjacency rule has started to bite but not yet to
rule.

The ladder is five levels: pole (raw bookkeeping — domino coupling plus
"a pinned pole erases its neighbours"), then count (each clue as a
per-sign census over all cells of the line) and flux (the signed sum over
crossing cells only), then gac, then probe.

count and flux are incomparable — the census sees every cell but
cannot mix signs; the flux mixes signs but sees only the crossing cells.
Neither subsumes the other. But every constraint of this puzzle lives
inside some line: horizontal adjacency in the row, vertical adjacency in
the column, and each domino's coupling in whichever line the domino lies
in. So gac — exact enumeration of one line at a time — is a roof over
both middle rungs, and over pole too. That is a theorem that predicts the
ablation table, and the measurement agreed bit for bit:

10×10	finished	cells pinned	fixpoints that moved	line assignments built	probes
full	40.0%	80.5%	—	3,424	215
−pole	40.0%	80.5%	0 of 20	6,071	215
−count	40.0%	80.5%	0 of 20	3,491	215
−flux	40.0%	80.5%	0 of 20	3,548	215
−gac	25.0%	58.6%	8 of 20	0	476
−probe	25.0%	40.9%	15 of 20	327	0

Remove any of the three cheap rules and the fixpoint does not move by a
single bit, on any board, at any size (6×6 and 8×8 show the same zeros).
What moves is the bill: dropping pole nearly doubles the roof's
enumeration work. The middle rungs' preconditioning discount is small
(2.8–9.6%); the biggest accelerator was the cheapest bookkeeping. Only the
roof and the probe change what gets solved.

One more zero worth printing: pole alone finishes 0.0% of boards at
every size. With no domino revealed, coupling and adjacency have no
purchase — 100% of this puzzle's information is in the margins.

Soundness is pinned by an independent engine that shares no machinery with
the ladder: it deals each domino its three states in scan order, with only
raw bookkeeping, and scores every leaf against the rule text. The two
engines agreed on 462/462 solution counts across mixed clue regimes.

But engine-vs-engine agreement can miss a shared misunderstanding, so the
raw engine also gets checked against something outside the repo. On a
clue-free 1×2k strip, the number of legal fillings obeys the transfer
matrix over {neutral, +−, −+}, giving a(k) = 2a(k−1) + a(k−2) — OEIS
A001333, the numerators of the continued-fraction convergents of √2:

k	1	2	3	4	5	6	7	8	9
engine	3	7	17	41	99	239	577	1,393	3,363

All nine terms, horizontal and transposed. √2 has never read our code.

Under full clues, a single domino can never change state silently:
flipping a magnet moves the ± counts of the two lines it crosses, and
toggling magnet ↔ neutral moves every line it touches. The tests prove this
exhaustively — every domino, every alternative state, on a stream of random
boards. So the cheapest ambiguity is a pair: two parallel dominoes on the
same two tracks trading states so that all four line counts balance.

Scanning a finished grid for such a pair — no search, no solver — explains
a large share of all non-uniqueness, with zero false alarms:

n	non-unique boards	explained by one pair
4×4	92	34 (37.0%)
6×6	83	39 (47.0%)
8×8	71	29 (40.8%)

And probe ⇔ unique held on the whole stream: 680 boards, no exception in
either direction.

A line's clue pair splits into a sum and a difference, and the difference is structurally blind to in-line dominoes — it is a signed flux through the line's boundary.
The anisotropy dial runs uniqueness 0% → 50% → 0% with the clue count fixed: the orientation of the tiling decides how much the same numbers say.
Neutral-is-always-legal makes the filling generator dead-end-free as a theorem, not a retry statistic; its density dial is easy at both ends and hard in the middle.
Two incomparable middle rungs under one exact roof: ablation leaves the fixpoint bit-identical without any cheap rule, while −pole doubles the roof's work.
The raw engine reproduces the √2 convergent numerators (A001333) on strips, nine terms, and matched the propagating engine 462/462.
A tiny impossibility theorem (no silent single-domino move) turns into a pair certificate that explains ~40% of non-uniqueness with zero false positives.
probe ⇔ unique: 680 boards, no exceptions. 31 tests.

All code is public: https://github.com/sen-ltd/magnets

bars used

pieces crossing a 3-column block