Claude Fermat Reality Check: verified formalization, not a new proof of FLT

Anthropic's September 4, 2026 Fermat's Last Theorem announcement is unusually strong evidence for an AI capability claim because the output is not just a screenshot or a vendor-scored benchmark: the company published a very large Lean 4 repository that can be checked by proof-assistant kernels. But several headlines blur together three different claims. The mathematical theorem is not new, the formal Lean artifact is publicly checkable, and the 11-day AI generation run itself is not yet independently reproducible with a public model.

What Anthropic actually says it ran

Anthropic says dozens of Claude agents, coordinated through Prove2Me and a Claude Code-based multi-agent harness, completed the end-to-end formalization in 11 days. The campaign generated about 13 million lines of Lean, proved 30,300 theorems, used roughly 29,500 of them in the final proof, and consumed about six billion output tokens. Anthropic also says failed early approaches contributed about 7% of the non-boilerplate lines that remained in the final repository.

The identity caveat matters: Anthropic describes the generator only as a general-purpose internal research model roughly comparable to Claude Fable 5.1. That is not the same as saying the public claude-fable-5-1 API model produced the repository. The exact internal checkpoint, context limits, serving configuration and per-token latency for the campaign are not published, so public Fable 5.1 benchmark scores or context specifications should not be silently transferred to this run.

Prove2Me is itself a substantive part of the result. Its public paper describes a collaboration platform for Lean formalization, while Anthropic says its theorem DAG, statement/proof separation and natural-language indexing addressed earlier failures in agent memory and coordination. This makes the result a model-plus-harness-plus-verifier system result, not a clean foundation-model benchmark.

Sources: Anthropic's technical account and the Prove2Me paper.

What was proved — and what was not

Fermat's Last Theorem was already proved by Andrew Wiles and Richard Taylor in the 1990s. Anthropic explicitly says the novelty here is verification/formalization, not new mathematics. Its formalization follows the Darmon-Diamond-Taylor exposition of the Wiles/Taylor-Wiles route and incorporates credited material from earlier open Lean projects.

That distinction is also emphasized by Kevin Buzzard, who leads Imperial College London's human FLT formalization project. In his September 4 review, Buzzard says the formalization "checks out" after he compiled the code and ran comparator, while arguing that it adds essentially no new mathematical knowledge; its significance is what it demonstrates about large-scale autoformalization.

There is one useful technical nuance in Buzzard's discussion: the new Anthropic development handles the hard route for prime exponents at least 17, while already-formalized regular-prime work covers the remaining small cases needed for the complete theorem. The public repository's final Lean theorem is stated for all natural-number exponents n >= 3.

Primary review: Kevin Buzzard, Xena Project, September 4, 2026.

How strong is the verification evidence?

The public Anthropic FLT repository pins Lean 4.33.1 and Mathlib v4.33.0 and exposes a final theorem whose build guard permits only Lean's three standard axioms: propext, Classical.choice, and Quot.sound. The repository says there is no sorry, added axiom, native_decide, unsafe, extern, implemented_by, partial def, or #eval in the proof modules.

Anthropic documents three checks:

1. A from-scratch Lean build checks every declaration.
2. leanprover/comparator verifies that the proved statement and constants match the challenge expressed using stock Mathlib and replays the environment through the Lean kernel.
3. A second Lean kernel implementation, nanoda 0.4.13, accepted an export containing 1,052,234 declarations with no errors. Anthropic says its four nanoda patches add progress output or improve definitional-equality performance without weakening typing rules.

Those repository checks are author-run evidence, but there is also an independent expert signal: Buzzard says he personally compiled the codebase and ran comparator and that it checked out. That is stronger than a normal vendor benchmark claim. It is still not the same as a published independent reproduction of the original 11-day generation campaign or an independently documented nanoda replay.

The trust boundary is narrower, not nonexistent. The repository notes that proof kernels can check the formal statements and derivations, but they cannot decide whether every machine-generated intermediate theorem name conveys the semantics a human reader expects. Human-readable mathematical exposition remains a different deliverable.

Reproducibility has a substantial hardware cost

Anthropic's repository gives concrete verification requirements. Its reported from-scratch build took 5 hours 32 minutes at 96 parallel jobs, peaked at 153 GB RAM, and used about 67 GB under .lake/ plus roughly 220 GB of generated C files. Comparator took 14 hours 46 minutes on one core and peaked at 230 GB RAM, with the instructions recommending about 300 GB. Exporting the environment produced a 37.8 GB file; the nanoda check itself took about 30 minutes at 16 threads.

This is unusually reproducible for a frontier-agent demonstration, but it is not laptop-scale verification. The repository provides enough detail for a well-resourced third party to replay the proof checks; it does not provide the internal model needed to replay the generation process.

Cost: $300,000 is a retail-equivalent illustration, not the experiment's bill

Public Claude Fable 5.1 pricing is $10 per million input tokens and $50 per million output tokens. Multiplying six billion reported output tokens by the public Fable 5.1 output rate gives a simple retail-equivalent figure of $300,000 for output alone.

That number should not be presented as Anthropic's actual cost. The campaign used an internal research model only described as roughly comparable to Fable 5.1; input volume, cache behavior, infrastructure cost, internal transfer pricing and any batch economics are not disclosed. Buzzard's blog comments show public disagreement about how to translate API prices into underlying inference cost, which reinforces that the actual experiment cost is unknown.

Public model pricing: Claude Fable 5.1.

Benchmark hygiene: SWE-bench scores are not evidence for this result

SWE-bench Verified and SWE-bench Pro are not evaluations of this FLT formalization. They test software-engineering issue resolution under particular repositories and agent harnesses. Importing a Fable 5.1 SWE-bench score into this story would be doubly misleading because Anthropic did not identify the FLT generator as the public Fable 5.1 checkpoint and because theorem formalization is a different task.

The most relevant measurable evidence is instead the formal artifact itself: successful kernel checking, statement comparison, scale, generation duration, token use, and the independently reported compile/comparator check. There is no standardized pass@1, sample size, confidence interval, or matched multi-model FLT benchmark here because this is a one-project system demonstration.

Public feedback: expert validation and real disagreement

Buzzard's September 4 post is the strongest accessible independent reaction because it combines subject expertise with a concrete check of the artifact. He is positive about the autoformalization implication while explicitly separating it from new mathematics and from his project's goal of a readable, modern formalization.

The comments on that post also illustrate uncertainty rather than consensus. On September 4-5, readers debated the retail-equivalent token cost and whether a generated repository this large could hide a checker exploit. Buzzard replied that he had manually inspected the non-proof/non-definition code and random mathematical sections and regarded a hidden finishing hack as extremely unlikely, while acknowledging that manual inspection is not perfect. These comments are anecdotal discussion, not a controlled security audit.

Fresh searches did not surface a stable X post with a more reproducible independent run than Buzzard's compile-and-comparator report, so no X consensus is claimed.

Practical takeaway

This is best understood as evidence that a frontier multi-agent system, given a structured theorem DAG and a machine-verifiable target, can turn a vast body of established mathematics into a checked formal artifact at a scale that was previously impractical. The key advantage is that correctness of the final formal object does not depend on trusting the model's prose or a vendor judge.

The limits are equally important: the run used an unreleased internal model; the complete generation process cannot currently be replayed by outside researchers; verification itself requires heavy compute; the formal artifact is far larger and less readable than a human-oriented mathematical development; and the result formalizes established mathematics rather than discovering a new proof of Fermat's Last Theorem.

For AI evaluation, that makes the result more interesting as a verifiable long-horizon agent-system case study than as a leaderboard score for Claude Fable 5.1.