Fermat’s Last Theorem was proved in 1994–95 by Andrew Wiles, with Richard Taylor, after 350 years. Writing that proof out so that a computer can check every step — formalizing it — was expected to take years: in 2024 Kevin Buzzard began a five-year, £1 million project at Imperial College London to do it. On September 4, 2026, Anthropic released a complete Lean formalization produced by Claude agents in eleven days: about 13 million lines, some 29,500 intermediate theorems, checked by Lean, by a comparison tool, and by a second, independently written kernel. Buzzard compiled it himself: “it checks out.” He also said that “mathematically this work of anthropic tells us essentially nothing” — it follows the 1995 exposition and adds nothing — while what it does tell us “is what is possible in the field of autoformalization.” On November 9, launching Claude Fable 5.2, Anthropic said the new model, with about a thousand agents, did the whole formalization in thirty hours, using no mathematical references, where the previous model finished 26% in eighteen. The September proof is public and verified, and its own attribution file lists 106 files adapted from human formalization projects, including Buzzard’s. The thirty-hour run is a company claim. The new capability is real, and it is a capability for checking, not for discovering.
A mathematical proof is written for people. A formal proof is written for a program, the Lean proof assistant, which checks every inference down to a few axioms. Turning the first into the second has been slow, specialist work. Fermat’s Last Theorem — no whole numbers solve aⁿ + bⁿ = cⁿ for n above 2 — was proved by Wiles and Taylor in the mid-1990s, and in 2024 Kevin Buzzard began a five-year, £1 million project to formalize it with a community of volunteers.[5][6]
On September 4, 2026, Anthropic published a complete formalization, assembled by Claude agents in eleven days.[1][2] Its repository states the theorem in plain Lean and lists how it was checked: a full build in which the Lean kernel accepted every declaration; the comparator tool, which confirmed that the proved statement is exactly the standard one and that no extra axioms were used — “Your solution is okay!”; and a second, independently written kernel, nanoda, which reported “Checked 1052234 declarations with no errors.”[1] Reporting put the scale at about 13 million lines and 29,500 intermediate theorems.[6]
Buzzard checked it himself the same day. “I’ve compiled the code base and run comparator on it — it checks out.” Then the judgment that matters: “Mathematically this work of anthropic tells us essentially nothing.” The formalization “just faithfully follows the early literature on the proof and adds nothing” — the 1995 exposition by Darmon, Diamond and Taylor, not the modern route his project follows. “What this work does tell us, however, is what is possible in the field of autoformalization.”[5]
On November 9, launching Claude Fable 5.2, Anthropic returned to the theorem. The first formalization, it said, “took 11 days” and “relied on a purpose-built harness along with guidance from a human researcher.” Fable 5.2, with about a thousand agents, “fully formalized the theorem in just 30 hours, with minimal human intervention,” using “no mathematical references, only a list of intermediate theorem statements to score progress,” with a third of the effort and a proof seven times shorter. The previous model “completed only 26% of the formalization in 18 hours.”[3]
The public proof is unusually well documented about its own debts. Its attribution file lists 106 files containing Lean text taken or adapted from human projects — material from the Imperial College London FLT project led by Buzzard and from the flt-regular project — and reproduces each upstream author list. The file explains why that was needed: the Lean was “assembled by AI agents” and published without comments, so the attributions were restored afterwards by line-by-line comparison.[4] The eleven-day result stands partly on human formalization work, and says so.
The repository is equally plain about what no tool can check: “What no tool can check is that each intermediate theorem means what its name suggests; that is for the reader to judge.”[1] That is the same gap Anthropic named for its ETH proof in UC-339, and the gap UC-333 found in a machine check that covered less than its paper claimed. Here the statement at the top is tied to the standard one by the comparator; the meaning of the thirty thousand steps beneath it is not.
The thirty-hour claim is different in kind. It is the more striking number — no references, a third of the effort — and it is the one nobody outside can yet inspect. The announcement does not link its files.[3] The honest reading is two results: an eleven-day formalization, public and confirmed by the field’s leading expert, and a thirty-hour formalization reported by the company that made the model, on the day it launched it.
Mathematically this work of anthropic tells us essentially nothing. What this work does tell us, however, is what is possible in the field of autoformalization. — Kevin Buzzard, September 4, 2026 [5]
| Dimension | Evidence |
|---|---|
| Operational (D6) Origin · 88 | Eleven days with a harness and human guidance; a reported thirty hours with about a thousand agents.[1][3]Days, Then Hours |
| Quality (D5) L1 · 84 | Lean kernel, comparator and a second kernel: “Checked 1052234 declarations with no errors.”[1]Checked Three Ways |
| Employee (D2) L1 · 80 | A five-year human project overtaken; 106 files adapted from human formalizations.[4][5]Overtook, and Built On |
| Regulatory (D4) L2 · 70 | “Mathematically this work of anthropic tells us essentially nothing.”[5]Checked Is Not New |
| Revenue (D3) L2 · 58 | About six billion output tokens for the first run; the second announced with a model launch.[3][6]A Launch Headline |
The cascade originates in D6 (Operational): a process — AI agents in a purpose-built harness, then about a thousand of them — that turns a known proof into a checked one in days or hours.[1][3] It propagates to D5 (Quality), where the public proof passes three independent checks,[1] and to D2 (Employee), the people whose multi-year formalization work it overtook and partly reused.[4][5] It lands in D4 (Regulatory), the field’s norms for what counts as progress — checked versus new[5] — and in D3 (Revenue), the cost of such runs, reported at roughly $300,000 in model output for the first, and the commercial launch that carried the second.[3][6] D1 (Customer) is not scored.
It follows UC-342, which counted mathematicians doing the slow work of understanding machine-made proofs. This case is the other side: a machine doing the slow work of checking a human-made one. Together they make the point the library keeps arriving at — producing and checking are getting fast, while understanding still runs at the speed of people. The review in February will look for the thirty-hour run’s files, independent replications, and what Buzzard’s project does next.
-- UC-343: Eleven Days, Then Thirty Hours: 6D Amplifying Cascade
-- FLT: Wiles and Taylor 1994-95. Buzzard Imperial project from 2024, five years, 1M pounds (EPSRC). Anthropic repo anthropics/fermats-last-theorem published Sep 3-4 2026: Lean 4.33.1, Mathlib v4.33.0; three standard axioms; comparator okay; nanoda checked 1052234 declarations; about 13M lines, 29,500 theorems, 11 days, about 6B output tokens; ATTRIBUTION lists 106 files from Imperial FLT and flt-regular; no tool checks that intermediate theorems mean what their names say. Buzzard Sep 4: it checks out; mathematically tells us essentially nothing; follows Darmon-Diamond-Taylor 1995; shows what is possible in autoformalization. Anthropic Nov 9 2026, Fable 5.2: first run 11 days with harness and human guidance; Fable 5.2 about 1,000 agents, 30 hours, no mathematical references, one-third the action tokens, proof seven times shorter; Opus 5.5 26 pct in 18 hours. 30-hour files not published.
FORAGE eleven_days_then_thirty_hours
WHERE known_proof_formalized_by_agents = true
AND independent_kernel_check_passed = true
AND expert_confirmed_no_new_mathematics = true
ACROSS D6, D5, D2, D4, D3
DEPTH 3
SURFACE eleven_days_then_thirty_hours
DIVE INTO checked_not_new
WHEN second_run_files_public = false
AND human_formalization_reused = true
TRACE autoformalization_cascade
EMIT eleven_days_then_thirty_hours_signal
DRIFT eleven_days_then_thirty_hours
METHODOLOGY 88
PERFORMANCE 40
FETCH eleven_days_then_thirty_hours
THRESHOLD 1000
ON MONITOR CHIRP high 'Claude agents formalized Fermat's Last Theorem in Lean in eleven days, checked by three tools and confirmed by Kevin Buzzard, who said it adds nothing mathematically but shows what autoformalization can do. Fable 5.2 reportedly did it in thirty hours with no references; those files are not published.'
SURFACE analysis AS json
Runtime: @stratiqx/cal-runtime · Spec: cal.semanticintent.dev · DOI: 10.5281/zenodo.18905192
A proof expected to take a five-year human project was formalized in eleven days, and checked three ways.[1][5]
The field’s own expert: it tells us nothing new about mathematics, and a lot about autoformalization.[5]
106 files adapted from human projects are credited line by line. The first proof stood partly on human work.[4]
Primary sources are Anthropic’s public repository — its README, verification record and attribution file — Kevin Buzzard’s own post, and Anthropic’s November 9 announcement, all read at source. Press coverage supplies scale figures. The thirty-hour run is reported only by Anthropic. Source 8 is an interactive companion made for this case.
This case follows the slowest part of mathematics — verification — becoming fast, and the human judgment that still decides what it means. The method behind it is open.