A Claude-Assisted Riemann Proof Passed Lean's Compiler. That's Not the Same as Proving It

2026-11-21来源 dev.toEnglish

MIT's Andrew Sutherland independently compiled the Lean code, and it passed. That means the proof has no hard logical errors — as far as the machine can tell. But there is still one step between "the code compiles" and "the Riemann hypothesis is proved": the comparator run, which checks whether the code actually proves the Riemann hypothesis mathematicians mean, and not a lookalike. Until that step is done, the accurate description is "a proof candidate that passed machine checking" — not "proved."

The timeline: October 6 to November 20

Date Event
1859 Bernhard Riemann proposes the Riemann hypothesis: the distribution of primes is encoded in the zeros of the zeta function
2026-10-06 Levent Alpöge begins working with Claude across several areas of mathematics
2026-11-15 The date of a key step, according to his own timeline
2026-11-20 Alpöge publishes a 4-page note plus Lean formalization code (14 files), claiming proofs of the Riemann hypothesis and the generalized Riemann hypothesis
2026-11-20 MIT's Andrew Sutherland independently compiles the code — it passes
2026-11-20 A second proof appears the same day: Masullo, a 12-year human route, privately reviewed for months by Stanford's Brian Conrad

Two months earlier, OpenAI said its AI had solved another Millennium Prize problem (the fluid motion equations). The story of AI in mathematics is shifting from "assisting with computation" to "claiming to solve open problems."

What Lean formalization actually verifies

Lean is a theorem prover: you write a proof as code, and Lean's kernel checks every step for type correctness. A successful compile means the machine says "under the given axioms and definitions, every step of your derivation is free of logical errors."

But it does not check three things:

  1. Whether the statement is written correctly. You can formalize a proposition that looks like the Riemann hypothesis but is actually weaker, and it will still compile. This is the most common failure mode in formal verification.
  2. Whether definitions were swapped. Code can redefine a symbol's meaning to make the proof easier. Catching that requires a human reading the definitions, not just watching the compile succeed.
  3. Whether the trust base contains extra assumptions. sorry leaves an unproved placeholder; an extra axiom declaration quietly expands what counts as "known." The compiler will not judge whether those assumptions are reasonable.

So Sutherland's exact words are worth reading literally: "Honestly the chance that anything is fishy here is approximately zero." That is confidence at the level of compilation and re-checking — not a verdict that "the proof is established."

The comparator run: what the real gate looks like

According to Kevin Buzzard of Imperial College London, writing in the Lean community, the comparator run does two things:

  • (a) Statement matching: confirm that the theorem statement in the code is the same proposition the mathematical community recognizes as the Riemann hypothesis — no redefined symbols, no swapped definitions.
  • (b) Multi-kernel re-checking: recompile in paranoid mode with several independently implemented kernels, to rule out the possibility that the proof merely exploits an unknown bug in one kernel.

The process usually takes several hours. At the time of writing, no result has been published. In other words, every "almost certainly true" judgment so far rests on the compilation layer, not on the final confirmation.

Two proofs side by side: the AI route vs. the human route

Dimension Alpöge + Claude Masullo (human)
Time spent About 6 weeks of focused work (from 10-06) 12 years
Form of evidence Lean formalization code (14 files) Traditional handwritten draft
Verification progress Independent compile passed; comparator run pending Privately reviewed by Brian Conrad for months
How it was released A 4-page note on a personal website Published by Ravi Vakil, president of the American Mathematical Society
Point of contention Timing — the day after Anthropic's IPO; the note called "garbled" No public controversy so far

Two independent claims on the same day is itself a signal: either the problem had reached a moment where several people were closing in at once, or at least one of the verification processes is about to expose a new methodological problem. Either way, it is good for mathematics — the verification machinery is being stress-tested in public.

Honest limitations: what this post does not do

  • I have not read the original Lean code, so this post does not walk through the proof line by line.
  • It does not claim the proof is established: peer review has not begun, and the comparator run result is not out.
  • Granville's criticism ("What he released is garbled") targets the clarity of the written note, not the correctness of the proof — the two should be kept separate.
  • The Clay Institute's $1 million prize can, by its rules, only be considered for award from 2028 at the earliest. It is far from "money next week."
  • Alpöge consulted Anthropic CEO Dario Amodei before publishing, and he addressed the timing question in his note.

Four takeaways for developers

  1. Formalization is a guardrail for AI mathematics, not decoration. A natural-language proof can be vague; Lean code cannot — the compiler is the one reviewer that does not do favors.
  2. Verification has layers. Compiling, statement matching, multi-kernel re-checking, and peer review are four different checks, and missing any one of them means you cannot call it "proved." The same applies to agent systems: one passing check does not make a system trustworthy.
  3. Reproducibility is becoming hard currency. A proof anyone can recompile carries more weight than ten pages of eloquent argument. The same goes for technical writing: runnable code beats a pretty conclusion.
  4. Watch the comparator run, not the headline. If it passes, AI-assisted mathematics crosses a real threshold. If it catches a swapped statement, that is the formal verification machinery successfully intercepting an error.

The question

How would you judge this proof — wait for the comparator run, or go read those 14 Lean files first? And if you build agent systems: do you have your own equivalent of a comparator run — a check that the thing your system verified is actually the thing you asked it to verify? Let me know in the comments.

Sources: Scientific American (two articles), Nature, phys.org, DataCamp. The Lean mechanism description reflects standard knowledge in formal verification. This post will be updated when the comparator run result is published.

原文:https://www.a8q9.cn/en/article/a-claude-assisted-riemann-proof-passed-lean-s-compiler-that-s-not-the-same-as-pr-66d025.html

相关文章