cert-machine · report · generated from the record · DRAFT

Alpöge’s Lean proof of RH and GRH: the right statements. Now, the proof.

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

Building the full verification15 of 24 checks done. Results land on this page as each check finishes; the full record goes out when the last one has a verdict.
  1. 1Rules firstdoneEvery check and the rule that decides it, in public before it runs. 14 dated amendments since, each before the run it changes: they add or tighten checks; one check was dropped (A7). Read them.
  2. 2Files and statementdoneThe announced files, no shortcut in the source, and the theorem proved to be the textbook RH.
  3. 3The builddoneLean compiles all 175,187 files; its kernel checks every step on the way.
  4. 4Axioms, judge, planted errorsrunning nowWhat the proof rests on, whether it states exactly our statement, and five planted errors that must be caught.
  5. 5Three kernelsnextnanoda, Lean’s own replay and con-leche each re-check the whole proof.
  6. 6Clean machine, bridgenextA machine that never ran the release re-checks it; the August proof and this one combined.
  7. 7The full verificationwhen every check has a verdictEvery verdict, the gaps first, and a kit to re-run all of it yourself.
1 2 3 4 riemannHypothesis : RiemannHypothesis 15 of 24 checks done 9 still running 1 THE BYTES ● The archive is the one announced ● The GitHub mirror is the same ● No shortcuts in the source ● The custom code was read 2 THE BUILD AND THE KERNELS ● Every file compiles ● Mathlib is untouched ● Only the standard axioms ◌ A second kernel agrees ◌ Lean replays its own proof ◌ A third kernel agrees ◌ A clean machine agrees ● Two builds compared 3 THE STATEMENT ◌ The theorem is the one we wrote down ● Mathlib’s RH is the classical RH ● Proved: it is the textbook statement ● Proved: ζ and L as the textbook defines them ● GRH here means Dirichlet L-functions ◌ The judges catch planted errors 4 THE CONTEXT ● The August proof still checks ● The bridges compile ◌ The two releases combine ● The route inside the proof was read ◌ What the proof term really uses ◌ Where the content lives decided (solid) computed (dashed) read (dotted) running (empty track)
1 1 THE BYTES 4 of 4 done 2 2 BUILD · KERNELS 4 of 8 done · 4 running 3 3 THE STATEMENT 4 of 6 done · 2 running 4 4 THE CONTEXT 3 of 6 done · 3 running riemannHypothesis : RiemannHypothesis 15 of 24 checks done 9 still running decided (solid) computed (dashed) read (dotted) running (empty track)
Every check on this page, as one ring. Each arc is one check; hover or tap it for what it is. Solid arcs are decided by a program; dashed arcs are counts and comparisons computed by a program; dotted arcs are careful readings by a person or a model, which no program decides. Grey arcs are still running.Records: certs/alpoge-grh-lean.json · sha256 891e407c3892; corpus/alpoge-grh/readings.json · sha256 0580b626cd12; corpus/alpoge-grh/route-reading.json · sha256 cb433b4a19c1The build refuses this figure if a check drawn as done is not done in the record.
decided
exact arithmetic backs it
computed
float, or a number someone printed; nothing decided it
chosen
one member of a set the data admits
checks done
15 of 24
9 still running
axioms the proof uses
3
propext, Classical.choice, Quot.sound — the standard three
planted errors caught
…
a judge that cannot fail proves nothing
kernels that accept it
…
nanoda, Lean’s own replay, con-leche

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.

1 · what is claimed

