Artificial Intelligence Daily edition
ARTIFICIAL INTELLIGENCE VERIFICATION
Claude industrialises verification of Fermat's Last Theorem
Anthropic claims an agent system worked for eleven days to produce the first complete formalisation of Fermat's Last Theorem in Lean. The result does not discover new mathematics, but converts a monumental proof into an object that a verifier can accept or reject step by step.
The headline invites misunderstanding: Claude 'solved' a 350-year-old mystery. In reality, the mystery was solved in 1995 with the proof by Andrew Wiles and Richard Taylor. What is new is something else, less romantic and perhaps more decisive for the era now beginning: a general-purpose model has converted a route from that proof into Lean code that a small logical kernel can mechanically review.
The difference matters. A proof written for mathematicians can omit steps the community considers obvious, rely on shared conventions and require months of expert reading. Lean does not allow this leeway. Every definition, dependency and inference must be expressed with sufficient precision for the system to check the entire chain. The value lies not in the AI sounding convincing, but in its output being subject to an external criterion that does not negotiate with rhetoric.
From a historic proof to a certificate factory
Anthropic's experiment shows the extent to which this translation can scale. For eleven days, dozens of agents collaborated to define concepts, solve intermediate results and assemble successive levels of the proof. The process produced some thirteen million lines of Lean and 30,300 auxiliary theorems; 29,500 ended up in the final proof. The scale is revealing: the artefact is more than five times the size of Mathlib, the main community library on which it relies.
Coordination was as important as the model. The first attempts lost the project's state and ceased to collaborate effectively. The team then switched to Prove2Me, a platform that represents theorems as a directed graph, separates statements and proofs into different files and maintains natural language descriptions to aid search and reuse. With this scaffolding and a multi-agent system based on Claude Code, the project consumed nearly six billion output tokens from an internal model comparable, according to the company, to Claude Fable 5.1.
The mathematical route did not emerge from a vacuum either. Claude followed a simplified version of Wiles's proof presented by Henri Darmon, Fred Diamond and Richard Taylor, and reused work from previous community initiatives. Human intervention focused on high-level instructions and priorities, but the intellectual architecture, the libraries and the criteria for what should be formalised came from years of human work. Kevin Buzzard, a proponent of the Fermat formalisation at Imperial College, reviewed the result, and the code was published for inspection.
This is why the advance is more relevant to verification than to mathematical creativity. If models increasingly generate conjectures, proofs, programs and policies, the bottleneck will be checking them. An output in natural language forces one to either trust the model or redo its work; an output accompanied by a formal certificate can be submitted to an independent checker. The same logic extends beyond theorems: authorisation rules, protocols, financial algorithms or security components can be described as properties that the software must satisfy.
But 'verified' does not mean 'true in every sense'. Lean checks that the conclusion follows from the axioms, definitions and statements introduced. If the specification misrepresents the problem, the proof can be impeccable and the real system can still fail. We also do not yet know the total cost of reproducing the project, how easily such a gigantic artefact can be compressed, or how much human effort will be needed to turn it into a readable exposition. The experiment itself acknowledges that some failed attempts survived in the final version and that the formalisation is much more extensive than necessary.
The bottleneck shifts to review
This is precisely where the bottleneck shifts. If models begin to rapidly produce extensive conjectures and proofs, human review cannot grow at the same pace. A formal version acts as an integrity check: it forces the declaration of assumptions, detects gaps and allows components to be reused without relying solely on reputation or intuition. It does not eliminate the need for mathematical judgement—choosing problems, interpreting results and explaining why an idea is fertile—but it can reduce the mechanical burden that currently consumes months of work from referees and formalisation teams.
The business application is not to turn every contract into a theorem tomorrow. It is to adopt the principle: an agent's responses must end up with independent verifiers when the cost of an error is high. In software, this could be a test suite and a static analyser; in finance, deterministic accounting rules; in operations, limits that the agent cannot rewrite. Claude's success in Lean is less an invitation to delegate truth than an example of how to wrap probabilistic generation in rigorous checking.
Tags
- Anthropic
- Claude
- Lean
- Formal verification
- Fermat
- Mathlib
BOLDERROR Daily edition Rubén Campoy