Dev.to AI πŸ€– Ai πŸ‘ 0 πŸ“– 3 min read

Yesterday, an AI Riemann Hypothesis proof passed formal verification. Humans are now translating all 17 million lines.

Yesterday, an AI Riemann Hypothesis proof passed formal verification. Humans are now translating all 17 million lines. On 20 November 2026, Anthropic mathematician Levent AlpΓΆge posted a four-page note announcing that h

Yesterday, an AI Riemann Hypothesis proof passed formal verification. Humans are now translating all 17 million lines.

On 20 November 2026, Anthropic mathematician Levent AlpΓΆge posted a four-page note announcing that he and Claude had discovered and formalized a proof of the Riemann Hypothesis and the Generalized Riemann Hypothesis over six weeks. Rather than releasing an AI-written paperβ€”which had already ballooned past 250,000 pagesβ€”he released 175,187 Lean 4 modules totaling roughly 17 million lines of formal code.

On 21 November 2026, the Lean and Mathlib communities, endorsed by the Lean Focused Research Organization (Lean FRO) and the Mathlib Initiative, certified the formal verification in the Lean community blog statement.

What the verification actually proved

Software engineers often confuse "a model claimed it" with "a kernel checked it." Here is what the verification logs from the Lean FRO and Andrew Sutherland's MIT verification page establish:

  1. Statement accuracy and matching: The headline theorem proves Mathlib's existing RiemannHypothesis definition. Isolated challenge files importing only Mathlib were matched against the proved theorems using comparator, con-leche --compare, and its Rust port con-ron.
  2. Axiom audit: Running #print axioms on the five headline theorems confirmed zero sorry placeholders and zero non-core axiomsβ€”only Lean's three standard axioms (propext, Classical.choice, Quot.sound). All 8,322 Mathlib .olean files matched the official cache byte-for-byte.
  3. Independent sandboxed rebuild: An offline, read-only lake build Main compiled all 175,187 modules with zero errors and produced an identical 61,570,595,788-byte proof export.
  4. Multi-kernel checking: The exported proof passed Lean's official kernel as well as independently written checkers in separate languages (nanoda, lean4lean, con-leche, and con-ron).

What remains open

Formal machine verification is still distinct from human mathematical consensus and the Clay Millennium Prize, which requires peer-reviewed publication and broad community understanding over two years. AlpΓΆge himself noted that he presented the formalization before mastering every neighbourhood of the surrounding mathematics. Mathematicians at the University of Waterloo and IHES have already published preliminary working expositionsβ€”including a 164-page draft translating the zeta-function argument back into classical analytic number theory.

The engineering shift: verification outlives comprehension

For decades, software delivery assumed a human reviewer could read every changed line before merge. When an AI workflow produces 17 million lines in six weeks, line-by-line comprehension stops being the gate.

What survives that shift is an isolated verification architecture:

[Illustrative AI-assisted verification gate]

1. Human-owned spec       ->  Freeze the target contract / theorem statement
2. Untrusted generator    ->  Agent writes implementation or proof (any volume)
3. Statement comparator   ->  Verify the output still proves the frozen contract
4. Independent checker    ->  Run deterministic kernel / tests outside the LLM
5. Human audit            ->  Review spec assumptions and flagged edge cases

Notice where human effort sits in that loop. You do not spend human hours reading 250,000 pages of generated prose. You spend human hours auditing the specification, checking that the comparator prevents goal-post moving, and running independent deterministic verifiers that cannot be sweet-talked by a confident model.

Four habits for AI engineering teams

  1. Verify the contract, not just the diff. Invest in strict schemas, type invariants, and property-based checks before scaling code-generation speed.
  2. Isolate the verifier. Lean's export cleared four independent kernels written in different languages. Never let the generating model be the sole grader of its own output.
  3. Separate machine truth from human audit. Let deterministic checkers pass or fail correctness, and focus human review on specification assumptions.
  4. Refuse unreadable bloat. AlpΓΆge rejected a 250,000-page prose dump and shipped machine-checkable modules instead. Demand concise, testable artifacts from your coding agents too.

Sources: Levent AlpΓΆge's note (alpo.ge/remark.pdf, 20 Nov 2026), Lean Community Blog (leanprover-community.github.io/blog/posts/riemann-hypothesis/, 21 Nov 2026), and MIT Mathematics verification log (math.mit.edu/~drew/grh/, updated 22 Nov 2026).

πŸ“° Read the original article on Dev.to AI

Originally published by Dev.to AI. Aggregated on AIWithGhost for educational purposes β€” full credit and traffic to the original publisher.