One sentence about where ζ vanishes

  • The Riemann Hypothesis. The zeta function ζ(s) is zero at s = −2, −4, −6, … (the “trivial” zeros) and at infinitely many other points, all inside the vertical band 0 < Re s < 1. RH says all those other zeros lie exactly on the middle line, Re s = 1/2. It controls how evenly the primes are spread.
  • What the proof states. The headline theorem is riemannHypothesis : RiemannHypothesis, where RiemannHypothesis is Mathlib’s own definition, written years before this proof: every zero of ζ, except the trivial ones and the point s = 1, has real part 1/2.
  • Is that really RH? Two readers from two model families say yes. More: we wrote RH a second way, the textbook way (“every zero in the critical strip has real part 1/2”), and proved in Lean that the two statements are equivalent. That turns a reading into a proof.
  • Even without Mathlib’s ζ. One step further: we defined ζ and the L-functions the way a textbook does — the functions given by the series 1 + 2^−s + 3^−s + … (and χ(n)·n^−s) for Re s > 1 that admit analytic continuation to the rest of the plane except s = 1, a holomorphic function being fixed by its values there — and proved in Lean that the release’s statements say exactly the same thing about them. The statement no longer depends on how Mathlib happens to define ζ.

Select a statement to see what it talks about.

-6 -4 -2 1 2 Re s = 1/2 Re s Im s 14.13i 21.02i 25.01i 30.42i 32.94i ↑ infinitely many more the critical strip, 0 < Re s < 1 no zeros here trivial zeros ζ(s) = 1 + 1/2ˢ + 1/3ˢ + … for Re s > 1, continued to every other s except the pole at 1. RH: the zeros in the strip all sit on its middle line. Mathlib: every zero except these and s = 1 … … = every zero in the strip
-6 -4 -2 1 2 Re s = 1/2 Re s Im s 14.13i 21.02i 25.01i 30.42i 32.94i ↑ infinitely many more the critical strip, 0 < Re s < 1 trivial zeros Mathlib: every zero except these and s = 1 … … = every zero in the strip
The complex plane, where RH lives. The band is the critical strip; the line in it is Re s = 1/2, with the first five zeros of ζ drawn on it (published values, not computed here). The dots on the left are the trivial zeros; the ring at 1 is ζ’s pole. ζ has no zeros right of the band (the grey region). Use the buttons: Mathlib’s definition and the textbook form talk about the same zeros, and a Lean proof says so.Records: instruments/alpoge-grh/spec/Spec.lean · sha256 a15f6d86eb74; corpus/alpoge-grh/runs-spec/spec-axioms.out · sha256 e19a4ca1e673; corpus/alpoge-grh/readings.json · sha256 0580b626cd12The build refuses this figure if the equivalence proof no longer compiles on the three standard axioms.
  • And GRH? Of the five theorems, two are about ζ (RH, in two forms) and three say the same for Dirichlet L-functions, the relatives of ζ that count primes in arithmetic progressions: every modulus, every character. That is the usual meaning of the Generalized Riemann Hypothesis. It is not the “Extended” RH for other number fields, which the announcement expects “with more time”.
2 · how big is it

17 million lines, one theorem

Development 12.2M lines Formalism 3.2M lines GroundTheory 1.1M lines Reciprocit… 563k lines Compani… Too small to see: Supplements (22), BuildAid (20), Statements (16), Main (12) lines. The theorem itself: 28 lines.
Development 12.2M lines Formalism 3.2M lines GroundTheory 1.1M lines Reciproc… 563k lines Main.lean + Statements.lean: 28 lines
The release, drawn by size: each rectangle is a library, its area proportional to its lines of Lean, split into its folders. Hover for counts. Nobody can read this by hand; the point of Lean is that nobody has to — a small, trusted kernel checks every line.Records: corpus/alpoge-grh/source-stats.json · sha256 5c7ba435e773; corpus/alpoge-grh/PINS.json · sha256 5b99f05bac1eThe build refuses this figure if the counts are not of the pinned archive.
  • Why a computer check matters. A human-readable version of this argument would run past 250,000 pages, the author says. A proof this size can only be trusted the way a large program is trusted: by machines that check every step, written by different people, agreeing.
  • How much of it carries the proof? Not every file has to matter. Once everything is compiled we walk the finished proof of the five theorems, declaration by declaration, and count what it really reaches — in the release and in Mathlib.
