Verification files for the Lean proof of the Riemann Hypothesis
Announced at alpo.ge/remark.pdf on 20 November 2026.
Andrew Sutherland (MIT), checks run with Claude Code. Page last updated 2026-11-20 22:05 UTC. Results below are as of that time and this page will be updated as the remaining checks finish.
Summary
The published Lean source compiles without errors, the five headline theorems depend only on the three standard axioms, every module has been replayed through the Lean kernel, two independently written kernels, nanoda and con-leche, accept the full exported proof, and lean4lean accepts every compiled module. con-leche's --compare mode, an independent implementation of Comparator's statement matching, confirms all five theorems against the challenge. The lake comparator run and the Lean-kernel replay of the export are still in progress.
| Check | Result | Detail |
|---|---|---|
| All 175,187 modules compile (Lean v4.33.1, Mathlib v4.33.1) | pass | zero errors; finished 16:43:21 UTC |
#print axioms for the five theorems in Main.lean | pass | propext, Classical.choice, Quot.sound only (audit.log) |
| No axioms declared outside Lean core | pass | 15 axioms in the environment, all in Init |
| Mathlib files identical to the official cache | pass | 8,322 Mathlib and 378 dependency .olean files, byte for byte |
leanchecker kernel replay of every module | pass | 175,187 of 175,187; zero rejections; finished about 18:17 UTC |
| Challenge export equals the one published by Deicyde/riemann-hypothesis CI | match | sha256 bd484ac9…b2b9 |
| nanoda (independent Rust kernel) on the full export | accepts | exit 0 at 19:05:45 UTC; 27 min 42 s on 80 threads (nanoda.log) |
| Lean default kernel and Lean paranoid kernel on the export | running | single-threaded; no verdict yet |
lake comparator (Lean v4.36.0) end to end | running | statement comparison and axiom check already passed in one run; kernels in progress |
con-leche master (cd2eceab) on the full export | accepts | 1,468,418 declarations accepted in --verified mode; exit 0 at 21:19:04 UTC; 3 min 15 s on 64 threads (log) |
con-leche --compare (branch compare, 5dc36dc1): challenge against solution | accepts | all five theorems "justified by the solution"; 51,692 challenge declarations accepted; exit 0 at 21:19:12 UTC (log) |
lean4lean (67f63b0c, built with Lean v4.33.1) on the compiled files, module by module | pass | 175,187 of 175,187; finished about 21:55 UTC. 175,182 passed with default settings. Five hit lean4lean's default step limit ("deterministic timeout") on decide +kernel computations and passed when rerun with the limit raised (timeouts, reruns with flags) |
| con-leche and con-ron as bundled with Lean v4.36.0 | declined | exit 2, not a rejection: those older binaries do not support one reflexive inductive type in the proof. con-leche master, above, does. (log, log) |
| lean4lean bundled with Lean v4.36.0 | not applicable | cannot read a v4.33 core library (unknown constant 'Decidable.intro') |
What was verified
The theorem riemannHypothesis : RiemannHypothesis in the submission's Main.lean, where RiemannHypothesis is Mathlib's own definition (Mathlib/NumberTheory/LSeries/RiemannZeta.lean):
def RiemannHypothesis : Prop := ∀ (s : ℂ) (_ : riemannZeta s = 0) (_ : ¬∃ n : ℕ, s = -2 * (n + 1)) (_ : s ≠ 1), s.re = 1 / 2
and four further theorems, including the analogous statement for all Dirichlet L-functions. "GRH" here means Dirichlet L-functions only.
Downloads
The exported proof: output of lean4export on module Main. Unpacks to 61,570,595,788 bytes.
The exported challenge: the five statements with sorry proofs, importing only Mathlib. Unpacks to 350,862,970 bytes.
Smaller files:
- comparator.json: Comparator config naming the checkers that can process this proof
- SHA256SUMS: hashes of everything on this page
- audit.log and Audit.lean: the axiom audit and the file that produced it
- project-oleans.sha256: sha256 of each of the 175,187 compiled files (29 MB)
- nanoda.log: timing and exit status of the nanoda run
- con-leche-master.log and con-leche-compare.log: the two con-leche runs
Check it yourself
With Lean v4.36.0 installed, nothing needs to be built. You need roughly 100 GB of RAM and 70 GB of disk.
zstd -d --long=30 solution.ndjson.zst # --long=30 is required zstd -d --long=27 challenge.ndjson.zst sha256sum solution.ndjson challenge.ndjson # compare with the hashes above lake comparator --config comparator.json \ --challenge-from-export challenge.ndjson --solution-from-export solution.ndjson
nanoda alone took about 28 minutes on 80 threads. The Lean kernels are single-threaded and take much longer.
The fastest independent check is con-leche built from source (Lean v4.36.0, about two minutes to build). It needs about 50 GB of RAM and took under four minutes on 64 threads:
git clone https://github.com/leanprover/con-leche && cd con-leche git checkout compare # 5dc36dc1; master (cd2eceab) for the plain check lake build con-leche .lake/build/bin/con-leche --compare challenge.ndjson solution.ndjson
Provenance
| Item | Value |
|---|---|
| Source archive | lean.tar.gz, the 14 parts from alpo.ge joined; 239,275,554 bytessha256 9631b4f020199e580ba86178cb56c6e9b09f690c2369a80dc4334aa93f49c7fc |
| Source mirror | Deicyde/riemann-hypothesis, byte-identical to the archive apart from the Comparator files it adds |
| Lean / Mathlib | Lean v4.33.1 (commit 819816b2); Mathlib tag v4.33.1 (0df444a3) |
| Exporter | lean4export tag v4.33.0 (15f6055e), built with Lean v4.33.1; target list as in Deicyde's export-targets.txt |
| Judge and extra kernels | Lean v4.36.0: lake comparator, leanchecker, leanchecker-paranoid, nanoda_bin |
| lean4lean | digama0/lean4lean at 67f63b0c, built with Lean v4.33.1; run on the compiled .olean files, not the export |
| con-leche | leanprover/con-leche master at cd2eceab and branch compare at 5dc36dc1, each built with Lean v4.36.0 |
Main.olean | sha256 9146dfb4148e24d2252e04c50742f3e49dd126dfcc5006d10bf5f873ddf796ad |
| Manifest of all compiled files | sha256 375cbee2fc3fc0f5088ef2e6dc9a5ac5530924310dc62422ec65aac9dc4c1d25 |
Caveats
- The build ran on cloud machines without a sandbox, and compiled each file by calling
leandirectly with the same inputslakesupplies, not throughlake build. A 77-module sample of the output is byte-identical to a reallake build; the full set has not been compared against one. - The export therefore has the same unsandboxed provenance. An export from a sandboxed build (the Deicyde protocol) should have the same sha256 if exporting is deterministic; that comparison has not been made yet.
- A passing check shows that the formal statements, as written in Lean against Mathlib's definitions, follow from the three standard axioms according to the kernels used. It relies on those kernels and on Mathlib's definitions being what they are intended to be.
- A first build attempt used a wrong module root and was discarded in full; none of it is in these results.