AI Converts Fermat's Last Theorem's 129-Page Handwritten Proof into 13 Million Lines of Lean Code in 11 Days

7 Years vs. 11 Days: How FLT's Lean Formalization Happened

On September 4, 2026, Anthropic released the first complete machine-verifiable proof of Fermat's Last Theorem. Claude completed it autonomously in 11 days, with results as described in the article's lede.

In 1637, Pierre de Fermat scribbled in the margin of his copy of Diophantus's Arithmetica: there are no positive integers a, b, c such that aⁿ + bⁿ = cⁿ (n>2). On the next line, he claimed he had a "truly marvelous proof," but the margin was too small to contain it. For over 350 years, no one found that proof. In 1908, a 100,000-German-goldmark prize was offered; 621 incorrect proofs arrived in the first year alone.

In June 1993, Andrew Wiles announced at Cambridge that he had proven Fermat's Last Theorem, but a fatal flaw surfaced two months later. Working with his student Richard Taylor, he published the complete 129-page proof in May 1995, ultimately confirming that Fermat's own "marvelous proof" almost certainly never existed.

That was only the first half. Rewriting a proof written by humans for humans into Lean code that a computer can check line by line — that was the harder second half. In 2006, Dutch computer scientist Jan Bergstra proposed the idea; in 2024, Imperial College's Kevin Buzzard spearheaded a community collaboration. Just the "blueprint" describing how the initial work should proceed ran 86 pages, and the original estimate was several years.

Anthropic researcher Tianyi Peng brought Claude in to try. The Anthropic blog post describes it this way: over 11 days, dozens of Claude agents (AI entities capable of autonomously completing multi-step tasks) worked in concert — first defining concepts, then proving intermediate lemmas, then using those lemmas to climb step by step, ultimately delivering an end-to-end verifiable version. The final results are as described in the lede. Buzzard commented that the process covered formalizations across algebra, harmonic analysis, geometry, and number theory; the autoformalization output is solid enough that future researchers can build on it.

11 Days, Dozens of Claudes Tag-Teaming: Translating Wiles's 129-Page Manuscript into 13 Million Lines of Lean

Not "one super AI writing it all in one shot," but a swarm of agents dividing labor, hitting walls, and re-dividing.

The initiator, Tianyi Peng, is both a researcher at Anthropic and the lead of an AI formalization tools team at Columbia University. The goal was clear: translate Andrew Wiles's 129-page handwritten proof from 1995 into code the Lean proof assistant could understand — not a single step skipped.

Lean is a proof checker: you write mathematical reasoning as code, and it verifies the logic line by line. Every step must be spelled out; skip one and it throws an error. Where a mathematician can write "clearly" and skip dozens of steps, Lean won't accept it.

Claude's approach was to spin up dozens of agents running in parallel. Peng's human instructions were short and high-level, like "treat Jacobians as schemes, high priority" or "push through Mazur's theorem ASAP." How exactly to prove something, which lemma to write, what to do when stuck — all of that was decided by the agents themselves. Once an agent finished an intermediate lemma, later agents would use it as a building block to prove harder propositions.

The initial attempts almost all failed. Agents quickly lost state, had no idea what others were doing, and the collaboration collapsed outright. The first wave of failed attempts ultimately contributed only 7% of the final non-boilerplate code. It took several more rounds before things clicked.

The full experiment ran 11 days, producing an end-to-end, machine-verifiable proof of Fermat's Last Theorem. The final scale is as stated in the lede and the cards in this section.

An "agent" here means a Claude instance that can independently read, write, and run code: give it a goal, and it can break the task down on its own, look things up, edit files, run Lean to check for errors, and rewrite when it hits one. Running dozens in parallel is a matter of Anthropic's compute orchestration — it's not that the model itself grew 30 extra pairs of hands.

The Bottleneck Isn't Claude — It's Who Tells It What to Prove Next

FLT's formalization was stuck for two years, and the bottleneck was "coordination protocol," not AI compute. A task graph pulled the whole pipeline together.

Anthropic initially had Claude work on FLT directly, and it ran most of the way through without being able to close it out. Columbia researcher Tianyi Peng's AI formalization tool, Prove2Me, was plugged in, and the previously-stuck multi-agent pipeline immediately came alive.

Prove2Me did three things.