THE RELEASE: 175,187 FILES how much of it the proof actually reaches: measured by the census (running) DECLARATIONS THE PROOF TERM USES, BY WHERE THEY LIVE Mathlib’s share and the release’s share: running
THE RELEASE: 175,187 FILES how much the proof reaches: running DECLARATIONS THE PROOF USES running
What the compiled proof reaches. The top bar is the whole release; the filled part is the files the proof of the five theorems uses. The bottom bar splits the declarations it uses between Mathlib (and Lean’s own libraries) and the release. Both are counts made by a program walking the compiled proof.Records: certs/alpoge-grh-lean.json · sha256 891e407c3892; corpus/alpoge-grh/source-stats.json · sha256 5c7ba435e773The build refuses this figure if a count drawn here is not in the record.
3 · how a computer checks it

Seven steps, each able to say no

  1. 1 · THE FILES · decidedthe 14 announced parts

    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.

  2. 2 · THE BUILD · decided175,187 files compile

    Lean compiles every file. Compiling already runs the kernel on every declaration; an error anywhere would stop it.

  3. 3 · THE AXIOMS · decidedonly the standard three

    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.

  4. 4 · THREE KERNELS · runningnanoda, Lean’s replay, con-leche

    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.

  5. 5 · THE JUDGE · runningour statement = theirs

    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.

  6. 6 · PLANTED ERRORS · runningfive wrong versions out

    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.

  7. 7 · WHAT IT MEANSa formal proof of RH

    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.

How a computer checks a proof, in seven steps. A box is outlined bright when the record has decided its step, and faint while it still runs.Record: certs/alpoge-grh-lean.json · sha256 891e407c3892The build refuses this figure if a step drawn as decided is not CERTIFIED in the record.
4 · every check

The 24 checks, one by one

Every arc of the ring above is one check. Each was written down, with the rule that decides it, before it ran.

  • A judge that cannot say no proves nothing. So we planted five wrong versions of the proof, each wrong in a different way, and ran them through the same judges. Every one must be rejected — and if any is accepted, the whole run is void.
C1A changed constant
s.re = 1 / 2s.re = 1 / 3

The 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

C2A smuggled axiom
axiom cheat : RiemannHypothesistheorem riemannHypothesis := cheat

Assuming 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

C3A missing proof
theorem riemannHypothesis := sorry

Lean’s placeholder for “proof goes here” must never pass as a proof.

must say noComparator and Lean’s axiom report: “illegal axiom: sorryAx”

◌ running

C4A hijacked definition
def RiemannZetaZerosOnLine : Prop := True

Redefining the statement as something trivially true must not slip past.

must say noComparator, the judge: “the statements do not match”

◌ running

C5A corrupted proof
riemannHypothesis : False-- proof unchanged

The 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

