More than 100 top mathematicians have spent decades writing 150,000 pages of proof.
Now, in just 24 days, AI has transformed one of the largest projects in the history of human mathematics into more than 43 million lines of code that can be progressively verified by a computer.
What's even more surprising is that when AI examined the proofs left behind by these mathematicians, it also uncovered an argumentation flaw that has existed for almost 40 years.
This is not an arithmetic question, nor a dozen-page mathematical paper, but a finite-group classification theorem known as the "Enormous Theorem".
Starting in the mid-20th century, hundreds of mathematicians participated in the study. In 1983, mathematician Daniel Gorenstein announced that the classification had been completed, but it was discovered that parts of it were still incomplete.
On October 26, AI mathematics company Axiom Math announced that dozens of AI Agents, organized by human mathematicians and engineers, had completed the Lean formalization of this giant theorem in 24 days, generating about 43.1 million lines of code, 20.5 million formalized statements, giving the first computer inspection to cover the entire classification theorem.
Originally dispersed in over 500 papers, the mathematical reasoning is now organized into a system of formats that can be gradually checked. More surprisingly, in the process, Agent not only detects errors in historical papers, but also participates in the construction of a new group of theoretical results.
Axiom's open-ended single-group classification theoretical formalization project contains approximately 43.1 million lines of Lean code, 2.05 million statements, 100 milestones, and includes 715 references. Source: Axiom Math
It's been decades in mathematics.
What exactly does this prove?
The difficulty of understanding this work, to say the least, comes from "symmetry".
A square sheet of paper, rotating 90 degrees, is completely reconfigured to its original shape; the same is true for 180°, 270° rotation. Mathematicians refer to these rotational operations and their combinations as "groups". From geometry to particle physics, group theory provides a general language for studying symmetry.
Complex finite groups can be broken down into more basic parts in some sense. Just as integers can be broken down into mass factors, these "basic particles" that cannot continue to be broken down are called finite monogroups.
The finite group classification theorem answers a seemingly simple question: What are all these basic particles?
The final list includes the prime number cyclic group, the intersection group, 16 infinite series of Li-like monogamous groups, and 26 special "scattered monogamous groups". The largest of these, the "monster group", has about 8×10^53 elements.
This is a diagram of the relationships between the "scattered monkeys". The top M represents the largest scattered monkeys, while the other nodes represent different scattered monkeys.
To find these groups, only half the work was done. It is really difficult to prove: apart from the type in the list, there can be no further 27th scattered in the single group, and there is no new type that has not yet been discovered.
In 1963, Walter Feit and John Thompson used a 255-page paper to prove that all non-exchangeable finite sets of stages are even numbers, opening a breakthrough for subsequent classifications. In 1972, Gorenstein proposed a 16-step study plan; in 1983, he announced that the classification was complete.
Large proofs are like a web of relationships spanning decades: one paper cites another theorem and the latter relies on earlier reasoning. Many steps also omit the conditions that the authors think are obvious. Even if each paper alone seems reasonable, it is difficult for one person to examine every link in the whole system.
Axiom is trying to turn all of these connections into proofs that a computer can verify.
24 days of Agent work,
Almost dragged by "correct proof".
It's not like having a large model read 150,000 pages and spit out tens of millions of lines of code all at once.
On October 1, Axiom opened its dedicated Slack channel, using existing Lean databases and mathematical literature to compile a proof-of-work roadmap: 108 milestones, about 380 specific missions. On October 2, the first batch of Agents began accrediting missions through GitHub Issues.
Some agents are responsible for dismantling the theorems, some searches have resulted, some generate Lean proofs, some review propositions, integrate code. Encountering unfinished prepositions, the agent can continue to assign tasks to other agents. Human mathematicians deal with critical obstacles and engineers are responsible for coordinating these ongoing systems.
These agents are coordinated and operated by AxiomProver, a mathematical proof system developed by Axiom independently. The project uses a continuously adjusted combination of multiple models, but does not disclose a specific list of underlying models. The system emphasizes task dismantling, proof generation and collaborative verification between different agents rather than relying on single models to complete reasoning.
A rectangular tree diagram of Axiom's finite single group classification theoretical formalization project (Treemap) shows the size of the Lean statements and code in different mathematical modules. Source: Axiom Math.
Shortly after the start of the project, a tricky problem arose: Agent was able to prove a mathematical proposition without necessarily proving the one that the project really needed.
For example, it was required to prove that a bridge can pass heavy trucks safely, but Agent added a condition: "assuming the bridge is strong enough". With this premise, it successfully proved that trucks can pass, and even Lean recognizes the entire drive.
But the problem is that the bridge is not strong enough and has not been proven at all.
Similar problems occurred repeatedly early in the project. Some seemingly completed mathematical tasks actually introduced unproven assumptions. Axiom can't help but remove tens of thousands of lines of code based on these assumptions and rearrange the work.
As the code library expanded, Lean's inspection speeds also began to fall short of Agent output. Modifying a basic theorem may force re-examination of all the code it relies on. Engineers introduced a shared build caching and parallel verification mechanism to allow different Agents to duplicate confirmed results as much as possible.
On October 10, the team received good news on the Slack channel: "WE PROVED MONSTER IS SIMPLE".
However, three days later, the progress of the project suddenly slowed down. On October 13, despite the fact that dozens of agents were still generating code, the team completed only one phased proofing task throughout the day.
The remaining mathematical problems are too complex, and under one big problem are many small problems that have not yet been solved. Although Agent is able to write new proofs, it is difficult to determine exactly how many key steps he has solved and how far he is from the end goal.
Axiom can't help but rearrange the strategy, breaking down complex proofs into smaller, clearer tasks, and asking Agent to explain how these small proofs were combined step by step to ultimately reach the desired conclusion.
It's been going on for 40 years now.
Added a new proof
As he proceeds to the depths of the historical literature, Agent discovers something more troublesome than task scheduling: the original mathematical paper may be wrong.
Human mathematicians often omit familiar reasoning, but Lean requires that every premise is clearly written. According to Axiom, there are 34 notable literary biases that need to be addressed in the formalization process, including errors, omissions, and substantive problems that must be redirected.
An example is found in Aschbacher and Smith's work "The Thin Group" in an original argument that two quantities are equal, where Agent uses the group SL2[5] to find a counterexample: one quantity is 1, and the equation requires it to be 2. To transform the equation into an unequal, the argument can be corrected, but later reasoning relied on that argument. The team only had to extend the scope of the previous argument to rework the affected situation.
A larger obstacle came from John Walter's 1986 study of the "Unbalanced Group Theorem, UGT".
UGT is an important tool for finite group classification. It helps mathematicians to use specific local structures within a group to infer what type the whole group may belong to. Walter's key reasoning is by default: if an operation is performed on a particular group, the resulting single group is still in the original group.
As a starting point, considering the matrix induced by its finite field self-constitution, the single-group constituents of the associated centralized subgroups appear to be PSL2 (7). However, the latter does not belong to the Walter finite group, and the original closed assumption cannot be established.
This does not overturn the conclusion of the UGT, but it does mean that one step along this path of proof must be taken to find another basis.
Axiom consulted with group theorists Richard Lyons and Ronald Solomon. Solomon's great 2-dimensional theory in 1976 provided key ideas for the new route.
Agent subsequently constructed and formalized a new group result, "Preservation of simple tops", which demonstrates that, under the necessary conditions, the relevant single group structure can be preserved when compared to specific subgroups. It was written in a 35-page paper titled The Unbalanced Group Theorem, as the theorem 2.3, and combined with other already available results, completed the required UGT proof for classification.
Interestingly, after its formalization, Axiom's mathematicians found a shorter path in the first-generation proof method to reach an objective conclusion without invoking the new theorem. However, the new theorem and its complete proofs were retained as an additional mathematical result of this work.
The Axiom team participated in the completed study of the unbalanced group theorem, in which the theorem 2.3 "Preservation of simple tops" is the new mathematical result of this formalization process.
After 43.1 million years of Lean,
What is the change in mathematical proof?
Eventually, Axiom uploaded the entire project to GitHub, revealing some 43.1 million lines of Lean code. The final classification proposition in the repository is that each finite subgroup has a built-in subgroup of the list.
The project statement ultimately proves that it does not contain sorry in Lean, and that it is a temporary bypass for unfinished proofs. The end result relies only on standard axioms and can be checked gradually by the Lean core. Axiom also provides an interactive proof-of-dependence diagram that allows researchers to track which preconditions a conclusion relies on.
Axiom's open-ended finite-group classification theorem defines Lean code. The final conclusion is proved by calling for a formalized underlying, behind which is the proof engineering that makes up tens of millions of lines of Lean code. Source: Axiom Math / GitHub.
The foundation for this work also includes formalised projects such as Mathlib, TauCeti and Qiuzhen-CFSG, of which about 1.2 million lines are from Qiuzhen-CFSG. Research results accumulated by human mathematicians, an early formalised infrastructure, and AI Agents that can work in parallel, are put into the same engineering process.
For subsequent mathematical studies, a key change is that the proof can be maintained continuously. In the past, the theory of finite-group classification may have been cited in hundreds of papers; now, researchers can follow a formalized chain of dependence to examine specifically which definitions, conditions, and inferences are used.
Axiom's open warehouse will review the status quo as a team's self-evaluation. Next, external mathematicians will still be able to check whether formal definitions match the original propositions accurately and review the mathematical choices in this massive project. But Lean has provided another previously unobtainable capability: allowing tens of millions of lines of proof to be driven by logic to accept unified, mechanised checks.
Looking back over the last 24 days, it's not so much about how long AI has been writing code, but how it has been working on a large-scale research project that has in the past relied heavily on human experts: dismantling tasks, tracking proofs, finding errors in old literature, and participating in constructing new proofs when the old lines don't work.
Decades of accumulated mathematical knowledge are moving from scattered arguments in papers to structures that can be process-checked, replicated, and further expanded. Axiom is a concrete attempt by AI to move from solving one-way mathematical questions to engaging in the construction of a whole set of mathematical theories.
This is not the case.
© THE