AI AI Toolkit
AI Newsindustry

Axiom 智能体集群用 24 天完成有限单群分类定理的���器验证

X:Rohan Paul (@rohanpaul_ai)2026-10-27T23:31:32.000Z

Key Highlights

Formal verification of mathematics just hit a landmark: an AI agent cluster from Axiom reportedly formalized the Classification of Finite Simple Groups—one of the longest proofs in mathematical history—into more than 38 million lines of machine-checked code in 24 days, surfacing 34 serious discrepancies in the published record.

What Happened

The Classification of Finite Simple Groups, or CFSG, is among the grandest engineering efforts in twentieth-century mathematics, proving that every finite simple group falls into a handful of families. Humans took decades to complete the proof, and it sprawls across more than 500 papers and roughly 15,000 pages, carrying real risk of hidden errors. Axiom set multiple agents to work translating the proof step by step into strict code for proof assistants like Lean, with automatic cross-checking.

Technical Detail

Formal proofs turn every inference into an object a computer can check line by line, eliminating "jumps" and typos entirely. In this project the formalized code reached about 43 million lines and has been growing at a slope of roughly doubling every 37 days—meaning this "proof-as-code" engineering is scaling fast. The 34 discrepancies found will be fed back to the mathematical community for review.

Compared With Rivals

DeepMind's AlphaProof and OpenAI's o-series have also done formalization at IMO-level problems, but mostly as single-problem solving. Axiom's differentiator is end-to-end formalization of an entire monograph-scale proof—far beyond single problems in scale and engineering complexity, closer to the paradigm of "automatically proofreading the mathematical canon."

Industry Impact

Machine verification is shifting from "solving problems" to "auditing the canon." For mathematics, it offers a credible knowledge audit; for software and chip verification, legal compliance, and other evidence-heavy domains, the same agent-cluster approach can turn long chains of argument into auditable code, sharply lowering the cost of human oversight.

Practical Notes

Treat the 34 discrepancies as leads, not verdicts—human mathematicians still must confirm each. The real near-term value is a continuously checkable backbone for results no single person can fully hold in their head.

Caveats

Scale here is staggering but the work depends on the source literature being machine-readable enough to translate. Discrepancies may reflect transcription choices as much as genuine errors, so the finding is a prompt for review, not a refutation of CFSG.

Closing Thought

If agent clusters can audit the longest proofs in history in days, the line between "doing mathematics" and "checking mathematics" starts to blur. That is a quiet revolution in how humanity can trust its own hardest results.

Background

Mathematical proof has always been a social process: results are checked by peers, but no single human can hold an entire monograph-scale proof in their head at once. Formalization turns that tacit trust into explicit, machine-checkable steps. What is new here is the scale and speed—an entire classification theorem, not a single contest problem.

Why It Matters

If agent clusters can audit the longest proofs in history within days, the line between doing mathematics and checking mathematics starts to blur. The same cluster approach applies wherever arguments are long and evidence matters: chip verification, compiler correctness, legal reasoning, regulatory compliance. The 34 discrepancies are a feature, not a bug—they show the method finds real issues.

Closing Thought

This is a quiet revolution in how humanity can trust its hardest results. The bottleneck was never human brilliance alone but the inability to verify vast, interlocking arguments. Agent clusters change that, turning proof into something we can inspect line by line at scale.

What To Watch

Watch whether the 34 discrepancies survive human mathematical review, and whether the "double every 37 days" scaling of formalized code holds. Both will tell us if this is a one-off feat or a repeatable pipeline.

Bottom Line

Agent clusters auditing the longest proofs in history is a quiet revolution in trust. The method turns proof from something no one can fully hold in their head into something we can inspect line by line at scale.

Deeper Context

Mathematical proof has always been a social process: results are checked by peers, but no single human can hold an entire monograph-scale proof in their head. Formalization turns that tacit trust into explicit, machine-checkable steps, and what is new here is scale and speed rather than the underlying idea.

Who Should Care

Researchers in verification, chip design, compiler correctness, and any field where long arguments must be auditable should watch this closely. The cluster approach is portable beyond mathematics.

Risks and Open Questions

The 34 discrepancies are leads, not verdicts; human mathematicians must still confirm each. The method also depends on source literature being machine-readable enough to translate, so some findings may reflect transcription choices. Treat it as a powerful audit, not a final authority.