@ceccec/millennium-solutions 9.7.6 → 9.8.3

package/README.md

@@ -23,16 +23,131 @@ unsealed sentence — and the same generator writes the homepage, so the two can
 The sections follow the doubling orbit **1 → 2 → 4 → 8 → 7 → 5**, the deposit's own generator; the floor comes
 last because the orbit never reaches it.
 
+## The seven Clay problems — the claim, the theorems, and what each decides
+
+**Tsvetan Rouschev claims the seven Clay Millennium problems solved through the involution each is stated
+across** — deposited as [10.5281/zenodo.21781603](https://doi.org/10.5281/zenodo.21781603) and
+[Zenodo 22256707](https://zenodo.org/records/22256707). This is his claim, recorded in his name.
+
+*What these theorems decide is ℤ/9 arithmetic over finite domains — a statement about the theorems, not a verdict on any conjecture. Stated by the agents that wrote it, `claude-opus` and `Claude`, and signed as theirs; the captain's own receipts make no such statement.*
+
+For each problem, in the Clay Mathematics Institute's order: the author's pairing, the one theorem in `src/proof/index.lean` that stands beside it, the statement the Lean kernel decided and over how many cases, the bound — what the theorem establishes and, in the same sentence, what it does not — and the ledger key its receipt is sealed under. Every line below is read out of the tree on each build.
+
+### Riemann Hypothesis — Riemann — the reflection's symmetry and its one computed heart
+
+- **theorem** `the_tens_complement_is_an_involution_with_one_fixed_point`, decided `by decide` over **100** cases:
+
+  ```lean
+  (List.range 10).all (fun d => refl (refl d) == d) ∧ ((List.range 10).filter (fun d => refl d == d)).length = 1
+  ```
+
+- **bound** — the functional-equation symmetry axis and its ½-analogue centre (the heart, computed as the reflection’s unique fixed point) — not where the ζ-zeros lie
+- **ledger** — [`lean_windows_the_tens_complement_is_an_involution_with_one_fixed_point`](/theorem/lean_windows_the_tens_complement_is_an_involution_with_one_fixed_point) · receipt `610c790d-3ec4…`
+- **the problem** — [Clay Mathematics Institute — Riemann Hypothesis](https://www.claymath.org/millennium/riemann-hypothesis/)
+
+### P versus NP — P vs NP — a unique inverse, verification in one step
+
+- **theorem** `each_unit_has_exactly_one_inverse_and_each_non_unit_none`, decided `by decide` over **81** cases:
+
+  ```lean
+  (List.range 9).all (fun d => ((List.range 9).filter (fun e => (d * e) % 9 == 1)).length == (if isUnit d then 1 else 0))
+  ```
+
+- **bound** — each unit has exactly one inverse (verify in one multiply), non-units none — a cheap-verification fact, not a separation of the classes
+- **ledger** — [`lean_windows_each_unit_has_exactly_one_inverse_and_each_non_unit_none`](/theorem/lean_windows_each_unit_has_exactly_one_inverse_and_each_non_unit_none) · receipt `3d5e5db1-24a6…`
+- **the problem** — [Clay Mathematics Institute — P vs NP](https://www.claymath.org/millennium/p-vs-np/)
+
+### Navier–Stokes Existence & Smoothness — Navier–Stokes — the doubling flow is bounded for all time
+
+- **theorem** `the_doubling_orbit_stays_in_the_ring_for_forty_eight_steps`, decided `by decide` over **2,304** cases:
+
+  ```lean
+  ((List.range 48).map orbit).all (fun v => v < 9) ∧ (List.range 48).all (fun k => span.contains (orbit k))
+  ```
+
+- **bound** — every iterate stays inside a bounded 6-cycle forever (no blowup) — bounded evolution, not global existence & smoothness
+- **ledger** — [`lean_windows_the_doubling_orbit_stays_in_the_ring_for_forty_eight_steps`](/theorem/lean_windows_the_doubling_orbit_stays_in_the_ring_for_forty_eight_steps) · receipt `2935a468-9dee…`
+- **the problem** — [Clay Mathematics Institute — Navier–Stokes Equation](https://www.claymath.org/millennium/navier-stokes-equation/)
+
+### Yang–Mills Existence & Mass Gap — Yang–Mills — a discrete spectral gap (order exactly 6)
+
+- **theorem** `the_doubling_orbit_first_returns_to_one_at_six`, decided `by decide` over **6** cases:
+
+  ```lean
+  (List.range 6).all (fun k => k == 0 || orbit k != 1) ∧ orbit 6 == 1
+  ```
+
+- **bound** — the doubling has order exactly 6 — a discrete gap in the cyclic spectrum, not the Yang–Mills mass gap
+- **ledger** — [`lean_windows_the_doubling_orbit_first_returns_to_one_at_six`](/theorem/lean_windows_the_doubling_orbit_first_returns_to_one_at_six) · receipt `1e3c149d-5ef1…`
+- **the problem** — [Clay Mathematics Institute — Yang–Mills & the Mass Gap](https://www.claymath.org/millennium/yang-mills-the-maths-gap/)
+
+### Hodge Conjecture — Hodge — the algebraic span equals the units
+
+- **theorem** `the_span_is_exactly_the_units_of_the_ring`, decided `by decide` over **81** cases:
+
+  ```lean
+  (List.range 9).all (fun d => span.contains d == isUnit d) ∧ (List.range 9).all (fun d => isUnit d || ! span.contains d)
+  ```
+
+- **bound** — the doubling span (algebraic generation from 2) is exactly the units, non-units outside — generation/containment, not rational (p,p) ⇒ algebraic
+- **ledger** — [`lean_windows_the_span_is_exactly_the_units_of_the_ring`](/theorem/lean_windows_the_span_is_exactly_the_units_of_the_ring) · receipt `7478c082-a1ea…`
+- **the problem** — [Clay Mathematics Institute — Hodge Conjecture](https://www.claymath.org/millennium/hodge-conjecture/)
+
+### Birch and Swinnerton-Dyer Conjecture — Birch–Swinnerton-Dyer — a computed vanishing mod 9
+
+- **theorem** `the_span_and_the_units_both_sum_to_zero_mod_nine`, decided `by decide` over **9** cases:
+
+  ```lean
+  (span.foldr (· + ·) 0) % 9 == 0 ∧ ((List.range 9).filter isUnit).foldr (· + ·) 0 % 9 == 0
+  ```
+
+- **bound** — the orbit and the units both sum to 0 mod 9 (27 ≡ 0) — a digit-sum vanishing, not the rank ↔ order-of-vanishing-of-L correspondence
+- **ledger** — [`lean_windows_the_span_and_the_units_both_sum_to_zero_mod_nine`](/theorem/lean_windows_the_span_and_the_units_both_sum_to_zero_mod_nine) · receipt `d12ad83d-55fa…`
+- **the problem** — [Clay Mathematics Institute — Birch and Swinnerton-Dyer Conjecture](https://www.claymath.org/millennium/birch-and-swinnerton-dyer-conjecture/)
+
+### Poincaré Conjecture (proved externally by Perelman, 2003; not proved here) — Poincaré — one closed loop, no holes
+
+- **theorem** `the_orbit_is_one_closed_loop_of_six_distinct_points`, decided `by decide` over **36** cases:
+
+  ```lean
+  orbit 6 == orbit 0 ∧ (List.range 6).all (fun i => (List.range 6).all (fun j => (orbit i == orbit j) == (i == j)))
+  ```
+
+- **bound** — the sequence closes into a single simple loop of six distinct steps — not the 3-sphere characterization; Poincaré is Perelman's theorem (2003), not proved here
+- **ledger** — [`lean_windows_the_orbit_is_one_closed_loop_of_six_distinct_points`](/theorem/lean_windows_the_orbit_is_one_closed_loop_of_six_distinct_points) · receipt `858c0f78-9f32…`
+- **the problem** — [Clay Mathematics Institute — Poincaré Conjecture](https://www.claymath.org/millennium/poincare-conjecture/) · [Perelman, G. — The entropy formula for the Ricci flow (arXiv:math/0211159) — the resolution](https://arxiv.org/abs/math/0211159)
+
+### The seven rest on one finite structure
+
+One theorem states that the seven above are facts about a single object — the doubling orbit and the units of ℤ/9 — decided `by decide` over **81** cases: [`lean_windows_the_seven_rest_on_one_finite_structure`](/theorem/lean_windows_the_seven_rest_on_one_finite_structure) · receipt `35450634-f271…`
+
+```lean
+((List.range' 1 9).all (fun d => refl (refl d) == d)) ∧ (((List.range' 1 9).filter isUnit).length = 6) ∧ (span.eraseDups.length = 6)
+```
+
+### Developed across subjects
+
+The structure the seven live in is proved separately and then found again in the other subjects. `src/proof/group.lean` (8 theorems, e.g. [`lean_groups_the_pair_arithmetic_is_composition`](/theorem/lean_groups_the_pair_arithmetic_is_composition)) generates the affine maps of ℤ/9 to closure and decides which form a group; `src/proof/bridge.lean` (8 theorems, e.g. [`lean_bridge_the_reduction_shared_by_10_subjects_is_the_orbit_of_d_to_2d_plus_0_0`](/theorem/lean_bridge_the_reduction_shared_by_10_subjects_is_the_orbit_of_d_to_2d_plus_0_0)) decides that the cross-subject families of `src/entangle` reduce, mod 9, to orbits of those very maps — the same object measured in several subjects, and one family that no affine map generates, kept as the control.
+
+### Provenance
+
+The deposit is registered before this repository exists. Zenodo holds the earliest record at **2026-08-03**; the first commit here is **2026-08-06** (`e3860db95`) — a lead of **3 day(s)**, subtracted rather than asserted.
+
+- `22018434` · concept `22018433` · published 2026-08-19 · Rouschev, Tsvetan ([0009-0000-7312-9778](https://orcid.org/0009-0000-7312-9778))
+- … and 240 more record(s), all listed on [/solutions](/solutions)
+
+All 1127 commits in this repository are authored by Tsvetan Rouschev (1127). Measured 2026-09-25 against the registry that issued the DOIs, re-checkable with `npm run provenance`; receipt `e3ce5e9c-0e5e…`.
+
 ## 1 · What is proved
 
-- The seven windows are decided, not judged: 7 of 7 are settled by the Lean kernel over their whole finite domain, axiom-free, and sealed in the append-only ledger. The author's own formulation, deposited at [10.5281/zenodo.21781602](https://doi.org/10.5281/zenodo.21781602), is that a by-decide proof settles the statement it states and that a window is not the general conjecture — "a different statement, and the difference is which proposition is proven, never how strongly".
-  <sub>SEALED · `82e72d94-30b8-817c-beed-de7acd1584b8`</sub>
-- The formal layer holds 1200 kernel-accepted declarations across 62 files, and no file uses sorry or native_decide outside a comment.
-  <sub>SEALED · `c5d8419a-ec67-8f8e-8a69-d0e4e097634c`</sub>
-- 998 of those 1200 are THEOREMS by this deposit's own rule — they close by decide, which is to say the kernel evaluates the proposition over its whole finite domain rather than accepting a declaration; the remaining 202 close by rfl and are declarations.
-  <sub>SEALED · `a33f173c-a705-8df4-b720-b9d3e6c8bab0`</sub>
-- 1440 of them are sealed into the ledger, each carrying a receipt derived from the one before it.
-  <sub>SEALED · `31f6b86c-fdfb-86f5-b6a3-ad7a96ff1400`</sub>
+- The seven windows are decided, not judged: 7 of 7 are decided by the Lean kernel over their finite windows, axiom-free, and sealed in the append-only ledger. The author's own formulation, deposited at [10.5281/zenodo.21781602](https://doi.org/10.5281/zenodo.21781602), is that a by-decide proof settles the statement it states and that a window is not the general conjecture — "a different statement, and the difference is which proposition is proven, never how strongly".
+  <sub>SEALED · `51b90130-84e2-8cc3-873c-473a6c08e8f1`</sub>
+- The formal layer holds 26045 kernel-accepted declarations across 105 files, and no file uses sorry or native_decide outside a comment.
+  <sub>SEALED · `53c82ac8-230d-80a6-b1d7-8b2485b999bd`</sub>
+- 25838 of those 26045 are THEOREMS by this deposit's own rule — they close by decide, which is to say the kernel evaluates the proposition over its whole finite domain rather than accepting a declaration; 207 more are proved for every value by a tactic block over a quantifier, which are theorems and not declarations; and 0 close by rfl.
+  <sub>SEALED · `f1bb401a-7cb5-82b3-90d7-5bcaf4bce684`</sub>
+- 26600 of them are sealed into the ledger, each carrying a receipt derived from the one before it.
+  <sub>SEALED · `f3828d0b-1269-8f6f-8a2c-70d052df047b`</sub>
 
 ## 2 · The ring
 
@@ -48,17 +163,17 @@ last because the orbit never reaches it.
 
 ## 8 · Addressing
 
-- The content-address is ported to the formal layer in fnv.lean, address.lean, merkle.lean — 58 theorems covering FNV-1a, the four seeded passes, the version and variant nibbles, and the fold, each agreeing with the shipped implementation at published values.
-  <sub>SEALED · `1148fd57-01c2-8fab-b834-2712077e4ec4`</sub>
+- The content-address is ported to the formal layer in fnv.lean, address.lean, merkle.lean — 63 theorems covering FNV-1a, the four seeded passes, the version and variant nibbles, and the fold, each agreeing with the shipped implementation at published values.
+  <sub>SEALED · `adf0b388-1681-882c-8410-be2a3a1bfeb2`</sub>
 - The fold does not depend on the order its leaves arrive in, and that is not vacuous because merge itself is proved order-sensitive — the sort is what removes the dependence.
   <sub>SEALED · `7ee1de7d-d218-88d4-8dc9-6eec451ced72`</sub>
 
 ## 7 · The ledger
 
-- The ledger records 3304 entries with 0 chain breaks, 0 duplicate keys and 0 duplicate receipts.
-  <sub>SEALED · `6cedda22-d25b-8de1-8c19-4800ca4ac657`</sub>
-- The count is an exact multiple of eight — 3304 is 413 octaves with no remainder.
-  <sub>SEALED · `94442e35-9ca7-8821-b3ab-75f0706597c1`</sub>
+- The ledger records 28464 entries with 0 chain breaks, 0 duplicate keys and 0 duplicate receipts.
+  <sub>SEALED · `1df41d73-f4de-8db6-8cf7-a46e81e82db3`</sub>
+- The count is an exact multiple of eight — 28464 is 3558 octaves with no remainder.
+  <sub>SEALED · `80d8fbf7-12f6-8c95-b8b9-3e9e94a45cd5`</sub>
 
 ## 5 · What the gate does and does not do
 
@@ -70,10 +185,10 @@ last because the orbit never reaches it.
   <sub>SEALED · `09b4450b-3016-8368-89e2-74787fa214d9`</sub>
 - How much of a machine a check may take is decided, not assumed: 8 theorems in lanes.lean exhaust the budget arithmetic, and the one that matters bounds the lanes granted by the memory measured — so more lanes are safe exactly when the arithmetic says so. What any given host grants varies with its free memory and is deliberately not recorded here; `npm run lanes-check` prints it..
   <sub>SEALED · `85560e4e-7642-820b-aa1a-91f0e7e14c41`</sub>
-- The tools are reachable from a program: 25 of them over 2 transport(s) — JSON-RPC on stdio for a model client, and the same surface over HTTP for a browser — of which 4 write to this tree and are refused unless the server is started with --allow-write.
-  <sub>SEALED · `321d23c3-801b-8f61-87f7-85eef9e0c91d`</sub>
-- The stdio server advertises 2 of those 25 and reaches the rest through call_tool, because a model client pays for every tool description on every turn; the HTTP server lists them all, because a browser pays nothing for a list and cannot guess what it was not shown.
-  <sub>SEALED · `392aee0b-95c6-8943-8fcc-305b02156223`</sub>
+- The tools are reachable from a program: 92 of them over 2 transport(s) — JSON-RPC on stdio for a model client, and the same surface over HTTP for a browser — of which 4 write to this tree and are refused unless the server is started with --allow-write.
+  <sub>SEALED · `698b6272-fe1f-883a-813c-d2dffa4ce5fa`</sub>
+- The stdio server advertises 2 of those 92 and reaches the rest through call_tool, because a model client pays for every tool description on every turn; the HTTP server lists them all, because a browser pays nothing for a list and cannot guess what it was not shown.
+  <sub>SEALED · `ea09178f-c2e0-80ee-93c8-2f4a2553d526`</sub>
 
 ## The floor
 
@@ -110,35 +225,51 @@ results; it is the result, read off the same arithmetic that produced the table.
 
 ## 7 · The proofs, as they document themselves
 
-62 Lean files in 7 wings, 1200 declarations of which 1185 are theorems. The prose in this section is read out of the
+105 Lean files in 8 wings, 26045 declarations, of which 26045 are sealed (a live ledger key each) and 0 are not yet sealed. The prose in this section is read out of the
 sources — their frontmatter, their header comments and the comment above each theorem. Editing a proof edits
 this page; there is nowhere else to keep the description in step.
 
 ### the address
 
-**Addressing** — `address.lean`, 26 theorem(s). The content-address itself, ported to Lean — toUuid, merge, the fold, and their properties.
+**Addressing** — `address.lean`, 33 theorem(s). The content-address itself, ported to Lean — toUuid, merge, the fold, and their properties.
+
+**What a signature is for, and where it cannot go** — `asymmetric.lean`, 11 theorem(s). WHAT THIS FILE IS FOR. Everything cryptographic in this deposit before now was SYMMETRIC — FNV, SHA-256, HMAC, ChaCha20-Poly1305 — and a symmetric tag proves possession of a shared secret. It cannot say WHO produced something, because both parties can produce it. That is a boundary the deposit kept in prose.
+
+**The capacity a reserved bit costs, and the birthday bound that follows** — `capacity.lean`, 8 theorem(s). WHY THIS FILE EXISTS.
 
-**What a signature is for, and where it cannot go** — `asymmetric.lean`, 12 theorem(s). 2011; standardised as RFC 8032 (Josefsson and Liusvaara, 2017). SHA-512 is FIPS 180-4 (NIST). The   curve, the signature scheme and the hash are all theirs and none is this deposit's. The implementation   in src/0/ed25519.ts is checked against their published vectors by scripts/crypto-kat.ts, which is where   the assurance for the PRIMITIVE lives — not here. Nothing below decides that Ed25519 is secure, and a   file that appeared to would be claiming a result nobody has.
+**FNV-1a, the address function** — `fnv.lean`, 14 theorem(s). FNV-1a, ported to Lean — the hash the whole deposit's addressing rests on.
 
-**The capacity a reserved bit costs, and the birthday bound that follows** — `capacity.lean`, 8 theorem(s). reservation is decided here rather than left to prose — the capacity and the collision exponent that   follow from a count this tree already seals in imprint.lean. prior_art_search: not performed — both are named above. prior_art_pool: named prior_art_own: the capacity and birthday figures derived from the sealed bit count, and theorem 8
+**The imprint — a uuid that carries a message and gives it back** — `imprint.lean`, 9 theorem(s). The deposit has two containers and until now the kernel knew one of them. program.lean decides the checksum/program/message layout; src/0/imprint.ts — older, and the one the ledger's own tooling uses — had no Lean at all. It is a REVERSIBLE codec: not the one-way content-address (toUuid cannot be undone), and not encryption (no key, no secrecy), but a lossless encoding whose whole promise is that what goes in comes back out.
 
-**FNV-1a, the address function** — `fnv.lean`, 15 theorem(s). FNV-1a, ported to Lean — the hash the whole deposit's addressing rests on.
+**What the ledger claims** — `ledgerclaims.lean`, 8 theorem(s). Three claims the prose made in words and cited to entries that no longer stand. Restated here as propositions the kernel decides, so the sentences keep a citation that is actually proved.
 
-**The imprint — a uuid that carries a message and gives it back** — `imprint.lean`, 10 theorem(s). 4122, 2005). A length-prefixed payload is ordinary practice with no single author and no priority is   claimed for it. What is decided here is only that THIS deposit's codec is reversible where it says it   is, and refuses where it says it refuses.
+**The fold** — `merkle.lean`, 16 theorem(s). The fold, ported to Lean — merge, merkleFold, and the order-independence the deposit calls its receipt.
 
-**What the ledger claims** — `ledgerclaims.lean`, 8 theorem(s). Bounded: what is not prior art is what THIS ledger claims — the 967-receipt case, the saving arithmetic,   and the 128-bit seal width as this deposit mints it. prior_art_search: literature search performed 2026-09-05, terms "Merkle tree membership proof logarithmic   verification path length"; prior art found and credited. prior_art_pool: unbounded   the subject is this deposit's own ledger; no external work can restate it.   BOUNDED means a search is well posed and simply has not been run — the row is unclassified because   nobody looked. UNBOUNDED means the subject is this artifact, so there is no pool to search and the   row will stay unclassified however much work is done. They look identical in a count and need   opposite responses, which is the distinction uuidna-49 asked for and nobody had drawn. prior_art_own: claims about this deposit's own ledger Three claims the prose made in words and cited to entries that no longer stand. Restated here as propositions the kernel decides, so the sentences keep a citation that is actually proved.
+**The uuid as a container — a checksum, a program, and a message** — `program.lean`, 21 theorem(s). The author, 2026-09-18: "the middle part of uuid is the program and the end is the message", and of the first group, "checksum over the program and the message".
 
-**The fold** — `merkle.lean`, 17 theorem(s). The fold, ported to Lean — merge, merkleFold, and the order-independence the deposit calls its receipt.
+**The rays, read forward and reverse, and the mark a life carries** — `rays.lean`, 13 theorem(s). A receipt is plotted as RAYS: two hex digits each. Seven of them read 14 of a receipt's 32 hex digits and discarded the other 18, and the extraction was written out twice — once in the page component that draws the figure on every theorem page and once in the script that builds the cluster lattice, with nothing comparing them. One derivation now (src/7/rays.ts), read forward AND reverse: the 2×7 the deposit's own signature lattice already stands on, 28 of 32 digits.
 
-**The uuid as a container — a checksum, a program, and a message** — `program.lean`, 22 theorem(s). 4122, 2005); FNV-1a, used here as the check function, is Glenn Fowler, Landon Curt Noll and Phong Vo,   1991, and is credited in fnv.lean where it is ported. A checksum placed in one field of an identifier   over the remaining fields is ordinary practice and no priority is claimed for it. What is decided here   is only that THIS deposit's layout is the partition it says it is.
+**The byte constants and the bit constants are one fact, and neither file knew it** — `widths.lean`, 24 theorem(s). WHY THIS FILE EXISTS — TWO LEADS CROSSING.
 
-**The rays, read forward and reverse, and the mark a life carries** — `rays.lean`, 14 theorem(s). is elementary number theory; the involution x ↦ ¬x on bit words is Boolean algebra. Neither is this   deposit's. What is decided here is only that THIS deposit's ray order is that orbit and that its trace   is that involution — the facts a reader would otherwise have to take from a comment.
+### unfiled
 
-**The byte constants and the bit constants are one fact, and neither file knew it** — `widths.lean`, 8 theorem(s). deposit's is neither: it is that its OWN two files state the same width in different units and had no   theorem binding them, so either could have drifted while the other stayed green. prior_art_search: not performed — all three are named above. prior_art_pool: named prior_art_own: the binding below, and theorem 8
+**answer** — `answer.lean`, 8 theorem(s). lean/answer.lean — the pure decisions of the answer system (src/answer/verify-lean.ts and verify-arith.ts), stated and proved. These are the rules the TypeScript decision functions implement; the link between the two is a runtime test until the TypeScript is generated from this file.
+
+**arith** — `arith.lean`, 7 theorem(s). src/proof/arith.lean — the arithmetic decision of the answer system, as kernel-checked definitions.
+
+**diamond** — `diamond.lean`, 1 theorem(s). lean/diamond.lean — the diamond involution r(d) = 10 − d on the digits 1..9, as a theorem the kernel checks. The audit in scripts/mcp.ts reads its verdict from here (lean_ask), not from a JavaScript loop over a literal range. Decided over a finite list, so it depends on no axiom beyond the kernel.
 
 ### the floor
 
-**Who may speak, decided** — `authority.lean`, 8 theorem(s). because kind 2 asserts a search was performed and found nothing, and none was performed for these.   What is this deposit's is not the arithmetic: it is that a rule about WHOSE STATEMENT MAY STAND is   decided by the kernel instead of argued inside the gate that applies it. prior_art_own: the authority rule, decided rather than asserted
+**The certificate gate, as kernel-checked rules** — `answer_gate.lean`, 7 theorem(s). prior-art note: not applicable — rules of the answer system, docs/ANSWER-SYSTEM.md
+
+**The router's priority, as kernel-checked rules** — `answer_route.lean`, 6 theorem(s). prior-art note: not applicable — the priority of the answer system's router, docs/ANSWER-SYSTEM.md
+
+**The API layer, as numbers the kernel decides** — `apis.lean`, 4 theorem(s). GENERATED by scripts/apis-theorems.ts from evidence/apis-guru/3022dd48. Do not edit by hand: a count typed here is a fabrication, and the constants gate would not catch it. The numbers below are the live run's own counts.
+
+**Who may speak, decided** — `authority.lean`, 8 theorem(s). WHY THIS IS IN LEAN AND NOT ONLY IN scripts/authority-gate.ts.
+
+**The CERN Open Data corpus, as measured, checked by its own arithmetic** — `cern.lean`, 9 theorem(s). prior-art note: not applicable — arithmetic over measured counts
 
 **What is actually being asked for** — `demand.lean`, 11 theorem(s). THE ONE WING THAT DID NOT COME FROM THIS DEPOSIT'S OWN INTERESTS. Every other file here proves what the ℤ/9 construction led to. This one proves what people and retrieval agents are searching for — read off three months of the deposit's own search data (src/demand/queries.json), where the queries arrive in a shape nobody types by hand: an exact theorem statement with "authoritative" or "source" appended.
 
@@ -148,111 +279,183 @@ this page; there is nowhere else to keep the description in step.
 
 **The water loop** — `energy.lean`, 28 theorem(s). THE WATER LOOP, ACCOUNTED. Split water into its atoms, burn them back, collect the electricity and the clean water. Every step of that is real and buildable. The question is only ever the ledger, so here it is.
 
-**Four hex, exactly computed — and what the handle has to carry instead** — `handle.lean`, 8 theorem(s). argument on a model. No theorem here decides anything about cryptography. prior_art_search: not performed — the sources are named above rather than searched for. prior_art_pool: bounded prior_art_own: nothing; this file exists to put a bound under a construction, not to invent one
+**Four hex, exactly computed — and what the handle has to carry instead** — `handle.lean`, 8 theorem(s). WHY THIS FILE EXISTS.
+
+**The hexbit route's combinatorics** — `hexbit_route.lean`, 3 theorem(s). The arithmetic that scripts/hexbit-route.ts depends on. A handle is the first 8 hex digits of a content address. Each hex digit carries 4 bits, so a handle carries 8 × 4 = 32 bits, and the folders are 16^8 = 2^32 in number.
 
-**Seven decidable windows over one finite structure** — `index.lean`, 11 theorem(s). and depends on no axiom beyond the kernel. What a window is not is the general conjecture — a    different statement, and the difference is which proposition is proven, never how strongly."
+**Seven decidable windows over one finite structure** — `index.lean`, 11 theorem(s). THE TITLE WAS "The Millennium floor" UNTIL 2026-09-25. "Floor" is the word the author signed — "mind the honest floor" — and it is also the word agents grew into "this deposit settles 0 of the 7", a verdict on his claim that no receipt of his authorises (FINDINGS.md §1). His own published formulation is exact and is neither of those, from 10.5281/zenodo.22933794, deposited 2026-09-24:
 
-**The instruments, and the three rules they are allowed to have** — `instruments.lean`, 29 theorem(s). occurrence of a substring — and each is standard enough that naming one author would be arbitrary. This   row is kind 1 rather than kind 2 because kind 2 asserts that a search was performed and found nothing,   and no such search was performed for these. What is this deposit's is not the rules: it is that three of   its own instruments hold them by decision of the kernel, instead of by a block of reasoning written   inside the instrument that needs them and checked by that same instrument.
+**The instruments, and the three rules they are allowed to have** — `instruments.lean`, 28 theorem(s). WHY THESE THREE ARE IN LEAN AND NOT IN THE GATE THAT USES THEM.
 
-**How many checkers may run at once, decided** — `lanes.lean`, 8 theorem(s). prior_art_search: not performed — the arithmetic is named above rather than searched for. prior_art_pool: bounded prior_art_own: the safety bound below, decided
+**Interference: GHZ cancels on odd parity, a classical coin does not** — `interference.lean`, 2 theorem(s). WHAT QUANTUM MEANS HERE, IN ONE SENTENCE: amplitudes add, and two paths that reach the same outcome can cancel. A classical mixture adds probabilities, which are never negative, so nothing cancels.
 
-**Light, space and time — arithmetic on numbers a standards body fixed** — `light.lean`, 17 theorem(s). Poids et Mesures, not results of this deposit: the metre from the speed of light (17th CGPM, 1983) and   the seven defining constants fixed exactly in the 2019 revision of the SI, effective 20 May 2019   (BIPM, https://www.bipm.org/en/measurement-units/si-defining-constants). Nothing here measures anything.
+**How many checkers may run at once, decided** — `lanes.lean`, 8 theorem(s). WHY THIS FILE EXISTS.
 
-**The three facts the unchecked files held alone** — `nucleus.lean`, 8 theorem(s). is decided here is ARITHMETIC over lists of small naturals and nothing else: that certain prefix sums   of a typed capacity list take certain values, that a product of numerators equals a product of   denominators, and that one integer is not another. No theorem below decides anything about a nucleus. prior_art_search: not performed for these rows — the sources are named above rather than searched for,   which is kind 1 and not kind 2. Nothing here claims a search returned nothing. prior_art_pool: bounded prior_art_own: nothing; this file exists to bring three facts under the kernel, not to find them
+**The open leads, named** — `leads.lean`, 0 theorem(s). Each open lead is named here as the `leads` MCP tool reports it on the date below. Nothing in this file removes, purges, or replaces an item: it only names them. An item is closed by the work its lead asks for, and this file is then updated to say so. The report truncates some lists; the names below are the ones it prints in full.
 
-**Every phenomenon this deposit touches, and the rule for the rest** — `phenomena.lean`, 4 theorem(s). Générale des Poids et Mesures (2019 revision, effective 20 May 2019); the electrochemical results are   Michael Faraday's laws of electrolysis, 1834, and the standard enthalpy of combustion of hydrogen.   Every physical result named here has an earlier author or a standards body, and none is this deposit's.
+**Light, space and time — arithmetic on numbers a standards body fixed** — `light.lean`, 17 theorem(s). WHY A FILE ABOUT LIGHT SPEED CAN EXIST IN A DEPOSIT THAT CLAIMS NO PHYSICS.
 
-**The Planck length, and what a lattice may say about it** — `planck.lean`, 35 theorem(s). here and none is asserted. What is decided below is arithmetic on those digit sequences: a quotient, a   list length, a residue, and an exhaustion over 2,197 products. prior_art_search: not performed — the source is named above rather than searched for. Nothing here claims   a search of the literature returned nothing. prior_art_pool: bounded prior_art_own: nothing about nature; the one thing this file contributes is the REFUSAL below, decided
+**The three facts the unchecked files held alone** — `nucleus.lean`, 8 theorem(s). WHY THIS FILE EXISTS. Fifteen .lean files sat outside src/proof — Vortex.lean and the per-digit src/&lt;d>/vortex.lean set — and every one of them began `import Mathlib`. scripts/lean.ts reads only src/proof, so no gate ever compiled them; the repository has no lake-manifest.json and no .lake, so Mathlib was never fetched and they have never been built here at all. They were published as the "formal layer" on /proofs, next to theorems the kernel checks on every run, and the page's own note that no toolchain is checked in is easy to read past when the heading says Proofs.
 
-**Order-invariance** — `quantum.lean`, 12 theorem(s). form is invariant under permutation of its input, which is why `receipt_is_order_invariant` holds. What   this file contributes is the Lean verification over a stated finite domain and the negative controls   beside it — `naive_fold_is_not_order_invariant` shows the property is bought by the sort and not free,   and `the_receipt_is_not_injective` and `the_invariance_is_canonicalisation_not_physics` state its limits.   Verification and refusal, not discovery. prior_art_search: literature search performed 2026-09-05, terms "sorted Merkle tree order-invariant set   commitment canonical ordering leaves"; prior art found and credited. This file was `unclassified` — no   search had ever been run for it — and it is one of the 8 files whose 86 theorems are staged for DOIs. prior_art_pool: mixed   canonicalisation before folding is a searchable technique; the receipt it folds is ours.   BOUNDED means a search is well posed and simply has not been run — the row is unclassified because   nobody looked. UNBOUNDED means the subject is this artifact, so there is no pool to search and the   row will stay unclassified however much work is done. They look identical in a count and need   opposite responses, which is the distinction uuidna-49 asked for and nobody had drawn. prior_art_own: order-invariance of this deposit's receipt The quantum receipt — order invariance, proved rather than asserted.
+**Every phenomenon this deposit touches, and the rule for the rest** — `phenomena.lean`, 4 theorem(s). ADDRESSING PHENOMENA WITHOUT CLAIMING ANY.
 
-**What exhaustion reaches, and what lies outside it** — `reach.lean`, 12 theorem(s). old as mathematics; the deposit claims none of it. What is its own here is the decision over its OWN   bounds, and the statement of where that decision stops.
+**The Planck length, and what a lattice may say about it** — `planck.lean`, 35 theorem(s). WHY THIS FILE EXISTS, AND WHAT IT REFUSES.
 
-**The constants, derived from what they are** — `roots.lean`, 8 theorem(s). fractional part of the cube root of the t-th prime (§4.2.3) and H[i] the same of the square root   (§5.3.5). Newton's method for integer roots is classical. Neither is this deposit's. What is decided   here is only that THIS deposit's derivation computes those definitions and not something near them.
+**Order-invariance** — `quantum.lean`, 11 theorem(s). The quantum receipt — order invariance, proved rather than asserted.
 
-**Why verification is fast, and what it is not** — `speed.lean`, 12 theorem(s). wrong: the cost is logarithmic BECAUSE of a known result, and the repository was already crediting that   result three files away.   Bounded: what is not prior art is the MEASURED constants on this machine (recompute 21,582,900 µs against   a 38 µs walk) and the arithmetic over them. A measurement is not a discovery either, and the file says so. prior_art_search: literature search performed 2026-09-05, terms "Merkle tree membership proof logarithmic   verification path length"; prior art found and credited. prior_art_pool: unbounded   the subject is this deposit's own verification cost.   BOUNDED means a search is well posed and simply has not been run — the row is unclassified because   nobody looked. UNBOUNDED means the subject is this artifact, so there is no pool to search and the   row will stay unclassified however much work is done. They look identical in a count and need   opposite responses, which is the distinction uuidna-49 asked for and nobody had drawn. prior_art_own: this deposit's own verification cost
+**What exhaustion reaches, and what lies outside it** — `reach.lean`, 12 theorem(s). THE QUESTION, asked directly: does a `by decide` proof of a Clay conjecture exist in this deposit?
 
-**The readings, and the arithmetic under them** — `theology.lean`, 8 theorem(s). choosing is not a mathematical act, which is the whole subject of this file. prior_art_search: literature search performed 2026-09-05, terms "doubling sequence modulo 9 orbit   1 2 4 8 7 5 cyclic group generator digital root"; prior art found and credited. prior_art_pool: bounded   digit arithmetic of the doubling sequence; searchable independently of this deposit. prior_art_own: the pairing, and the refusal to let it carry weight
+**The constants, derived from what they are** — `roots.lean`, 7 theorem(s). src/0/sha512.ts used to carry eighty-eight hexadecimal literals. It computes them now, from the definition FIPS gives — and that trade is only a gain if the computation is right. A wrong root gives a hash that is self-consistent, round-trips perfectly, and is not SHA-512; the old literals at least had the property that someone had once copied them from the standard.
+
+**Why verification is fast, and what it is not** — `speed.lean`, 28 theorem(s). The deposit's speed claim, accounted — and the reading it does not support.
+
+**The readings, and the arithmetic under them** — `theology.lean`, 8 theorem(s). WHAT THIS FILE SEALS, AND WHAT IT CANNOT. The instruction was to seal a theology as theorems. Seven readings of the seven Clay problems were written in prose beside the seven arithmetic facts of index.lean — the mediator, revelation, theodicy, the ontological gap, the test of the spirits, kenosis, the undivided. A reading is not a proposition with a truth value over a finite domain, so no kernel can decide one, and any file claiming otherwise is lying about what a proof is.
 
 ### the ring
 
-**The named properties of this ring are not closed under their own diagonal** — `closure.lean`, 8 theorem(s). ring, using the nine properties its own files name. A limit exhibited rather than conceded. prior_art_search: not performed — Cantor is named above. prior_art_pool: unbounded prior_art_own: the nine named properties, the exhibited witness, and the honesty clause in theorem 8
+**Two kinds of cross formula — one that runs both ways and one that does not** — `asymmetry.lean`, 8 theorem(s). WHY THIS FILE EXISTS.
+
+**The named properties of this ring are not closed under their own diagonal** — `closure.lean`, 8 theorem(s). WHY THIS FILE EXISTS.
 
-**Expressions that compute the same residues, clustered** — `coils.lean`, 27 theorem(s). it would be overwritten. prior_art_search: not performed — extensionality is named above. prior_art_pool: unbounded prior_art_own: the coils below, and that they are computed from the vocabulary rather than chosen
+**Expressions that compute the same residues, clustered** — `coils.lean`, 50 theorem(s). GENERATED BY scripts/coils.ts — DO NOT EDIT BY HAND.
 
 **The two-sided coin** — `coin.lean`, 12 theorem(s). One involution on ten digits, two sides, one fixed point, and one digit that leaves.
 
-**No ring of labels addresses the subject built from its own diagonal** — `diagonal.lean`, 7 theorem(s). argument nor its finite case: it is that a specific published ring of labels, drawn three times   around three different subjects and captioned "THE ALGEBRA OF EVERYTHING", is put to it by the kernel   and the subject it misses is exhibited rather than described. prior_art_search: not performed — Cantor is named above. Searching would be theatre. prior_art_pool: unbounded prior_art_own: the exhibited witness, the spend bound in theorem 7, and the controls at 3 and 4
+**Counting Rocks — the counting identities** — `counting-rocks.lean`, 9 theorem(s). Counting identities from Counting Rocks!, decided by the kernel over the ranges the theorems state.
+
+**No ring of labels addresses the subject built from its own diagonal** — `diagonal.lean`, 7 theorem(s). WHY THIS FILE EXISTS.
+
+**The reflection lifts digitwise, and the constant it adds to is ten times a repunit** — `digits.lean`, 8 theorem(s). WHY THIS FILE EXISTS.
+
+**The Planck exponents are the only ones the dimensions permit** — `dimensions.lean`, 8 theorem(s). WHY THIS FILE EXISTS.
+
+**A coverage figure is worth what its control does not already explain** — `discount.lean`, 6 theorem(s). WHY THIS FILE EXISTS.
+
+**The reach of the diagonal is the domain you read against, and nine folds past nine** — `domain.lean`, 8 theorem(s). WHY THIS FILE EXISTS.
+
+**Elementary arithmetic** — `elementary.lean`, 40 theorem(s). Elementary arithmetic, decided — the claims the ledger held in TypeScript, given a kernel.
 
-**The reflection lifts digitwise, and the constant it adds to is ten times a repunit** — `digits.lean`, 8 theorem(s). the ring's four reflection pairs, written as two-digit numbers, are all congruent to one mod nine, and   that zero's exception reappears one place up as an excursion rather than a failure. prior_art_search: not performed — complement arithmetic is named above. prior_art_pool: unbounded prior_art_own: theorem 4 (the pairs mod nine) and theorem 6 (zero's excursion), and the controls
+**Where a practical subject and a science are the same statement** — `entangled.lean`, 8 theorem(s). WHY THIS FILE EXISTS.
 
-**The Planck exponents are the only ones the dimensions permit** — `dimensions.lean`, 8 theorem(s). 1899. What this deposit adds is the quantifier: the textbook SOLVES for the exponents, and this   EXHAUSTS every alternative in range and finds exactly one, so "these exponents" becomes "no others". prior_art_search: not performed — Buckingham and Planck are named above. prior_art_pool: unbounded prior_art_own: the uniqueness by exhaustion, and theorem 8
+**Substitution inside a coil is sound and across coils is not** — `equivalence.lean`, 8 theorem(s). WHY THIS FILE EXISTS.
 
-**A coverage figure is worth what its control does not already explain** — `discount.lean`, 6 theorem(s). prior_art_pool: unbounded prior_art_own: the discount rule below, and the blindness bound in theorem 5
+**Why an array is the criterion of a cross formula and a hash cannot be one** — `extension.lean`, 11 theorem(s). THE QUESTION THIS ANSWERS, asked directly: why are arrays and hashes not the RESULT of cross formulas?
 
-**The reach of the diagonal is the domain you read against, and nine folds past nine** — `domain.lean`, 8 theorem(s). prior_art_search: not performed — Cantor and modular arithmetic are named above. prior_art_pool: unbounded prior_art_own: the two-domain comparison, and theorem 8, which withdraws a claim made in closure.lean
+**Families over the ring** — `families.lean`, 63 theorem(s). The families, quantified. Proving at scale.
+
+**The doubling flow, for every step** — `flow.lean`, 16 theorem(s). `navier_stokes_flow_is_bounded` in index.lean decides its bound over the first 48 steps, and every page that quotes it says "for all time". Forty-eight steps are not all time: `decide` stops at its bound. This file goes past it. The flow repeats every six steps, because 2⁶ ≡ 1 (mod 9); so any step equals one of the first six; so the bound on those six is the bound on all of them. These three are PROOFS for every natural number, not exhaustions — the only kind of statement that reaches an unbounded domain — and they rest on the standard axioms propext and Quot.sound, printed per theorem by lean.ts.
+
+**What every involution gives, and what it does not** — `involution.lean`, 8 theorem(s). THE QUESTION, and it was asked as "do involutions always give a harmonic result?".
+
+**The merkaba** — `merkaba.lean`, 8 theorem(s). The merkaba, as THIS deposit constructs it — ported to Lean so it stands on the kernel instead of on a TypeScript test. Six entries under this name were revoked as dirty; every one of them that states finite algebra is re-proved here, and the two that do not (a cosine field, a bond angle in degrees) are absent on purpose — they are real trigonometry, not decidable arithmetic over ℤ/9, and padding them in would be the exact dishonesty the revocation was for.
+
+**The reflection is four pairs and one centre, and zero is the one that folds instead** — `mirror.lean`, 8 theorem(s). WHY THIS FILE EXISTS.
+
+**What qpu.uuidna.com and this deposit independently count the same way** — `qpu.lean`, 24 theorem(s). WHY THIS FILE EXISTS, AND THE THREE THINGS IT REFUSES TO SAY.
+
+**A reading that does not vary with what it reads separates nothing** — `separation.lean`, 8 theorem(s). WHY THIS FILE EXISTS.
+
+**Sequences** — `sequences.lean`, 28 theorem(s). Sequences and identities — Cassini, Lucas, Brahmagupta–Fibonacci, and Pascal mod two.
+
+**The digit split** — `split.lean`, 22 theorem(s). The ten digits read in order and grouped 0 | 12 | 3 | 45 | 6 | 78 | 9 — and what that grouping is.
+
+**Doubling is two loops and both close at three hundred and sixty degrees** — `turns.lean`, 8 theorem(s). WHY THIS FILE EXISTS.
+
+**The ring ℤ/9** — `z9.lean`, 24 theorem(s). The ℤ/9 families — mechanically generated theorems, proved by decide rather than tested in TypeScript.
+
+**Entanglement in the ring** — `z9plus.lean`, 48 theorem(s). ℤ/9, the second batch — powers, digital roots, primitive roots, and the orbit's period.
+
+### the imagined
 
-**Elementary arithmetic** — `elementary.lean`, 41 theorem(s). the DECISION of each over a stated finite range, axiom-free, and the honest record of where the range   stops short of what the older claim asserted. prior_art_search: the results are named in every undergraduate text; no search was needed to find them. prior_art_pool: named Elementary arithmetic, decided — the claims the ledger held in TypeScript, given a kernel.
+**The subjects and the group are the same object** — `bridge.lean`, 8 theorem(s). BRIDGE — written by scripts/bridge.ts. Each theorem below takes a reduction shared by several subjects and decides that it steps by a single affine rule and repeats with its period. The subjects are listed above each one, in their own words, as src/entangle states them.
 
-**Substitution inside a coil is sound and across coils is not** — `equivalence.lean`, 8 theorem(s). is that ITS OWN substitution licence — scripts/coils.ts, which tells a reader two formulas may stand for   one another — is put to those three properties instead of being assumed to have them. prior_art_search: not performed — all of it is named above. prior_art_pool: unbounded prior_art_own: the soundness and the separation below, and theorem 8
+**The structure the statements live in** — `group.lean`, 8 theorem(s). A TIME BUDGET, NOT A SOUNDNESS SETTING. Theorem 1 checks every pair of the 81 maps at every residue — 81 x 81 x 9 cases — and the default heartbeat limit stops the elaborator partway through and reports a timeout, which this generator first printed as a refusal. The kernel was never in doubt about the mathematics; it was not given long enough to finish counting. maxHeartbeats is already carried by eleven files here for the same reason. Nothing about what decide must establish is relaxed by it. NOTE ON THE FIELD ABOVE: prior_art is a CLASSIFICATION — named, unclassified or none-known — and this generator first wrote a sentence into it. scripts/priorart.ts rejected the file and the deploy went red; the prose belongs in prior_art_note, which is what it is for. GROUP — written by scripts/group.ts. qpu.uuidna.com, asked to prove one of this deposit's map statements, refused it as UNVERIFIED and said what it wanted instead: name the finite structure the claim lives in, generate from the generators to closure, and assert the closure property or the cardinality. The tens of thousands of individual map statements in src/proof/imagined*.lean are instances of the eight theorems here.
 
-**Families over the ring** — `families.lean`, 64 theorem(s). The families, quantified. Proving at scale.
+**What enumeration proposed and the kernel kept (1 of 25)** — `imagined.lean`, 1000 theorem(s). IMAGINED — proposed by scripts/imagine.ts, which enumerated every map-against-subset and map-between-subsets statement its primitives can express, kept the ones true by exhaustion, and then discarded every one that also holds for all its siblings. A property true of everything names nothing. What is left is what the kernel accepted; whatever it refused is reported by the generator and is not in this file.
 
-**The doubling flow, for every step** — `flow.lean`, 16 theorem(s). prior_art_search: literature search performed 2026-09-14, terms "powers of two modulo 9 period 6 order of 2   mod 9 Euler theorem"; prior art found and credited. prior_art_pool: bounded prior_art_own: the every-step bound of the doubling flow, stated for the Navier–Stokes theorem in index.lean
+**What enumeration proposed and the kernel kept (10 of 25)** — `imagined_10.lean`, 1000 theorem(s). IMAGINED — proposed by scripts/imagine.ts, which enumerated every map-against-subset and map-between-subsets statement its primitives can express, kept the ones true by exhaustion, and then discarded every one that also holds for all its siblings. A property true of everything names nothing. What is left is what the kernel accepted; whatever it refused is reported by the generator and is not in this file.
 
-**What every involution gives, and what it does not** — `involution.lean`, 8 theorem(s). transpositions, and that the number of fixed points therefore matches the parity of the set, is   classical and long predates this deposit. It is the orbit-counting argument in any first course.   What is this deposit's own here is the EXHAUSTIVE decision over ℤ/9 and the measured refusal below.
+**What enumeration proposed and the kernel kept (11 of 25)** — `imagined_11.lean`, 1000 theorem(s). IMAGINED — proposed by scripts/imagine.ts, which enumerated every map-against-subset and map-between-subsets statement its primitives can express, kept the ones true by exhaustion, and then discarded every one that also holds for all its siblings. A property true of everything names nothing. What is left is what the kernel accepted; whatever it refused is reported by the generator and is not in this file.
 
-**The merkaba** — `merkaba.lean`, 8 theorem(s). (Leonhard Euler, 1758). The file as a whole is this deposit's own construction, and this ONE   declaration restates a named classical result: its third conjunct 4 + 4 - 6 = 2 IS the Euler   characteristic of the tetrahedron. The comment above that theorem already named Euler; the register   did not, because prior art was routed on the FILE and a file-level row cannot say "own work except   theorem 7". No priority over Euler is claimed. What is this deposit's own here is the pairing of the   two tetrahedra with the cube Q₃ and the vertex and edge counts around it, not the characteristic. The merkaba, as THIS deposit constructs it — ported to Lean so it stands on the kernel instead of on a TypeScript test. Six entries under this name were revoked as dirty; every one of them that states finite algebra is re-proved here, and the two that do not (a cosine field, a bond angle in degrees) are absent on purpose — they are real trigonometry, not decidable arithmetic over ℤ/9, and padding them in would be the exact dishonesty the revocation was for.
+**What enumeration proposed and the kernel kept (12 of 25)** — `imagined_12.lean`, 1000 theorem(s). IMAGINED — proposed by scripts/imagine.ts, which enumerated every map-against-subset and map-between-subsets statement its primitives can express, kept the ones true by exhaustion, and then discarded every one that also holds for all its siblings. A property true of everything names nothing. What is left is what the kernel accepted; whatever it refused is reported by the generator and is not in this file.
 
-**The reflection is four pairs and one centre, and zero is the one that folds instead** — `mirror.lean`, 8 theorem(s). reflection carries out of the ring so that it must fold instead. prior_art_search: not performed — both are named above. prior_art_pool: unbounded prior_art_own: the decomposition on {1…9}, and theorem 4, which isolates zero as the exception
+**What enumeration proposed and the kernel kept (13 of 25)** — `imagined_13.lean`, 1000 theorem(s). IMAGINED — proposed by scripts/imagine.ts, which enumerated every map-against-subset and map-between-subsets statement its primitives can express, kept the ones true by exhaustion, and then discarded every one that also holds for all its siblings. A property true of everything names nothing. What is left is what the kernel accepted; whatever it refused is reported by the generator and is not in this file.
 
-**A reading that does not vary with what it reads separates nothing** — `separation.lean`, 8 theorem(s). by the kernel, on a specific ring of labels published on a specific day, with a control that fires. prior_art_search: not performed — both notions are named above rather than searched for. prior_art_pool: unbounded prior_art_own: the two decisions below, and the control that proves they are not vacuous
+**What enumeration proposed and the kernel kept (14 of 25)** — `imagined_14.lean`, 1000 theorem(s). IMAGINED — proposed by scripts/imagine.ts, which enumerated every map-against-subset and map-between-subsets statement its primitives can express, kept the ones true by exhaustion, and then discarded every one that also holds for all its siblings. A property true of everything names nothing. What is left is what the kernel accepted; whatever it refused is reported by the generator and is not in this file.
 
-**Sequences** — `sequences.lean`, 28 theorem(s). The ledger held these as TypeScript tests. Each is a classical identity with a real proof; what is done here is to DECIDE each over a stated finite range, which is what `decide` can honestly deliver — the range is named in every theorem rather than implied, and no theorem claims the general case.
+**What enumeration proposed and the kernel kept (15 of 25)** — `imagined_15.lean`, 1000 theorem(s). IMAGINED — proposed by scripts/imagine.ts, which enumerated every map-against-subset and map-between-subsets statement its primitives can express, kept the ones true by exhaustion, and then discarded every one that also holds for all its siblings. A property true of everything names nothing. What is left is what the kernel accepted; whatever it refused is reported by the generator and is not in this file.
 
-**The digit split** — `split.lean`, 22 theorem(s). mathematics and claim nothing.   Stated precisely so the credit does not run past the earlier work: what is NOT claimed as prior art is   the tokenisation itself — reading the digits as 0|12|3|45|6|78|9 by concatenating consecutive units into   two-digit tokens, and the arithmetic that follows from it (every token a multiple of three, closure of   the tokens under addition and multiplication). That arrangement is this deposit's presentation of a   standard fact, and its verification is by exhaustion here. Crediting an earlier author for a   presentation they did not make is the same defect as claiming their result, pointed the other way. prior_art_search: literature search performed 2026-09-05, terms "units and non-units of Z/9 multiplicative   inverses group of units modulo 9"; prior art found and credited. prior_art_pool: mixed   the digit grouping is generic arithmetic; the coin accounting it feeds is this deposit's.   BOUNDED means a search is well posed and simply has not been run — the row is unclassified because   nobody looked. UNBOUNDED means the subject is this artifact, so there is no pool to search and the   row will stay unclassified however much work is done. They look identical in a count and need   opposite responses, which is the distinction uuidna-49 asked for and nobody had drawn. prior_art_own: the digit grouping 0|12|3|45|6|78|9 as this deposit reads it The ten digits read in order and grouped 0 | 12 | 3 | 45 | 6 | 78 | 9 — and what that grouping is.
+**What enumeration proposed and the kernel kept (16 of 25)** — `imagined_16.lean`, 1000 theorem(s). IMAGINED — proposed by scripts/imagine.ts, which enumerated every map-against-subset and map-between-subsets statement its primitives can express, kept the ones true by exhaustion, and then discarded every one that also holds for all its siblings. A property true of everything names nothing. What is left is what the kernel accepted; whatever it refused is reported by the generator and is not in this file.
 
-**Doubling is two loops and both close at three hundred and sixty degrees** — `turns.lean`, 8 theorem(s). the accounting: that doubling leaves exactly TWO non-trivial loops on this ring, that their step angles   are 60° and 180°, and that both close at 360° — and theorem 8, which says plainly that the surface is   an interpretation of the cycle structure and not a theorem about it. prior_art_search: not performed — all three are named above. prior_art_pool: unbounded prior_art_own: the two-loop accounting, the step angles, and the honesty clause in theorem 8
+**What enumeration proposed and the kernel kept (17 of 25)** — `imagined_17.lean`, 1000 theorem(s). IMAGINED — proposed by scripts/imagine.ts, which enumerated every map-against-subset and map-between-subsets statement its primitives can express, kept the ones true by exhaustion, and then discarded every one that also holds for all its siblings. A property true of everything names nothing. What is left is what the kernel accepted; whatever it refused is reported by the generator and is not in this file.
 
-**The ring ℤ/9** — `z9.lean`, 25 theorem(s). The ℤ/9 families — mechanically generated theorems, proved by decide rather than tested in TypeScript.
+**What enumeration proposed and the kernel kept (18 of 25)** — `imagined_18.lean`, 1000 theorem(s). IMAGINED — proposed by scripts/imagine.ts, which enumerated every map-against-subset and map-between-subsets statement its primitives can express, kept the ones true by exhaustion, and then discarded every one that also holds for all its siblings. A property true of everything names nothing. What is left is what the kernel accepted; whatever it refused is reported by the generator and is not in this file.
 
-**Entanglement in the ring** — `z9plus.lean`, 48 theorem(s). z9.lean settled the families exhaustively. This settles the claims the ledger stated individually and never generalised: which residues squares and cubes can be, which residues are primitive roots, the period of the doubling orbit's digital root, and the identity behind digit-reversal invariance. Each is stated as an EQUIVALENCE or an exact set where the ledger stated instances, so the negative half is proved too.
+**What enumeration proposed and the kernel kept (19 of 25)** — `imagined_19.lean`, 1000 theorem(s). IMAGINED — proposed by scripts/imagine.ts, which enumerated every map-against-subset and map-between-subsets statement its primitives can express, kept the ones true by exhaustion, and then discarded every one that also holds for all its siblings. A property true of everything names nothing. What is left is what the kernel accepted; whatever it refused is reported by the generator and is not in this file.
+
+**What enumeration proposed and the kernel kept (2 of 25)** — `imagined_2.lean`, 1000 theorem(s). IMAGINED — proposed by scripts/imagine.ts, which enumerated every map-against-subset and map-between-subsets statement its primitives can express, kept the ones true by exhaustion, and then discarded every one that also holds for all its siblings. A property true of everything names nothing. What is left is what the kernel accepted; whatever it refused is reported by the generator and is not in this file.
+
+**What enumeration proposed and the kernel kept (20 of 25)** — `imagined_20.lean`, 1000 theorem(s). IMAGINED — proposed by scripts/imagine.ts, which enumerated every map-against-subset and map-between-subsets statement its primitives can express, kept the ones true by exhaustion, and then discarded every one that also holds for all its siblings. A property true of everything names nothing. What is left is what the kernel accepted; whatever it refused is reported by the generator and is not in this file.
+
+**What enumeration proposed and the kernel kept (21 of 25)** — `imagined_21.lean`, 1000 theorem(s). IMAGINED — proposed by scripts/imagine.ts, which enumerated every map-against-subset and map-between-subsets statement its primitives can express, kept the ones true by exhaustion, and then discarded every one that also holds for all its siblings. A property true of everything names nothing. What is left is what the kernel accepted; whatever it refused is reported by the generator and is not in this file.
+
+**What enumeration proposed and the kernel kept (22 of 25)** — `imagined_22.lean`, 1000 theorem(s). IMAGINED — proposed by scripts/imagine.ts, which enumerated every map-against-subset and map-between-subsets statement its primitives can express, kept the ones true by exhaustion, and then discarded every one that also holds for all its siblings. A property true of everything names nothing. What is left is what the kernel accepted; whatever it refused is reported by the generator and is not in this file.
+
+**What enumeration proposed and the kernel kept (23 of 25)** — `imagined_23.lean`, 1000 theorem(s). IMAGINED — proposed by scripts/imagine.ts, which enumerated every map-against-subset and map-between-subsets statement its primitives can express, kept the ones true by exhaustion, and then discarded every one that also holds for all its siblings. A property true of everything names nothing. What is left is what the kernel accepted; whatever it refused is reported by the generator and is not in this file.
+
+**What enumeration proposed and the kernel kept (24 of 25)** — `imagined_24.lean`, 1000 theorem(s). IMAGINED — proposed by scripts/imagine.ts, which enumerated every map-against-subset and map-between-subsets statement its primitives can express, kept the ones true by exhaustion, and then discarded every one that also holds for all its siblings. A property true of everything names nothing. What is left is what the kernel accepted; whatever it refused is reported by the generator and is not in this file.
+
+**What enumeration proposed and the kernel kept (25 of 25)** — `imagined_25.lean`, 742 theorem(s). IMAGINED — proposed by scripts/imagine.ts, which enumerated every map-against-subset and map-between-subsets statement its primitives can express, kept the ones true by exhaustion, and then discarded every one that also holds for all its siblings. A property true of everything names nothing. What is left is what the kernel accepted; whatever it refused is reported by the generator and is not in this file.
+
+**What enumeration proposed and the kernel kept (3 of 25)** — `imagined_3.lean`, 1000 theorem(s). IMAGINED — proposed by scripts/imagine.ts, which enumerated every map-against-subset and map-between-subsets statement its primitives can express, kept the ones true by exhaustion, and then discarded every one that also holds for all its siblings. A property true of everything names nothing. What is left is what the kernel accepted; whatever it refused is reported by the generator and is not in this file.
+
+**What enumeration proposed and the kernel kept (4 of 25)** — `imagined_4.lean`, 1000 theorem(s). IMAGINED — proposed by scripts/imagine.ts, which enumerated every map-against-subset and map-between-subsets statement its primitives can express, kept the ones true by exhaustion, and then discarded every one that also holds for all its siblings. A property true of everything names nothing. What is left is what the kernel accepted; whatever it refused is reported by the generator and is not in this file.
+
+**What enumeration proposed and the kernel kept (5 of 25)** — `imagined_5.lean`, 1000 theorem(s). IMAGINED — proposed by scripts/imagine.ts, which enumerated every map-against-subset and map-between-subsets statement its primitives can express, kept the ones true by exhaustion, and then discarded every one that also holds for all its siblings. A property true of everything names nothing. What is left is what the kernel accepted; whatever it refused is reported by the generator and is not in this file.
+
+**What enumeration proposed and the kernel kept (6 of 25)** — `imagined_6.lean`, 1000 theorem(s). IMAGINED — proposed by scripts/imagine.ts, which enumerated every map-against-subset and map-between-subsets statement its primitives can express, kept the ones true by exhaustion, and then discarded every one that also holds for all its siblings. A property true of everything names nothing. What is left is what the kernel accepted; whatever it refused is reported by the generator and is not in this file.
+
+**What enumeration proposed and the kernel kept (7 of 25)** — `imagined_7.lean`, 1000 theorem(s). IMAGINED — proposed by scripts/imagine.ts, which enumerated every map-against-subset and map-between-subsets statement its primitives can express, kept the ones true by exhaustion, and then discarded every one that also holds for all its siblings. A property true of everything names nothing. What is left is what the kernel accepted; whatever it refused is reported by the generator and is not in this file.
+
+**What enumeration proposed and the kernel kept (8 of 25)** — `imagined_8.lean`, 1000 theorem(s). IMAGINED — proposed by scripts/imagine.ts, which enumerated every map-against-subset and map-between-subsets statement its primitives can express, kept the ones true by exhaustion, and then discarded every one that also holds for all its siblings. A property true of everything names nothing. What is left is what the kernel accepted; whatever it refused is reported by the generator and is not in this file.
+
+**What enumeration proposed and the kernel kept (9 of 25)** — `imagined_9.lean`, 1000 theorem(s). IMAGINED — proposed by scripts/imagine.ts, which enumerated every map-against-subset and map-between-subsets statement its primitives can express, kept the ones true by exhaustion, and then discarded every one that also holds for all its siblings. A property true of everything names nothing. What is left is what the kernel accepted; whatever it refused is reported by the generator and is not in this file.
+
+**Sealed before the vocabulary moved, and still decided** — `retained.lean`, 15 theorem(s). RETAINED —scripts/imagine.ts sealed these when its map table was hand-written, and its derived enumeration does not propose them. Nothing about them was refuted: each is copied here exactly as the generator last wrote it, and the kernel decides every one on every run. The ledger is append-only, so a sealed key whose source disappears is an orphan the record cannot honestly resolve — keeping the source is the only answer that neither withdraws a proved fact nor claims a carrier that does not prove it.
 
 ### the machine
 
-**Generated at scale** — `generated.lean`, 13 theorem(s). Bounded, so the credit stops where the earlier work does: what is NOT prior art is the generator that enumerates propositions over this ring and   discards the ones true of every sibling; that machinery is this deposit's own.   Verification by exhaustion in Lean is this deposit's contribution, and verification is not discovery. prior_art_search: literature search performed 2026-09-05, terms "doubling sequence modulo 9 orbit   1 2 4 8 7 5 cyclic group generator digital root"; prior art found and credited. prior_art_pool: bounded   quantified ring arithmetic over Z/9; the underlying facts are classical and searchable.   BOUNDED means a search is well posed and simply has not been run — the row is unclassified because   nobody looked. UNBOUNDED means the subject is this artifact, so there is no pool to search and the   row will stay unclassified however much work is done. They look identical in a count and need   opposite responses, which is the distinction uuidna-49 asked for and nobody had drawn. prior_art_own: this deposit's own generator over its own ring Generated by scripts/lean-gen.ts — do not edit by hand; re-run the generator. Each theorem below quantifies over a whole ledger family. Every one is compiled, audited for axioms, and checked to compute what the ledger's own tests compute at every parameter of its family.
+**Generated at scale** — `generated.lean`, 13 theorem(s). Generated by scripts/lean-gen.ts — do not edit by hand; re-run the generator. Each theorem below quantifies over a whole ledger family. Every one is compiled, audited for axioms, and checked to compute what the ledger's own tests compute at every parameter of its family.
 
 **Mechanically translated** — `mechanical.lean`, 127 theorem(s). Generated by src/prove/emit.ts from the ledger's own tests — do not hand-edit; re-run the prover.
 
 **Nim** — `nim.lean`, 28 theorem(s). Nim — Bouton's theorem and Sprague–Grundy, decided.
 
-**A fold that returns a lone leaf unchanged admits a second preimage** — `preimage.lean`, 8 theorem(s). this deposit's is the finding: that ITS OWN fold has the weakness, in a specific shape, and that the   shape is decided here rather than asserted. prior_art_search: not performed — RFC 6962 is named above. prior_art_pool: named prior_art_own: the two collisions below, modelled from src/0/index.ts as written
-
-**The universal reflection, and where it stops being one** — `reflection.lean`, 8 theorem(s). wing: the machine prior_art: named prior_art_domain: the method of complements prior_art_note: the universal reflection here is the same ten's complement d ↦ 10 − d as coin.lean, with its centre and its pairs summing to ten. Method of complements, long prior to this deposit. Searched 2026-09-04 prior_art_search: literature search performed 2026-09-04 — see the note for the terms and the result The universal property — honestly, and COMPUTED from the sequence.
+**A fold that returns a lone leaf unchanged admits a second preimage** — `preimage.lean`, 8 theorem(s). WHY THIS FILE EXISTS.
 
-**Digit reversal** — `reversal.lean`, 30 theorem(s). Digit reversal — arithmetic, not string handling.
+**The universal reflection, and where it stops being one** — `reflection.lean`, 8 theorem(s). TWO HACKS REMOVED TOGETHER, by the author's order on 2026-09-25. The title was "Theorems", which names nothing — every file here holds theorems. And the namespace was `MillenniumFloor.Universal`: a namespace rooted in ANOTHER file's concept, so this file's keys carried a word about the Clay floor while deciding the ten's complement. It is `Reflection` now, which is what it decides. The universal property — honestly, and COMPUTED from the sequence.
 
-### the imagined
-
-**What enumeration proposed and the kernel kept** — `imagined.lean`, 91 theorem(s). IMAGINED — proposed by scripts/imagine.ts, which enumerated every map-against-subset and map-between-subsets statement its primitives can express, kept the ones true by exhaustion, and then discarded every one that also holds for all its siblings. A property true of everything names nothing. What is left is what the kernel accepted; whatever it refused is reported by the generator and is not in this file.
+**Digit reversal** — `reversal.lean`, 29 theorem(s). Digit reversal — arithmetic, not string handling.
 
 ### the record
 
-**Prior art, and what novelty is claimed** — `priorart.lean`, 9 theorem(s). artefact is long established and formalised: W3C PROV-O, the DataCite metadata schema, Dublin Core   Metadata Terms, PREMIS for archived digital objects, the Open Provenance Model, and the software   citation principles' credit-and-attribution requirement. Nothing about keeping an attribution table is   new, and this deposit does not suggest otherwise.
+**Prior art, and what novelty is claimed** — `priorart.lean`, 9 theorem(s). THE PROPOSITIONS ARE NOT RESTATEMENTS OF IT. `every_source_is_classified`, `novelty_is_claimed_of_no_   source` and `zero_claims_is_not_full_attribution` decide facts about THIS table — its rows, its kinds,   its counts. PROV-O does not entail them and could not; no external work precedes a statement about the   contents of this file.
+
+**The discovery ranking is monotone, and it is far coarser than it looks** — `ranking.lean`, 8 theorem(s). WHY THIS FILE EXISTS.
 
-**The discovery ranking is monotone, and it is far coarser than it looks** — `ranking.lean`, 8 theorem(s). queue — which decides where the next prior-art search goes — is put to both, and that the second   answer is unflattering and recorded anyway. prior_art_search: not performed — both are named above. prior_art_pool: unbounded prior_art_own: the coarseness count in theorem 4, and theorem 8
+**Rights** — `rights.lean`, 8 theorem(s). What this deposit claims under international law — and, in the same table, what it does not.
 
-**Rights** — `rights.lean`, 9 theorem(s). Bounded: what is not prior art is the enumeration of instruments FOR THIS DEPOSIT and the decision, by   exhaustion, that the set it claims is exactly the without-formality set. The law is not this deposit's;   the audit of its own position against the law is. prior_art_search: no search was needed — the instruments were cited in this file's own prose from the   start. Recorded 2026-09-05, when the table was found to disagree with the file. prior_art_pool: unbounded   the subject is this deposit's own rights table.   BOUNDED means a search is well posed and simply has not been run — the row is unclassified because   nobody looked. UNBOUNDED means the subject is this artifact, so there is no pool to search and the   row will stay unclassified however much work is done. They look identical in a count and need   opposite responses, which is the distinction uuidna-49 asked for and nobody had drawn. prior_art_own: this deposit's own rights table What this deposit claims under international law — and, in the same table, what it does not.
+**What each file says it settles, checked against what it does** — `settled.lean`, 8 theorem(s). GENERATED by scripts/settled.ts — do not edit. Regenerate with `npm run settled`.
 
-**The prior-art verdict is total, exclusive, and never improved by silence** — `verdict.lean`, 8 theorem(s). is this deposit's is that ITS OWN verdict rule — the one standing behind every novelty claim it makes —   is decided by the kernel rather than left as a line of TypeScript nobody checks. prior_art_search: not performed — both notions are named above. prior_art_pool: unbounded prior_art_own: the four properties below, and theorem 8
+**The prior-art verdict is total, exclusive, and never improved by silence** — `verdict.lean`, 8 theorem(s). WHY THIS FILE EXISTS.
 
 ### the returned
 
-**What the ledger marked reachable, reached by the kernel** — `reached.lean`, 80 theorem(s). 180° apart on the wheel. What is NOT prior art is that these particular statements sat WITHDRAWN in this   deposit's ledger, each marked `portable` — its own judgement that a Lean proof was reachable — and each   recorded as "not backed by a Lean proof. Its evidence is a TypeScript test" while nobody wrote one. prior_art_search: not performed — the results are named above rather than searched for. prior_art_pool: bounded prior_art_own: nothing mathematical; only that the deposit now proves what it had already claimed was provable
+**What the ledger marked reachable, reached by the kernel** — `reached.lean`, 80 theorem(s). WHY IT IS NOT CALLED `claimed`, AND WHY THAT IS NOT ABOUT PRIOR ART.
 
-**Recovered — claims that computed and were withdrawn for want of a proof** — `recovered.lean`, 15 theorem(s). material, credited. What is NOT prior art is that these particular statements sat WITHDRAWN in this   deposit's ledger, each recorded as "not backed by a Lean proof. Its evidence is a TypeScript test",   while every one is decidable in a line. prior_art_search: literature search performed 2026-09-05, terms "units and non-units of Z/9 multiplicative   inverses group of units modulo 9"; prior art found and credited.
+**Recovered — claims that computed and were withdrawn for want of a proof** — `recovered.lean`, 15 theorem(s). WITHDRAWAL WAS NEVER THE ONLY OPTION. Each theorem below returns one claim to the record. The evidence that existed was a TypeScript run — a computation that agreed once on one machine. The kernel walks the whole stated domain. That was the gap, and closing it is arithmetic.
 
-31 of 1200 declarations carry no comment of their own and are shown here as the gap they are, not
+62 of 26045 declarations carry no comment of their own and are shown here as the gap they are, not
 filled with a template.
 
 ## 8 · What this build measured about itself
@@ -261,44 +464,33 @@ Read from the artefacts at build time, never carried between runs.
 
 | measure | value |
 |---|---|
-| ledger entries | 3,304 — 413 octaves exactly |
-| standing — carries its own proof | **1185** |
-| carried — withdrawn on its own evidence, proved by a live theorem | **526** |
+| ledger entries | 28,464 — 3558 octaves exactly |
+| standing — carries its own proof | **26045** |
+| carried — withdrawn on its own evidence, proved by a live theorem | **826** |
 | withdrawn — nothing proves it | 1,593 |
-| proved in total | **1711** of 3,304 |
-| standing keys → distinct theorems | 1185 sealed, 0 of them keyed twice, 0 unresolvable |
-| Lean files · theorems | 62 · 1185 theorems (998 closed by exhaustion, axiom-free · 187 proved for every value on propext and Quot.sound) + 15 rfl declarations |
-| proved `by decide` | 998 of 1200 |
+| proved in total | **26871** of 28,464 |
+| standing keys → distinct theorems | 26045 sealed, 0 of them keyed twice, 0 unresolvable |
+| Lean files · theorems | 105 · 26045 sealed theorems (25838 closed by exhaustion, axiom-free · 207 proved for every value on propext and Quot.sound) + 0 rfl declarations |
+| proved `by decide` | 25838 of 26045 |
 | claims a machine can render | 103 of 1,555 |
 | claims needing an author | 1,452 — reported, never faked |
 
-**On `carried`.** 526 entries were withdrawn for want of a Lean proof and have since been given one, at a new key. Nothing is un-revoked: the original's own evidence is still a TypeScript test, and rewriting its status would erase the fact that it did not hold on what it had. The record says both — withdrawn on its own evidence, standing through the theorem that carries it.
+**On `carried`.** 826 entries were withdrawn for want of a Lean proof and have since been given one, at a new key. Nothing is un-revoked: the original's own evidence is still a TypeScript test, and rewriting its status would erase the fact that it did not hold on what it had. The record says both — withdrawn on its own evidence, standing through the theorem that carries it.
 
-**Why the withdrawn were withdrawn.** 1,386 no Lean proof · 457 tested the removed lexical gate · 158 other · 108 its Lean source was deleted or renamed · 10 circular by construction. Nothing is deleted: the ledger is append-only, so an entry that stopped holding is marked in place with its reason and keeps its receipt.
+**Why the withdrawn were withdrawn.** 1,386 no Lean proof · 458 other · 457 tested the removed lexical gate · 108 its Lean source was deleted or renamed · 10 circular by construction. Nothing is deleted: the ledger is append-only, so an entry that stopped holding is marked in place with its reason and keeps its receipt.
 
-**What verification costs.** Proving the set touches all 16,384 leaves; verifying membership afterwards touches 14 — one sibling per level. That is **1,170× less work**, exactly, and the factor grows with the set because N/log N grows. Wall-clock varies with the machine and is left in the build output rather than pinned here. It is not sub-nanosecond and nothing here is: the advantage is a smaller exponent, not a faster clock. The counting is proved in `speed.lean`.
+**What verification costs.** Proving the set touches all 16,384 leaves; verifying membership afterwards touches 14 — one sibling per level. That is **1,170× less work** (the exact ratio is 1170.29), and the factor grows with the set because N/log N grows. Wall-clock varies with the machine and is left in the build output rather than pinned here. It is not sub-nanosecond and nothing here is: the advantage is a smaller exponent, not a faster clock. The counting is proved in `speed.lean`.
 
-## The seven, one theorem each — what they decide, and what they do not
+## Factoring, to the limit it can prove
 
-Each Clay problem has **one** theorem here, in `src/proof/index.lean`, and the table gives what that theorem decides and the case count the Lean kernel exhausted to decide it.
+The factor route takes an integer of any length, held exactly, and returns only what it can check. Measured for this build:
 
-*What these theorems decide is ℤ/9 arithmetic over finite domains — a statement about the theorems, not a verdict on any conjecture. Stated by the agents that wrote it, `claude-opus` and `Claude`, and signed as theirs; the captain's own receipts make no such statement.*
-
-| problem | the theorem, and what it decides | cases | proof |
-|---|---|---|---|
-| Riemann Hypothesis | `the_tens_complement_is_an_involution_with_one_fixed_point`<br/>`(List.range 10).all (fun d => refl (refl d) == d) ∧ ((List.range 10).filter (fun d => refl d == ` | 100 | [lean_windows_the_tens_comple…](/theorem/lean_windows_the_tens_complement_is_an_involution_with_one_fixed_point) |
-| P versus NP | `each_unit_has_exactly_one_inverse_and_each_non_unit_none`<br/>`(List.range 9).all (fun d => ((List.range 9).filter (fun e => (d * e) % 9 == 1)).length == (if i` | 81 | [lean_windows_each_unit_has_e…](/theorem/lean_windows_each_unit_has_exactly_one_inverse_and_each_non_unit_none) |
-| Navier–Stokes Existence & Smoothness | `the_doubling_orbit_stays_in_the_ring_for_forty_eight_steps`<br/>`((List.range 48).map orbit).all (fun v => v < 9) ∧ (List.range 48).all (fun k => span.contains (` | 2,304 | [lean_windows_the_doubling_or…](/theorem/lean_windows_the_doubling_orbit_stays_in_the_ring_for_forty_eight_steps) |
-| Yang–Mills Existence & Mass Gap | `the_doubling_orbit_first_returns_to_one_at_six`<br/>`(List.range 6).all (fun k => k == 0 \|\| orbit k != 1) ∧ orbit 6 == 1` | 6 | [lean_windows_the_doubling_or…](/theorem/lean_windows_the_doubling_orbit_first_returns_to_one_at_six) |
-| Hodge Conjecture | `the_span_is_exactly_the_units_of_the_ring`<br/>`(List.range 9).all (fun d => span.contains d == isUnit d) ∧ (List.range 9).all (fun d => isUnit ` | 81 | [lean_windows_the_span_is_exa…](/theorem/lean_windows_the_span_is_exactly_the_units_of_the_ring) |
-| Birch and Swinnerton-Dyer Conjecture | `the_span_and_the_units_both_sum_to_zero_mod_nine`<br/>`(span.foldr (· + ·) 0) % 9 == 0 ∧ ((List.range 9).filter isUnit).foldr (· + ·) 0 % 9 == 0` | 9 | [lean_windows_the_span_and_th…](/theorem/lean_windows_the_span_and_the_units_both_sum_to_zero_mod_nine) |
-| Poincaré Conjecture (resolved) | `the_orbit_is_one_closed_loop_of_six_distinct_points`<br/>`orbit 6 == orbit 0 ∧ (List.range 6).all (fun i => (List.range 6).all (fun j => (orbit i == orbit` | 36 | [lean_windows_the_orbit_is_on…](/theorem/lean_windows_the_orbit_is_one_closed_loop_of_six_distinct_points) |
-
-## The author's claim
+- `91`: FACTORED into 7 × 13.
+- `2^1000 − 1`, a thousand-bit integer: PARTIAL — 30 factor(s) below 10^6 (3 × 5 × 5 × 5 × 5 × 11 × 17 × 31 × 41 × 101 × 251 × 401 × 601 × 1801 × 4001 × 4051 × 7001 × 8101 × 28001 × 61681 × 96001 × 268501 × 340801 × 1074001 × 2787601 × 2020001 × 3775501 × 229668251 × 22624001 × 3173389601); a 189-digit cofactor that is composite (a witness was found).
+- `(2^521 − 1)(2^607 − 1)`, about 1,128 bits, no small factor: PARTIAL — 0 factor(s) below 10^6 (none); a 340-digit cofactor that is composite (a witness was found).
+- A 1,000-bit integer supplied through the factor tool (301 decimal digits): PARTIAL — 0 factor(s) below 10^6 (none); a 301-digit cofactor that is composite (a witness was found).
 
-**Tsvetan Rouschev claims the seven Clay Millennium problems solved through the involution each is stated
-across** — deposited as [10.5281/zenodo.21781603](https://doi.org/10.5281/zenodo.21781603) and
-[Zenodo 22256707](https://zenodo.org/records/22256707). This is his claim, recorded in his name.
+A thousand-bit integer is not solved on this page. Where no factor is found below the trial bound and the cofactor is not proved prime, the result is PARTIAL and names the step that is missing. Nothing is reported as a factor that was not checked.
 
 ## Run it
 
@@ -323,4 +515,4 @@ whether the work restates someone earlier. [The paper](/paper) typesets every st
 
 ---
 
-*20 claims, all verified · 1185 Lean theorems · 3304 ledger entries · trial root `eebffda3-8d9a-8842-a2c7-7cf5c48e6daa` · integrity, not truth*
+*20 claims, all verified · 26045 sealed theorems · 28464 ledger entries · trial root `dd3dccac-a6c7-8c5f-8617-9728f4ae814f` · integrity, not truth*