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
Exactly what is proved
| Statement | Status |
|---|---|
| Riemann Hypothesis (Mathlib's definition) | Proved |
| No zeros of any Dirichlet L-function with \(\operatorname{Re}s\gt \tfrac12\), for all moduli and all characters | Proved |
| 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 general | Not 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:
- Right statement. Mathlib's
RiemannHypothesis, "carefully vetted by experts in Lean and number theory". - Compiles. "Dozens of people have reported correct compilation of the codebase, reproducing the same raw proof export file."
- Proves that statement. A challenge file importing only Mathlib was compared with the solution by two independent tools (comparator and con-leche
--compare). - 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.
| Evidence | What it establishes | What 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. |
Points that matter for a data mindset:
- There is no sampling and no confidence interval. Every declaration was checked, not a sample. The remaining uncertainty is not statistical. It sits in the trusted base: the axioms, Mathlib's definitions, and correct checkers.
- Replication here means bit-identical reproduction. "Dozens of people" reproduced the same export file, and the MIT page records an independent sandboxed build whose export is byte-identical. Those are independent re-runs of a deterministic pipeline. They are not independent statistical samples, and their value is in catching tampering and environment errors.
- Provenance is checkable. The archive is 239,275,554 bytes with a published SHA-256. The unpacked export files have published hashes too (see the developers page). Anyone can confirm they are checking the same data.
- Numerical work keeps its value. Explicit computations remain the way to get concrete constants and to test software, and they now act as a check on any future claimed counterexample, which is impossible unless the trusted base is broken.
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).
| Measure | Value | Source |
|---|---|---|
| Lean modules (files) | 175,187 | ours; MIT agrees |
| Lines of Lean | 17,374,215 (the community statement says "about 17 million") | ours |
| Declarations checked by con-leche | 1,468,418 | MIT |
| Archive | 14 parts, 239,275,554 bytes; 1.03 GB unpacked | ours |
| File sizes | median 3.5 KB, largest 914 KB | ours |
Import closure of Main | all 175,187 modules; the longest import chain is 203 modules deep | ours |
| Directory-level dependency graph | 343 groups, 1,237 edges | ours |
| External dependencies | Mathlib only (pinned commit), plus Mathlib's standard dependencies. 8,322 Mathlib and 378 dependency .olean files match the official cache byte for byte | community statement; MIT |
| Proof export (input to the kernels) | 61.6 GB unpacked | MIT |
| Fastest independent kernel run | nanoda, 27 min 42 s on 80 threads | MIT |
| Resources for checking it yourself | about 50 GB RAM for con-leche; about 100 GB RAM and 70 GB disk for the full lake comparator | MIT |
| Our partial build | 1,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 it | ours |
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.
- Source and elaboration (untrusted).
lake buildruns 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. - Export (a boundary).
lean4exportwrites every declaration as plain data (NDJSON). The export is "inert": no project code runs when it is checked. Independent rebuilds produced byte-identical exports. - 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. - Specification check. comparator and
con-leche --compareconfirm 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.
| Threat | Mitigation | Residual risk |
|---|---|---|
| Wrong statement: proving something that only looks like RH | RiemannHypothesis 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 kernel | Our 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 bug | Diverse 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 machine | Dozens 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
- RH being true doesn't break anything. RSA rests on the difficulty of factoring, and elliptic-curve schemes on discrete logarithms. Neither problem's difficulty depended on RH being false. The proof contains no factoring or discrete-log algorithm, and nothing needs rotating or patching.
- Post-quantum schemes (lattices, hashes, codes) rest on unrelated problems and are unaffected.
- What does change is guarantees, not attacks. Miller (1976) showed that, if the extended Riemann hypothesis (here: GRH for Dirichlet L-functions) holds, his primality test needs to try only about \((\ln n)^2\) bases, which makes it deterministic and polynomial-time. Bach (1990) made this explicit: under that hypothesis every odd composite \(n\) has a strong witness (a base that exposes it in the Miller–Rabin test) below \(2(\ln n)^2\). For whole numbers Bach's proof needs the hypothesis only for ζ and Dirichlet L-functions, which is exactly what has now been proved, so the bound now holds unconditionally. That step rests on Miller's and Bach's published proofs; it is not part of the Lean check. In practice, real systems run fast randomised tests such as Miller–Rabin; an unconditional deterministic polynomial-time test already existed (AKS, 2002), but it is rarely used because it is slow. GRH for Dedekind zeta functions of number fields, which some other algorithms assume, is not covered.
- Analyses that assume GRH for number fields stay conditional. That GRH (Dedekind and Hecke L-functions) was not proved here.
- Security tooling lesson. The real security story is the verification method: an untrusted, enormous, AI-assisted artefact was made trustworthy through a small trusted base, inert data exchange, reproducible builds and diverse checkers. That pattern carries over to verified software and to the software supply chain.
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.
- No direct operational or market impact. No algorithm, product or security property in everyday use depended on RH being unresolved. Banking, payments, crypto-assets and encryption are unaffected (see cryptography).
- The residual risk is specification risk, not execution risk. Execution, meaning whether each step is valid, was checked exhaustively and redundantly. What remains is whether the formal statement captures the intended claim. The same split applies to any AI-generated work: machine checking can remove execution risk, but someone still has to own the requirements.
- Verification has a real cost. Checking took tens of GB of RAM per run, several machines, and a projected 40–45 hours for a full build on a modest 8-vCPU machine (our measurement). It is affordable for a landmark result, but it is not free, so budget for it when assessing formal methods.
- Verification arrived before understanding. The proof was certified about a day after release, but there is no human-readable account yet. Decisions that depend on using the method, such as extending it or reusing its intermediate results, carry more uncertainty than decisions that depend only on RH being true.
- We make no market claims. We don't estimate commercial value, prize outcomes or effects on any company. For the Clay Institute's position, see Status.
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:
- Credit and authorship when an AI system did much of the work. The announcement says the proof was found "working with Claude".
- Publication norms. Certification is not peer review. How journals and prize committees should treat a Lean-only proof is open (for any news, see Status).
- Research assessment. How to value verification infrastructure, library maintenance and exposition alongside headline theorems.
- Education. Australian curricula already teach proof, primes and complex numbers; see Australian classrooms for where this connects.
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
- Human understanding. There is no complete human-readable proof. A draft guide (21 Nov 2026) explains the strategy and derives RH from one main inequality, but takes that inequality from the Lean code (see How the argument works). The author describes the argument as using "an astounding amount of mathematics" and expects it to be "massively simplified". Absorbing it will take the field a long time.
- Which internal results are faithful to the literature. The library proves its own versions of many famous theorems (Galois representations, local Langlands, and others). Their correctness is guaranteed, because they are proved. Whether each one is a faithful formalisation of the published theorem with the same name has not been assessed, by us or, as far as we know, by others. This affects how reusable they are, not whether RH is proved.
- Extensions. Whether the method extends to other L-functions is open.
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.