DEV Community

Cover image for 17.4M lines, 0 sorry: I opened the GRH proof
frank chu
frank chu

Posted on

17.4M lines, 0 sorry: I opened the GRH proof

17.4M lines, 0 sorry: I opened the GRH proof

17,374,215 lines of Lean. Zero sorry. Zero admit. Zero extra axioms declared. That is what I found when I downloaded Levent Alpöge's claimed proof of the Generalized Riemann Hypothesis this morning and ran the checks I could run. The proof itself is 17 million lines long and no human has read it. But the artifact is real, it is structured exactly like a proof, and the same day brought a second Millennium-scale claim — finite-time blow-up for the unforced Navier–Stokes equations — whose Lean formalization I also opened. One of the two repos has a hole in it, and it is not the one you would expect.

Friday, November 20, 2026, is the day the Riemann Hypothesis may have fallen. Alpöge, a mathematician at Anthropic, announced that he and Claude had found and formalized a proof of RH and its Dirichlet generalization, GRH. The Hacker News thread hit 2,304 points. A second GRH claim, by Alessandro Masullo, appeared the same day. Terence Tao blogged about all three of the day's claims — the GRH proof, the Navier–Stokes blow-up, and an unforced Euler blow-up — and Scott Aaronson wrote that his bet is the proof will stand. I am not a mathematician and I did not verify the mathematics. What I did is what I always do: open the artifact and measure it.

The GRH archive: what is actually in the 14 parts

Alpöge's announcement is a 4-page PDF (245,114 bytes) at alpo.ge/remark.pdf. The proof itself is not in the PDF — the PDF is a personal note describing the collaboration, and it points to fourteen archive parts, lean.tar.gz.part01 through part14. The note says the formalization is finished and that producing a huge, unreadable human-readable document from it would be routine, so he chose to present only the Lean. His one mathematical line, for the record: the argument is a descendant of Stepanov's proof of RH over function fields, using chained theta lifts to mimic multiplicity, with the chain length for a von Mangoldt sum of length X being √X.

