Source: Anthropic's official research announcement. The image illustrates mathematical formalization; it is not a screenshot of Claude's output.
Claude's Fermat's Last Theorem proof sounds like an AI discovered new mathematics. That is not what happened. Anthropic used a multi-agent system to convert a known proof route into 13 million lines of Lean that proof-checking software could verify. The real breakthrough is the speed and scale of formalization—and the most useful lesson for developers is why machine-verifiable work changes how we should judge AI agents.
Quick Navigation
- What is the result? A complete machine-checked formalization, not a new theorem.
- What changed? A job expected to take years was completed in 11 days.
- How did it work? A dependency graph coordinated dozens of agents while Lean checked every declaration.
- Why should builders care? Formal verification turns correctness into an executable acceptance test.
- What remains unclear? Cost, readability, repeatability, and transfer beyond formal domains.
- FAQ: Five direct answers for readers deciding how much this result matters.
What is Claude's Fermat's Last Theorem proof?
Claude's Fermat's Last Theorem proof is the first published end-to-end Lean formalization that a proof assistant can check from its statement down to accepted axioms, not a new human-style proof of the theorem. Anthropic says dozens of Claude agents, coordinated through the Prove2Me dependency graph, produced about 13 million lines of Lean in 11 days and used 29,500 intermediate theorems. The public repository pins Lean 4.33.1 and Mathlib, rejects sorry and extra axioms, and documents checks by Lean, comparator, and the independent nanoda kernel. Kevin Buzzard, who leads another FLT formalization effort, says he compiled the code and ran comparator successfully. The important change is therefore verification throughput: AI converted a known mathematical route into machine-checkable code at unprecedented scale. It does not show Claude discovered a new proof, understood every generated lemma, or can repeat the result cheaply on ordinary hardware.
What We Know So Far
- The primary result: Anthropic reports that Claude worked largely autonomously for 11 days and produced the first complete, computer-checked formalization of Fermat's Last Theorem.
- The public artifact: the Apache-2.0 GitHub repository contains the Lean source, pinned toolchain, proof path, offline documentation, and three verification routes.
- The independent check: mathematician Kevin Buzzard says he compiled the code and ran comparator; his conclusion is that it checks out.
- The important boundary: Buzzard also says the project adds essentially no new mathematics. It formalizes an established path through Frey, Serre, Ribet, Wiles, and Taylor-Wiles.
- The product boundary: Anthropic describes an internal research model and a Claude Code-based multi-agent harness. It did not announce a public one-click theorem-proving product.
What changed in formal verification?
The theorem itself did not change, and neither did the standard of proof. What changed was the amount of formalization work an AI system could coordinate and finish under a machine-checkable target.
- Fermat's Last Theorem was the last remaining challenge on a widely used list of 100 formalization problems: New public evidence: Anthropic published a complete Lean repository, and Buzzard says it compiles and passes comparator; Why it matters: A 20-year formalization benchmark is now complete
- The parallel Imperial College project expected years of human formalization work: New public evidence: Anthropic reports an 11-day multi-agent run; Why it matters: AI can compress the translation step when correctness is executable
- Agent collaboration often loses project state across long tasks: New public evidence: Prove2Me maintained a dependency graph of theorem statements and reusable results; Why it matters: The scaffold, not only the model, enabled the agents to coordinate
- A generated proof could hide shortcuts or unsupported assumptions: New public evidence: The repository documents checks by Lean, comparator, and nanoda, plus bans on
sorry, added axioms, and unsafe escape hatches; Why it matters: Multiple checking paths narrow the room for a fake success
The scale is hard to ignore: Anthropic reports 30,300 intermediate theorems, 29,500 used in the final proof, and roughly six billion output tokens. But scale is also a warning. The repository says a clean build took 5 hours 32 minutes on 96 jobs, while comparator used nearly 15 hours and peaked at 230 GB of memory.
This is a research artifact, not a lightweight workflow. The repository says it is not maintained and does not accept contributions.
How did Claude and Lean produce a checkable proof?
Anthropic's early multi-agent attempts lost track of project state and stopped collaborating effectively. The run succeeded after the team moved to Prove2Me, a platform that represents a formalization mission as a directed acyclic graph, or DAG. In plain English, the graph makes dependencies explicit: an agent can see which smaller theorem must be proved before a larger theorem can close.
Source: Anthropic's original Prove2Me dependency graph. The diagram shows three major branches feeding the final theorem; it is a proof-plan map, not evidence that every generated explanation is human-readable.
Prove2Me separated theorem statements from proofs, reduced repeated compilation, and kept natural-language descriptions that made prior results searchable. Dozens of Claude agents could then define concepts, prove intermediate statements, and reuse completed work instead of repeatedly rediscovering the project state.
Lean provided the hard boundary. The public repository says its default build checks all 60,475 modules with the Lean kernel. A comparator replays the environment against a challenge statement written with Mathlib, and nanoda—a separate Lean kernel written in Rust—accepted an exported environment after four disclosed performance patches.
That does not make every label or explanation trustworthy. The repository explicitly says machine-generated names and English summaries may be wrong; the Lean statement is authoritative. Formal verification proves that the formal statement follows from the accepted axioms. Humans still have to decide whether the formal statement represents the intended mathematics.
The developer view
The transferable pattern is straightforward: give agents a target that another program can reject. Lean is unusually strict, but the idea applies to code generation, migrations, infrastructure, and data work.
For a serious agent workflow, separate the plan into a dependency graph, keep task state outside the model's context, make outputs reusable, and run an independent verifier after generation. Unit tests and type checks are weaker than a proof kernel, but they still turn vague confidence into a repeatable gate.
There is also a warning for multi-agent systems. Anthropic says its first attempts produced failed work because agents lost shared state. Adding more agents did not solve coordination. The useful gain came from a scaffold that exposed dependencies and made completed work discoverable.
The product enthusiast view
If you use Claude as a normal chat or coding assistant, there is no new button to press. Anthropic used an internal research model roughly comparable to Claude Fable 5.1, a custom harness, Prove2Me, large compute, and a domain where answers can be checked mechanically.
The result is still meaningful because it shows a credible AI product shape: not one model writing a perfect answer, but many agents proposing pieces while a deterministic system rejects incorrect work. That pattern is more trustworthy than a polished response that nobody can verify.
Why should builders care now?
- Verification changes the economics of review. An agent can generate far more output than a person can read, so scalable checking matters more than raw generation speed. 2. External state beats conversational memory. A durable dependency graph kept the project coherent when agents could not. 3. Parallelism needs shared contracts. The agents became useful when theorem statements and dependencies gave each worker a precise interface. 4. Independent replay matters. A second checker and an expert-run comparator are stronger evidence than the vendor's success message alone. 5. Readable output still matters. The proof may be correct while remaining too large and machine-shaped for humans to learn from or maintain.
My decision rule is simple: teams with formal specifications, deterministic simulators, strong test suites, or reproducible builds should experiment now. Teams whose success criteria depend on taste, ambiguous requirements, or changing external systems should treat this as a design pattern—not as proof that autonomous agents are ready to replace expert review.
What remains unclear?
- The internal model, harness configuration, and total compute cost are not fully public.
- Anthropic reports six billion output tokens, but that is not enough to calculate a fair production price.
- The repository is enormous, resource-intensive to replay, and explicitly not maintained.
- The formalization follows existing mathematics; it does not show the system can reliably discover new proofs.
- Kernel checks establish logical validity of formal statements, not whether generated names and summaries match human mathematical intent.
- It is not yet clear how often the same scaffold can reproduce this speed on unrelated theorems.
- The result says little about open-ended software tasks whose requirements and environments change during execution.
Quick Take
- What is actually new?: Evidence-backed answer: A complete Lean formalization was produced and published after an 11-day AI-agent run
- Is this a new proof of Fermat's Last Theorem?: Evidence-backed answer: No; it formalizes an established proof route
- What is the strongest independent evidence?: Evidence-backed answer: Kevin Buzzard says he compiled the repository and ran comparator successfully
- What made the agents work?: Evidence-backed answer: Prove2Me's dependency graph, reusable results, and machine-checkable goals
- Who should try the pattern now?: Evidence-backed answer: Builders with deterministic tests, formal specs, or replayable verification
My take: the headline is not “AI solved Fermat.” It is “AI made an enormous known proof executable, and the verifier—not the model's confidence—decided whether it counted.”
FAQ
Did Claude prove Fermat's Last Theorem?
Claude helped produce a complete Lean formalization of an existing proof route. Lean checked that the formal statement follows from its accepted axioms. Claude did not discover Fermat's Last Theorem or replace Wiles's mathematical proof with a new human-readable argument.
Was Claude's Fermat proof independently verified?
The public repository documents Lean, comparator, and nanoda checks. Kevin Buzzard independently says he compiled the code and ran comparator successfully. That is strong verification of the formal artifact, though the full cost and internal generation process are not independently reproduced.
What is Lean in this project?
Lean is a proof assistant whose kernel checks whether each formal step is valid. It does not judge prose or mathematical elegance. In this project, the Lean statement is authoritative even when machine-generated names, comments, or summaries are hard to read.
Can developers use this system today?
The repository and Prove2Me research are public, but Anthropic did not release the complete internal model-and-harness setup as a consumer product. Developers can study the architecture and reproduce parts of the verification workflow, subject to substantial compute and tooling requirements.
Does this mean AI can reliably discover new mathematics?
No. This result shows large-scale autoformalization of known mathematics. Anthropic says formal Lean work may help models check hypotheses, but repeatable discovery of important new results is a different claim and needs separate evidence.
Discover practical AI products and emerging developer tools at AIToolHunt.