The Lean Community Certifies the Riemann Hypothesis Proof Made With Claude

The Lean Community Certifies the Riemann Hypothesis Proof Made With Claude

The Lean and Mathlib communities say Levent Alpöge's 17-million-line proof is correct. We set their statement against the check logs: what passed, what is still running, what is left.

ZharfAI ResearchNovember 21, 202615 minutes

On Saturday, November 21, 2026, the Lean and Mathlib communities published a joint statement, dated 13:55 UTC, on the proof of the Riemann Hypothesis that Levent Alpöge, a number theorist who works at Anthropic, released a day earlier as a Lean project made with Claude. The statement says: "We have full confidence that Alpöge's proof of the Riemann Hypothesis is correct," and "We hereby certify that both the statement and the proof of the Riemann Hypothesis are correct." It is endorsed by the Lean FRO, the organization that develops Lean, and by the Mathlib Initiative.

Status when this article was published (21 November 2026, 20:19 UTC): the formal proof is certified by the Lean and Mathlib communities, and no checker in the published logs has rejected it. Two long runs of Lean's own kernel over the full exported proof, and the end-to-end comparator run, were still listed as in progress on Andrew Sutherland's verification page at MIT. There is still no human-readable proof and no journal publication, which the Clay Institute's prize rules require first, and we found no statement from Anthropic.

Yesterday we downloaded the 14-part archive and read it without building it, and called the result a claim. This article picks up from there: what the certification rests on, how it matches what we saw in the files, and what it does not settle.

What the joint statement says

The statement rests on four tests set out on November 12 on the Xena blog, a long-running blog about mathematicians learning Lean. That post was written after OpenAI published 722 mathematics papers, many with Lean code, and it found that in around 38 of the 290 OpenAI results that came with Lean code, the code "does not even state, let alone prove, the main theorem of the paper." Its conclusion: "one has to do some work beyond 'the Lean code compiles'." The four tests are:

  1. Is the statement right? Here the statement is not new. It is Mathlib's own RiemannHypothesis, which the joint statement says "has been carefully vetted by experts in Lean and number theory."
  2. Does the code compile? The statement says "dozens of people have reported correct compilation," reproducing the same exported proof file.
  3. Does the code prove that exact statement? The statement says a separate file states the theorem while importing only Mathlib, and that two tools, comparator and con-leche --compare, confirmed that the theorem proved in Alpöge's library is exactly that statement, with no redefinition hidden along the way.
  4. Is the proof valid? The statement says the exported proof was checked by several independent proof checkers, including Lean's official kernel.

One detail matters more than it looks. The checks ran on "an inert export of the proof, out of reach of hypothetical malicious code in the Lean proof sources." Building a Lean project runs the project's own code. Lean's reference manual tells anyone checking a proof that might be "malicious," a category it says includes "un-reviewed AI-generated proofs and programs," to use comparator. So the 17 million lines were built once, exported as plain data, and the checkers read only that data inside a sandbox.

Checking the statement against the logs

The joint statement points to a verification page at MIT by the mathematician Andrew Sutherland, "checks run with Claude Code," for details. The volunteer repository leanprover-community/riemann-hypothesis keeps its own notes. We read both and set the four tests against them. The MIT page was last updated at 12:55 UTC on November 21, an hour before the time on the joint statement, and was unchanged when we checked again at 20:19 UTC.

  • The statement. Joint statement: Mathlib's RiemannHypothesis. Logs: the five theorems are restated in a challenge file that imports only Mathlib, and every notion in them (riemannZeta, DirichletCharacter, LFunction, IsPrimitive) is Mathlib's.
  • Compiling. Joint statement: dozens of reports, all producing the same export. Logs: all 175,187 modules compile with zero errors on Lean 4.33.1. The repository's notes record one independent rebuild that produced the same 61.6 GB proof export, byte for byte. The other reports may be on the Lean Zulip chat, which we did not read.
  • Proving that statement. Joint statement: comparator and con-leche --compare agree. Logs: con-leche --compare accepts all five theorems. lake comparator had passed its statement and axiom checks; its kernel stage was still running.
  • A valid proof. Joint statement: Lean's kernel, con-leche, con-ron and third-party checkers. Logs: Lean's kernel replayed every compiled module with zero rejections. Two independently written kernels accepted the full export: nanoda, written in Rust, in 27 minutes on 80 threads, and con-leche, which accepted 1,468,418 declarations in 3 minutes 15 seconds on 64 threads. lean4lean accepted all 175,187 modules.

Two of these need care. First, the kernel replay that passed was module by module; Lean's default and hardened kernels running over the single full export were still listed as "running." Second, the joint statement names con-ron among the checkers. In the logs we could read, the versions of con-leche and con-ron bundled with Lean 4.36 both stopped with exit code 2, which the MIT page calls "not a rejection": those builds do not support one kind of type definition, a mutual inductive type with a reflexive member, that the proof uses. The newer con-leche from its main branch handled it and accepted the proof. We did not find a con-ron run that accepted the proof. That may exist somewhere we could not see, and the other kernels' verdicts do not depend on it.