I cloned a GitHub mirror of the archive (the original is a 14-part tarball; the mirror's concatenated archive has SHA-256 9631b4f020199e580ba86178cb56c6e9b09f690c2369a80dc4334aa93f49c7fc) and ran the counts:

$ find . -name "*.lean" | wc -l
175187
$ find . -name "*.lean" -exec cat {} + | wc -l
17374215
$ grep -rn "sorry" --include="*.lean" . | wc -l
0
$ grep -rn "^axiom" --include="*.lean" . | wc -l
0
Enter fullscreen mode Exit fullscreen mode

175,187 Lean files. 17,374,215 lines. That is Aaronson's "17.4 million (!!) lines" to within 0.15% — the number checks out. Two details matter for whether the count is honest. First, there is no .lake directory in the project: none of the 17.4 million lines are vendored Mathlib. All 1.4 GB of it is the project's own source. Second, the line count is wc -l over every .lean file, so it includes blank lines and comments — it is a size measure, not a proof-step count. Even discounted for that, it is the largest formal proof ever released by several orders of magnitude.

The zero sorry count is the check that matters most. In Lean, sorry is the escape hatch: a proof that says "trust me." A formalization containing sorry proves nothing. This one contains none — not in the 17.4 million lines, and none of its cousins either: rg -w "admit" and rg "sorryAx" both came back empty across the whole project. There are also no top-level axiom declarations smuggled in. Whatever this is, it is not a proof with the conclusion assumed.

The statement is anchored to Mathlib, not homemade

The part I could actually read is the entry point, and it is twelve lines long:

import Statements
import Supplements.Kernels.MainTheoremsAll

theorem riemannHypothesis : RiemannHypothesis := rhOfAll

theorem riemannZeta_eq_zero_re : RiemannZetaZerosOnLine := rhOfAll

theorem LFunction_ne_zero_of_half_lt_re : DirichletLNonvanishingRightOfHalf := allChi

theorem LFunction_eq_zero_re : DirichletLZerosOnLine := claimAll.2.1

theorem LFunction_eq_zero_re_of_isPrimitive : PrimitiveDirichletLZerosOnLine := critAll
Enter fullscreen mode Exit fullscreen mode

RiemannHypothesis here is Mathlib's own RiemannHypothesis, and the definitions in Statements.lean are written in terms of Mathlib's riemannZeta and DirichletCharacter.LFunction:

def RiemannZetaZerosOnLine : Prop :=
  ∀ s : ℂ, riemannZeta s = 0 → (¬∃ n : ℕ, s = -2 * ((n : ℂ) + 1)) → s ≠ 1 → s.re = 1 / 2
Enter fullscreen mode Exit fullscreen mode

That anchoring is doing real work. The oldest trick in formalization is proving a theorem about a definition you wrote yourself that turns out to be vacuous or wrong. Here the statement is Mathlib's standard one: every nontrivial zero of the zeta function has real part 1/2, with the trivial zeros at the negative even integers excluded explicitly. The main theorem reduces in one step — rhOfAll : RiemannHypothesis := Formalism.VW.rh_of_every allChi — to allChi, the claim that the Dirichlet L-function statements hold for all characters. So the whole 17.4 million lines hang off one reduction, and everything upstream of it is the proof of that reduction.

What I could not verify

Here is the honest boundary. I did not build the project. A full Lean build of 17.4 million lines needs an enormous amount of memory and time — the mirror's own README says "a partial independent replay verified the statement definitions and several conditional reductions. The full proof build remains unverified here." As of this evening, nobody has publicly reported a completed build. A zero sorry count is necessary for a proof; it is not sufficient. The build is the thing that would make it sufficient, and it has not happened yet in public.

There are two more caveats, both from Aaronson's post. First, Lean itself has had kernel bugs in the past that allowed proofs of 0 = 1; a sufficiently motivated AI could in principle exploit a soundness hole rather than prove a true statement. Aaronson says he sees zero indications of that happening here, and notes that not one AI result with a Lean certificate has needed retraction so far (while several without certificates have). Second, mathematicians will not be satisfied with 17 million lines of Lean. They will be satisfied when they can explain, distill, and reconstruct the ideas themselves — and Aaronson expects that to take years.

Tao's note on the proof's content is the best early signal about what the argument is: "from very initial analysis, [it] appears to use the full power of modern developments on the Langlands program and arithmetic geometry." The verification effort is being followed on the Lean Zulip thread, which Tao calls the best place to watch.

The Navier–Stokes repo, and the hole in it

The day's second claim is finite-time blow-up for the unforced incompressible Navier–Stokes equations in three dimensions — a Millennium Prize problem — by Alpöge and Tristan Buckmaster, again with heavy AI assistance. The repo was created today at 10:40 UTC, one commit, and it comes with a 79-page paper. I cloned it and ran the same checks:

$ find . -name "*.lean" | wc -l
2271
$ find . -name "*.lean" -exec cat {} + | wc -l
616060
$ grep -rn "sorry" --include="*.lean" lean/ | wc -l
24
$ grep -rn "sorry" --include="*.lean" lean/Breakdown/ | wc -l
0
Enter fullscreen mode Exit fullscreen mode

2,271 files, 616,060 lines — the README says "about 2,270 files and 600,000 lines," so the artifact matches its own description. The 24 sorrys are all in the ten top-level Challenge*.lean statement files, exactly where the README says they should be: the statement files declare the theorems with sorry in place of proofs, and Solution.lean proves them from the library in Breakdown/. The proof library itself has zero sorry. Each comparator*.json pairs a statement file with Solution.lean, names the theorems whose statements must agree, and permits only the three standard axioms (propext, Quot.sound, Classical.choice).

That is a clean structure, and it is more careful than the GRH archive in one respect: the statements are written independently of the proof and checked against it by the comparator, so the proof cannot quietly prove a weaker statement than the paper claims.

But the README contains a sentence that changes what the repo actually establishes:

"No certificate is given in this package."

The proof's structure is: if a certificate exists — finitely many functions and numbers satisfying the conditions in Appendix B — then blow-up follows. The Lean code proves that implication. The certificate itself, the numerical data that makes the implication concrete, is not in the repository. Whether the certificate satisfies Appendix B is established by a rigorous computation using interval arithmetic (128 bits of precision, with the Arb library through FLINT), which is also not in the repository. The paper says the certificate will be released. Until it is, the loop is not closed from the public artifact alone: the Lean proves a conditional, and the condition's verification lives in a computation nobody outside the authors can yet rerun. The README is equally blunt about the build state: "The patched package was not rebuilt when this repository was assembled."

One more detail from the README that inverts the usual order of things: "The formalization came first: a first draft of the paper was obtained from the Lean proof, and the paper was then rewritten." The paper is the human-readable shadow of a machine-checked argument, not the other way around. Theorem 1.1, for the record: the solutions blow up at the rate $(T-t)^{-1/4}$.

The scoreboard

Claim              Files     Lines       sorry in proof lib   Build verified?
GRH (Alpöge)       175,187   17,374,215  0                    No (partial replay only)
Navier–Stokes      2,271     616,060     0                    No (patched, not rebuilt)
Euler (unforced)   —         —             —                    Per Tao: Lean formalized
Enter fullscreen mode Exit fullscreen mode

The third claim, unforced Euler blow-up by Alpöge, Buckmaster, and Matei Coiculescu, has a human-readable proof and a Lean formalization per Tao's post; I did not open that repo this evening. For scale: the GRH formalization is 28 times the size of the Navier–Stokes one, and the Navier–Stokes one is itself roughly the size of a large software project.

What would settle each claim: for GRH, a completed Lean build with #print axioms on riemannHypothesis showing only the three standard axioms — that is the single command the whole world is waiting on. For Navier–Stokes, the release of the certificate plus its interval-arithmetic verification, and a rebuild of the patched package. For both, the years of human digestion Aaronson describes. Until then, the honest statement is narrower than the headlines: two enormous, structurally clean, sorry-free formalizations were published today, one of them conditional on data that has not been released yet, and neither has been fully built in public. That is already the most extraordinary day in the history of formal mathematics. It is not yet a proof.

Limitations, stated plainly

  • I ran static checks only: file/line counts, sorry/admit/sorryAx searches, axiom-declaration searches, and reading the entry-point statements. I did not build either Lean project and I did not read the mathematics.
  • Line counts are wc -l over all .lean files, including blanks and comments.
  • The GRH mirror I cloned is a third-party mirror of Alpöge's 14-part archive, not the original; the mirror states the concatenated archive's SHA-256, which I did not independently re-verify against alpo.ge.
  • Everything about the Euler claim comes from Tao's post, not from a repo I opened.

Sources: Alpöge, "remark.pdf" (announcement) (Nov 20, 2026); Navier–Stokes repo, tristanbuckmaster/navier-stokes (created Nov 20, 2026); GRH Lean mirror, 1337isnot1337/riemann-hypothesis-solved; Terry Tao, "Unforced Euler singularity, unforced Navier-Stokes singularity, and the Generalized Riemann Hypothesis" (Nov 20, 2026); Scott Aaronson, "The stochastic parrots have apparently proved the Riemann Hypothesis" (Nov 20, 2026); Masullo GRH announcement (Nov 20, 2026). All repo checks run locally November 20, 2026.

Top comments (0)