On 20 November 2026 Levent Alpöge announced a proof of the Riemann Hypothesis and of GRH for Dirichlet L-functions, made with Claude and released only as a computer proof: 175,187 files of Lean, a language in which a small program, the kernel, checks every step. Done: the files are the announced ones, and Lean proofs show that the statement is exactly the textbook RH, even with ζ defined by its series rather than by Mathlib. Running now: the replay of every file, the statement judge, three kernels (two of them written independently of Lean) and five planted errors the checkers must catch. If every check passes, independent checkers will have accepted a proof of exactly the textbook statements; understanding why the argument works remains a task for mathematicians. What a computer check cannot tell you is said just as plainly.
Draft. 9 of 24 checks are still running. Every check and the rule that decides it were published before that check ran. This page rebuilds from the record as results arrive.
Last updated 2026-11-21 17:30 UTC · changes to this page
This page checks a computer proof: whether the files compile, what the theorem says, and whether independent checkers accept it. It does not judge the mathematics as mathematics, and it is not a refereed review.
Select a statement to see what it talks about.
The archive is fetched from alpo.ge and every part checked against the checksums recorded the day it appeared. Three fetches, from two continents, gave the same bytes.
Lean compiles every file. Compiling already runs the kernel on every declaration; an error anywhere would stop it.
Lean reports which axioms each theorem ultimately rests on. Anything beyond propext, Classical.choice and Quot.sound — or the placeholder sorry — would be a hole.
The whole proof is exported and re-checked by nanoda and by con-leche, two kernels written independently of Lean, and replayed by Lean’s own checker in a fresh environment. A bug in Lean’s kernel would have to be repeated in both independent ones.
Comparator, Lean’s official judge, checks that the proved theorems state exactly what our own statement file says, word for word, using Mathlib only — so no definition in the release can change their meaning.
A judge that never says no proves nothing. We planted five errors — a changed constant, a smuggled axiom, a missing proof, a hijacked definition, a corrupted proof — and every one must be rejected.
If every check passes, independent kernels accept a proof of exactly the textbook RH from the three standard axioms. That is the strongest evidence a computer can give; it is not a human understanding of why the proof works.
Every arc of the ring above is one check. Each was written down, with the rule that decides it, before it ran.
s.re = 1 / 2s.re = 1 / 3The judge must notice when the theorem proved is not the theorem asked, even by one character.
must say noComparator, the judge: “the statements do not match”
◌ running
axiom cheat : RiemannHypothesistheorem riemannHypothesis := cheatAssuming RH and calling it a proof must be caught by two different tools.
must say noComparator and Lean’s axiom report: “illegal axiom: cheat”
◌ running
theorem riemannHypothesis := sorryLean’s placeholder for “proof goes here” must never pass as a proof.
must say noComparator and Lean’s axiom report: “illegal axiom: sorryAx”
◌ running
def RiemannZetaZerosOnLine : Prop := TrueRedefining the statement as something trivially true must not slip past.
must say noComparator, the judge: “the statements do not match”
◌ running
riemannHypothesis : False-- proof unchangedThe release’s own exported proof, with its theorem re-typed as False, must fail in the independent kernel.
must say nonanoda, the second kernel: a type mismatch
◌ running
| Check | Group | State | What it means |
|---|---|---|---|
| The archive is the one announced | The bytes | decided | All 14 parts match their checksums, fetched three times from alpo.ge by two machines. |
| The GitHub mirror is the same | The bytes | computed | All 175,190 files of the mirror equal the archive; it adds a README. |
| No shortcuts in the source | The bytes | computed | No sorry, no added axiom, no native_decide, unsafe or extern code in 175,187 files. |
| The custom code was read | The bytes | read | Every place the release extends Lean was read: none inserts a declaration past the kernel. |
| Every file compiles | The build and the kernels | decided | Lean builds all 175,187 files with zero errors and no sorry. |
| Mathlib is untouched | The build and the kernels | decided | The library the proof stands on equals a clean download of the same version, file by file. |
| Only the standard axioms | The build and the kernels | decided | The five theorems rest on propext, Classical.choice and Quot.sound, and nothing else. |
| A second kernel agrees | The build and the kernels | running | nanoda, a checker written independently in Rust, re-checks the whole exported proof. |
| Lean replays its own proof | The build and the kernels | running | Lean’s checker replays every declaration in a fresh environment. |
| A third kernel agrees | The build and the kernels | running | con-leche, a third independently written checker, re-checks the export and matches it against our statement again. |
| A clean machine agrees | The build and the kernels | running | On a fresh machine that never ran the release’s code, two kernels re-check the exported proof against a statement built there. |
| Two builds compared | The build and the kernels | computed | Our compiled files compared byte for byte with Andrew Sutherland’s independent build. |
| The theorem is the one we wrote down | The statement | running | Lean’s judge, Comparator, matches the five theorems against our own statement file, which imports Mathlib only. |
| Mathlib’s RH is the classical RH | The statement | read | Read twice, by two model families: every nontrivial zero of ζ has real part 1/2. |
| Proved: it is the textbook statement | The statement | decided | A Lean proof that Mathlib’s definition is equivalent to “every zero in the critical strip lies on the critical line”. |
| Proved: ζ and L as the textbook defines them | The statement | decided | A Lean proof that the statements stay the same when ζ and the L-functions are defined by their series, not by Mathlib’s definitions. |
| GRH here means Dirichlet L-functions | The statement | read | Read twice: every modulus, every character; not other number fields. |
| The judges catch planted errors | The statement | running | Five wrong versions — a changed constant, a smuggled axiom, a missing proof, a hijacked definition, a corrupted proof — must all be rejected. |
| The August proof still checks | The context | decided | The “two thirds of the zeros” release re-checked on this Mathlib: 326 files unchanged, two kernels accept. |
| The bridges compile | The context | decided | Given RH, the August bounds move onto the critical line; and Masullo’s claim, as we read it, implies this release’s. |
| The two releases combine | The context | running | One environment holds both proofs; the combined statements pass Comparator. |
| The route inside the proof was read | The context | read | From Main.lean down, by Astra 6.2: RH from Dirichlet nonvanishing and ζ’s functional equation. |
| What the proof term really uses | The context | running | Which constants named in J. L. Nielsen’s critique are in the compiled proof. |
| Where the content lives | The context | running | The sub-proofs that feed the two key inequalities, traced in the compiled term. |