AI Writes 43.1 Million Lines of Code in 24 Days, Machine-Verifies Humanity's Largest Mathematical Proof

Exium used an AI Agent cluster to turn the Classification of Finite Simple Groups into 43.1 million lines of LEAN code in 24 days, machine-verified, finding 34 paper errors.
Exium used an AI Agent cluster to convert the 15,000-page Classification of Finite Simple Groups, scattered across over 500 papers, into 43.1 million lines of LEAN code in 24 days, and it has passed computer verification. The theorem is called the "Enormous Theorem," and its classification resembles a "periodic table" containing infinite families and 26 sporadic simple groups. The Agent cluster adopted a divide-and-conquer strategy, splitting the argument into 108 milestones and 380 subtasks, with a main Agent decomposing and reviewing while other Agents searched and wrote LEAN code. During formalization, the AI found 34 discrepancies with the original papers, including a counterexample to a key argument cited for 40 years, and helped find a new proof route. All code is open source, but it has not yet been independently reproduced externally and still requires community review. This work marks the potential of AI as a "formalization engineer" in ultra-large-scale mathematical verification.
From a 15,000-Page Proof to 43.1 Million Lines of Code: An Engineering Revolution in Mathematical Proof
The Classification of Finite Simple Groups is often called the "Enormous Theorem" and is one of the pinnacle achievements of 20th-century mathematics. Over several decades, more than a hundred mathematicians worked in relay, with results scattered across over 500 papers totaling roughly 15,000 pages—so long that no one can read it all. Now, a company called Exium has used a cluster of AI Agents to convert it into 43.1 million lines of LEAN code in 24 days, and it has passed computer verification. This is not only a milestone in AI-assisted mathematics but also means that humanity's largest proof can finally be checked line by line by a machine.

What Is the Classification of Finite Simple Groups?
Group theory studies symmetry and transformation rules. Take a square: rotating or flipping it so that it still looks the same—these operations form a group. If the number of transformations is finite, it is a finite group. Complex finite groups can be decomposed layer by layer according to specific rules until they can no longer be split—these indivisible "fundamental atoms" are the finite simple groups. The goal of the classification theorem is to exhaust all possible finite simple groups and prove that none are missing. Within mathematical circles it is respectfully called the "Enormous Theorem," which shows its scale and difficulty.

The ultimate answer resembles a "periodic table": each blue cell represents a family containing infinitely many different groups; there are also 26 sporadic simple groups, the largest of which, the Monster Group, contains about 8×10^53 elements. With such an enormous structure, traditional manual verification is nearly impossible.

LEAN is an interactive theorem prover and also a programming language, initiated by Leonardo de Moura at Microsoft Research in 2013. It is based on dependent type theory, allowing users to write mathematical definitions, theorems, and proofs as code, which a computer kernel then checks line by line to see whether each step of reasoning is logically valid. Compared with similar tools such as Coq and Isabelle, LEAN has attracted attention in the mathematical community in recent years due to the rapid expansion of the mathlib library. mathlib is a large community-maintained library of formalized mathematics that already covers a great deal of content from basic algebra to analysis. To "formalize" a proof into LEAN code means translating natural-language arguments on paper into machine-verifiable symbolic derivations; any skipped step or implicit assumption will be rejected by the kernel. Therefore, passing LEAN verification is logically equivalent to every line of the proof having been independently checked.
Sporadic simple groups are the 26 exceptional individuals in the classification of finite simple groups that do not belong to any infinite family. Most of them are related to highly symmetric combinatorial structures or algebraic systems, such as the Mathieu groups, Conway groups, Fischer groups, and others. The largest sporadic simple group is called the Monster Group, whose order is about 8×10^53, containing far more symmetry transformations than the total number of atoms in the universe. The Monster Group is also famous for its deep connection with modular forms and the monstrous moonshine conjecture in string theory, a connection proposed by Conway and Norton in 1979 and later proved by Borcherds. The existence and uniqueness of the sporadic simple groups are among the most difficult parts of the classification theorem, and the construction and verification of many sporadic simple groups took mathematicians decades.
How Does the Agent Cluster Break Down the "Enormous Theorem"?
Exium assembled a cluster of Agents to transform the vast network of mathematical arguments into individual tasks, ultimately splitting it into 108 milestones and 380 subtasks. The main Agent is responsible for decomposition and review, while other Agents search existing results and write them into LEAN-checkable code. This "divide and conquer" strategy allows AI to process massive proof fragments in parallel while maintaining logical consistency. Completing 43.1 million lines of code in 24 days demonstrates the potential of Agent collaboration in ultra-large-scale formal verification.
An AI Agent cluster refers to a multi-agent collaboration architecture: multiple agents driven by large language models each take on specific roles and work together to accomplish complex goals through task decomposition, result review, and iterative feedback. In this architecture, there is usually a "main Agent" responsible for breaking high-level goals into subtasks, assigning tasks, and reviewing output, while other "worker Agents" execute specific work such as searching, writing code, and verification in parallel. Unlike a single call to a large model, an Agent cluster can maintain long-term context, invoke external tools (such as the LEAN compiler), retry upon failure, and reduce single-point error rates through cross-checking. This pattern has already been applied in software engineering, but using it for ultra-large-scale mathematical formalization requires solving additional challenges such as dependency management between tasks, logical consistency, and splicing of proof fragments.
34 Paper Errors and a 40-Year-Old Counterexample
During the formalization process, the AI found 34 places that did not match the original papers. In one mathematics paper, a key piece of reasoning had been cited countless times by mathematicians over the past 40 years, yet the AI found a counterexample proving the reasoning was wrong. With the help of human mathematicians, the AI found a new proof route. This discovery highlights the value of formal verification: machines do not rely on authority, only on logic.

