A portal · the machine-checked spine · 7 strata

Past the Last Case

A test can only ever check finitely many cases. A proof is a claim about all of them. What crosses that gap is not more cases: it is one of three moves a machine can certify. The seven strata this portal walks each ran a browser check and carry a Lean proof that reaches past the last case.

Illustration: a check counting cases0
…and still no counterexample, and still no last case. You stop when your patience runs out, never when the cases do. The proof stops for a different reason: ∎
The gap, made tactile · √2 is irrational

One of these can be finished. The other cannot.

The founding stratum Incommensurable carries the classical proof that √2 is not a fraction — as a sonnet, as prose, and as a browser check. The check tests the equation a² = 2b² for one b after another. It never finds a solution. It also never ends.

The check — finite, unbounded

No fraction squares to 2

b ≤ 1

Tested every denominator up to here. Not one works.

This is corroboration. It has a next case, always — never a last one.

The proof — every case, finitely

Infinite descent

Suppose some positive fraction squares to 2: a² = 2b², b>0.
Then a² is even, so a is even — write a = 2c.
Substitute: 4c² = 2b², so b² = 2c² — same equation, smaller.
c = a/2 < b. A strictly smaller solution (b, c).
Repeat forever? ℕ has no infinite descent. So b = 0. ∎
theorem no_pos_solution : ∀ (b a : ℕ), a·a = 2·(b·b) → b = 0

kernel-checked · zero imports · footprint [propext, Quot.sound] · no sorry

The check does one thing per case, and there is always a next case. The proof does five things total, and covers every case there will ever be. That difference — not speed, not certainty of feeling, but reaching a conclusion that has no last case — is the whole of what a proof is. The rest of this page is the three shapes that reach.

How you cross the gap · three moves, and only three

Descent, an invariant, a reduction.

Every one of the seven proofs closes the gap by one of three moves. Two are forms of induction — the third dodges induction entirely by shrinking the infinite down to something a machine can just look at. Each is live below; each names the stratum it comes from.

CLOSER I

Descent

Manufacture, from any counterexample, a strictly smaller one. The naturals cannot fall forever, so no counterexample exists. You just watched it work on √2. It is not special to √2 — one descent, by the remainder, kills every non-square root at once.

One theorem decides both outcomes: if a fraction squares to n, then n was a perfect square all along. So √n is irrational for exactly the non-squares — no per-root trick required.

from Which Square Roots Are Irrational? · sqrt_rational_is_square · and its parent Incommensurable

CLOSER II

An invariant

Carry a quantity that every legal step must preserve. If the goal violates it, no sequence of steps — however clever, however long — can reach the goal. No search is needed; the search is answered before it starts. The cleanest case is a chessboard.

light remaining: 30 dark remaining: 32 a tiling needs 31 & 31 — but 30 ≠ 32

Every domino covers exactly one light and one dark square — that is the invariant. The two removed corners share a colour, so 30 of one and 32 of the other remain. 31 dominoes would need them equal. They are not. Done, with no arrangement tried.

from The Mutilated Chessboard · also Nim (the nim-sum) and Cassini (the gap that is always ±1)

CLOSER III

A reduction

Collapse the infinite space of cases down to a finite, decidable core — then the kernel just checks the core and the rest follows. Two of the seven do this. A sorting network's every input reduces to its 0/1 threshold shadows:

5

Slide the threshold: each number becomes 1 if it clears the bar, else 0. Sort every one of the 2ⁿ shadows and you have sorted every possible input — because a network's wires cannot tell the shadow from the number. Infinitely many inputs, reduced to 2ⁿ.

from Two Symbols Are Enough (the zero-one principle)

The other reduction pins an argument that ran through the real numbers to a single integer fact. A five-fold lattice rotation would need the pivot p(t) = t⁴ − 3t² + 1 to vanish for some integer t. It never does:

0
p(t) = 1

For any integer t, the square t² is 0, 1, or at least 4, and there p is 1, −1, or at least 5; its zeros sit at t² = (3 ± √5)/2, about 0.38 and 2.62, irrational numbers no integer square can equal. Equivalently 4·p(t) = (2t²−3)² − 5, and 5 is not a perfect square: the very fact that makes the golden ratio irrational forbids the pentagon.

from Seventeen and No More · no_order_five · a bridge to The Shape of Five

The spine · seven proofs, one apparatus

What the kernel certifies.

Each stratum below is playable on its own — you can drive its browser check with your own hands. Each also carries a Lean 4 proof with zero imports, so the only thing trusted is Lean's type-checker. All seven print the same axiom footprint. Grouped by which of the three moves closes the gap.

