Claude Just Proved Fermat's Last Theorem — and Computers Checked Every Line
Fermat's Last Theorem sat unsolved for 358 years. Andrew Wiles finally cracked it in 1995 after nearly a decade of work, in a proof so dense it took other mathematicians months just to verify it wasn't wrong. This week, Anthropic announced that Claude took that proof, rewrote it in a language a computer can check line by line — and did it in 11 days, largely on its own.
Here's what actually happened, and why it matters more than the headline number.
The Problem With "I Solved It, Trust Me"
Fermat scribbled his famous claim in a book margin around 1637, saying he had a "truly marvelous proof" that the margin was too small to contain. Turns out he probably didn't — no elementary proof has ever been found, and Wiles's eventual solution needed mathematical machinery that didn't exist for another three centuries.
Even Wiles's proof had a scare: two months into peer review, a gap was found that took him a year to fix. That's the real problem with hard math — a proof can look right to experts for months and still be broken. Understanding a novel result deeply enough to trust it can take years.
What "Formalizing" Actually Means
The fix mathematicians have been chasing is formalization: rewriting a proof in a language like Lean, where every single logical step — no matter how obvious it seems to a human — has to be spelled out completely. A computer then checks the whole chain automatically. No skipped steps, no benefit of the doubt.
The catch is that formalizing is brutally slow. The community's own plan just for the first phase of formalizing Fermat's Last Theorem ran to 86 pages, and the project was expected to take years.
Claude did it in 11 days.
The Numbers Are the Wrong Thing to Focus On (But Here They Are)
Working largely autonomously, dozens of Claude agents wrote 13 million lines of Lean code — more than 5x the size of Mathlib, the entire community-maintained library of formalized math that the proof builds on. Along the way they proved 30,300 intermediate theorems, using 29,500 of them in the final chain. The whole effort burned about six billion output tokens.
It wasn't clean the first time. Early agent attempts lost track of the project's state and stopped collaborating effectively — those failed runs still make up about 7% of the final proof's lines. What actually worked was pairing Claude with Prove2Me, a collaborative platform that keeps a shared map of which theorems are proven, which are still needed, and what depends on what — solving the exact problem that was tripping the agents up: memory degradation across a huge, long-running task.
Kevin Buzzard, the mathematician who led the multi-year community effort to formalize this exact theorem, reviewed Claude's proof and called it "an extraordinary autoformalization achievement" that proves the theorem "with no assumptions other than the axioms of mathematics."
Why Verification, Not Discovery, Is the Real Story
It's tempting to read this as "AI does advanced math," but that's not quite it — Claude didn't discover anything new here. It took an existing, already-accepted proof and did the tedious, exacting work of making it checkable by a machine instead of trusted on faith.
That distinction matters more than it sounds. As AI systems produce more and more claimed proofs and results, the bottleneck isn't generating ideas — it's the years of human referee time needed to confirm they're actually correct. If formalization can happen this fast, checking becomes cheap even when the underlying math stays hard. Buzzard put it plainly: this kind of autoformalization can start "rigorously checking LLM-generated mathematics," which right now is an extremely costly, human-led process.
What This Means If You Use OpenClaw
The part of this story that should stick with anyone running AI agents isn't the theorem — it's the shape of the work. Dozens of agents, running largely unsupervised for 11 days straight, coordinating through a shared source of truth about what's done, what's in progress, and what's next.
That's the same underlying pattern OpenClaw is built around: an agent that doesn't lose the thread between sessions, that tracks real progress on a real task instead of just answering the last thing you typed. Anthropic's team only kept things on track by giving Claude an external system to track state — which is exactly why persistent memory isn't a nice-to-have for agents doing real work, it's the difference between a project finishing and an agent quietly going in circles for 11 days.
You don't need six billion tokens and a Fields Medal-adjacent proof to feel that difference. Any long-running task — a multi-step coding job, a research pass, an ongoing workflow — benefits from an agent that remembers where it left off.