RH · checked in Lean

For analysts: scope, trust and implications

The shared facts come first: what is proved and how it was checked. After that, each kind of analyst gets a section on what matters for their work. We use only figures from the community statement, the MIT verification page, published papers, or our own measurements of the Lean archive, and say which is which.

TL;DR

  • Proved and machine-verified: the Riemann Hypothesis, and GRH for Dirichlet L-functions. Not covered: GRH for other L-function families.
  • Trust rests on a small trusted base: Lean's logic, Mathlib's definitions, and several independent checkers that agree.
  • Practical impact is mostly on guarantees (for example, some algorithm bounds become unconditional), not on cryptography or day-to-day systems.
  • Main open questions: a human-readable explanation, and how prize bodies and journals respond.

Jump to your section with the chips below.

Bottom line

The Riemann Hypothesis, and the Generalized Riemann Hypothesis for Dirichlet L-functions, are proved, and the proof has been machine-verified. The Lean and Mathlib communities, endorsed by the Lean FRO and the Mathlib Initiative, "certify that both the statement and the proof of the Riemann Hypothesis are correct" (21 Nov 2026).

Exactly what is proved

StatementStatus
Riemann Hypothesis (Mathlib's definition)Proved
No zeros of any Dirichlet L-function with \(\operatorname{Re}s\gt \tfrac12\), for all moduli and all charactersProved
Zeros of Dirichlet L-functions in the critical strip lie on \(\operatorname{Re}s=\tfrac12\) (all characters; primitive ones separately)Proved
Robin's and Lagarias's inequalities for the divisor sum, unconditionally (via the independent Robin1984 formalisation)Proved and checked
GRH for Dedekind zeta functions, Hecke L-functions, automorphic L-functions in generalNot among the checked statements

The MIT page puts it plainly: "'GRH' here means Dirichlet L-functions: all moduli and all characters. Dedekind zeta functions, Hecke L-functions and automorphic L-functions in general are not among the statements that were checked." Alpöge's announcement suggests the method gives more ("Extended Riemann Hypothesis too"), but only the five Main.lean theorems were certified.

The trust model

The community applied four criteria from a Xena Project post of 12 Nov 2026, written as general guidance eight days before this proof appeared:

  1. Right statement. Mathlib's RiemannHypothesis, "carefully vetted by experts in Lean and number theory".
  2. Compiles. "Dozens of people have reported correct compilation of the codebase, reproducing the same raw proof export file."
  3. Proves that statement. A challenge file importing only Mathlib was compared with the solution by two independent tools (comparator and con-leche --compare).
  4. Valid proof. Checked by Lean's kernel and by several independent kernels written in different languages. Two of these (con-leche, con-ron) are formally proved unable to accept a false proof, relative to set theory.

What remains in the trusted base: the logic of Lean (standard axioms: propositional extensionality, choice, quotient soundness), Mathlib's definitions of ζ and L-functions (well established and widely reviewed), and the hardware and software that ran the checkers, which is diversified across several machines and implementations. The security section sets this out as a threat model.

Data and statistical analysts: three kinds of evidence

Numerical checks and statistics made RH believable; only the formal proof covers every zero.

RH was "believed" long before it was proved, for two very different kinds of reason. This proof adds a third kind of evidence. They are worth keeping apart.

EvidenceWhat it establishesWhat it can't do
Rigorous numerical verification. Platt and Trudgian (2021) used interval arithmetic to show that every zero with \(0\lt\gamma\le 3{,}000{,}175{,}332{,}800\) lies on the line. That is the lowest 12,363,153,437,138 zeros.A finite, certain fact, provided the code and hardware are right. Interval arithmetic controls rounding error, so floating-point drift can't cause a false "on the line".Say anything about the infinitely many zeros above that height. Some famous conjectures held for enormous ranges and then failed.
Statistical and heuristic evidence. An example is the random-matrix (GUE) statistics of zero spacings: Montgomery's pair-correlation work (1973) and Odlyzko's large-scale computations (1987 onwards).A striking pattern: the spacings match random-matrix predictions closely, which made RH feel natural.Explain why RH is true, or prove anything. It is a pattern, not an explanation, and a good fit is not a guarantee.
Formal proof (this result). Over a million declarations (1,468,418 in the export). Every module was replayed through Lean's own kernel, and the full export was accepted by three independently written checkers (nanoda, con-leche, and con-ron in its comparison run), and lean4lean accepted every compiled module. (The module replay used leanchecker, which is Lean's own kernel, so it is not independent.) For checks still running on the MIT page, see Status.All zeros, at every height, relative to the trusted base above.Explain why it's true to a human reader, at least not yet.
Not evidence: conditional theory. Thousands of results were proved "assuming RH". Those are consequences, not evidence: deriving more consequences without contradiction says little about whether RH is true, and a counterexample would simply have left them unproven. Now that RH and GRH for Dirichlet L-functions are proved, those that rest on them become unconditional (see the consequences under Policy and research strategy).

