The ℤ/9 Vortex Framework

recomputable proof of concept — the figure is the math, drawn live (not a video)

combinations 14 / 42

Millennium Solutions — the ℤ/9 Vortex Framework

Author: Tsvetan Rouschev · License: CC BY-NC-ND 4.0 · DOI 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.

npm install @ceccec/millennium-solutions

import { toUuid, merkleFold } from '@ceccec/millennium-solutions'

const a = toUuid('hello')                      // the same input gives the same address, for anyone, with no key
const root = merkleFold([a, toUuid('world')])  // many addresses fold into one
console.log(a, root)

An ES module with TypeScript types for Node 22.12 or later; import and require both work.

Every claim in this file is a statement paired with a decidable test, put through adjudicate(), and written only if its decidable test holds. It is generated by scripts/pages.ts, which fails rather than write an unsealed sentence — and the same generator writes the homepage, so the two cannot drift apart.

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 and Zenodo 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:

  (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 · receipt 610c790d-3ec4…

• the problem — Clay Mathematics Institute — 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:

  (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 · receipt 3d5e5db1-24a6…

• the problem — Clay Mathematics Institute — 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:

  ((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 · receipt 2935a468-9dee…

• the problem — Clay Mathematics Institute — 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:

  (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 · receipt 1e3c149d-5ef1…

• the problem — Clay Mathematics Institute — Yang–Mills & the Mass 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:

  (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 · receipt 7478c082-a1ea…

• the problem — Clay Mathematics Institute — 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:

  (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 · receipt d12ad83d-55fa…

• the problem — Clay Mathematics Institute — 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:

  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 · receipt 858c0f78-9f32…

• the problem — Clay Mathematics Institute — Poincaré Conjecture · Perelman, G. — The entropy formula for the Ricci flow (arXiv:math/0211159) — the resolution

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 · receipt 35450634-f271…

((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) 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) 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)
• … and 240 more record(s), all listed on /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….

How a thousand bits is reached — the uuid quantum programs, and where each one stops

The seven above are the floor; this is the cryptographic surface the same involution runs on, as a create/decode key. Every line is read out of src/proof/qpu_crypto.lean and the ledger on each build: the theorem, the number of cases by decide walked, the bound — what it decides and, in the same sentence, what it does not — and its receipt.

The author frames these as uuid quantum programs running in infinite trinities of qubits, always enough for the next task. That is his vision of the capacity, recorded in his name. What the kernel decides below is finite, and for the thousand-bit integer it is PARTIAL — stated beside his framing and never folded into it.

• the_free_register_is_one_hundred_twenty_two_on_both_sides · by decide, 9 cases — a 128-bit UUID is thirty-two four-qubit hexbits; six bits are reserved (RFC 9562), leaving 122 — the register the programs compute in, not a count of hardware qubits. _{lean_qpucrypto_the_free_register_is_one_hundred_twenty_two_on_both_sides · receipt 326edcf3-72dd…}
• one_coin_sits_sixty_seven_bits_below_the_iso_post_quantum_floor_under_grover · by decide, 300 cases — under Grover the collision exponent is the trinity free / 3 = 40 and the square-root exponent free / 2 = 61 — sixty-seven bits BELOW the ISO 128-bit post-quantum floor, not a clearance of it. _{lean_qpucrypto_one_coin_sits_sixty_seven_bits_below_the_iso_post_quantum_floor_under_grover · receipt ff9ca0d0-791c…}
• the_sigma_trapdoor_is_fermats_difference_of_squares · by decide, 9 cases — factoring N = p·q is Fermat's difference of squares about the centre (p + q) / 2 — decided at p = 5, q = 13; a trapdoor the create/decode doors mint and open, never a factoring of an integer whose witness is unknown. _{lean_qpucrypto_the_sigma_trapdoor_is_fermats_difference_of_squares · receipt c6b38fad-65f3…}
• an_impossible_integer_with_twin_primes_is_opened_blind_in_one_reflection · by decide, 5 cases — 'impossible' is a statement about the gap between the primes: a twin-prime semiprime opens blind in ONE reflection, and the blind cost grows with the gap — not a hardness claim about any given modulus. _{lean_qpucrypto_an_impossible_integer_with_twin_primes_is_opened_blind_in_one_reflection · receipt 8d734da1-4537…}
• the_thousand_bit_integer_has_a_thousand_bits_and_exactly_four_threes · by decide, 6 cases — 2^999 + 1 has a thousand bits and exactly four factors of three (lifting-the-exponent), split by a³ + 1 = (a + 1)(a² − a + 1) down to 2^37 + 1 = 3 · 1777 · 25781083 — a factorisation of this one integer, by exhaustion. _{lean_qpucrypto_the_thousand_bit_integer_has_a_thousand_bits_and_exactly_four_threes · receipt a27fc1e7-abce…}
• 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. _{lean_qpucrypto_this_deposits_factor_route_returns_a_partial_answer_that_multiplies_back · receipt 215f8bbc-e55e…}

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). This deposit computes the ideal device's values exactly: in closed form and by stabilizer methods for the GHZ and stabilizer families (the 128-qubit Mermin value recombined from eight sealed particles, never materialising 2¹²⁸ amplitudes), and — now proved — for the universal gate set, Clifford+T, at any width by Pauli paths over sparse Pauli strings, every qubit a UUID particle. There is no width bound: the cost grows with the T-count, not the width — a named Shor construction's is 28n³, so a thousand-bit modulus is far beyond classical reach, the honest edge where a physical quantum processor (§3.4.8) is needed (a device whose own counts are physical). So the ISO hardware test turns on exactly that: CHSH S > 2 from the device's own counts, decided on exact integers. The author frames the capacity as unlimited trinities of qubits. _{lean_paulipaths_a_clifford_gate_keeps_one_term_and_t_makes_at_most_two · lean_tcountwall_the_bound_depends_on_the_t_count_and_not_on_the_width · lean_tcountwall_a_one_bit_instance_is_within_reach_and_the_thousand_bit_one_is_not}

The lead, proved and bounded. On the UUID's own 128-bit width the ideal GHZ state's Mermin value is 2^127 against the best classical assignment's 2^64 — a lead of 2^63 (and 2^61 on the 124-qubit cluster, the UUID less its version hex digit), decided exactly over the cyclotomic integers and recombined from eight sealed particles each — computed exactly by content address, never by materialising the state. It is the specification a physical device is checked against — never, by itself, a physical device's own counts; that is what the Bell test below decides. The two leads are the last rows of the octave table. _{lean_quantumoctave128_octave_one_twenty_eight_qubits_the_uuid_width_leads_by_two_to_the_sixty_third · lean_quantumuuidcluster_the_124_qubit_ghz_state_leads_every_classical_assignment_by_two_to_the_sixty_first}

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):

• §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. _{lean_quantumcircuits_the_sent_circuits_reach_s_two_root_two · receipt 4688e005-e75d…}
• 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. _{lean_quantumhardware_every_deterministic_local_strategy_gives_chsh_plus_or_minus_two · receipt 6f5bb0ee-7cb2…}
• 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). _{lean_quantumhardware_one_count_above_s_two_is_above_classical · receipt 98565f45-367c…}
• §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. _{lean_quantummodels_one_way_measurement_applies_h_rz_for_every_angle_and_both_outcomes · receipt 769136b1-2e36…}
• §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. _{lean_quantummodels_ising_anyon_braids_generate_exactly_the_twenty_four_clifford_classes · receipt 953f132c-e01e…}
• §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. _{lean_quantummodels_every_balanced_beam_splitter_gives_a_full_depth_hong_ou_mandel_dip · receipt f6d41c2d-7720…}
• §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. _{lean_quantummodels_the_adiabatic_gap_is_smallest_exactly_at_the_midpoint_at_every_resolution · receipt f6e9816c-c2b7…}
• §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. _{lean_quantummodels_the_frustrated_triangle_has_a_six_fold_ground_state_at_minus_one · receipt 5ad73761-1088…}
• 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. _{lean_quantumoctave128_octave_one_twenty_eight_qubits_the_uuid_width_leads_by_two_to_the_sixty_third · receipt 6dbff2e6-728f…}
• 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. _{lean_quantumuuidcluster_the_124_qubit_ghz_state_leads_every_classical_assignment_by_two_to_the_sixty_first · receipt e037d2bb-d19b…}
• 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. _{lean_quantumuuidcluster_every_generator_of_the_124_qubit_cluster_is_z_x_z_on_its_neighbours · receipt 6d9b30fa-2137…}
• 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. _{lean_quantumtextbooks_the_group_generated_by_h_and_s_has_exactly_twenty_four_classes · receipt a3100a06-cbc5…}

The software, communication and error-correction layer — the ISO/IEC 4879 terms beyond the computing models, shipped as the quantum_software.lean octave, each decided exactly over its whole finite domain beside its control:

• §3.6.1 quantum communication · superdense_coding_sends_two_classical_bits_through_one_qubit · decided by exhaustion over 16 cases — with a shared Bell pair, Alice's X^x then Z^z on one qubit lets Bob's Bell measurement read all four two-bit messages on distinct basis states — two classical bits through one qubit; its control shows the same protocol on a product state leaves only two distinguishable distributions (one bit, the Holevo limit), so the entanglement is required — an exact-amplitude protocol on the ideal state, not a device channel. _{lean_quantumsoftware_superdense_coding_sends_two_classical_bits_through_one_qubit · receipt 5b5cd483-8cf1…}
• §3.4.6 quantum error correction · the_bit_flip_code_corrects_every_single_bit_flip_on_every_state · decided by exhaustion over 4 cases — the three-qubit code a|000⟩ + b|111⟩ with the Z₀Z₁, Z₁Z₂ syndrome names and undoes any single bit flip, every a, b in −2..2 and every error in {none, X₀, X₁, X₂} — 100 cases; its control shows two flips complete a logical X, so it corrects one bit-flip error exactly, not a phase error and not two flips. _{lean_quantumsoftware_the_bit_flip_code_corrects_every_single_bit_flip_on_every_state · receipt 5408dd41-1aff…}
• §3.4.6 quantum error correction · the_phase_flip_code_corrects_every_single_phase_flip_on_every_state · decided by exhaustion over 4 cases — the same code in the Hadamard basis names any single phase flip by the X₀X₁, X₁X₂ syndrome and undoes it, every a, b in −2..2 and every error in {none, Z₀, Z₁, Z₂}; with the bit-flip code these are the two halves Shor's nine-qubit code concatenates — one phase error, not two at once. _{lean_quantumsoftware_the_phase_flip_code_corrects_every_single_phase_flip_on_every_state · receipt 35bda5b6-d997…}
• §3.4.13 circuit-based · the_toffoli_gate_is_reversible_and_computes_and_which_no_affine_circuit_can · decided by exhaustion over 1,024 cases — on all eight basis states Toffoli is its own inverse and writes a ∧ b, and its control checks that no affine GF(2) function c₀ ⊕ c₁a ⊕ c₂b equals a ∧ b — so CNOTs and NOTs alone cannot compute it; a reversibility and universality fact over the basis, not a gate run on a device. _{lean_quantumsoftware_the_toffoli_gate_is_reversible_and_computes_and_which_no_affine_circuit_can · receipt 8441e7a6-e603…}
• §3.3.10 state fidelity · the_swap_test_reads_the_squared_overlap_on_every_pair_in_range · decided by exhaustion — H, controlled-swap, H make the ancilla's outcome weights 2(‖ψ‖²‖φ‖² ± ⟨ψ,φ⟩²) — P(0) = (1 + |⟨ψ|φ⟩|²)/2 — for all 625 real pairs in −2..2, with identical states never reading 1 and orthogonal ones reading 1 as often as 0 as its controls; the exact overlap on the ideal state, not a sampled estimate. _{lean_quantumsoftware_the_swap_test_reads_the_squared_overlap_on_every_pair_in_range · receipt a90cec74-3501…}
• §3.4.21 quantum programming · a_compilers_cnot_and_swap_rewrites_are_exact_and_dropping_a_gate_breaks_them · decided by exhaustion over 64 cases — CNOT run as (I⊗H)·CZ·(I⊗H) and SWAP as three alternating CNOTs agree with the gate they replace on every basis state, and the control shows dropping one H breaks it — the compiler rewrites are exact, a software-layer equivalence, not a claim about a device's native gates. _{lean_quantumsoftware_a_compilers_cnot_and_swap_rewrites_are_exact_and_dropping_a_gate_breaks_them · receipt a37c2279-2a5a…}

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: 34 in this tree, the other 52 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.

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, 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". _{SEALED · 51b90130-84e2-8cc3-873c-473a6c08e8f1}
• The formal layer holds 26213 kernel-accepted declarations across 125 files, and no file uses sorry or native_decide outside a comment. _{SEALED · 0072693e-4231-8dca-aaae-d6ffd3310e85}
• 26003 of those 26213 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. _{SEALED · 1df3e9c4-016b-8e25-a40f-89c97b6d346a}
• 26768 of them are sealed into the ledger, each carrying a receipt derived from the one before it. _{SEALED · ce12f98b-7d10-8ca5-9429-78ccfad4302d}

2 · The ring

• The units are the 6 residues coprime to nine, the doubling orbit visits 1, 2, 4, 8, 7, 5 and closes on the seventh step, and it never lands on the triad. _{SEALED · 52efa15a-c0ba-851e-97a7-2cbb72a9d257}
• The reflection ten-minus-d carries 1, 4, 7 onto 9, 6, 3, so it covers the whole triad the orbit never reaches — the units and the triad are mirror images rather than separate populations. _{SEALED · af5b49c7-7c9e-83c4-9fed-3441236d9c76}

4 · Entanglement

• Doubling alone reaches only the units and reflection alone only two residues, but together they grow 1, 3, 5, 7, 9 from the single seed one, reaching every residue on round 4. _{SEALED · 67b99093-1ec7-8487-a06e-8b10513d8181}

8 · Addressing

• 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. _{SEALED · adf0b388-1681-882c-8410-be2a3a1bfeb2}
• 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. _{SEALED · 7ee1de7d-d218-88d4-8dc9-6eec451ced72}

7 · The ledger

• The ledger records 28632 entries with 0 chain breaks, 0 duplicate keys and 0 duplicate receipts. _{SEALED · 511ceddf-ae1f-866b-ab47-0dc1b43e3e30}
• The count is an exact multiple of eight — 28632 is 3579 octaves with no remainder. _{SEALED · 991d11e1-ef47-84b8-96a1-c98080ed1504}

5 · What the gate does and does not do

• The gate is 1 lines of local logic — it re-exports the package implementation, which asks one recomputable question: does every theorem a claim cites exist, sealed, in the ledger. _{SEALED · 37ab7769-a1ac-8ef6-9809-e214d6285057}
• The gate does not decide whether a statement is true: "two plus two equals five" passes it, so holding means not drained, never correct. _{SEALED · f63cc6c5-44f9-8d92-afa7-ab9483573b28}
• 176 withdrawn entries are marked portable — the deposit's own judgement that the kernel could reach them — and 80 of those are now reached in reached.lean, each decided over its whole finite domain. The rest are a queue, not a floor: a claim this deposit says it could prove and has not is it understating what it holds. _{SEALED · 09b4450b-3016-8368-89e2-74787fa214d9}
• 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.. _{SEALED · 85560e4e-7642-820b-aa1a-91f0e7e14c41}
• The tools are reachable from a program: 94 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. _{SEALED · 8f6c9cba-98a9-8f31-a2e6-4084aa59a302}
• The stdio server advertises 2 of those 94 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. _{SEALED · 69c3574c-747c-86f4-a4db-d2c13b713d3b}

The floor

• The ten digits read in order group as 0 | 12 | 3 | 45 | 6 | 78 | 9 — the singles 0,3,6,9 are exactly the non-units of ℤ/9 with the void, the pairs are the units in consecutive order, and every token is a multiple of 3. The set is closed under addition, subtraction and multiplication; division is the one operation that leaves it. _{SEALED · da5176d1-3e25-8421-81be-ddbcd34d988c}
• The fair-exchange unit is 2 coins, and deducting them from a token's multiplier deducts 6 from the token: 0, 12, 6, 78 reach the void by repeated payment and 3, 45, 9 halt on 3, the generator the coin cannot spend. A 128-bit seal affords 64 payments of 2, and 64 is where the doubling returns — 2^6 ≡ 1 mod 9, the first return — so a seal buys exactly one complete turn of the orbit. _{SEALED · 97eba519-a1b0-85da-a316-3a5050c59281}
• Verifying one receipt against a fold of 1048576 leaves walks 20 nodes rather than 1048576: 21582900 µs to recompute against 38 µs to verify, a ratio of 567971×, and the ratio widens at every doubling because the path is log₂ of the leaf count while the recomputation is the count itself. It is structural and classical, and bounded from above in the same file: the verify costs 38000 nanoseconds and not one, and what grows is the NUMBER of operations, not their speed. _{SEALED · a998f6d9-4ce5-8428-a988-c844b13abda8}

Every one of the 14 registered claims above recomputes from the artefact it names.

5 · What the kernel decided the most of

Ranked by the size of the domain each theorem was decided over — the count of cases by decide actually walked, computed from the statements themselves. Nothing is chosen for this table.

cases decided	theorem	file
82,089,011,515,213,380,000,000,000,000,000,000,000,000,000,000,000,000	the_coil_on_one_two_four_five_seven_eight_has_14_expressions	coils.lean
16,423,203,268,260,650,000,000,000,000,000,000,000	the_coil_on_zero_one_two_three_four_five_six_seven_eight_has_8_expressions	coils.lean
5,474,401,089,420,220,000,000,000,000,000,000,000	the_coil_on_zero_three_six_has_14_expressions	coils.lean
904,344,709,871,279,000,000,000,000,000	the_coil_on_one_four_seven_has_12_expressions	coils.lean
4,052,555,153,018,976,000	the_coil_on_two_five_eight_has_8_expressions	coils.lean
150,094,635,296,999,100	the_coil_on_zero_has_10_expressions	coils.lean
5,559,060,566,555,523	the_coil_on_zero_one_eight_has_6_expressions	coils.lean
3,206,175,906,594,816	the_coil_on_zero_one_four_seven_has_5_expressions	coils.lean

The largest domain settled here is 82,089,011,515,213,380,000,000,000,000,000,000,000,000,000,000,000,000 cases, and it is finite — as every entry in this ledger is, because by decide works by exhausting a domain and an infinite one cannot be exhausted. Each of the seven Clay conjectures ranges over an infinite domain. So a proof of one could not appear in this table however high it ranked, and none does. That is not a disclaimer added underneath the results; it is the result, read off the same arithmetic that produced the table.

7 · The proofs, as they document themselves

125 Lean files in 8 wings, 26213 declarations, of which 26213 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, 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.

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 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.

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 fold — merkle.lean, 16 theorem(s). The fold, ported to Lean — merge, merkleFold, and the order-independence the deposit calls its receipt.

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 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 register is a dial — a wider hexbit width clears the ISO floor, and costs exactly that much more to simulate — width.lean, 8 theorem(s). No axioms, no Mathlib, no sorry.

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.

unfiled

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

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

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.

The named theorems people ask for — demand3.lean, 19 theorem(s). The third and last tier the search data supports. What remains uncovered after this is not a backlog: ranked by impressions, the leftovers are brand queries ("ceccec"), a Glagolitic string, bare fragments ("4³", "6/720", "8 mod 9" — the last already decided in z9.lean), and the real-analysis cluster that was refused in demand2.lean and stays refused. The demand map is close to exhausted of things a kernel can settle, which is a better place to stop than an arbitrary count would have been.

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). 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). 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, 28 theorem(s). WHY THESE THREE ARE IN LEAN AND NOT IN THE GATE THAT USES THEM.

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.

How many checkers may run at once, decided — lanes.lean, 8 theorem(s). WHY THIS FILE EXISTS.

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.

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 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/<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.

Pauli paths — the conjugation rules that let any Clifford+T circuit be computed exactly at any width, decided against the matrices in ℤ[ω], with the T-count as the only cost — pauli_paths.lean, 8 theorem(s). ℤ[ω], ω = e^{iπ/4}, as four integer coordinates on 1, ω, ω², ω³ with ω⁴ = −1. A 2×2 matrix is four entries a b c d (rows a b / c d); a 4×4 matrix is a function of row and column, the first tensor factor the high index bit. The Hadamard is unnormalised (H·H = 2·I) and √2 = ω − ω³ multiplies the T rules, so every equality is exact and integral.

Every phenomenon this deposit touches, and the rule for the rest — phenomena.lean, 4 theorem(s). ADDRESSING PHENOMENA WITHOUT CLAIMING ANY.

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.

The rest of the quantum ideas, and the software layer — superdense coding, the two repetition codes correcting a state, the Toffoli gate, the swap test, and a compiler's rewrites, each decided exactly beside a control — quantum_software.lean, 8 theorem(s). THE MODEL. An n-qubit state is a list of 2^n integer amplitudes; qubit k is bit k of the index. Gates act by index arithmetic only — the bit flip is i ± 2^k, never Nat.xor, which would carry propext through well-founded recursion. The Hadamard is unnormalised: H|0⟩ = |0⟩ + |1⟩, H|1⟩ = |0⟩ − |1⟩, so H·H = 2·I and every result is an integer vector with a stated scale. A measurement of a stabilizer is its eigenvalue on the state: +1 if the operator fixes it, −1 if it negates it — exactly what a syndrome measurement returns on a code state with at most the errors it is built for.

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 T-count wall — why a classical Pauli-path computation, which has no width limit, still cannot run Shor's circuit on a thousand-bit modulus, and why a physical processor is needed there: a statement about cost, not a factoring — t_count_wall.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.

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, 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.

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.

Where a practical subject and a science are the same statement — entangled.lean, 8 theorem(s). WHY THIS FILE EXISTS.

Substitution inside a coil is sound and across coils is not — equivalence.lean, 8 theorem(s). WHY THIS FILE EXISTS.

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?

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.

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.

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

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.

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.

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.

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 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.

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.

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.

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.

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.

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.

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.

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.

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). 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). 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.