The files are the ones we opened on day one

The MIT page lists the source archive as the 14 parts joined: 239,275,554 bytes with SHA-256 9631b4f020199e580ba86178cb56c6e9b09f690c2369a80dc4334aa93f49c7fc. That is the exact checksum we published yesterday, so the files the community certified are byte for byte the files we read.

Most of what we reported on day one now has independent confirmation:

  • Pins. Lean 4.33.1, and Mathlib at commit 0df444a3, which the repository's notes identify as Mathlib's official v4.33.1 tag.
  • Five theorems. The Riemann Hypothesis in Mathlib's wording, the same statement written out, and three statements about Dirichlet L-functions.
  • Axioms. We wrote that #print axioms would have to list only Lean's three standard axioms. It does: propext, Classical.choice and Quot.sound. No axiom is declared anywhere outside Lean's core.
  • Scope. The MIT page states that "GRH" here means Dirichlet L-functions only, the family that governs how primes spread among classes such as numbers ending in 1, 3, 7 or 9. Dedekind zeta functions, Hecke L-functions and automorphic L-functions in general were not checked.

One thing we missed. We wrote that the project's own Lean metaprogramming came down to five small files that hide names from lemma search and one helper that copies theorems. The repository's notes, corrected after a reader's report, list more: a tactic called kexactB, used in 67 files, and another called kcopy. Both place a proof term into a goal without the elaborator first checking its type. That does not let anything past the kernel, which checks every declaration, but it leaves the kernel as the only check for those steps. We have added a correction to our first article.

The notes also give a measure of how machine-made the project is: 17,374,215 lines, 818,755 theorems and lemmas, and not a single comment.

Why it took several kernels, not one

A Lean proof is trusted because a small program, the kernel, checks every step. The rest of Lean, including the tactics that write the proof terms, can have bugs without making a false proof pass. That argument holds only if the kernel is right, and in 2026 that has been tested. Leonardo de Moura, chief architect of the Lean FRO, has written that "AI agents are very effective at finding vulnerabilities" in it, after two postmortems on kernel soundness this summer. The repository's notes add that Lean 4.33.1, the version this project is pinned to, predates fixes for runtime bugs that Lean's release notes say could potentially be turned into a proof of False with deliberately constructed input. So a successful build on 4.33.1 "counts as limited evidence here," and the proof was judged with Lean 4.36 and independent kernels.

Each of those kernels removes a different doubt:

  • nanoda is a separate kernel written in Rust, so a bug in Lean's own implementation is unlikely to be repeated in it.
  • lean4lean is a kernel written in Lean that closely follows the official one; it checked the compiled files.
  • con-leche is a kernel written in Lean with a machine-checked proof that every environment it accepts has a model in set theory. In de Moura's words, it "was implemented and proven consistent by Claude (Fable and Opus), under heavy supervision by Joachim Breitner" at the Lean FRO.
  • con-ron is a Rust translation of con-leche, proved to follow the same algorithm, so that a bug in Lean's compiler is unlikely to affect both.

An AI-assisted proof checked by a kernel that an AI helped build, on a page whose checks were run with an AI coding tool, can sound circular. It is less so than it sounds. Con-leche's consistency proof is itself checked by Lean's official kernel. Nanoda and Lean's own kernel replay reached the same verdict independently. And none of these checkers decides whether the statement means what mathematicians mean; for that, the statement is Mathlib's, which existed before this project began. For more on why checkable answers matter when AI does the work, see our explainer on learning from verifiable rewards.

A check that does not depend on the zeta function

The weakest link in any formal proof is the definitions. If Mathlib's zeta function were subtly wrong, a proof about it could be valid and still prove the wrong thing. The MIT page closes that gap with an independent check.

In 1984 Guy Robin showed that the Riemann Hypothesis is equivalent to a statement about σ(n)\sigma(n), the sum of the divisors of nn. For every nn larger than 5,040,

σ(n)<eγ nlog⁡log⁡n,\sigma(n) < e^{\gamma}\, n \log\log n,

where γ\gamma is Euler's constant, about 0.5772. Take n=5,040n = 5{,}040 itself: its divisors add up to 19,344, while the bound gives about 19,237, so 5,040 breaks the rule. The Riemann Hypothesis holds exactly when no larger number ever does. A separate formalization of Robin's criterion and of Jeffrey Lagarias's related one, the Robin1984 project, was combined with Alpöge's proof. The result is two theorems with no hypotheses and no mention of the zeta function, only divisor sums, Euler's constant, harmonic numbers, exponentials and logarithms.

