AI Agents Formalize 15 000 Pages of Proofs in 24 Days and Find a Gap

Dozens of AI agents turned a proof of about 15 000 pages into more than 43 million lines of code that a computer checks step by step, and they did it in 24 days. Leading mathematicians worked on the original text for decades, and it is one of the largest constructions in the history of mathematics. Along the way, the system found a logical gap in the authors' reasoning that had existed for almost 40 years.

A Page Worth Three Thousand Lines

Formalizing a proof means that every step a mathematician skips in a paper with the phrase "as is easy to verify" has to be written out explicitly. A verifier program must then accept that record. If there is a hole anywhere in the chain, the code simply fails the check.

The arithmetic shows the scale. 43 million lines over 15 000 pages comes to about 2 900 lines per page. Over 24 days, that is on the order of 1.8 million lines per day, or about 75 thousand per hour without stopping. A human team could not have handled such volumes: formalizing even small theorems usually takes specialists months.

Why a Machine Found the Gap

The nearly 40-year-old gap survived dozens of attentive readers. That is not down to their carelessness. Checking 15 000 pages by hand is unrealistic: a reviewer relies on the authors' authority and on the assumption that intermediate steps are obvious enough. A verifier gets no such credit. It either accepts or rejects every transition.

That is why formalization also works as an audit. An agent trying to encode a step runs into a place where no justification exists. For mathematics, this is a serious signal: it concerns the integrity of the whole structure, not a cosmetic fix.

The Economics: How Many Tokens a Build Like This Costs

This is the editors' estimate, not project data. At 10–12 tokens per line, the final code comes to about half a billion output tokens. Actual consumption is much higher, because agents write drafts, receive verifier errors, rewrite, and check again. Counting those iterations, the total most likely runs into the billions of tokens.

The 24-day timeline was achieved through parallelism. A large proof naturally decomposes into a graph of lemmas with dependencies, and independent branches can be handed to different agents at the same time. The verifier acts as an arbiter with a binary answer, "accepted or not," so the agents do not have to take each other's word for anything.

Key figures of the project:

• about 15 000 pages of the original proof, assembled over decades;
• 24 days of system runtime;
• several dozen agents working in parallel;
• more than 43 million lines of verifiable code;
• about 1.8 million lines per day on average;
• about 2 900 lines of code per page of text;
• one gap in the argument, almost 40 years old.

What Engineering Teams Can Take From This

The main lesson is not limited to mathematics. Agent systems scale best where an unambiguous automated checker exists: a compiler, a test suite, a proof engine. In that setting, hundreds of thousands of generated lines do not require manual review, because the machine does the filtering.

The same scheme applies to formal verification of cryptographic libraries, compilers, consensus protocols, and hardware blocks. The conditions are always the same: a detailed specification, a strict verifier, and the ability to split the work into independent pieces. For teams planning agent pipelines, the practical conclusion is clear. Start by investing in the verifier and in task decomposition; the number of agents and the size of the model are secondary. There is one more takeaway for peer review: a formalized proof gives a reproducible guarantee that a handwritten text of 15 000 pages cannot.