Riemann Hypothesis Lean proof: what the checkers actually check

The Riemann Hypothesis Lean proof that Levent Alpöge posted on November 20, 2026 is 17.4 million lines of code in 175,187 files, and it compiles. Strangers have built it, several independently written checkers accept the exported proof, and one check was still running when I last looked on Saturday afternoon (GMT+7). This post explains what each of those checks covers, what it leaves open, and what a developer can reuse from the way people are checking AI-written proofs.

{% embed https://www.youtube.com/watch?v=FKotjbyp558 %}

Everything below is a claim under review, and no part of it is an accepted result yet. I use "claims", "compiles" and "accepts" on purpose.

TL;DR

  • Levent Alpöge, a mathematician at Anthropic, posted a four-page note saying he believes he has, working with Claude, discovered a proof of the Riemann Hypothesis and its generalization, and released only Lean code (note).
  • Andrew Sutherland of MIT reports that all 175,187 modules compile with zero errors, and that the five headline theorems use only the three standard axioms (MIT verification page).
  • Kernels written by other people accept the 61.6 GB export: nanoda in 27 minutes 42 seconds and con-leche in 3 minutes 15 seconds.
  • As of Saturday November 21, 17:05 GMT+7, the official lake comparator run on the full proof and the Lean kernel replays were still running. Its statement comparison and axiom check had passed in one run, and con-leche's compare mode accepted all five theorems.
  • Nobody has digested the argument yet. Terence Tao wrote that this will take some time.

What the Riemann Hypothesis Lean proof actually contains

Alpöge's note says Claude "flew, and danced, and sparkled near that finish line", and that a prose version he generated hit more than 250,000 pages, which he called slop. He posted none of it. What exists is a Lean archive split into 14 parts, about 239 MB compressed, 17,374,215 lines in 175,187 files according to the import analysis people posted on the Lean Zulip thread.

Lean is a proof assistant. You write a statement and a proof, and a small program called the kernel checks every step against a short list of rules. If the kernel accepts, the statement follows from the axioms you allowed. The Riemann Hypothesis here is Mathlib's own definition, which in Lean reads that every nontrivial zero of the zeta function has real part one half. Its doc comment in the library says that constructing a term of that type is worth a million dollars (Mathlib source).

Sutherland's page notes that "GRH" in this archive means Dirichlet L-functions only, so I avoid calling it the extended hypothesis.

Buzzard's four questions: what does a green Lean build check?

Nine days earlier, Kevin Buzzard of Imperial College London published a checklist for exactly this kind of repository (Xena Project post):

  1. Does the Lean statement match the informal statement?
  2. Does the code compile?
  3. Does the code prove the theorem as stated? His tool for this is lake comparator.
  4. Does the code exploit a bug in Lean's official kernel? His tool is lake comparator --paranoid, which uses several independent kernels.

Buzzard, who tried to compile Anthropic's 13 million line Fermat formalization in September and ran out of memory, writes that AI-generated code needs these tests before anyone makes a correctness claim. I covered that Fermat episode when it came out and stamped it SHIP IT; this one needs more review.

Question two: does it compile?

This is the easy one, if you own a big machine. Sutherland's page reports zero errors across all 175,187 modules and #print axioms output listing only propext, Classical.choice and Quot.sound for the five headline theorems. To run the official check yourself you need about 100 GB of memory, per the same page. Buzzard wrote on the Lean Zulip that the answer to this question is yes.

Question four: could the kernel be fooled?

Scott Aaronson points out that Lean's kernel has had bugs that allowed proofs of 0 = 1, and says those issues should be fixed urgently (his post). He also notes that so far none of the AI results with Lean certificates has needed to be retracted, while several without certificates have.

The practical answer is to run more than one kernel. According to Sutherland's page, nanoda, an independent Rust kernel, accepted the full export in 27 minutes 42 seconds on 80 threads, and con-leche accepted it in 3 minutes 15 seconds on 64 threads. Joachim Breitner of the Lean community wrote that con-leche is backed by a consistency proof, and that the high-level summary is that this proof is now "very very thoroughly checked". lean4lean accepted every compiled module as well, with five modules needing a raised step limit.

Questions one and three: is it the right theorem?

These are the dangerous ones. The statement is short and trusted. The proof sits behind 17 million untrusted lines, and any of them could in principle redefine a symbol and prove something easier. That is what lake comparator is for: it checks that the theorem in a trusted file and the theorem delivered through the untrusted imports are identical, and that only the standard axioms are used. I explained the tool on November 10 in the episode about Google's checked proofs for Signal's code.

Where the comparator run stood

At the last update to the MIT page (2026-11-21 10:05 UTC, which is 17:05 GMT+7; the status rows were the same when I re-read the page at 21:29), the official lake comparator run on the full proof was listed as running. The page says its statement comparison and axiom check had already passed in one run, and that the slow stages replay the proof in Lean's default and paranoid kernels, single-threaded on a 62 GB export. Sutherland wrote on the Zulip that he did not expect it to complete before that night, more likely the next day.

Two other checks cover part of the same ground:

| Check | Status on the MIT page (17:05 GMT+7) | |---|---| | lake comparator end to end on the full proof | running | | Lean default and paranoid kernel replay of the export | running, single-threaded | | con-leche --compare, an independent implementation of Comparator's statement matching | accepts all five theorems | | Robin's inequality, a divisor-sum statement with no zeta in it, combined with an independent Robin formalization | compiles; con-leche and nanoda accept |

Robin's inequality says that for every n above 5040, the sum of divisors of n is smaller than e to the Euler constant times n times log log n. It is an old equivalent of the Riemann Hypothesis, so a proof that implies it without mentioning zeta tests the statement from another side. Sutherland wrote that this effectively rules out holes in the definitions used in the Mathlib formulation. His own page also says the result relies on the kernels and on Mathlib's definitions being what they are intended to be.

The MIT verification page at the time of the recording, with the "page last updated 2026-11-21 09:30 UTC" line marked

Status pages like this move quickly. If you are reading this later, go to the page rather than to my table.

The human-written rival and the unreadable proof

The same morning, Ravi Vakil, president of the American Mathematical Society, posted a draft general Riemann Hypothesis proof by Alessandro Masullo, written with no AI, which Brian Conrad had been reviewing for months (Vakil's post). About eight hours later Vakil added that several people had reported problems, found with the help of different AI models, and that he makes no claim as to the correctness of the proof strategy. Conrad told Scientific American that the draft is undergoing major revision (SciAm).

One claim comes with a machine that says yes. The other comes with a PDF that people are arguing about. Neither is an accepted proof.

A compiling Lean file also cannot say why the argument works. Terence Tao wrote that the digestion process will take some time, though there is a human author to talk to (Tao's post). Aaronson says mathematicians will be satisfied when they can explain and reconstruct the ideas themselves.

What developers can reuse from this

  1. Read the specification before the code. A checker proves the statement you gave it, so look at who wrote the statement and how small it is.
  2. Ask what compares the proof to the statement. The comparator pattern, a trusted spec checked against what the implementation delivers, applies to any AI-written code.
  3. Run a second checker that someone else wrote. Several independent kernels agreeing is far stronger than one kernel agreeing with itself.
  4. Treat reproducibility as a property to test. Sutherland's page notes that the per-file hashes of the compiled files depend on the build directory, because Lean can store the source path inside them: 98,219 of the 175,187 compiled files contain it.

Scientific American notes that the result has no immediate real-world applications. Nothing in your stack changes tonight.

Verdict: NEEDS REVIEW

I'd ship the checking and hold the conclusion. The compile is real, strangers' checkers agree, the official comparator run was unfinished at the last update, and mathematicians have not yet digested the argument.

One market footnote: Anthropic's shares fell more than eight percent on Friday, from $97.17 to $88.91, in a sell-off The Guardian does not tie to the proof (The Guardian). I do not either, and this is not investment advice.

FAQ

Does a Lean proof that compiles mean the Riemann Hypothesis is proved? It means the Lean statement follows from the allowed axioms according to the checkers used. Whether the Lean statement says what mathematicians mean, and whether the argument is understood, are the questions the comparator, the independent kernels and human review address.

What is lake comparator? A Lean tool that checks that the theorem stated in a trusted file and the theorem proved through untrusted imports are identical, and that only the standard axioms are used.

How long does it take to check the Alpöge proof? On the MIT page, nanoda took 27 minutes 42 seconds on 80 threads and con-leche 3 minutes 15 seconds on 64 threads for the exported proof. Compiling the source took hours on large machines, and the Lean kernel replays are single-threaded and slower.

Is the Masullo proof correct? Nobody has said so. Vakil makes no claim as to its correctness and Conrad says it is undergoing major revision.

Sources


This article expands on an episode of The Daily Diff, a five-minute daily video on what shipped and what broke in tech. Watch the episode · Subscribe on YouTube · the written diff lands in your inbox every morning at thedailydiff.dev.

Video transcript and primary sources