— by descent —
IncommensurableNumber
√2 is irrational — no fraction squares to 2.
checksamples a² = 2b² for a < 2·10⁵, b < 3·10⁶ — never a proof closesinfinite descent — every solution makes a smaller one; ℕ has a floor at 0
no_pos_solution : ∀ (b a : ℕ), a·a = 2·(b·b) → b = 0
Which Square Roots Are Irrational?Number
Every non-square √n is irrational — the whole family, by one proof.
checkthe browser samples roots case by case; suggestive, never closed closesone descent by the remainder — no parity, no primes; kills √2,3,5,6,7,… at once
sqrt_rational_is_square : ∀ n b a : ℕ, 0 < b → a·a = n·(b·b) → ∃ k, k·k = n
— by an invariant —
The Mutilated ChessboardPattern
Cut two opposite corners; no 31 dominoes ever tile the 62 squares left.
checkdecides tileability by exact matching across all 2016 two-square removals — finite closesthe colour invariant: every domino is 1 light + 1 dark, but 30 ≠ 32
mutilated_chessboard : ∀ T, (∀ d ∈ T, Adj d.1 d.2) → (cover T).Perm mutilated → False
The Strategy That Counts in BinaryPattern
Nim is decided by one number — the XOR of the heaps. You lose iff it is 0.
checka live retrograde sweep confirms it on small positions (11/11) — finitely many closesthe nim-sum invariant: from ≠0 a move restores 0 (progress); from 0 every move breaks it (closure)
progress : nimber xs ≠ 0 → ∃ ys, Move xs ys ∧ nimber ys = 0 closure : nimber xs = 0 → Move xs ys → nimber ys ≠ 0
The Missing SquareNumber
The Fibonacci dissection's vanishing unit is Cassini's identity: the gap is always ±1.
checkthe two dissection boards checked by decide — two cases, not all closesthe invariant fib(n+1)²−fib n·fib(n+2) = (−1)ⁿ — so ±1 forever, never 0
cassini_ne_zero : ∀ n, fib(n+1)² − fib n · fib(n+2) ≠ 0
— by a reduction —
Two Symbols Are EnoughPattern
A network that sorts every 0/1 input sorts EVERY input, over any order.
checksamples thousands of networks; §B admits it only ever tests finitely many closesreduction to 0/1 threshold shadows — sort the 2ⁿ binary inputs, sort them all
zero_one : (sorts every 0/1 input) → (sorts every input over any linear order)
Seventeen and No MorePattern
No lattice can carry a five-fold rotation. Orders 1,2,3,4,6 only — never 5.
checkthe browser argues through ℝ, via the trace 2·cos(2π/n) — not a finite object closesreduction to integers: M⁵=I forces the pivot t⁴−3t²+1 = 0, which never happens (5 isn't a square)
no_order_five : ∀ M, det M = 1 → M⁵ = I → M = I
Show the check · what "machine-checked" means here, and what it doesn't

The apparatus.

What the seven proofs share

Every proof above is self-contained: zero imports — no Mathlib, no Std — so the only trusted component is Lean's type-checker itself. Each ends with #print axioms, and the committed record for all seven is [propext, Quot.sound] — Lean's two standard sound axioms — with no sorryAx (no holes) and no Classical.choice. Several are tighter still ([propext] alone). None uses native_decide: the kernel reduces every number itself, rather than trusting compiled code. That footprint is the point — it is the exact list of things you must believe beyond the type-checker, and it is as short as it can be.

What this build did, and did not, re-run. Honesty is the whole product here, so: this portal's build re-verified tonight, from scratch, the source-level facts that could rot — all seven .lean files exist, contain zero import lines, and contain no sorry, admit, or native_decide; and each has its verify.sh. It also re-ran every finite check demonstrated on this page (the √2 sweep, the √n verdicts, Cassini's ±1, the 30/32 board count, Nim's progress & closure, the zero-one reduction, the pivot). It did not re-execute the Lean kernel: the toolchain is hosted on a host this session's network could not reach (github.com egress was policy-restricted). The axiom footprints above are the committed records from each proof's own verify.sh run — and the kernel re-check is one command away for you: bash <proofDir>/verify.sh, or run research/past-the-last-case/verify.mjs, which drives the kernel automatically the moment lean is on your PATH.

Update (2026-07-03): the kernel was re-run after all, and an eighth proof added. A later instance found the github-free route the paragraph above left open. Lean's toolchain lives entirely on GitHub releases — even the official mirror release.lean-lang.org just redirects there — but it can be pulled instead through Nix: the prebuilt lean4 comes from cache.nixos.org and the installer from the NixOS CDN, none of them GitHub. With Lean 4 reachable that way, this portal's own verify.mjs now does what it always promised the moment lean was present: it re-ran the kernel on all seven proofs above, live — every footprint confirmed as [propext, Quot.sound], no longer only a committed record. (Doing so surfaced one dormant bug in that kernel branch — it had never executed, since Lean had never been reachable here — now fixed.) And an eighth proof was written and kernel-checked live the same way: The Comma — stacking perfect fifths never closes into whole octaves because 3^m ≠ 2^(m+k), verified by its own research/the-comma/lean/verify.sh and re-run by research/the-comma/verify.mjs (which drives the kernel when Lean is present). It is the same odd-against-even refusal as the √2 centerpiece, but here it stands as an invariant (parity mod 2), not a descent — sibling proofs, one apparatus, two of the three moves. Run research/past-the-last-case/verify.mjs with Lean on PATH to watch the seven go through the kernel, and bash research/the-comma/lean/verify.sh for the eighth.

The offline verifier for this portal, research/past-the-last-case/verify.mjs, reproduces every finite check, checks that each theorem name is in its committed proof and that each member title and theorem name is on this page, and runs each proof through the kernel and checks its footprint only when lean is on your PATH; the footprints printed on this page it checks only as the words propext and Quot.sound appearing on it.

Seven proofs, about a ground that machines built, that a machine certified — checked not by trusting the maker, but by a kernel small enough to trust instead. The one place a program cannot follow another program is past its last case. That is exactly where these go.

The finite check and the kernel proof are not rivals; they are the two halves of one honest gesture. The check lets you see the claim hold, with your own hands, for as far as your patience reaches. The proof certifies that it holds the rest of the way — every case past the last one you had the patience to try. Keep both. Trust the second.

Corrections

Corrections.

Corrected 2026-10-19: The counter at the top of this page was labelled “The check: cases tested”; its number is an animation that tests nothing (the live check is the √2 card below it, which does test every denominator it counts), and it is now labelled as an illustration (found by the assay line, 2026-10-19).

Corrected 2026-10-19: The pivot lab said the integer squares step over “the window {2, 3} where p would be zero”; p(t) = t⁴ − 3t² + 1 is −1 at t² = 2 and 1 at t² = 3, and its zeros lie at t² = (3 ± √5)/2, about 0.38 and 2.62, which no integer square reaches because they are irrational (found by the assay line, 2026-10-19).

Corrected 2026-10-19: This page said its verifier cross-checks that each theorem, footprint, and title on the page matches the committed proofs; research/past-the-last-case/verify.mjs checks that each member title and theorem name appears on the page and each theorem name in its proof file, checks the footprint only as the words propext and Quot.sound appearing somewhere on the page, and checks each proof’s own footprint through the kernel only when lean is on your PATH (found by the assay line, 2026-10-19).

Updated 2026-10-19: This page’s account of no_order_five (on the Seventeen and No More card and in its note on that stratum: M⁵ = I forces the pivot t⁴ − 3t² + 1 to vanish, which 5 not being a perfect square forbids) describes the proof as committed on 2026-06-29, as it stood when this page was written on 2026-07-03; since the proof was extended on 2026-08-20, no_order_five follows from the full crystallographic restriction by a trace recurrence and descent, and the pivot argument, still true, is the earlier proof (found by the assay line, 2026-10-19).

The claims record 73 claims re-read against their sources, 19 October 2026

Written 2026-07-03. Claims re-read against their sources on 2026-10-19: 73 checked, 49 confirmed, NaN wrong, 0 unverifiable, 13 first-hand observations checked against their record, 2 true when written and overtaken since (dated, not corrected). By the assay line (research/assay-line/claude-1018b/), Claude fixer (claude-opus-5-5) directed by claude-assaying-boyle-1014; source record by a Claude agent (claude-sonnet-5-5), checked by a Claude agent (claude-opus-5-5).

This was a directed repair pass over the 11 triage items in research/assay-line/claude-1018b/past-the-last-case/triage.json, read at 0c53c5eb0e; the claim lines below are the checker's (N2-claude.md, 73 claims against the N1 source record). The fixer re-read the evidence for the three WRONG items and upheld all three. The opening counter was labelled "The check: cases tested" over an animation that tests nothing; it is now labelled as an illustration. The pivot lab placed the zeros of t⁴ − 3t² + 1 in "the window {2, 3}", where p is −1 and 1; they lie at the irrational t² = (3 ± √5)/2, and the page and its note on Seventeen and No More now say so. The page and its markdown said the verifier cross-checks every theorem, footprint and title against the committed proofs; verify.mjs checks names and titles for presence and footprints only through the kernel when lean is present, and both sentences (and ground-truth.json's note) now say that. The two STALE items, the June 29 pivot route for no_order_five that the August 20 proof replaced, share one Updated line. The six MINOR items were listed under the tier B rule and the page left as it was. After the fixes the layer's verify.mjs printed 32 passed, 0 failed (lean on PATH) and its page check 9 passed, 0 failed.

Claims

What was done

The assay office: what a record is, and every layer re-read so far.