Points that matter for a data mindset:

Systems analysts: the proof as a large system

A very large codebase, but small trusted checkers sit at the end of the pipeline, several of them independent, and a sandboxed rebuild produced a byte-identical export.

Treat the proof as a software system: components, interfaces, a build pipeline and trust boundaries. These figures come from our own measurement of the downloaded archive (marked ours) or from the MIT verification page (marked MIT).

MeasureValueSource
Lean modules (files)175,187ours; MIT agrees
Lines of Lean17,374,215 (the community statement says "about 17 million")ours
Declarations checked by con-leche1,468,418MIT
Archive14 parts, 239,275,554 bytes; 1.03 GB unpackedours
File sizesmedian 3.5 KB, largest 914 KBours
Import closure of Mainall 175,187 modules; the longest import chain is 203 modules deepours
Directory-level dependency graph343 groups, 1,237 edgesours
External dependenciesMathlib only (pinned commit), plus Mathlib's standard dependencies. 8,322 Mathlib and 378 dependency .olean files match the official cache byte for bytecommunity statement; MIT
Proof export (input to the kernels)61.6 GB unpackedMIT
Fastest independent kernel runnanoda, 27 min 42 s on 80 threadsMIT
Resources for checking it yourselfabout 50 GB RAM for con-leche; about 100 GB RAM and 70 GB disk for the full lake comparatorMIT
Our partial build1,056 modules with 0 errors at about 1.1 modules/s on 8 vCPUs. A full build was projected at 40–45 hours, so we did not complete itours

Architecture. The code is split into several Lake libraries. Development is by far the largest, with 141,928 files and 12.2 million lines (ours). The directory-level graph is not layered: libraries import each other in both directions. For example, Development has 41,859 import lines into Formalism, and Formalism has 236 back into Development. At the file level there are no cycles, because Lean forbids them. A system that big with that coupling is hard to maintain or reuse, though that has no bearing on correctness. The proof map follows one path through it.

The pipeline and its trust boundaries.

  1. Source and elaboration (untrusted). lake build runs Lean's elaborator, tactics and the project's own code to produce compiled proof terms. A bug here can't create a false proof, because everything is re-checked downstream.
  2. Export (a boundary). lean4export writes every declaration as plain data (NDJSON). The export is "inert": no project code runs when it is checked. Independent rebuilds produced byte-identical exports.
  3. Kernels (trusted, diversified). Lean's own kernel checked every module (directly and via leanchecker, which replays modules through that same kernel). Independently written checkers re-verified the proof: nanoda (Rust), con-leche and con-ron on the full export, and lean4lean on every compiled module.
  4. Specification check. comparator and con-leche --compare confirm that the theorems have exactly the types written in a separate challenge file, which imports only Mathlib, and that only the allowed axioms are used.

Operational wrinkles (from the MIT page): the original build ran unsandboxed and invoked lean directly, and a later sandboxed build reproduced it. One module compiles non-deterministically, so .olean files need to be compared one by one. Older bundled checker binaries declined (exit 2, not a rejection) because of one reflexive inductive type, while current builds accept.

Security analysts: trusted computing base and threat model

Each way a false proof could slip through was closed by an independent check; what remains is trust in Lean's logic, Mathlib's definitions and the checkers' hardware. Encryption is unaffected.

The useful question is: how could a false proof get accepted? Here is each attack path and what closed it.

