@ceccec/millennium-solutions 9.8.6 → 9.8.7

package/CITATION.cff

@@ -23,6 +23,11 @@ keywords:
   - Clay Millennium Problems
   - Lean 4
   - recomputable research
+  - quantum computing
+  - ISO/IEC 4879
+  - Bell test
+  - Mermin inequality
+  - cluster state
 abstract: >-
   A free, open, recomputable Z/9 vortex and (Z/7)* rosette framework with a
   classical simulator of quantum algorithms (TypeScript, Lean 4, VitePress).

package/README.md

@@ -2,6 +2,10 @@
 
 **Author:** Tsvetan Rouschev · License: CC BY-NC-ND 4.0 · DOI [10.5281/zenodo.21819217](https://doi.org/10.5281/zenodo.21819217)
 
+Machine-checked Lean 4 theorems, content-addressed UUIDs and a recomputable ledger: the seven Clay Millennium
+problems' involutions, a thousand-bit cryptographic surface, and the ISO/IEC 4879 quantum computer — every quantum
+computing model decided exactly, the Bell test scaled to 128 qubits, and a CHSH run on real IBM Quantum hardware.
+
 ```bash
 npm install @ceccec/millennium-solutions
 ```
@@ -157,16 +161,66 @@ The seven above are the floor; this is the cryptographic surface the same involu
 - **`this_deposits_factor_route_returns_a_partial_answer_that_multiplies_back`** · `by decide`, 1 cases — the factor route returns PARTIAL on 2^999 + 1 — fourteen factors and a 244-digit cofactor Pollard rho did not split; the kernel adds only that the account is an identity and that 2 is a Fermat witness against the cofactor. It does not factor the integer and does not say it does.
   <sub>[`lean_qpucrypto_this_deposits_factor_route_returns_a_partial_answer_that_multiplies_back`](/theorem/lean_qpucrypto_this_deposits_factor_route_returns_a_partial_answer_that_multiplies_back) · receipt `215f8bbc-e55e…`</sub>
 
+## Quantum hardware — what ISO/IEC 4879 calls a quantum computer, and the Bell test that verifies one
+
+A **real quantum computer** is, by ISO, all three at once: **hardware** (ISO/IEC 2382:2015 — physical components of an information system), a **quantum processor** (ISO/IEC 4879:2024 §3.4.8 — a tangible device processing information held in physical qubits through superposition and entanglement) and a **computer** (§3.4.10 — fully programmable, any unitary on its Hilbert space). A classical program computing the same numbers is §3.4.22, a quantum simulator. What separates them is where the counts come from, so the test is **CHSH S > 2 from a device's own counts**, decided on exact integers.
+
+**Device verdict: no run yet.** The accepted system is IBM Quantum Platform (quantum.cloud.ibm.com), Qiskit Runtime REST API, under IBM's terms of use; the run is `npm run quantum:hardware` with the depositor's own IBM_QUANTUM_TOKEN and IBM_QUANTUM_CRN. Until it runs, nothing below is hardware evidence: it is the exact specification a run is checked against.
+
+Every quantum computing model ISO/IEC 4879 names is decided at its known optimum, each beside a control and each cross-checked against a public source (linked on [/hardware](/hardware)):
+
+- **§3.4.13 circuit-based** · `the_sent_circuits_reach_s_two_root_two` · decided by exhaustion — the CHSH gates sent to IBM Quantum give S = 2√2 exactly — Tsirelson's maximum — for an ideal device, in ℤ[ω] with no float; it is the specification a run is checked against, not a run.
+  <sub>[`lean_quantumcircuits_the_sent_circuits_reach_s_two_root_two`](/theorem/lean_quantumcircuits_the_sent_circuits_reach_s_two_root_two) · receipt `4688e005-e75d…`</sub>
+- **the classical line** · `every_deterministic_local_strategy_gives_chsh_plus_or_minus_two` · decided by exhaustion — every classical strategy gives S = ±2, so a device must cross 2 strictly; it says nothing about any device until its counts arrive.
+  <sub>[`lean_quantumhardware_every_deterministic_local_strategy_gives_chsh_plus_or_minus_two`](/theorem/lean_quantumhardware_every_deterministic_local_strategy_gives_chsh_plus_or_minus_two) · receipt `6f5bb0ee-7cb2…`</sub>
+- **the verdict rule** · `one_count_above_s_two_is_above_classical` · decided by exhaustion — a device's counts are judged on exact integers — one count past S = 2 is seen, one count short is refused (its control).
+  <sub>[`lean_quantumhardware_one_count_above_s_two_is_above_classical`](/theorem/lean_quantumhardware_one_count_above_s_two_is_above_classical) · receipt `98565f45-367c…`</sub>
+- **§3.4.14 one-way** · `one_way_measurement_applies_h_rz_for_every_angle_and_both_outcomes` · decided by exhaustion over 16 cases — measuring a cluster qubit applies J(θ) = H·diag(1, e^{iθ}) to its neighbour with an X^m byproduct, every π/4 angle and both outcomes.
+  <sub>[`lean_quantummodels_one_way_measurement_applies_h_rz_for_every_angle_and_both_outcomes`](/theorem/lean_quantummodels_one_way_measurement_applies_h_rz_for_every_angle_and_both_outcomes) · receipt `769136b1-2e36…`</sub>
+- **§3.4.16 topological** · `ising_anyon_braids_generate_exactly_the_twenty_four_clifford_classes` · decided by exhaustion — Ising braids generate exactly 24 classes up to phase, closed — the single-qubit Clifford group — so braiding alone is not universal.
+  <sub>[`lean_quantummodels_ising_anyon_braids_generate_exactly_the_twenty_four_clifford_classes`](/theorem/lean_quantummodels_ising_anyon_braids_generate_exactly_the_twenty_four_clifford_classes) · receipt `953f132c-e01e…`</sub>
+- **§3.5.8 boson sampling** · `every_balanced_beam_splitter_gives_a_full_depth_hong_ou_mandel_dip` · decided by exhaustion over 64 cases — every balanced beam splitter on the π/4 phase grid is unitary with permanent 0 — the full Hong–Ou–Mandel dip; distinguishable photons coincide half the time.
+  <sub>[`lean_quantummodels_every_balanced_beam_splitter_gives_a_full_depth_hong_ou_mandel_dip`](/theorem/lean_quantummodels_every_balanced_beam_splitter_gives_a_full_depth_hong_ou_mandel_dip) · receipt `f6d41c2d-7720…`</sub>
+- **§3.4.15 adiabatic** · `the_adiabatic_gap_is_smallest_exactly_at_the_midpoint_at_every_resolution` · proved for every value — for every rational schedule point the one-qubit gap is never below √2 and reaches it at the midpoint — proved for every value, not sampled.
+  <sub>[`lean_quantummodels_the_adiabatic_gap_is_smallest_exactly_at_the_midpoint_at_every_resolution`](/theorem/lean_quantummodels_the_adiabatic_gap_is_smallest_exactly_at_the_midpoint_at_every_resolution) · receipt `f6e9816c-c2b7…`</sub>
+- **§3.4.31 annealer** · `the_frustrated_triangle_has_a_six_fold_ground_state_at_minus_one` · decided by exhaustion — the frustrated triangle's whole spectrum: ground state −1 six-fold, only all-up and all-down at +3.
+  <sub>[`lean_quantummodels_the_frustrated_triangle_has_a_six_fold_ground_state_at_minus_one`](/theorem/lean_quantummodels_the_frustrated_triangle_has_a_six_fold_ground_state_at_minus_one) · receipt `5ad73761-1088…`</sub>
+- **128 qubits** · `octave_one_twenty_eight_qubits_the_uuid_width_leads_by_two_to_the_sixty_third` · rewritten from sealed theorems, then decided — on the UUID width the GHZ state's Mermin value is 2¹²⁷ against the classical 2⁶⁴ — a lead of 2⁶³ — recombined from eight sealed particles; exact classical computation of the ideal state, not a device result.
+  <sub>[`lean_quantumoctave128_octave_one_twenty_eight_qubits_the_uuid_width_leads_by_two_to_the_sixty_third`](/theorem/lean_quantumoctave128_octave_one_twenty_eight_qubits_the_uuid_width_leads_by_two_to_the_sixty_third) · receipt `6dbff2e6-728f…`</sub>
+- **124 qubits** · `the_124_qubit_ghz_state_leads_every_classical_assignment_by_two_to_the_sixty_first` · rewritten from sealed theorems, then decided — the UUID less its version hex digit: the GHZ state's Mermin value 2¹²³ against the classical 2⁶², a lead of 2⁶¹, recombined from eight sealed particles; the ideal state, not a device result.
+  <sub>[`lean_quantumuuidcluster_the_124_qubit_ghz_state_leads_every_classical_assignment_by_two_to_the_sixty_first`](/theorem/lean_quantumuuidcluster_the_124_qubit_ghz_state_leads_every_classical_assignment_by_two_to_the_sixty_first) · receipt `e037d2bb-d19b…`</sub>
+- **124-qubit cluster** · `every_generator_of_the_124_qubit_cluster_is_z_x_z_on_its_neighbours` · decided by exhaustion over 124 cases — all 124 generators carried through the whole CZ chain become Z·X·Z on their neighbours; sealed particles prove the exact bit pattern, commutation and independence, beside a no-chain and a ring control.
+  <sub>[`lean_quantumuuidcluster_every_generator_of_the_124_qubit_cluster_is_z_x_z_on_its_neighbours`](/theorem/lean_quantumuuidcluster_every_generator_of_the_124_qubit_cluster_is_z_x_z_on_its_neighbours) · receipt `6d9b30fa-2137…`</sub>
+- **textbook cross-check** · `the_group_generated_by_h_and_s_has_exactly_twenty_four_classes` · decided by exhaustion — qpu's Eastin–Knill 24 derived from ⟨H, S⟩ itself; quantum_textbooks.lean re-derives every qpu textbook number this way except Holevo's entropy, and each matches.
+  <sub>[`lean_quantumtextbooks_the_group_generated_by_h_and_s_has_exactly_twenty_four_classes`](/theorem/lean_quantumtextbooks_the_group_generated_by_h_and_s_has_exactly_twenty_four_classes) · receipt `a3100a06-cbc5…`</sub>
+
+**Scaled in octaves.** Mermin's GHZ test doubles with the qubits — the quantum value 2ⁿ⁻¹ against the classical 2^(n/2) (arXiv:0905.0151 §2), computed here by the literal Node port of the Lean (`npm run quantum:octave`):
+
+| qubits | quantum | classical | lead |
+|---:|---:|---:|---:|
+| 2 | 2^1 | 2^1 | 2^0 |
+| 4 | 2^3 | 2^2 | 2^1 |
+| 8 | 2^7 | 2^4 | 2^3 |
+| 16 | 2^15 | 2^8 | 2^7 |
+| 32 | 2^31 | 2^16 | 2^15 |
+| 64 | 2^63 | 2^32 | 2^31 |
+| 124 (128 − one hex digit) | 2^123 | 2^62 | 2^61 |
+| 128 | 2^127 | 2^64 | 2^63 |
+
+The **124-qubit cluster state** — the UUID minus its version hex digit — has 124 stabilizers, propagated through every CZ by a Pauli tableau: each is Z·X·Z on its neighbourhood and they all commute. Stabilizer states are exactly what a classical computer describes in polynomial time (Gottesman–Knill), which is why 128 qubits fit here — and why only a device's measured counts, never this computation, make "hardware" true.
+
+**Terminology.** The types are named by the standard's terms (`QuantumGate` §3.4.2, `QuantumCircuit` §3.4.5, `MeasurementCounts` §3.2.16, `AcceptedQuantumComputer` §3.4.10), and all 86 terms of ISO/IEC 4879 are listed once in `src/quantum/terminology.ts`, each a coin — the content address of its clause and term — with where it is realised: 23 in this tree, the other 63 by a named check in qpu. Each coin holds its skill — its section of the standard, with the ESCO skills search — and its tools: what computes or verifies it and the entry point that runs it, every one resolved in the tree; each of the 6 skill families is a coin too, the fold of its members' coins — on [/hardware](/hardware).
+
 ## 1 · What is proved
 
 - 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 26077 kernel-accepted declarations across 108 files, and no file uses sorry or native_decide outside a comment.
-  <sub>SEALED · `ce6f028f-f926-87d3-ba7b-7e5b67664e30`</sub>
-- 25870 of those 26077 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 · `02781461-244a-8ec5-8002-03fe0bda9ec9`</sub>
-- 26632 of them are sealed into the ledger, each carrying a receipt derived from the one before it.
-  <sub>SEALED · `03e12133-b339-8f62-b1d9-7409b6ef50c6`</sub>
+- The formal layer holds 26189 kernel-accepted declarations across 122 files, and no file uses sorry or native_decide outside a comment.
+  <sub>SEALED · `1cbee23b-9b3b-8f81-8b6e-08b8474af177`</sub>
+- 25979 of those 26189 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; 210 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 · `c1cdadd1-59b3-8470-a0c1-9a1a3dd0c1bb`</sub>
+- 26744 of them are sealed into the ledger, each carrying a receipt derived from the one before it.
+  <sub>SEALED · `05faed51-dd23-877f-b2c6-ca534158c9ba`</sub>
 
 ## 2 · The ring
 
@@ -189,10 +243,10 @@ The seven above are the floor; this is the cryptographic surface the same involu
 
 ## 7 · The ledger
 
-- The ledger records 28496 entries with 0 chain breaks, 0 duplicate keys and 0 duplicate receipts.
-  <sub>SEALED · `6d489195-5572-8748-ad1c-24d1e187f2f2`</sub>
-- The count is an exact multiple of eight — 28496 is 3562 octaves with no remainder.
-  <sub>SEALED · `1f017b49-2045-8daa-a1a1-ae547a69dc57`</sub>
+- The ledger records 28608 entries with 0 chain breaks, 0 duplicate keys and 0 duplicate receipts.
+  <sub>SEALED · `c087ba91-7cc3-882b-943f-605759a65bec`</sub>
+- The count is an exact multiple of eight — 28608 is 3576 octaves with no remainder.
+  <sub>SEALED · `a4588d07-0658-8774-b251-f93a0a3c206c`</sub>
 
 ## 5 · What the gate does and does not do
 
@@ -244,7 +298,7 @@ results; it is the result, read off the same arithmetic that produced the table.
 
 ## 7 · The proofs, as they document themselves
 
-108 Lean files in 8 wings, 26077 declarations, of which 26077 are sealed (a live ledger key each) and 0 are not yet sealed. The prose in this section is read out of the
+122 Lean files in 8 wings, 26189 declarations, of which 26189 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.
 
@@ -292,6 +346,8 @@ this page; there is nowhere else to keep the description in step.
 
 **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
 
+**Enumerative combinatorics, the decidable laws — learned from qpu's Combinatorics** — `combinatorics.lean`, 8 theorem(s). No axioms, no Mathlib, no sorry.
+
 **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.
 
 **The next tier of what is asked for** — `demand2.lean`, 12 theorem(s). THE SECOND COURSE OF THE SAME FLOOR. `demand.lean` closed the top eight topics in src/demand/queries.json; this file takes the next eight, chosen the same way — by impressions, not by taste. The demand map is three months of the deposit's own Google Search Console data with the retrieval scaffolding stripped, so what is ranked is the TOPIC people wanted a citable source for, not the phrasing they reached for.
@@ -322,16 +378,24 @@ this page; there is nowhere else to keep the description in step.
 
 **The Planck length, and what a lattice may say about it** — `planck.lean`, 35 theorem(s). WHY THIS FILE EXISTS, AND WHAT IT REFUSES.
 
+**Quantum error-correcting codes, the decidable parameters — learned from qpu's Surfacecode and Stabilizer** — `qec.lean`, 8 theorem(s). No axioms, no Mathlib, no sorry.
+
 **Order-invariance** — `quantum.lean`, 11 theorem(s). The quantum receipt — order invariance, proved rather than asserted.
 
 **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?
 
+**Annealer topology, QFT resource counts, and π's rational convergents — learned from qpu's Annealing, Qft, Pi** — `resources.lean`, 8 theorem(s). No axioms, no Mathlib, no sorry.
+
 **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.
 
+**Gate synthesis and fault-tolerance counts — learned from qpu's Clifford, Anyon, Magic and Qaoa** — `synthesis.lean`, 8 theorem(s). No axioms, no Mathlib, no sorry.
+
 **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 thousand-bit case, decided — its octave/trinity/cube structure and its utilisation of the register** — `thousandbit.lean`, 8 theorem(s). No axioms, no Mathlib, no sorry.
+
 ### the ring
 
 **Two kinds of cross formula — one that runs both ways and one that does not** — `asymmetry.lean`, 8 theorem(s). WHY THIS FILE EXISTS.
@@ -376,6 +440,8 @@ this page; there is nowhere else to keep the description in step.
 
 **What qpu.uuidna.com's cryptographic surface is, decided on its own integers** — `qpu_crypto.lean`, 16 theorem(s). WHY THIS FILE EXISTS, AND WHAT IT REFUSES TO SAY.
 
+**qpu's coin is a function of a 64-bit fold, so it spans at most 2^64 of its 2^122 layout** — `qpu_fold.lean`, 8 theorem(s). WHY THIS FILE EXISTS.
+
 **The two gateway bits are constant, so the teleport analogy has no bits to send** — `qpu_gateway.lean`, 8 theorem(s). WHY THIS FILE EXISTS.
 
 **A reading that does not vary with what it reads separates nothing** — `separation.lean`, 8 theorem(s). WHY THIS FILE EXISTS.
@@ -458,6 +524,22 @@ this page; there is nowhere else to keep the description in step.
 
 **A fold that returns a lone leaf unchanged admits a second preimage** — `preimage.lean`, 8 theorem(s). WHY THIS FILE EXISTS.
 
+**The CHSH circuits sent to a quantum device give exactly 2√2, decided over the cyclotomic integers** — `quantum_circuits.lean`, 8 theorem(s). WHY ℤ[ω] AND NOT FLOATS. Every angle the circuits use is a multiple of π/4, so with each rz written as diag(1, ω^k) (it differs from the device's rz by a global phase, which no probability can see) and sx as ½[[1+i, 1−i], [1−i, 1+i]] with i = ω², every amplitude is an element of ℤ[ω] over a power of two. Probabilities are then elements of ℤ[√2] over 2¹⁴, and E = ±√2/2 is an equality of integer quadruples the kernel decides.
+
+**When a quantum device's counts are above the classical bound, decided on exact integers** — `quantum_hardware.lean`, 8 theorem(s). WHAT THIS DECIDES AND WHAT IT REFUSES TO SAY. Per CHSH setting i, D_i = n00 + n11 − n01 − n10 and N_i is its shots, so E_i = D_i / N_i. S > 2 is decided as D₀N₁N₂N₃ + D₁N₀N₂N₃ + D₂N₀N₁N₃ − D₃N₀N₁N₂ > 2·N₀N₁N₂N₃, with no division. The kernel decides the rule and the classical bound. It decides nothing about any device: whether a run's counts came from a quantum processor is the provider's job record, read by scripts/quantum-hardware.ts, never this file.
+
+**Every quantum computing model ISO/IEC 4879 names, one exact instance each, decided over the cyclotomic integers** — `quantum_models.lean`, 8 theorem(s). WHAT IT DECIDES. Each model at its known optimum: the one-way pattern for every π/4 angle and both outcomes, the whole group Ising braids generate (24 classes, closed), every balanced beam splitter, the adiabatic gap for every rational schedule point (proved for every value, not sampled), and the frustrated triangle's whole spectrum.
+
+**The 124-qubit Mermin sum — the UUID minus one hex digit — as eight UUID particles** — `quantum_octave_124.lean`, 8 theorem(s) — *no summary in the source*
+
+**The 128-qubit octave, split into eight UUID particles — the Mermin lead 2⁶³ at the UUID width** — `quantum_octave_128.lean`, 9 theorem(s). WHY EIGHT PARTICLES. Particle b holds the weights k with ⌊k/16⌋ = b (the last one also k = 128). Each checks that its strings' GHZ expectations are real, Re(iᵏ), and sums its share of Σ C(128, k)·Re(iᵏ)·2⟨string_k⟩. Every particle stands alone within the kernel's default budget, and this file stands apart from the other quantum files, so scripts/lean.ts checks it in a lane of its own beside them, on the machine's cores. Nothing here is a device result.
+
+**The Bell test scaled in octaves — 2, 4, 8 … 128 qubits — with the quantum lead doubling its exponent** — `quantum_octaves.lean`, 7 theorem(s). WHY 128 QUBITS FIT. The GHZ state (|0…0⟩ + |1…1⟩)/√2 has two basis states, and a string of X and Y flips every bit, so its expectation is read from two phases carried qubit by qubit — Y contributes i on the way up and −i on the way down — never from a 2¹²⁸-entry vector. The Mermin operator M = Re ∏ (X_j + iY_j) weights a string with k Y's by Re(iᵏ), and the GHZ expectation of that string is Re(iᵏ) too, so the quantum value is Σ_k C(n, k)·Re(iᵏ)², counted exactly.
+
+**qpu's quantum textbook numbers, each derived exactly from the quantum mechanics that produces it** — `quantum_textbooks.lean`, 8 theorem(s). textbook_holevo (χ ≤ 1 bit for a qubit) is not re-derived: it is an entropy, a logarithm, outside ℤ[ω]. It stands on qpu's TypeScript holevoChi and its own integer seal, and nothing here adds to or subtracts from it.
+
+**124 qubits from the UUID — the Mermin lead 2⁶¹, the odd bound, and the 124-qubit cluster state, as coins** — `quantum_uuid_cluster.lean`, 8 theorem(s). WHAT IT REFUSES TO SAY. A stabilizer state is exactly what a classical computer describes in polynomial time; that is why 124 qubits fit in this file, and why nothing here is a quantum device or its output.
+
 **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.
 
 **Digit reversal** — `reversal.lean`, 29 theorem(s). Digit reversal — arithmetic, not string handling.
@@ -480,7 +562,7 @@ this page; there is nowhere else to keep the description in step.
 
 **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.
 
-62 of 26077 declarations carry no comment of their own and are shown here as the gap they are, not
+126 of 26189 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
@@ -489,14 +571,14 @@ Read from the artefacts at build time, never carried between runs.
 
 | measure | value |
 |---|---|
-| ledger entries | 28,496 — 3562 octaves exactly |
-| standing — carries its own proof | **26077** |
+| ledger entries | 28,608 — 3576 octaves exactly |
+| standing — carries its own proof | **26189** |
 | carried — withdrawn on its own evidence, proved by a live theorem | **826** |
 | withdrawn — nothing proves it | 1,593 |
-| proved in total | **26903** of 28,496 |
-| standing keys → distinct theorems | 26077 sealed, 0 of them keyed twice, 0 unresolvable |
-| Lean files · theorems | 108 · 26077 sealed theorems (25870 closed by exhaustion, axiom-free · 207 proved for every value on propext and Quot.sound) + 0 rfl declarations |
-| proved `by decide` | 25870 of 26077 |
+| proved in total | **27015** of 28,608 |
+| standing keys → distinct theorems | 26189 sealed, 0 of them keyed twice, 0 unresolvable |
+| Lean files · theorems | 122 · 26189 sealed theorems (25979 closed by exhaustion, axiom-free · 210 proved for every value on propext and Quot.sound) + 0 rfl declarations |
+| proved `by decide` | 25979 of 26189 |
 | claims a machine can render | 103 of 1,555 |
 | claims needing an author | 1,452 — reported, never faked |
 
@@ -540,4 +622,4 @@ whether the work restates someone earlier. [The paper](/paper) typesets every st
 
 ---
 
-*20 claims, all verified · 26077 sealed theorems · 28496 ledger entries · trial root `4aaaeead-9f4f-8251-b326-ef1da131d6f9` · integrity, not truth*
+*20 claims, all verified · 26189 sealed theorems · 28608 ledger entries · trial root `4c12235a-b815-8660-947e-6d37158e16df` · integrity, not truth*

package/dist/data/baked/contradictions.json

@@ -1 +1 @@
-{"tool":"contradictions","bytes":692,"answer":"  ○ 26 theorem(s) decide arithmetic under a name claiming about the world, in a file that CLAIMS physical and publishes the computation that breaks it — claimed boldly, falsifier attached, not a lead\n\n✓ contradictions: none — 26077 theorems (25870 by exhaustion + 207 proved for every value) + 0 rfl declarations = 26077 kernel-accepted; 26077 live keys = 26077 sealed + 0 keyed twice + 0 unresolvable; no sorry, no Mathlib, no native_decide, no axiom; nothing claims a Clay problem, all 960 Clay + 280 quantum + 1020 medical and physical-force overclaim phrasings are caught while 10 honest refusals survive; and 10 proved properties are stated on the pages, not only in the sources\n"}
+{"tool":"contradictions","bytes":692,"answer":"  ○ 26 theorem(s) decide arithmetic under a name claiming about the world, in a file that CLAIMS physical and publishes the computation that breaks it — claimed boldly, falsifier attached, not a lead\n\n✓ contradictions: none — 26189 theorems (25979 by exhaustion + 210 proved for every value) + 0 rfl declarations = 26189 kernel-accepted; 26189 live keys = 26189 sealed + 0 keyed twice + 0 unresolvable; no sorry, no Mathlib, no native_decide, no axiom; nothing claims a Clay problem, all 960 Clay + 280 quantum + 1020 medical and physical-force overclaim phrasings are caught while 10 honest refusals survive; and 10 proved properties are stated on the pages, not only in the sources\n"}