{"slug": "verification-files-for-the-lean-proof-of-the-riemann-hypothesis", "title": "Verification files for the Lean proof of the Riemann Hypothesis", "summary": "Andrew Sutherland of MIT reported on 20 November 2026 that the published Lean source for a claimed proof of the Riemann Hypothesis compiles without errors across all 175,187 modules under Lean v4.33.1 and Mathlib v4.33.1, with the five headline theorems depending only on the three standard axioms propext, Classical.choice and Quot.sound. Two independently written kernels, nanoda and con-leche, accepted the full exported proof, and lean4lean passed 175,187 of 175,187 compiled modules, though five hit its default step limit on decide +kernel computations and passed only when rerun with the limit raised. The lake comparator run and the Lean-kernel replay of the export were still in progress as of 2026-11-21 12:55 UTC.", "body_md": "# Verification files for the Lean proof of the Riemann Hypothesis\n\nAnnounced at [alpo.ge/remark.pdf](https://alpo.ge/remark.pdf) on 20 November 2026.\n\nAndrew Sutherland (MIT), checks run with Claude Code. Page last updated 2026-11-21 12:55 UTC. Results below are as of that time and this page will be updated as the remaining checks finish.\n\n## Summary\n\nThe 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.\n\n| Check | Result | Detail | \n|---|---|---|\n| All 175,187 modules compile (Lean v4.33.1, Mathlib v4.33.1) | pass | zero errors; finished 16:43:21 UTC | \n| `#print axioms` for the five theorems in`Main.lean` | pass | `propext` ,`Classical.choice` ,`Quot.sound` only ([audit.log](audit.log) ) | \n| No axioms declared outside Lean core | pass | 15 axioms in the environment, all in `Init` | \n| Mathlib files identical to the official cache | pass | 8,322 Mathlib and 378 dependency `.olean` files, byte for byte | \n| `leanchecker` kernel replay of every module | pass | 175,187 of 175,187; zero rejections; finished about 18:17 UTC | \n| Challenge export equals the one published by [Deicyde/riemann-hypothesis](https://github.com/Deicyde/riemann-hypothesis) CI | match | sha256 bd484ac9…b2b9 | \n| 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](nanoda.log) ) | \n| Lean default kernel and Lean paranoid kernel on the export | running | single-threaded; no verdict yet | \n| `lake comparator` (Lean v4.36.0) end to end | running | statement comparison and axiom check already passed in one run; kernels in progress | \n| 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-master.log) ) | \n| 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](con-leche-compare.log) ) | \n| 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](lean4lean-default-fuel-timeouts.log) ,[reruns with flags](lean4lean-raised-fuel.log) ) | \n| 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](con-leche-bundled-4.36.log) ,[log](con-ron-bundled-4.36.log) ) | \n| lean4lean bundled with Lean v4.36.0 | not applicable | cannot read a v4.33 core library ( `unknown constant 'Decidable.intro'` ) | \n\n## What was verified\n\nFive theorems, proved in the submission's `Main.lean`. Their statements are below exactly as they appear in the challenge file, which imports only Mathlib. All the mathematical notions in them (`riemannZeta`, `DirichletCharacter`, `DirichletCharacter.LFunction`, `IsPrimitive`) are Mathlib's.\n\n**1. The Riemann Hypothesis**, using Mathlib's own definition (`Mathlib/NumberTheory/LSeries/RiemannZeta.lean`): every zero of ζ other than the trivial zeros −2, −4, −6, … has real part 1/2. The condition `s ≠ 1` is there because Mathlib assigns ζ a conventional value at its pole.\n\n```\ndef RiemannHypothesis : Prop :=\n  ∀ (s : ℂ) (_ : riemannZeta s = 0) (_ : ¬∃ n : ℕ, s = -2 * (n + 1)) (_ : s ≠ 1), s.re = 1 / 2\n\ntheorem riemannHypothesis : RiemannHypothesis\n```\n\n**2. The same statement written out** in the submission's own words. Lean accepts the two as equal by definition.\n\n```\ntheorem riemannZeta_eq_zero_re :\n  ∀ s : ℂ, riemannZeta s = 0 → (¬∃ n : ℕ, s = -2 * ((n : ℂ) + 1)) → s ≠ 1 → s.re = 1 / 2\n```\n\n**3. No zeros to the right of the critical line, for every Dirichlet L-function.** For every modulus `N ≥ 1` and every Dirichlet character χ modulo N, primitive or not, L(χ, s) ≠ 0 whenever Re s > 1/2. The one excluded case is the trivial character at `s = 1`, where the L-function has its pole.\n\n```\ntheorem LFunction_ne_zero_of_half_lt_re :\n  ∀ (N : ℕ) [NeZero N] (χ : DirichletCharacter ℂ N) (s : ℂ),\n    1 / 2 < s.re → (χ ≠ 1 ∨ s ≠ 1) → DirichletCharacter.LFunction χ s ≠ 0\n```\n\n**4. Zeros in the critical strip lie on the critical line, for every Dirichlet L-function.**\n\n```\ntheorem LFunction_eq_zero_re :\n  ∀ (N : ℕ) [NeZero N] (χ : DirichletCharacter ℂ N) (s : ℂ),\n    0 < s.re → s.re < 1 → DirichletCharacter.LFunction χ s = 0 → s.re = 1 / 2\n```\n\n**5. The same for primitive characters**, the form in which the Generalized Riemann Hypothesis for Dirichlet L-functions is usually stated.\n\n```\ntheorem LFunction_eq_zero_re_of_isPrimitive :\n  ∀ (N : ℕ) [NeZero N] (χ : DirichletCharacter ℂ N), χ.IsPrimitive →\n    ∀ s : ℂ, 0 < s.re → s.re < 1 → DirichletCharacter.LFunction χ s = 0 → s.re = 1 / 2\n```\n\n**Scope.** \"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.\n\n## Arithmetic consequences\n\nAs a check that does not depend on Mathlib's definition of the zeta function, the proof was combined with [kimihiro64/Robin1984](https://github.com/kimihiro64/Robin1984) (commit `acab1a3`), an independent formalization of Robin's and Lagarias's criteria on the same Lean and Mathlib versions. Importing both gives two theorems about the divisor sum, with no hypotheses and no mention of zeta ([ArithSolution.lean](ArithSolution.lean); statements alone in [ArithChallenge.lean](ArithChallenge.lean), which imports only Mathlib):\n\n```\ntheorem robin_inequality :\n    ∀ n : ℕ, 5040 < n →\n      ((ArithmeticFunction.sigma 1 n : ℕ) : ℝ) <\n        Real.exp Real.eulerMascheroniConstant * (n : ℝ) * Real.log (Real.log (n : ℝ))\n\ntheorem lagarias_inequality :\n    ∀ n : ℕ, 0 < n →\n      ((ArithmeticFunction.sigma 1 n : ℕ) : ℝ) ≤\n        (harmonic n : ℝ) + Real.exp (harmonic n : ℝ) * Real.log (harmonic n : ℝ)\n```\n\n| Robin1984 on its own (its three equivalences with RH) | Result | Detail | \n|---|---|---|\n| Robin1984 builds with `lake build` | pass | 4,435 jobs, exit 0 | \n| con-leche `master` and`--compare` | accepts | 69,293 declarations accepted; all three theorems justified against its own challenge ( [log](robin1984-con-leche-compare.log) ) | \n| Unmodified Comparator v4.33.0 with the repository's own config | pass | nanoda accepts, Lean default kernel accepts, \"Your solution is okay!\"; exit 0 at 03:31:06 UTC ( [log summary](robin1984-comparator-v4.33.0.log) ) | \n| `lake comparator` (Lean v4.36.0) from exports | pass | Lean paranoid kernel, nanoda and Lean default kernel all accept; \"Your solution is okay!\"; exit 0 at 04:16:52 UTC ( [log summary](robin1984-lake-comparator-4.36.log) ) | \n\n| The two inequalities (RH proof combined with Robin1984) | Result | Detail | \n|---|---|---|\n| `robin_inequality` and`lagarias_inequality` compile;`#print axioms` | pass | `propext` ,`Classical.choice` ,`Quot.sound` only ([audit](arith-audit.log) ) | \n| con-leche `master` on the full combined export | accepts | 1,472,825 declarations accepted in `--verified` mode; exit 0 at 02:29:56 UTC ([log](arith-con-leche-master.log) ) | \n| con-leche `--compare` against`ArithChallenge` | accepts | both theorems \"justified by the solution\"; exit 0 at 02:29:06 UTC ( [log](arith-con-leche-compare.log) ) | \n| nanoda on the full combined export | accepts | exit 0 at 02:56:46 UTC; 33 min 46 s on 64 threads ( [log](arith-nanoda.log) ) | \n| `lake comparator` (Lean v4.36.0) on the combined export | running | statement comparison and axiom check passed; its Lean kernel stages are single-threaded on a 62 GB export and are expected to take many hours, as for the main proof | \n\nThe combined export is 61,752,134,938 bytes, sha256 44651dcc482a6e06e8d626994221aff638e422fded189bf856e0c31176926f0d; its challenge export has sha256 088a57c9e7454fa5279a86a825e551828ac8431694855aadd1f6e6a6eb37bb1d. These statements still rely on Mathlib's definitions of the divisor sum, Euler's constant, harmonic numbers, `exp` and `log`, and on the Robin1984 proof, which is why that proof was put through the same checks.\n\n## Downloads\n\n[solution.ndjson.zst](solution.ndjson.zst)7.7 GB (7,699,933,588 bytes)\n\nThe exported proof: output of lean4export on module `Main`. Unpacks to 61,570,595,788 bytes.\n\n[challenge.ndjson.zst](challenge.ndjson.zst)47 MB\n\nThe exported challenge: the five statements with `sorry` proofs, importing only Mathlib. Unpacks to 350,862,970 bytes.\n\nSmaller files:\n\n- [comparator.json](comparator.json) : Comparator config naming the checkers that can process this proof\n- [SHA256SUMS](SHA256SUMS) : hashes of everything on this page\n- [audit.log](audit.log) and[Audit.lean](Audit.lean) : the axiom audit and the file that produced it\n- [project-oleans.sha256](project-oleans.sha256) : sha256 of each of the 175,187 compiled files (29 MB). These hashes depend on the build directory; see[the note below](#manifest-path) .\n- [nanoda.log](nanoda.log) : timing and exit status of the nanoda run\n- [con-leche-master.log](con-leche-master.log) and[con-leche-compare.log](con-leche-compare.log) : the two con-leche runs\n\n## Check it yourself\n\nWith Lean v4.36.0 installed, nothing needs to be built. You need roughly 100 GB of RAM and 70 GB of disk.\n\n```\nzstd -d --long=30 solution.ndjson.zst      # --long=30 is required\nzstd -d --long=27 challenge.ndjson.zst\nsha256sum solution.ndjson challenge.ndjson  # compare with the hashes above\n\nlake comparator --config comparator.json \\\n  --challenge-from-export challenge.ndjson --solution-from-export solution.ndjson\n```\n\nnanoda alone took about 28 minutes on 80 threads. The Lean kernels are single-threaded and take much longer.\n\nThe 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:\n\n```\ngit clone https://github.com/leanprover/con-leche && cd con-leche\ngit checkout compare        # 5dc36dc1; master (cd2eceab) for the plain check\nlake build con-leche\n.lake/build/bin/con-leche --compare challenge.ndjson solution.ndjson\n```\n\n## Provenance\n\n| Item | Value | \n|---|---|\n| Source archive | `lean.tar.gz` , the 14 parts from alpo.ge joined; 239,275,554 bytessha256 9631b4f020199e580ba86178cb56c6e9b09f690c2369a80dc4334aa93f49c7fc | \n| Source mirror | [Deicyde/riemann-hypothesis](https://github.com/Deicyde/riemann-hypothesis) , byte-identical to the archive apart from the Comparator files it adds | \n| Lean / Mathlib | Lean v4.33.1 (commit `819816b2` ); Mathlib tag`v4.33.1` (`0df444a3` ) | \n| Exporter | lean4export tag `v4.33.0` (`15f6055e` ), built with Lean v4.33.1; target list as in Deicyde's`export-targets.txt` | \n| Judge and extra kernels | Lean v4.36.0: `lake comparator` ,`leanchecker` ,`leanchecker-paranoid` ,`nanoda_bin` | \n| lean4lean | [digama0/lean4lean](https://github.com/digama0/lean4lean) at`67f63b0c` , built with Lean v4.33.1; run on the compiled`.olean` files, not the export | \n| con-leche | [leanprover/con-leche](https://github.com/leanprover/con-leche)`master` at`cd2eceab` and branch`compare` at`5dc36dc1` , each built with Lean v4.36.0 | \n| `Main.olean` | sha256 9146dfb4148e24d2252e04c50742f3e49dd126dfcc5006d10bf5f873ddf796ad | \n| Manifest of all compiled files | sha256 375cbee2fc3fc0f5088ef2e6dc9a5ac5530924310dc62422ec65aac9dc4c1d25 valid only for the build directory `/home/ubuntu/grh/src/lean` ; see[the note below](#manifest-path) | \n| Build directory | the archive's `lean/` directory was at`/home/ubuntu/grh/src/lean` on every build machine, so each source file was passed to Lean as`/home/ubuntu/grh/src/lean/src/<Module/Path>.lean` | \n\n## Caveats\n\n- The build ran on cloud machines without a sandbox, and compiled each file by calling `lean` directly with the same inputs`lake` supplies (module name, package name and the lakefile's options), not through`lake build` .\n- **The per-file `.olean` hashes depend on the build directory.** In Lean v4.33.1 a compiled file stores each linter message together with the absolute path of its source file. Of our 175,187 compiled files, 98,219 contain the path`/home/ubuntu/grh/src/lean/src/…` ; the other 76,968, including`Main.olean` , contain no path. So`project-oleans.sha256` and its sha256 can be reproduced in full only by a build whose source tree is at`/home/ubuntu/grh/src/lean` . For a build at any other path, only the files of modules that emit no linter messages should match.\n What we checked: a`lake build` of 240 modules on a different machine, at a different path, gave 168 files identical to the manifest and 72 different; all 72 contain that build's path and none of the 168 do. Separately, 77 modules compiled both ways in the same directory, by`lake build` and by our direct invocation, were byte-identical. We have not compared the full set against a`lake build` .\n- The exported proof (`solution.ndjson` ) is the artifact the independent kernels checked. Its hash is the one to compare across builds; we have not examined whether the export format can carry a source path.\n- The export was produced from that unsandboxed build. We have not ourselves compared its sha256 with an export made from a sandboxed `lake build` .\n- 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.", "url": "https://wpnews.pro/news/verification-files-for-the-lean-proof-of-the-riemann-hypothesis", "canonical_source": "https://math.mit.edu/~drew/grh/", "published_at": "2026-11-21 15:54:34+00:00", "updated_at": "2026-11-21 16:13:34.447529+00:00", "lang": "en", "topics": ["artificial-intelligence", "ai-tools", "ai-research"], "entities": ["Andrew Sutherland", "MIT", "Lean", "Mathlib", "nanoda", "con-leche", "lean4lean", "Riemann Hypothesis"], "also_reported_by": [], "takeaway": "Independent kernel replay is the check that matters: nanoda accepted the full export in 27 min 42 s on 80 threads and con-leche accepted 1,468,418 declarations, while five lean4lean modules needed a raised step limit to clear decide +kernel computations.", "recommendation": {"advice": "Verify large Lean proofs with multiple independent kernels and raise lean4lean's step limit when decide +kernel modules hit the default deterministic timeout.", "playbook": "evals-testing", "playbook_url": "https://wpnews.pro/playbooks/evals-testing"}, "alternates": {"html": "https://wpnews.pro/news/verification-files-for-the-lean-proof-of-the-riemann-hypothesis", "markdown": "https://wpnews.pro/news/verification-files-for-the-lean-proof-of-the-riemann-hypothesis.md", "text": "https://wpnews.pro/news/verification-files-for-the-lean-proof-of-the-riemann-hypothesis.txt", "jsonld": "https://wpnews.pro/news/verification-files-for-the-lean-proof-of-the-riemann-hypothesis.jsonld"}}