ThreatMitigationResidual risk
Wrong statement: proving something that only looks like RHRiemannHypothesis is Mathlib's own definition, vetted by experts. The project defines no rival RiemannHypothesis, riemannZeta or LFunction (we searched). The other four statements were restated in a challenge file importing only Mathlib and compared mechanically by two tools.Mathlib's definitions must mean what mathematicians mean. That is the main non-mechanical assumption, and the MIT page says so explicitly.
Smuggled axioms: assuming the result, or sorry#print axioms on all five theorems shows only propext, Classical.choice and Quot.sound. The environment has 15 axioms, all in Lean's Init (MIT). Our scan of all 175,187 files found 0 sorry, 0 admit and 0 axiom declarations.None beyond trusting those three standard axioms, which are the standard axioms used throughout Lean and Mathlib.
Escape hatches: code that skips the kernelOur scan found 0 native_decide, 0 ofReduceBool, 0 @[implemented_by] or @[extern], 0 unsafe, 0 opaque, and no kernel-skipping options. The 5 run_cmds only edit Lean's library-suggestion deny list.Low. Kernels that read the inert export never run project code anyway.
Malicious metaprogramming (tactics or build scripts that tamper with the environment or files)The export is inert data, and checking it runs no project code. A sandboxed build with no network and read-only source reproduced the export byte for byte.Low. The trusted step is the export tool, cross-checked by those reproductions.
Kernel bugDiverse redundancy: Lean's own kernel (including the leanchecker replay) and the independently written nanoda (Rust), con-leche, con-ron and lean4lean all accept. The community statement says con-leche and con-ron "come with a formal proof, relative to set theory, that they cannot accept a false proof".Very low. A false proof would need the same flaw in independently written checkers, or a flaw in the formal soundness proofs.
Supply chain (tampered Mathlib, dependencies or toolchain)Mathlib is pinned to one commit, with no vendored or modified copy. 8,322 Mathlib and 378 dependency .olean files are byte-identical to the official cache. The toolchain is a pinned release (v4.33.1).Trust in the official Mathlib cache and the Lean release. Independent kernels that re-check the export reduce reliance on the compiled toolchain.
Compromised build machineDozens of independent reproductions of the same export, plus checks run on different machines.Very low, unless many independent parties were compromised in the same way.

The trusted computing base, then, is: Lean's logic and three standard axioms; Mathlib's definitions of ζ, Dirichlet characters and L-functions; at least one correct kernel (several were used); and the integrity of the export. That is a small, well-understood base for a 17-million-line artefact, and it is a strong real-world case for diverse, independently verified checkers.

Cryptography: be precise

Business, financial and risk analysts

No direct market or operational impact; the remaining risk is whether the formal statement says what was intended, and that was checked by experts.

Policy and research-strategy analysts

Many "assuming RH" results become unconditional, and machine checking delivered trust long before human understanding.

Mathematics

Results proved conditionally on RH, or on GRH for Dirichlet L-functions, become unconditional. Examples include the error term in the prime number theorem and Robin's inequality. Results that need GRH for other L-functions remain conditional.

AI and research

The author credits an AI system heavily. The lesson for the field is that machine-checkable output made a 17-million-line proof trustworthy within a day, without anyone reading it. It also shows that verification can arrive long before understanding.

Formal-methods infrastructure

Verifying the proof required tools such as comparator, inert exports, and several independent and formally verified kernels. They worked under real pressure, and that is evidence for formal verification in high-assurance software more broadly.

Public research infrastructure

The whole check rested on Mathlib, a community-maintained open library, and on open-source checkers. The proof depends directly only on Mathlib. Who funds and maintains such shared libraries is now a practical research-policy question.

Questions this raises for policy, without settled answers:

Quantitative analysts

Little direct relevance to pricing or risk; some explicit prime-counting bounds lose their "assuming RH" caveat.

Briefly: this result has little direct relevance to pricing, risk models or trading. Where it does matter is explicit number-theoretic bounds. For example, Schoenfeld (1976, Corollary 1) showed that RH implies

$$\left|\pi(x)-\operatorname{li}(x)\right|\lt \frac{1}{8\pi}\sqrt{x}\,\ln x\qquad\text{for all } x\ge 2657.$$

That bound is now unconditional. Note the provenance, though: the implication from RH to this bound is a classical human-proved theorem, and it was not part of the Lean verification. Only the five Main.lean theorems and the Robin/Lagarias inequalities were machine-checked. Code that relied on RH-conditional constants, such as prime-counting estimates or GRH-dependent algorithm bounds for Dirichlet characters, can now drop the "assuming RH" caveat. Nothing speeds up, and no random-number or hashing scheme changes.

What is not yet known

Challenge (raised 21 Nov 2026; our check 22 Nov 2026). A non-peer-reviewed paper argues the proof is invalid because a geometry condition in the code is defined as "true". We checked: the condition is on the proof path, but that doesn't affect what the checkers confirmed; it shows that the geometric step named in the code does no logical work, which is part of why the proof is not yet understood. See Challenges and responses; replies are tracked on Status.

Signals to watch

The things that would change the picture (Alpöge's write-up, peer review, the Clay Institute, the last MIT checks, replies to the challenge, and extensions of the method) are listed, with their latest state, on the Status page. We keep them there so this page doesn't go stale.

Sources: the community statement and MIT page (see Sources); D. Platt and T. Trudgian, "The Riemann hypothesis is true up to 3·1012", Bull. London Math. Soc. 53(3) (2021) 792–797 (arXiv); L. Schoenfeld, Math. Comp. 30 (1976) 337–360, Corollary 1; full list on the Sources page; our measurements of the Lean archive (developers page).