AI Agents Translated a 15,000-Page Proof Into 43 Million Lines of Code in 24 Days — and Found a 40-Year-Old Error

Translating a mountain of mathematics into something a machine can check

A team of several dozen AI agents spent 24 days rewriting one of the most unwieldy mathematical proofs in history — roughly 15,000 pages of text that leading mathematicians had spent decades building — into a format a computer can understand: more than 43 million lines of code, checked step by step by a verifier program. Along the way, the agents uncovered a logical gap in the reasoning that had gone unnoticed for nearly 40 years.

What "formalizing" a proof actually means

A typical math paper is written for humans and is full of phrases like "it is easy to see" or "it is obvious that" — the author skips intermediate steps, trusting that an expert reader will fill them in. Formalization requires spelling out every single one of those steps explicitly, as code that a dedicated verifier program then checks. If there's a gap anywhere in the chain of reasoning, the code simply fails to compile — there's no room for compromise.

The scale of the operation is clear from simple arithmetic: 43 million lines of code for a 15,000-page source document works out to about 2,900 lines per page of text. Spread over 24 days, that's roughly 1.8 million lines a day, or about 75,000 lines an hour of continuous work. For comparison, formalizing even modestly sized theorems typically takes human specialists months — a volume of work a team of mathematicians simply couldn't match by hand.

Why a machine found the gap that humans missed

The gap in the reasoning that the agents found had survived dozens of careful reviewers over nearly 40 years. That's not a sign of carelessness on the part of those reviewers — it's a consequence of how manual review works. Reading 15,000 pages start to finish and re-checking every logical transition is simply not humanly feasible. A reviewer inevitably leans on the authors' reputation and a gut sense that a given step "looks right."

A verifier has no such trust to lean on. Every transition from one statement to the next is either accepted as rigorously proven or rejected. As an AI agent tries to encode the next step of the proof, it eventually hits a point where the justification is missing — and the code just won't compile past that point. For the mathematical community, this is a serious signal, not a pedantic nitpick: it concerns the integrity of an entire construction that had been considered settled for decades.

What it costs in tokens

This is an estimate by the Hamidun News editorial team, not official project data. Assuming 10–12 tokens per line of finished code, the final 43 million lines translate to roughly half a billion tokens just for the polished output. The actual consumption is almost certainly much higher: agents write draft versions, get errors back from the verifier, rewrite fragments, and run the check again. Factoring in all those iterations, the real total is likely in the billions of tokens.

The tight 24-day timeline was possible because of parallel work. A large proof naturally breaks down into a dependency graph of lemmas, and independent branches of that graph can be handed to different agents simultaneously. The verifier acts as an impartial arbiter with a binary "accepted" or "rejected" answer — which means the agents don't need to take each other's results on faith: any piece of code either passes the check or it doesn't.

What engineering teams can take from this

The main lesson isn't limited to pure mathematics. Agentic systems scale best wherever there's an unambiguous automatic judge: a compiler, a test suite, or a proof engine. Under those conditions, hundreds of thousands of generated lines of code don't need to be reviewed by hand — the machine itself does the filtering.

The same model applies to formal verification of cryptographic libraries, compilers, consensus protocols, and hardware blocks. The requirements are the same everywhere: a detailed task specification, a strict automatic verifier, and the ability to split the work into independent chunks. Teams planning to build similar agentic pipelines should invest first and foremost in the verifier itself and in decomposing the task into independent units — the number of agents and the size of the model are secondary. One more practical takeaway concerns peer review: a formalized proof offers a reproducible guarantee of correctness that a handwritten 15,000-page text simply cannot provide.