On Friday, November 20, Anthropic mathematician Levent Alpöge posted a four-page note that opens with a sentence mathematicians have waited 167 years to read: “I believe I have, working with Claude, discovered a proof of the Riemann Hypothesis.” He says the method goes further and covers the Generalized Riemann Hypothesis (GRH). He didn’t publish a human-readable paper. He published Lean code, about 17.4 million lines of it, according to Scott Aaronson.
The same day, Alpöge and NYU’s Tristan Buckmaster also posted AI-assisted proofs of finite-time blowup for the 3D Euler and Navier-Stokes equations. Here’s what was actually claimed, how far verification has gotten, and why developers should care even if they never touch number theory.
What was announced
Terence Tao summed up the three results on his blog, listed “in decreasing order of how ‘digested’ the results currently are.”
| Claim | Authors | What’s public | Tao’s read |
|---|---|---|---|
| Finite-time blowup, unforced 3D Euler | Alpöge, Buckmaster, Matei Coiculescu | 55-page paper + Lean | Human-readable proof |
| Finite-time blowup, unforced 3D Navier-Stokes | Alpöge, Buckmaster | 79-page paper + Lean | Strategy clear; needs a “proper, professionally written proof” |
| Generalized Riemann Hypothesis | Alpöge, with Claude | Lean only | “Enormous,” digestion “will take some time” |
Alpöge explains the missing paper bluntly. Claude’s written version ran past 250,000 pages, and he didn’t want to post “some massive unreadable travesty of ‘slop,'” so “I decided to only present Lean.” He also says the argument is “incredibly long at the moment” and that he expects it to be “massively simplified, likely immediately.”
One scope detail matters. MIT’s Andrew Sutherland, who is running verification checks, notes on his verification page that “GRH” in the Lean files “means Dirichlet L-functions only.” That’s a huge result if it holds, but it isn’t GRH in its broadest sense.
Where verification stands
As of Sutherland’s last update (5:05 p.m. ET on Nov. 20), the results are strong but not finished:
- All 175,187 Lean modules compile with zero errors.
- The five headline theorems rely only on Lean’s three standard axioms.
- Independent kernels (nanoda, con-leche and lean4lean) accept the proof.
- The official
lake comparatorrun and Lean’s default and paranoid kernel rechecks were still running. - The build ran without a sandbox, and comparison against a sandboxed build hadn’t been done yet.
Why does the comparator matter? Kevin Buzzard, quoted by Scientific American, said it checks that the code doesn’t “redefine the meaning of any of the symbols in the statement” and isn’t “exploiting an as yet unknown bug in Lean’s official kernel.” Quanta describes the same risk: Lean “can itself contain bugs” and can be used to play “sneaky tricks.”
Aaronson flags those same weak spots. Lean has had kernel bugs that “in the past, allowed proofs of 0=1,” and its type theory has “uncertain soundness.” He thinks “a sufficiently motivated AI could almost certainly exploit them.” Still, he sees “zero indications” that’s happening here, and his bet “is that the proof will stand.”
Sutherland told Scientific American that “the chance that anything is fishy here is approximately zero.” Nobody has peer-reviewed this, though, and nobody yet understands the proof. NYU’s Maksym Radziwiłł told Quanta that Alpöge’s write-up contains “nonsensical statements” and doesn’t answer the question “why?”
The Navier-Stokes claim, read carefully
Navier-Stokes is one of the Clay Millennium Prize problems, so precision matters here. The paper’s abstract claims smooth initial data on R3 and on the torus whose solutions “without force blow up in finite time.” It says this disproves statements (A) and (B) of the problem as formulated by Fefferman, and so proves (C) and (D). In plain terms, it claims smooth fluid flows can break down.
Three caveats come straight from the repo itself:
- The numerical “certificate” the proof depends on “will be released soon.” It isn’t in the repo yet.
- A rigorous interval-arithmetic computation “is not part of the formalization.”
- A patch from Nov. 20 was applied, but “the patched package was not rebuilt.”
Buckmaster wrote that the write-up is “unpolished and heavily LLM-assisted.” Even if everything checks out, Clay’s rules require publication in a qualifying outlet, two years of waiting and “general acceptance” before a prize is considered.
There’s also a human-only contender. Stanford’s Ravi Vakil, president of the American Mathematical Society, rushed out Alessandro Masullo’s proposed GRH proof, written with no AI. About eight hours later, he added that several people had reported problems with it.
Why this matters beyond math
Six weeks ago the AI-math headline was OpenAI’s “quasi-Riemann” result. That proof confines the zeros to a strip between 1/8 and 7/8, within 3/8 of the critical line, as Quanta explained. The field going from that to a claimed full proof in about six weeks is a big jump, and it fits a run of AI proof claims we’ve covered, like OpenAI’s Exponential Time Hypothesis claim.
How the work got done matters too. Quanta contrasts it with OpenAI’s October batch, “almost all” of which came from a simple prompt. Here, Alpöge’s expertise drove “repeated, iterative attempts with Claude.” The expert framed the problem and picked the direction, and the model did the heavy technical work. That’s also the setup that works best with today’s coding agents.
Quanta also reported that Anthropic hadn’t made an official announcement as of its writing. We found nothing on Anthropic’s newsroom either. Alpöge addressed the timing, which came a day after Anthropic’s market debut, head-on: “The precise timing is horrible,” he wrote. He says the cynical reading “is false.”
What developers should take from it
The proof’s credibility doesn’t come from Claude sounding confident. It comes from a machine checker. That’s the lesson for anyone shipping AI-written code.
- Check the spec, not just the proof. Buzzard’s first question was whether the Lean statement matches the real theorem. In your codebase, that’s your tests. If AI writes both the code and the tests, a green CI run can be meaningless. See how to test an AI feature.
- Know your trusted base. A Lean proof is only as good as the kernel and the definitions. Your AI pipeline’s trust rests on your linters, type checker and test harness, so keep those human-owned.
- Use independent checkers. Sutherland ran several separately written kernels. Get a second model or a static analyzer to review important AI output.
- Don’t trust prose without a checker. Alpöge himself says parts of his timeline paraphrase a “slop” summary “which might make zero sense.” Fluent explanations can be wrong. Here’s why AI makes things up.
What to watch next
- The comparator and paranoid-kernel results on Sutherland’s page.
- The Lean Zulip thread, which Tao calls the best place to follow verification.
- Release of the Navier-Stokes certificate and a proper human write-up.
- Whether the strategy can be distilled into something people can read. Aaronson expects that “will probably take years.”
Our take: the machine-checking looks very good, and that’s new and historic. “Compiles in Lean” and “mathematicians understand it” are different milestones, though. Only the first one is in sight. Treat any headline saying “solved” as early until the comparator finishes and experts sign off.