It split theorem statements and proofs into separate files, making Lean compile faster and use less memory. With 1.3 billion lines of code, unsegmented compilation simply won't run. Each theorem got a natural-language description attached, making it easier to search and reuse later — adding an index to the knowledge base.

These three actions directly solve two chronic problems in multi-agent long-chain tasks: context forgetting(agents forgetting what was proven earlier as they push deeper) and concurrent coordination(multiple agents writing code simultaneously and stepping on each other). Peng's tool turned "who tells the AI what to do next" from manual orchestration into a built-in system capability. Anthropic frames this work as "autoformalization"(translating human-written mathematical proofs into machine-verifiable code): the proof skeleton still follows Wiles's approach, using the simplified Darmon-Diamond-Taylor version; the highlight is end-to-end Lean verifiability with no extra assumptions.

Double the compute, the model writes 20% more code; double the coordination protocol, and a task that wouldn't have finished in 11 days finishes in 11. The bottleneck isn't whether the model's brain is smart enough — it's how to make it know what it should be doing.

How a 350-Year-Old Problem Changed the Way We "Verify"

FLT holds no new math, but for the first time, "checking whether a proof is correct" has been compressed to the time it takes to run a compiler.

Wiles's 1995 handwritten proof took reviewers months to sign off on. Claude took 11 days to break it into 13 million lines of Lean(a language that lets computers check mathematical proofs line by line) code, plus 30,300 machine-readable intermediate lemmas — one pass through the machine and you have your answer. Anthropic's blog post is blunt: AI-generated proofs will keep growing, converting them into Lean should become standard, and "peer review" should mean "run it through the compiler."

What's changed is mathematics's most fundamental trust engine. It used to rely on a few experts reading and rereading for months, catching errors, asking questions; now every link in the logical chain is nailed down by machine, and humans only need to judge at a higher level — whether this proof is worth expanding into a new "building."

Buzzard mentioned a detail: the formalization artifacts generated along the way are "robust enough to be built upon by future researchers." In other words, it's not just FLT itself — the algebra, harmonic analysis, geometry, and number theory modules produced along the path can be reused by other proofs.

The real test is open problems. Conjectures like the Riemann hypothesis have no existing human proof for an AI to transcribe; the model would have to come up with its own constructions, write the arguments, and then verify them in Lean. Anthropic itself acknowledges this is a layer the FLT project never touched, and the capability boundary remains unexplored.

One more link: the Lean compiler itself is being rewritten by AI. In the community, someone has already used Claude Code to rewrite the Lean 4 compiler in Rust, under the repository xiyuzhai/lean-rs. The toolchain that verifies mathematics is starting to be rewritten by AI — once that loop closes, the pace will shift up another gear.

Two signals worth watching. First, in the next 18 months, will any team publicly announce a complete Lean formalization of an open problem (Riemann hypothesis, BSD conjecture magnitude)? If they do, the paradigm is confirmed; if they don't, the "can only transcribe, not create" boundary is holding firm.

Second, does the Lean 4 compiler's Rust rewrite reach a compilable, mergeable state? That determines whether the speed ceiling for AI formalization going forward is the model itself or the underlying tooling.

Where Can You See the 11-Day Proof, and What Should You Watch?

These numbers sound like a vendor press release. But Anthropic did publish the artifacts — this hands-on section covers what you can look at, what to wait for, and what not to trust.

First, what you can do right now: Anthropic's article explicitly states "We shared the resulting proof with Kevin Buzzard" and includes a link, meaning the code volume and 29,500 intermediate lemmas mentioned earlier are publicly available and verifiable.

As for the specific repository address, whether issues are open to the public, and whether downloading requires login — the original post didn't provide a complete path. So don't go hunting for links in second-hand coverage; watch Anthropic's official September 4 blog post. That's the authoritative source.

Working code doesn't mean the theorem has been "accepted by the mathematical community." Lean verifies that the logical chain is unbroken, but whether "this formalization faithfully reproduces every step of Wiles's 1995 proof" is a separate question — one that only Buzzard has publicly endorsed so far ("autoformalization artifacts are now robust enough to be built upon"). The math community is waiting for an independent group to review the code volume mentioned earlier, checking for cases where "the formalization is correct, but an underlying cited lemma is wrong." No third-party review has been published yet.

One last point for outsiders: this achievement compressed the cost of "trusting mathematics" from years to hours — it did not make AI invent new theorems on its own. Keep these two things separate, and you won't get swept up by future coverage.