On November 21, 2026, the Lean and Mathlib communities certified a 17-million-line proof of the Riemann Hypothesis, but the useful engineering lesson is not that Lean compiled a very large file. Assurance came from separate checks aimed at different failure modes: reproducing the artifact, proving the intended theorem, auditing its assumptions, and replaying its deductions through independently implemented checkers. A pipeline that stops at “the compiler exited zero” cannot distinguish a valid proof from the wrong theorem, a hidden axiom, a contaminated dependency cache, or a defective checking path.
The certification also needs a timestamp. Andrew Sutherland’s detailed MIT verification record, whose checks were run with Claude Code, was last updated at 04:35 UTC on November 22. At that point, the lake comparator run and Lean’s default and paranoid kernel checks on the exported proof were still running. The right conclusion is therefore bounded but substantial: many independent controls had passed, while specific named runs had not yet returned verdicts.
What was certified, and what each control contributes
Levent Alpöge released the library on November 20. The joint Lean and Mathlib statement, endorsed by the Lean FRO and the Mathlib Initiative, says the library depends directly only on Mathlib and certifies both its statement and its proof. That statement treats statement correctness, compilation, exact theorem matching, and proof checking as separate questions rather than treating compilation as a proxy for all four.
Sutherland’s record supplies the operational detail. Its controls are best understood as a map from artifacts to failures:
| Control and artifact | Recorded result | Failure a pass rules out | What remains outside that pass |
|---|---|---|---|
| Distributed compilation of the source and export | All 175,187 modules compiled with Lean and Mathlib v4.33.1 with zero errors; dozens of people reported reproducing the same raw export (joint statement, MIT record) | A one-off build accident or a result confined to the original workspace | The theorem’s identity, assumptions, and deductive validity |
| Dependency audit and sandboxed rebuild | 8,322 Mathlib and 378 dependency .olean files matched the official cache byte for byte; an independent build with no network and read-only source reproduced the export byte for byte (MIT record) | Undetected drift in cached dependencies and dependence on the original writable, networked environment | Whether the source states the right mathematics or every intermediate artifact is deterministic |
| Isolated statement comparison | Comparator and con-leche --compare confirmed an exact match with Mathlib’s statement; con-leche and con-ron comparison confirmed all five challenge theorems (joint statement, MIT record) | Proving a theorem other than the specified challenge | Whether Mathlib’s definitions capture the intended mathematical meaning |
| Axiom audit | The five headline theorems used only propext, Classical.choice, and Quot.sound; all 15 declared environment axioms were in Init (MIT record) | Unnoticed nonstandard assumptions introduced outside Lean core | The decision to accept those three standard axioms and the surrounding logical framework |
| Compiled-module replay | leanchecker replayed all 175,187 modules with zero rejections; lean4lean accepted every module after five deterministic step-limit cases were rerun with a raised limit (MIT record) | Invalid deductions escaping the completed per-module replay paths | Full-export checks, checker soundness, and correctness of the statement |
| Independent full-export checking | nanoda accepted the export in 27 minutes 42 seconds on 80 threads; con-leche built from master accepted 1,468,418 declarations in verified mode (MIT record) | Exclusive reliance on Lean’s official kernel implementation | Shared logical assumptions, checker or compiler defects, and the checks still running at the cutoff |
This division matters because a control cannot compensate for a question it never examines. A hundred successful builds still would not establish that the proved proposition is the Riemann Hypothesis. An exact statement match still would not establish that its proof is valid. Independent kernel acceptance strengthens the deduction check, but it cannot review whether the formal definitions express what a mathematician intended.
Reproduce the export, not merely the build message
The sandbox result is stronger than another successful invocation on the original machine. According to the MIT record, a separate machine built the archive with lake, without network access and with read-only source, exited successfully, and produced a byte-identical export. That tests both provenance and reproducibility: the result did not require an unrecorded network fetch or a writable source workspace.
The same page supplies a useful counterweight. 175,186 of the 175,187 compiled files were identical across the compared builds (MIT record), and one module compiled non-deterministically. That does not contradict the byte-for-byte export reproduction. It does rule out a broader claim that every intermediate build product was deterministic. An audit should compare the artifact that downstream checkers actually consume, while investigating intermediate differences rather than hiding them behind a final green status.
Version provenance belongs to the same control. Sutherland pins Lean v4.33.1 at commit 819816b2, Mathlib v4.33.1 at 0df444a3, and lean4export v4.33.0 at 15f6055e, built with Lean v4.33.1. The judge and additional kernels used Lean v4.36.0. These details allow another operator to distinguish a reproduced result from a superficially similar result obtained with a different toolchain.
A valid proof of the wrong theorem is still the wrong proof
The community added a file isolating the Riemann Hypothesis statement and importing only Mathlib. That creates a small review boundary: the challenge does not inherit the submission’s entire source tree merely to discover what was proved. Comparator and con-leche --compare then confirmed that Alpöge’s theorem was exactly Mathlib’s statement, according to the joint statement. Sutherland reports that the comparison modes of con-leche and its Rust port con-ron each confirmed all five theorems against a challenge containing 51,692 declarations (MIT record).
The axiom audit answers a different question. “Standard axioms only” does not mean “no axioms.” It means the five headline theorems depended on propext, Classical.choice, and Quot.sound, with no additional axioms declared outside Lean core. This prevents an unnoticed extra assumption from silently becoming part of the result, while leaving the accepted logical basis explicit.
Scope also needs to be stated mathematically, not inferred from the headline. According to secondary reporting by Unite.AI, the central theorem uses Mathlib’s definition: every zero of the Riemann zeta function other than the trivial zeros at negative even integers has real part one-half. The separate s ≠ 1 condition appears because Mathlib assigns the zeta function a conventional value at its pole. The checked set also includes Generalized Riemann Hypothesis statements for Dirichlet L-functions across all moduli and characters. It does not cover Dedekind zeta functions, Hecke L-functions, or general automorphic L-functions. Expanding “GRH was checked” into “every generalized L-function was checked” would be a requirements error, not a proof-kernel error.
Independent kernels narrow the trusted computing base
The joint statement says checking ran on an inert raw proof export, out of reach of hypothetical malicious code in the Lean proof sources. It reports acceptance by Lean’s official kernel, con-leche, con-ron, and third-party checkers written in different languages. It also says con-leche and con-ron carry formal proofs, relative to set theory, that they cannot accept a false proof.
Two distinctions keep that evidence accurate. First, nanoda and con-leche are the two independently written kernels that Sutherland reports accepting the full export; con-ron is a Rust port of con-leche, not a third independent full-export kernel in that summary. Second, the joint statement’s broad official-kernel wording should not be merged with Sutherland’s run-level table. His default and paranoid Lean-kernel checks on the export were still running at the cutoff. The records support reporting the community’s official-kernel claim and Sutherland’s pending runs separately, not declaring either that no official-kernel export check completed or that every such run finished.
Independent implementations reduce exposure to a defect in one checker. They do not prove that the implementations share no mistaken assumption, that their compilers and runtime environments are sound, or that the formal statement is the right requirement. This is a reduction in trusted components, not their disappearance.
A failed compatibility run is not a rejected proof
Sutherland’s matrix is especially useful because it preserves outcomes that a simplified dashboard would flatten into red crosses.
The con-leche and con-ron binaries bundled with Lean v4.36.0 exited with code 2 because they did not support one reflexive inductive type in the proof. The MIT record explicitly says this was not a rejection; versions built from master supported the type and accepted the proof. Likewise, lean4lean bundled with v4.36.0 was marked not applicable because it could not read a v4.33 core library, reporting the unknown constant Decidable.intro.
A deterministic resource limit needs the same care. Five modules initially hit lean4lean’s step limit during decide +kernel computations and passed with a raised limit. That is neither an unconditional first-run pass nor evidence of an invalid deduction. It is a completed acceptance with a recorded resource condition.
A reusable audit log should therefore distinguish at least these states:
- Pass or accept: the named checker completed its named artifact check.
- Match: statement comparison succeeded, which is not the same operation as kernel acceptance.
- Deterministic timeout: a declared resource bound was reached; a later pass must retain the changed bound.
- Compatibility exit: the tool could not process the artifact and returned no proof verdict.
- Not applicable: the checker and artifact format were incompatible.
- Running or no verdict: no completed result exists to cite.
Version drift is not peculiar to this announcement. An independent Rust-to-Lean verification experience report describes coordinating Hax-based work on Lean 4.26.0 and Aeneas-based work on 4.28.0. Its pipeline uses AI provers to close proof obligations, with every proof checked by the Lean kernel. That bounds the AI prover’s ability to bypass formal checking, but the version coordination shows why kernel acceptance cannot substitute for toolchain provenance.
What remains trusted after the kernels accept
A separate Lean verification report for JAX-derived computations makes the residual trust boundary explicit. It trusts the Lean kernel, Mathlib’s definitions, JAX’s tracer, and the jax-lean importer. The readable generated functions are not trusted; checked certificates link them to the imported program. That is the relevant model for AI-generated artifacts: generated text can be untrusted while the extraction path, formal definitions, and checker remain part of the trusted base.
The same paper offers a warning about scope. Its theorems are exact identities over real numbers and do not model IEEE-754 rounding, overflow, NaN, or infinities. Runtime tests with tolerances can provide evidence about execution, but they do not turn a real-number theorem into a proof about finite floating-point behavior. The analogous mistake here would be to treat kernel acceptance as validation of every intended mathematical interpretation or every software property surrounding the artifact.
Claude’s presence does not change that boundary. Sutherland documents checks run with Claude Code, and the secondary coverage describes Claude assistance, but the supplied evidence does not establish an autonomous solution. The assurance comes from what independent checks accepted, not from the provenance or confidence of the generating system.
A pipeline worth reusing
The following recommendation is an engineering inference from the distinct controls above, not the result of a comparative experiment on verification pipelines.
- Freeze and publish provenance. Record source, dependency, exporter, kernel, and comparator versions, including commits and relevant resource limits. Without this, another team cannot tell whether it reproduced the same experiment.
- Rebuild in a constrained environment. Use a separate machine or sandbox, restrict network access and source writes, and compare the downstream artifact byte for byte where determinism is expected. Report intermediate nondeterminism separately.
- Isolate the requirement. Import the challenge statement from the smallest appropriate trusted library, have its definitions reviewed, and compare the submitted theorem using independently implemented comparison paths. Proof checking cannot repair a mistranslated requirement.
- Audit assumptions and scope. List axioms explicitly and state which theorem families are covered and excluded. “Standard” and “generalized” are not substitutes for those lists.
- Replay both modules and exports. Use the official path where available, then add independently written checkers that consume the actual exported artifact. Keep per-module and full-export results separate.
- Publish the verdict ledger and residual trust. Record tool versions, accepted artifacts, timeouts, incompatibilities, and running checks. Name the kernels, definitions, importers, extraction tools, and logical axioms that remain trusted.
I would use that architecture for a large AI-generated proof-like artifact, but I would not promise that every AI-generated codebase can be made formally verifiable. The decision is whether a bounded formal property has earned enough independent assurance for the risk at hand. A pending run does not erase completed checks; it does prevent that run from supporting the claim.
Finally, mechanical certification is not mathematical comprehension. Secondary commentary on Alpöge distinguishes the certificate from a humanly explanatory argument and notes that the Clay Institute’s $1 million prize separately requires qualifying publication and two years of scrutiny. The available anchor records are rapid, community-authored evidence, not a broad independent mathematical review; the Xena criteria are asserted by the joint statement but were not independently examined here. For engineers, the durable result is still clear: certify exact properties with layered, reproducible checks, and keep comprehension, scope, and unfinished verdicts visible rather than letting one green status absorb them all.
Join the discussion
Share a useful perspective or ask a question about this article.