Thirteen million lines in the margin: what makes this the good case

Sat, 05 Sep 2026 00:00:00 +0000

On: “Formalizing Fermat’s Last Theorem” — Anthropic, 4 September 2026. ·

Eleven days, more than thirteen million four hundred thousand lines of Lean, twenty-nine thousand five hundred intermediate theorems and some six billion output tokens. With that, several dozen Claude agents produced the first end-to-end computer-checked proof of Fermat’s Last Theorem, closing out along the way the list of a hundred theorems Freek Wiedijk has kept open for twenty years. The mathematician who runs the project to formalize that same theorem reviewed the result and wrote that, mathematically, this tells us essentially nothing. He is right, and that is exactly why it is worth looking at.

What is inside the artifact

The version doing the rounds — the machine cracked in eleven days what took Wiles seven years — is false in both halves, and Anthropic itself does not claim it. Andrew Wiles proved the theorem in 1995, in a hundred and twenty-nine pages that took months to review and needed a patch a year later for a hole found during that review. What the agents did was not find a proof but transcribe one: they followed the simplified exposition by Darmon, Diamond and Taylor and poured it into a language whose compiler takes nothing on trust. The eleven days are wall-clock time for dozens of agents in parallel, coordinated through Prove2Me — an open platform from Tianyi Peng’s group at Columbia that maintains the dependency graph between theorems and tells each agent what is missing — with human intervention limited to occasional very high-level instructions, on the order of the Jacobian as a scheme sounds high priority.

The result is also narrower than the headline suggests: the formalization covers prime exponents greater than or equal to seventeen, and the rest was already done by humans.¹ Buzzard, who had gone on record before any of this saying he was 99.9% sure Fermat’s proof was correct, did not revise that figure after reading the repository. There is no new mathematical knowledge here. There is an engineering artifact at a scale that did not exist a month ago, and what it tells us is not about Fermat but about what these systems can do when someone puts something on the other side that can tell them no.

The kernel does not ask who wrote it

Anthropic writes, in a sentence that in institutional prose amounts to a confession, that formalization is a place where they feel unambiguously good about the role of AI. It is worth reconstructing why before arguing with it, because the reason is a good one and has nothing to do with the model’s virtues. Lean checks every step against a tiny kernel that admits only three axioms, and that kernel is indifferent to the provenance of what it checks: it does not know whether the lines were written by a doctoral student, a swarm of agents or a very lucky random generator, and its verdict costs a few hours of compute where producing what it checks cost six billion tokens.² An unreliable producer coupled to a cheap, independent, hostile verifier yields a reliable system. That is the whole trick, and it is a property of the domain, not of the model.

What survives of the standard objection — that nobody read the thirteen million lines and therefore nobody knows what they say — is smaller and sharper than it looks. The kernel certifies that the lines entail the statement from the axioms; it does not certify that the statement is the one you wanted to prove. That is why the team ran a comparator tool against Mathlib’s own formulation of the theorem, and why Buzzard went and looked at the statement. That step, the shortest in the whole process, is the only irreducibly human one, and no quantity of tokens shortens it: someone has to answer whether the line sitting on top of thirteen million others says what the world means by no positive integers satisfy the equation. The entire trustworthiness of the artifact rests on a three-line reading.

A gift the commons cannot lift

None of this happens without Mathlib. The community library the proof stands on was written over years by hundreds of mathematicians, largely unpaid for it; Anthropic’s repository credits a hundred and six files taken from Buzzard’s FLT project at Imperial College — funded by the UK’s EPSRC with a million pounds over five years — and from the flt-regular project. The resulting proof is over five times the size of Mathlib and takes nearly twenty times as long to compile, on a ninety-six-core machine. It is on GitHub, openly licensed, and it will probably stay there.

That is the part worth looking at slowly, because it is not an enclosure and calling it one would be more comfortable than accurate. Nothing was taken: Mathlib is intact, the code is published, and in a year when model releases have consisted of choosing which layer to open and which to charge for, a complete and auditable repository is more than usually shows up. The problem is of a different kind. Mathlib is a commons because it can be maintained: someone reads a file, understands what it does, generalizes it, refactors it, argues about the name of a lemma on Zulip. Thirteen million four hundred thousand lines written to satisfy a compiler do not admit that treatment, and Buzzard’s guess — a well-founded one — is that Anthropic will not do the work of turning them into something the community can absorb. His two stated goals, contributing the fundamental objects of modern number theory to Mathlib and building a dynamic document that lets a human walk through the proof, remain his and remain pending. A commons is measured not by what can be downloaded but by what someone can sustain; by that measure, what came back to the commons is not the proof but the news that the proof is possible.

Three subscriptions

There is a second experiment in the announcement that matters more to a reader in this region than the thirteen million lines: a group of agents running on three personal Claude Max subscriptions, coordinated by the same platform, formalized Vinogradov’s three primes theorem in three days. That is not a show of force; it is a change in the entry price, and it deserves to be conceded in full. Until this week, formalization was the one branch of contemporary mathematics whose barrier was time rather than capital: Lean runs on a laptop, Mathlib is free, and the community accepts contributions from anyone whose code compiles. For departments that will not be buying a GPU cluster this decade, it was the open door — it is still open, and now it takes less time to walk through.

The objection is not about access to the tool but about the unit of measurement. If what used to be a doctoral thesis’ worth of formalization becomes three days of agents, then what counts as a project in the field is set by whoever can pay for the largest swarm, and the distance between three subscriptions and dozens of agents on an internal model is not one of price but of availability: the model that did Fermat is not for sale.³ It is also worth naming what is not here, because critical vocabulary wears out when used reflexively: there was no data extraction from the South, no ghost annotation labour, no local corpus turned into raw material. The asymmetry is of another kind, simpler and harder to reverse, and it consists in the fact that the capacity that produced the result can neither be hosted here nor bought abroad.

What else has a kernel

The transferable lesson of these eleven days is not that machines can do mathematics. It is a criterion, and a more demanding one than it looks: AI works unsupervised where there exists a verifier that is cheap relative to production, independent of the producer, and public. It is worth walking through the deployments actually under discussion in the region with that criterion in hand. A benefits-allocation system has no cheap verifier: checking that a denial was correct costs more than issuing it, and the affected person finds out when the transfer does not arrive. An automated exam grader has no independent verifier: it is audited by whoever bought it. Medical triage has no public verifier: the truth arrives months later, scattered across records nobody cross-references. All three are being deployed anyway, and the difference from Fermat is not one of risk or ambition but of epistemic infrastructure.

Lean and Mathlib have been under construction for over a decade, largely on volunteer labour and public funding, and without that kernel this week’s result would not be a result but a thirteen-million-line file nobody would have reason to believe. The question it leaves open is not whether the machine proves theorems. It is how long a kernel takes to build, on whose money and under whose responsibility, when what needs verifying is not theorems but case files.