Formal verification refers to the process of using computer programs to rigorously check whether a mathematical proof or software system satisfies its specifications. In mathematics, formal verification requires translating a proof into machine-readable code based on logical axioms, with the kernel of a proof assistant applying inference rules one by one and accepting only what fully complies with the rules. Compared with manual peer review, formal verification does not rely on the reviewer's authority, intuition, or field consensus, and can therefore expose implicit skipped steps, erroneous citations, or missing boundary conditions in natural-language proofs. Historically, formal verification has played a role in projects such as the Four Color Theorem and the Kepler conjecture, but those projects were far smaller in scale than the Classification of Finite Simple Groups. This work shows that formal verification can not only confirm correctness but also actively discover reasoning flaws that have long gone unnoticed.
Open Source and Pending Verification: Sober Reflection After the Milestone
All the code is now public. However, Exium's CEO added that no one outside has yet rebuilt and reproduced it. This means the results of machine verification still need independent review by the community. Nevertheless, this work has already proven that a proof accumulated by humanity over decades—so large that no one can finish reading it—can now finally be verified line by line by a machine. For the mathematical community, this may be the beginning of a new era: proofs are no longer just narratives on paper but executable, checkable code.
From a broader perspective, AI here plays not the role of "prover" but of "formalization engineer": it translates the collective wisdom of human mathematicians into a machine-understandable language and discovers errors during the translation. This model may be applied to more large-scale mathematical projects in the future, and may even drive the comprehensive formalization of mathematical knowledge bases.
Related articles

Gemini 4 Neon Review: Benchmark Scores Rival Carbon, API Pricing and Quota Breakdown
Google Gemini 4 Neon is now live, benchmark scores closely tracking Carbon, API pricing 3/15 at twice Hydrogen's rate. This article compiles Bilibili creator testing: Neon can replace 90% of Carbon scenarios, AntiGravity quota consumption is only one-third of Carbon, plus subscription channel restrictions and 2API ban risks.

Gemini 4 Helium Coming Soon? Signals of Google Loosening Subscription Restrictions
Google team member hints releases will continue; community speculates Gemini 4 Helium (Flash Lite) may be next. Subscription ban controversy gets a response as product lead says "Soon," suggesting restrictions may be lifted. This article covers Gemini developments, OpenAI Coding Agent and risk management, Doubao real-time audio-video API, and compute business dynamics.

AI-Assisted React Development in Practice: Optimizing a Video App and Handling Errors
A 14-year veteran developer demonstrates AI-assisted React video app optimization: compressing video from 80MB to 5MB (~94%) via ImageKit, plus reliable error handling and retry mechanisms. Includes planning, code understanding, and verification methods for working with AI.