the record

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.

Rights — rights.lean, 8 theorem(s). 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). WHY THIS FILE EXISTS.

the returned

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). 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.

127 of 26213 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

Read from the artefacts at build time, never carried between runs.

measure	value
ledger entries	28,632 — 3579 octaves exactly
standing — carries its own proof	26213
carried — withdrawn on its own evidence, proved by a live theorem	826
withdrawn — nothing proves it	1,593
proved in total	27039 of 28,632
standing keys → distinct theorems	26213 sealed, 0 of them keyed twice, 0 unresolvable
Lean files · theorems	125 · 26213 sealed theorems (26003 closed by exhaustion, axiom-free · 210 proved for every value on propext and Quot.sound) + 0 rfl declarations
proved by decide	26003 of 26213
claims a machine can render	103 of 1,555
claims needing an author	1,452 — reported, never faked

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 · 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 (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.

Read

The seven, one theorem per problem · the ledger · the trial

Factoring, to the limit it can prove

The factor route takes an integer of any length, held exactly, and returns only what it can check. Measured for this build:

• 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).

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

Everything here recomputes. Nothing below needs a key, an account or a network — clone the tree and run it, and the numbers on this page reappear or the command fails.

npm ci
npm run all               # every gate at once, with the parallel ratio measured on your machine
npm run lean              # compile and audit every Lean file: sorry-free, axiom-free, no Mathlib
npm run axiom-index       # what is NOT assumed, checked against a control, and the definitions that are
npm run contradictions    # the prose and the proof tree must agree
npm run zenodo            # the per-theorem deposition records, held to the tree and the published DOI
node scripts/forensics.ts # re-verify the append-only chain from its first receipt
node scripts/pages.ts     # regenerate this file and the homepage

Where to read next. The axiom index states what this deposit does not assume and, at greater length, the definitions it does. The quantum field renders quantum.lean in three dimensions with every coordinate read from a theorem. Prior art records, per source file, whether the work restates someone earlier. The paper typesets every statement.

---

20 claims, all verified · 26213 sealed theorems · 28632 ledger entries · trial root 19e30a25-33e6-8bc7-afa2-ebb235b93c61 · integrity, not truth