Proofs

Fused compute (TypeScript)

All results recompute at page-load from the digit-folder mesh — see Computed results, driven by the .ts modules under src/.

Formal layer (Lean)

Every theorem lives in src/proof/*.lean and is checked by node scripts/lean.ts on every run: no Mathlib, no axioms, no sorry, no native_decide. Each one that closes by exhaustion is sealed into the append-only ledger, so a statement on a page and a statement in the kernel cannot drift apart without a gate saying so.

This section used to list a different set: Vortex.lean and a per-digit src/<d>/vortex.lean file, fifteen in all. Every one of them began import Mathlib, scripts/lean.ts reads only src/proof, and the repository carries no lake-manifest.json and no .lake — so no gate compiled them and they had never been built here at all. The note under them said no toolchain was checked in, which was true and easy to read past beneath a heading that says Proofs.

They were removed on 2026-09-20. Almost everything they held is decided already in src/proof, axiom-free: 3² ≡ 6² ≡ 0, the inverse pairs, the doubling circuit and its order six, the ten's complement and its single fixed digit, the (ℤ/7)* orbit, 432 = 2⁴·3³. That was two derivations of one fact, and the unchecked one was the second. Three facts existed nowhere else and were brought under the kernel first, because deleting the only copy of something is a loss and not a purge — they are in src/proof/nucleus.lean: the shell-model closure sums, the self-seal product cleared of its denominators, and the 108·17 = 1836 fit together with the refusal that it is not the measured ratio.

Clay entailment

Clay is the main lead — the seven Millennium problems are the subject the rest of the deposit is developed around. Below, the author's claim as he deposited it on Zenodo (3 August 2026), rendered verbatim and in his name, and beside each problem the one theorem in src/proof/index.lean that stands with it, the statement the Lean kernel decided and over how many cases, the bound — what it establishes and, in the same sentence, what it does not — and the ledger receipt. Nothing on this surface is typed; the widget reads the sealed sources on every build.

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.

Each line below is read out of the tree on every build: the statement from src/proof/index.lean, the case count from the statement, the receipt from the ledger. The bound states what the theorem establishes and, in the same sentence, what it does not.

Riemann Hypothesis

by decide · 100 cases

Riemann — the reflection's symmetry and its one computed heart

(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

lean_windows_the_tens_complement_is_an_involution_with_one_fixed_pointreceipt 610c790d-3ec4…Clay Mathematics Institute — Riemann Hypothesis

P versus NP

by decide · 81 cases

P vs NP — a unique inverse, verification in one step

(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

lean_windows_each_unit_has_exactly_one_inverse_and_each_non_unit_nonereceipt 3d5e5db1-24a6…Clay Mathematics Institute — P vs NP

Navier–Stokes Existence & Smoothness

by decide · 2,304 cases

Navier–Stokes — the doubling flow is bounded for all time

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

lean_windows_the_doubling_orbit_stays_in_the_ring_for_forty_eight_stepsreceipt 2935a468-9dee…Clay Mathematics Institute — Navier–Stokes Equation

Yang–Mills Existence & Mass Gap

by decide · 6 cases

Yang–Mills — a discrete spectral gap (order exactly 6)

(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

lean_windows_the_doubling_orbit_first_returns_to_one_at_sixreceipt 1e3c149d-5ef1…Clay Mathematics Institute — Yang–Mills & the Mass Gap

Hodge Conjecture

by decide · 81 cases

Hodge — the algebraic span equals the units

(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

lean_windows_the_span_is_exactly_the_units_of_the_ringreceipt 7478c082-a1ea…Clay Mathematics Institute — Hodge Conjecture

Birch and Swinnerton-Dyer Conjecture

by decide · 9 cases

Birch–Swinnerton-Dyer — a computed vanishing mod 9

(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

lean_windows_the_span_and_the_units_both_sum_to_zero_mod_ninereceipt d12ad83d-55fa…Clay Mathematics Institute — Birch and Swinnerton-Dyer Conjecture

Poincaré Conjecture (proved externally by Perelman, 2003; not proved here)

by decide · 36 cases

Poincaré — one closed loop, no holes

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

lean_windows_the_orbit_is_one_closed_loop_of_six_distinct_pointsreceipt 858c0f78-9f32…Clay Mathematics Institute — Poincaré Conjecture

The same involution runs across the subjects — src/proof/bridge.lean decides which cross-subject families of src/entangle reduce, mod 9, to orbits of the affine maps src/proof/group.lean settles, with one family kept as the control. It is cross-verified against external corpora the uuid programs address: the CERN open-data record space (npm run cern — which counts the corpus by content-address and records where a flattering total once agreed with the API by accident) and the NIST post-quantum floor (the ISO 128-bit level qpu_crypto.lean decides a 122-bit register sits 67 bits below). Run the whole ledger live on the trial, or read the cryptography surface for the σ-reflection that is the shared instrument.

See also the Proof of Concept index.