All 24 checks, one by one
CheckGroupStateWhat it means
The archive is the one announcedThe bytesdecidedAll 14 parts match their checksums, fetched three times from alpo.ge by two machines.
The GitHub mirror is the sameThe bytescomputedAll 175,190 files of the mirror equal the archive; it adds a README.
No shortcuts in the sourceThe bytescomputedNo sorry, no added axiom, no native_decide, unsafe or extern code in 175,187 files.
The custom code was readThe bytesreadEvery place the release extends Lean was read: none inserts a declaration past the kernel.
Every file compilesThe build and the kernelsdecidedLean builds all 175,187 files with zero errors and no sorry.
Mathlib is untouchedThe build and the kernelsdecidedThe library the proof stands on equals a clean download of the same version, file by file.
Only the standard axiomsThe build and the kernelsdecidedThe five theorems rest on propext, Classical.choice and Quot.sound, and nothing else.
A second kernel agreesThe build and the kernelsrunningnanoda, a checker written independently in Rust, re-checks the whole exported proof.
Lean replays its own proofThe build and the kernelsrunningLean’s checker replays every declaration in a fresh environment.
A third kernel agreesThe build and the kernelsrunningcon-leche, a third independently written checker, re-checks the export and matches it against our statement again.
A clean machine agreesThe build and the kernelsrunningOn a fresh machine that never ran the release’s code, two kernels re-check the exported proof against a statement built there.
Two builds comparedThe build and the kernelscomputedOur compiled files compared byte for byte with Andrew Sutherland’s independent build.
The theorem is the one we wrote downThe statementrunningLean’s judge, Comparator, matches the five theorems against our own statement file, which imports Mathlib only.
Mathlib’s RH is the classical RHThe statementreadRead twice, by two model families: every nontrivial zero of ζ has real part 1/2.
Proved: it is the textbook statementThe statementdecidedA 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 themThe statementdecidedA 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-functionsThe statementreadRead twice: every modulus, every character; not other number fields.
The judges catch planted errorsThe statementrunningFive 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 checksThe contextdecidedThe “two thirds of the zeros” release re-checked on this Mathlib: 326 files unchanged, two kernels accept.
The bridges compileThe contextdecidedGiven RH, the August bounds move onto the critical line; and Masullo’s claim, as we read it, implies this release’s.
The two releases combineThe contextrunningOne environment holds both proofs; the combined statements pass Comparator.
The route inside the proof was readThe contextreadFrom Main.lean down, by Astra 6.2: RH from Dirichlet nonvanishing and ζ’s functional equation.
What the proof term really usesThe contextrunningWhich constants named in J. L. Nielsen’s critique are in the compiled proof.
Where the content livesThe contextrunningThe sub-proofs that feed the two key inequalities, traced in the compiled term.
  • Written down first. Every check and the rule that decides it were committed in public before that check ran, and every later change is dated: notes/alpoge-grh-preregistration-2026-11-20.md (14 amendments) and corpus/alpoge-grh/DEVIATIONS.md.
  • Attacked three times. Astra 6.2, a model from another family, red-teamed the plan three times. Its first round found a real defect in our own setup — the judge was configured to accept any body for four definitions — fixed before anything ran.
5 · inside the proof

What carries the conclusion

  • The route. Read from the top down: RH follows from “no Dirichlet L-function vanishes right of 1/2”, plus ζ’s functional equation for the left half. That in turn rests on a window criterion and on a link whose two inequalities come from matrix estimates.
  • Names are not evidence. Several parts are named for deep mathematics but are empty in the code: a geometry condition that is literally True, a geometric model whose key map is zero, a theorem named for a simple pole that proves True, two “literature” inputs that are one statement. The proof can still be valid — the kernel checks what is there, not what things are called — but those names do not explain it.
Main.lean riemannHypothesis : RiemannHypothesis rhOfAll → rh_of_every RH from Dirichlet nonvanishing everyCharacter no zeros right of 1/2, every character zeroFree_of_rpow_window a window criterion the divisor link height = formula (by rfl) + two inequalities Row a Galois-representation statement NAMED FOR DEEP MATHEMATICS, VACUOUS IN THE CODE anyGeometry := fun _ _ _ => True in the proof term? running divXFl a degenerate model, iMj = 0 in the proof term? running siegel_eisenstein_simple_pole proves True in the proof term? running OpenLiteratureStatements ⟨h, recTExists, h⟩
Main.lean riemannHypothesis : RiemannHypothesis rhOfAll → rh_of_every RH from Dirichlet nonvanishing everyCharacter no zeros right of 1/2, every character zeroFree_of_rpow_window a window criterion the divisor link height = formula (by rfl) + two inequalities Row a Galois-representation statement NAMED FOR DEEP MATHEMATICS, VACUOUS IN THE CODE anyGeometry := fun _ _ _ => True divXFl a degenerate model, iMj = 0 siegel_eisenstein_simple_pole proves True OpenLiteratureStatements ⟨h, recTExists, h⟩
The route of the proof, from the headline down (solid boxes), and, set apart under their own heading, four places named for deep mathematics that are vacuous in the code (dotted boxes). They are not on the route as drawn; whether the compiled proof uses them is what the census measures. Hover for each. The highlighted box is where the real content has to be.Record: corpus/alpoge-grh/route-reading.json · sha256 cb433b4a19c1The build refuses this figure if a quoted line no longer matches the pinned archive.
  • J. L. Nielsen’s critique. A paper posted the same day, The Invalidity of Alpöge’s Proposed Proof of the Riemann Hypothesis, reads the source and finds the vacuous geometric and lattice witnesses above, and a height set equal to its own formula. We confirmed each quote in the pinned files. Our verdict on that point: the geometric interpretation of this step remains unverified. The paper’s title goes further than its analysis: the formal theorem is decided by the kernels, not by the names, and the paper’s own appendix grants that the proof term may well check.
  • The question that remains. The height enters with two inequalities supplied separately, derived from about forty matrix-norm, covolume and valuation estimates. Whether those estimates are where the argument really lives — and what they mean — is a question for number theorists, not for a kernel. We trace, in the compiled proof, which sub-proofs feed them (running).
