Table of Contents
Key Takeaway
- 🧮 The Achievement: The Claude Fermat proof — the first complete computer-checked formalization of Fermat’s Last Theorem in the Lean programming language — was published September 4, 2026, a task mathematicians expected to take years.
- 📏 The Scale: 13 million lines of Lean code, 30,300 theorems proved (29,500 used in the final proof), roughly six billion output tokens, and 11 days of largely autonomous work.
- 🔬 Why It Can’t Be Faked: The Lean compiler accepts or rejects — no plausible-sounding arguments, no benchmark inflation. A machine-checked proof of a 360-year-old theorem is the least forgeable AI achievement ever demonstrated.
- 🧠 The Verdict: Reviewer Kevin Buzzard of Imperial College London: “If the automatic formalization of FLT is possible now, then we have taken a big step towards automatic formalization of the modern mathematical literature.”
A machine just proved Fermat’s Last Theorem — not solved it, which Andrew Wiles did in 1995, but checked every logical step of Wiles’s 360-year-old result with a computer, in 11 days. Anthropic announced on September 4, 2026 that its Claude model produced the first end-to-end, machine-checked formalization of Fermat’s Last Theorem in the Lean programming language: 13 million lines of code, 30,300 theorems proved along the way, and a verification that rests on nothing but the three standard axioms of mathematics. Kevin Buzzard, the Imperial College London mathematician who reviewed the proof, called it an “extraordinary autoformalization achievement” and said that if formalizing Fermat is possible now, “we have taken a big step towards automatic formalization of the modern mathematical literature.”
The reason this AI math proof matters far beyond mathematics is the nature of the verification itself. In an era when every AI benchmark can be gamed, inflated, or quietly redefined, a Lean compiler is incorruptible: it either accepts the proof or rejects it, and there is no middle ground to negotiate. This is the first frontier-AI achievement that literally cannot be faked — and that changes what “AI did the impossible” means for every professional who has learned to discount AI claims.
What Claude Actually Did With Fermat’s Last Theorem
Precision first, because the distinction is the story. Fermat’s Last Theorem — the claim that no three positive integers a, b, and c satisfy aⁿ + bⁿ = cⁿ for any integer n greater than 2 — was conjectured in 1637 and proven by Andrew Wiles in 1995 across roughly 129 pages of dense modern mathematics. Claude did not discover a new proof. It translated Wiles’s simplified argument — tracing an exposition by Henri Darmon, Fred Diamond, and Richard Taylor — into Lean, the programming language in which mathematical claims become machine-checkable objects. The compiler verified the result using only Lean’s three standard axioms. No assumptions, no “trust me,” no plausible-sounding hand-waving.
The engineering behind it is as notable as the theorem. According to Anthropic’s research post, Claude ran several dozen parallel agents that collectively generated six billion output tokens over 11 days of wall-clock time. Early multi-agent runs collapsed because the agents accumulated too much local context, lost track of already-proved results, and duplicated work across the dependency graph. The breakthrough came from Prove2Me, an open collaborative platform built by Anthropic researcher Tianyi Peng’s Columbia University group: it maintains a directed acyclic graph of theorem statements and coordinates multiple Claude agents against it, so no step is done twice and no proved result gets forgotten. In other words, the Claude Fermat proof is as much an orchestration achievement as a reasoning one — the first proof of its size completed by a managed swarm rather than a single model call.
Even the failures are documented in a way the industry rarely shows: the first formalization attempt failed outright, and Prove2Me was added mid-run to make completion possible. A companion run formalized Vinogradov’s Three Primes Theorem in three days using consumer Claude Max plans — the same subscription a Manila freelancer holds. The finished proof is roughly five times the size of Mathlib, the community-maintained library the whole structure builds on.
The Benchmark Inflation Problem This AI Math Proof Solves
Every AI capability claim of the past three years has run through the same credibility gap: the company grades its own homework. Benchmarks leak into training data, “reasoning” scores get redefined between releases, and demo videos are edited. The formalization of Fermat’s Last Theorem is the first headline AI achievement with no gap between claim and verification — the artifact is the proof, and anyone can run the compiler. As one analysis put it, “A Lean proof does not accept plausible-sounding arguments; the compiler either verifies or rejects it.”
That property makes this the first AI benchmark that cannot be inflated. The Claude Fermat proof does not accept plausible-sounding arguments; the compiler either verifies or rejects it. When Anthropic says the machine checked 13 million lines, the number is not a marketing claim — it is a countable fact inside a public artifact. For professionals burned by benchmark theater, this is the first result in the AI race that arrives pre-audited, and it resets what “verified” should mean for every future AI claim about reasoning work. The full research post on the Claude Fermat proof publishes the complete methodology, and the Lean prover community documents the verification language any skeptic can run themselves.
The competitive subtext is real. SiliconANGLE’s coverage placed the achievement in direct competition with OpenAI’s Astra solving Erdős problems — the frontier labs are now openly racing on machine-checked mathematics as the credibility currency the industry lacks. Mathematicians had expected formalizing Wiles’s proof to take several years; the run finished in 11 days.
The Numbers Are Staggering — and the Honesty Is the Story
The topline numbers, from Anthropic’s own research post: 13 million lines of Lean code; 30,300 theorems proved, 29,500 of them used in the final proof; roughly six billion output tokens; 11 days wall-clock time across several dozen parallel agents. Each of those numbers survived Buzzard’s review — and Buzzard’s review is the part of this story that the AI industry rarely produces. His full verdict, from his public write-up: “This extraordinary autoformalization achievement, which Anthropic researchers say only took 11 days, proves Fermat’s Last Theorem with no assumptions other than the axioms of mathematics.”
The honesty inside the release is what separates this from benchmark theater. Anthropic’s own post credits the community infrastructure it did not build: Kevin Buzzard’s Imperial College FLT project, the Mathlib library, and Columbia University’s Prove2Me. An editor’s note circulating with the story observes that research funders and academic institutions treating this as a pure AI benchmark will face attribution disputes — whether open-source math infrastructure earns recognition or gets absorbed into corporate AI milestone narratives. That is a live dispute in mathematics departments right now, and it will decide how such achievements get credited in the future.
The run also produced a candid failure log: the first formalization attempt failed; the first multi-agent runs collapsed from context accumulation and duplicated work; the fix was a new coordination tool, not a smarter model. For engineering teams, that is the real lesson — the win came from orchestration, not raw capability.
What Machine-Checked Mathematics Means for Professionals
The distance from Lean proofs to paid knowledge work is shorter than it looks. Three implications land directly on professional practice:
Verification becomes a product category. The scarce resource in the AI era is not generation — it is verified correctness. A compiler-checked proof is generation wrapped in verification. Expect the same architecture to migrate into finance (machine-checked compliance proofs), law (machine-checked contract logic), and engineering (machine-checked safety cases). The professionals who learn to read verification artifacts — proofs, test logs, audit trails — are the ones who will certify everyone else’s AI output.
The orchestration layer is the moat. Claude did not out-think Wiles’s mathematics; the Prove2Me dependency graph out-organized every failed attempt. The lesson transfers: whoever owns the coordination layer — the DAG of tasks, the proof of who-did-what — owns the workflow. This is the same pattern our coverage tracked in enterprise agent rollouts: the Pentagon’s GenAI.mil platform play and Salesforce’s $300 million Claude deployment are coordination bets, not model bets.
Formal methods hiring is about to spike. Somebody has to maintain Mathlib, review 30,300-lemma proofs, and build the next Prove2Me. Formal verification, proof engineering, and dependent-type programming were niche skills; a frontier lab just demonstrated their economic value at unprecedented scale. For the Philippines’ engineering talent pool, this is a specialization window with very few qualified competitors worldwide. The professionals who move first on this, as our coverage of Amodei’s own jobs reckoning showed, are the ones who read capability shifts as career shifts — and the Claude Fermat proof is the loudest capability shift of the quarter.
What Comes After the First Machine-Checked Fermat
The next milestones are already visible. If Wiles’s 1995 argument can be autoformalized in 11 days, the formalization of the modern mathematical literature stops being a century project and becomes a scheduling question — Buzzard’s own extrapolation. The companion Vinogradov run on consumer subscriptions suggests the capability is already productized, not locked in a research lab. And the attribution fight — Anthropic’s name on the achievement, community infrastructure underneath it — will define how the next ten such milestones get credited. The Claude Fermat proof also sets the terms of the next credibility race: expect every frontier lab to answer with a machine-checked landmark of its own, and expect the phrase “independently verified” to carry real money in enterprise AI procurement from now on.
For 360 years, Fermat’s Last Theorem stood as the symbol of what only human genius could close. Wiles needed seven hidden years and a missing lemma. The machine needed 11 days, six billion tokens, and a coordination tool nobody had finished writing when the run started. The theorem did not change. The definition of “checked” did — and every profession built on trusting somebody else’s work just felt the first tremor. This article is for general information only and is not investment advice.
Frequently Asked Questions About the Claude Fermat Proof
Did Claude actually solve Fermat’s Last Theorem?
No. Andrew Wiles proved the theorem in 1995. Claude produced the first complete machine-checked formalization of Wiles’s argument — translating it into the Lean programming language so a compiler could verify every logical step. The mathematics is Wiles’s; the exhaustive verification is the machine’s. The distinction matters because the Claude Fermat proof does not diminish the original achievement — it demonstrates something new: machine-scale verification of human-scale genius.
How big is the Lean proof of Fermat’s Last Theorem?
According to Anthropic, the formalization spans roughly 13 million lines of Lean code — about five times the size of Mathlib, the community library it builds on — covering 30,300 proved theorems, of which 29,500 are used in the final proof chain. Verification uses only Lean’s three standard axioms.
How long did the formalization take?
Eleven days of wall-clock time, working largely autonomously across several dozen parallel Claude agents that collectively generated about six billion output tokens. The 11-day figure is the elapsed time of the orchestrated run, not the output of a single sustained agent.
Who verified the Claude Fermat proof?
The Lean compiler itself is the primary verifier — the proof is machine-checked by construction. Kevin Buzzard, professor of mathematics at Imperial College London, publicly reviewed the work and endorsed it, writing that it “proves Fermat’s Last Theorem with no assumptions other than the axioms of mathematics.”
What is Prove2Me?
An open collaborative platform for formalizing mathematics, built by Tianyi Peng and collaborators at Columbia University. It maintains a directed acyclic graph of theorem statements and coordinates multiple AI agents against the graph — the orchestration layer that made the 11-day run possible after the first attempt failed.
What does this mean for trust in AI claims generally?
Formal verification removes the credibility gap: a Lean proof is either accepted by the compiler or rejected, with no room for benchmark inflation. Expect verification-wrapped AI claims — machine-checked proofs, test-logged code, cryptographically attested outputs — to become the new standard of evidence in knowledge work.
Financial Disclaimer
This article is for general information only and is not financial, investment, or career advice. Technology capability claims reflect company announcements and named independent review as of September 2026. Consult qualified professionals before making investment or career decisions.
Sources: Anthropic research post on formalizing Fermat’s Last Theorem (September 4, 2026); Kevin Buzzard’s public review (Imperial College London); AI Weekly alert tracking (September 4-5, 2026); SiliconANGLE coverage.