Both passed con-leche, con-leche --compare and nanoda, and depend only on the three standard axioms. As of the page's last update, lake comparator on the combined export had passed its statement and axiom checks and was still running its kernels. These theorems still rely on Mathlib's definitions of the divisor sum and the other functions, but those are far simpler than the zeta function's analytic continuation.

What the certification does not settle

  • Understanding. The joint statement ends: "We look forward to all the activity in the mathematical community that will help explain the new ideas in this proof." Sutherland told Scientific American, after compiling the result himself, "There is much work to be done to understand the mathematical details of the proof." Alpöge's own note promises a readable account later.
  • GRH. The joint statement certifies the Riemann Hypothesis and does not mention the generalized version. The three Dirichlet L-function theorems passed the same checks on the MIT page, but only for Dirichlet L-functions.
  • The build environment. The MIT page lists its own caveats: the build ran on cloud machines without a sandbox and called lean directly rather than through lake build, and its export has not been compared with one from a sandboxed lake build. A pass relies on the kernels used and on "Mathlib's definitions being what they are intended to be."
  • The prize. The Clay Institute's rules require publication in a qualifying outlet, two years since publication and general acceptance in the mathematics community. A Lean certification is evidence for the third condition, not a substitute for the first two.
  • Anthropic. As of 20:19 UTC on November 21 we had found no statement from Anthropic itself. The claim and the code are still published on Alpöge's personal site.

A dispute over the byline, not the proof

The Lean community blog is a public GitHub repository, and its history shows an argument about who was speaking. The post, dated 13:55 UTC, was merged at 14:26 UTC. At 16:41 UTC a change by Patrick Massot titled "Urgent attribution fix" was merged. It changed the byline to the Lean FRO and the Mathlib Initiative alone and the text to "part of the Lean and Mathlib communities." His message said that attributing the post to the whole community "would at least require a discussion among Mathlib maintainers and reviewers." At 17:36 UTC a revert by Adam Topaz restored the original byline. The revert gives no reason.

Neither change touched the four tests or the verdict. The disagreement was over whether a statement in the name of a community needed that community's discussion first.

How mathematicians have reacted

Sutherland, who compiled and checked the proof, called it "indeed an historic moment" in Scientific American, and added: "to me this is a human triumph, and a day for celebration."

Other reactions we could not read at the source. The Next Web reported that Oxford's James Maynard told The New York Times he was "98 or 99 percent" certain the proof is correct, and that Stanford's Brian Conrad told the paper it was "frankly completely outrageous" to release a proof its author does not fully understand. We could not open the Times article, so those quotes are The Next Web's report of it.

Conrad's objection and the certification are about different things. The Lean check answers whether the proof is valid. Conrad's concern, as The Next Web reports it, is the release itself: a proof put out before its author fully understands it. For the wider question of what AI systems doing research could change, see our analysis of AI that improves itself.

What to watch next

  • The last kernel runs. Lean's default and hardened kernels over the full export, and lake comparator end to end. The community repository says Comparator's output will be added to its verification folder.
  • A sandboxed rebuild whose export matches Sutherland's checksum, which would close the MIT page's own caveat.
  • Alpöge's written account, and the first expert explanations of the method: Stepanov's method transplanted to the integers through chains of theta lifts, by his description.
  • Anthropic's own statement, if any, and how journals and the Clay Institute treat a proof published only as code.

Frequently asked questions

Is the Riemann Hypothesis proved now?

As a formal Lean proof, it has passed the tests the Lean community itself set out, and the Lean and Mathlib communities certify it as correct. What is still missing is the usual human side: a readable proof, experts who understand why it works, and journal publication.

Who certified it?

The post is signed "the Lean and Mathlib communities," endorsed by the Lean FRO and the Mathlib Initiative. The commit that added it lists six authors from the Lean and Mathlib community, and one contributor objected to the community-wide byline, as described above.

Did Claude check its own work?

No. The proof was checked by several independent kernels. Claude helped build one of them, con-leche, whose consistency proof is itself checked by Lean's kernel, and Sutherland ran his checks with Claude Code. Nanoda and Lean's own kernel reached the same verdict.

Can I check it myself?

Not on a laptop. The MIT page gives the commands: download the 7.7 GB compressed export, unpack it to about 61.6 GB, and run lake comparator with Lean 4.36 on a machine with about 100 GB of RAM. The fastest independent check, con-leche, needs about 50 GB of RAM and took under four minutes on 64 threads.

Does this break encryption?

No. As we explained in our first article, the Riemann Hypothesis is about how primes are distributed, not how to factor large numbers.

Source notes

Sources opened on November 21, 2026; the moving pages were re-read at 20:19 UTC. The comparison with our own archive inspection of November 20 is ZharfAI's.

TagsRiemann HypothesisLeanMathlibFormal VerificationClaudeNumber Theory

Related Posts

Name one process for a discovery call

If this note maps to a real system in your organisation, start with the services page or a shipped case study.