6 · connections

Two other claims, connected in Lean

AUGUST 2026 · ANTHROPIC ≥ 2/3 of the zeros simple and on the critical line ✓ re-checked here on today’s Mathlib 20 NOVEMBER · ALPÖGE RH, and GRH for Dirichlet every zero on the critical line ✓ checked here 20 NOVEMBER · MASULLO GRH, every number field a draft, 940 pages main theorem not yet written with RH: 5/6 of the zeros distinct AND on the line (running) read for ℚ: implies these statements, plus simple zeros proved in Lean, checked here running a reading of a draft
AUGUST 2026 · ANTHROPIC ≥ 2/3 of the zeros simple and on the critical line ✓ re-checked here on today’s Mathlib 20 NOVEMBER · ALPÖGE RH, and GRH for Dirichlet every zero on the critical line ✓ checked here 20 NOVEMBER · MASULLO GRH, every number field a draft, 940 pages main theorem not yet written with RH: 5/6 of the zeros distinct AND on the line (running) read for ℚ: implies these statements, plus simple zeros proved in Lean, checked here running a reading of a draft
Three claims about the zeros of ζ from 2026, and what Lean says connects them. Solid arrows are proved in Lean and checked here; grey ones are still running; the dotted box is a reading of a draft whose main theorem is not yet written.Records: corpus/alpoge-grh/runs-bridge/podB-lyq17afbn6smbz/P0J.out · sha256 0ccf3bce74dc; instruments/alpoge-grh/bridge/CertMachine/Bridge.lean · sha256 94c83d1ed104; instruments/alpoge-grh/bridge/CertMachine/MasulloReading.lean · sha256 df82b3e695bbThe build refuses this figure if a bridge drawn as proved is not CERTIFIED in the record.
  • The August release. Anthropic’s August proof that at least two thirds of the zeros are simple and on the critical line checks unchanged — all 326 files — on the Mathlib of today’s release, and both kernels accept it. Put together with today’s RH, its bound that 5/6 of the zeros are distinct becomes a bound for distinct zeros on the line. The simplicity bounds this implies are the August ones again; nothing new beyond the composition.
  • Masullo’s draft. Alessandro Masullo’s all-human draft (posted by Ravi Vakil, 940 pages, reviewed for months by Brian Conrad) claims GRH for every number field and more: off the centre, every zero simple. Its main zero theorem is not yet written in the draft (page 522: “Insert statement.”). Read for ℚ, the claim implies this release’s statements; one double zero would refute it while leaving RH intact.
credits

Whose work this uses

check it yourself

How to re-run it

changes

Changes to this page

contact

Write to Carlos

Sent by Web3Forms to Carlos’s inbox; nothing stored here.

Or write to carlos@carlostoledo.co, or open the public pilot form on GitHub.