--- title: Classification of Finite Simple Groups Formalized in Lean description: A team has produced a complete Lean formalization of the first-generation proof of the classification of finite simple groups, with every step checked by... canonical: https://daily.dev/posts/classification-of-finite-simple-groups-formalized-in-lean-yojto4wq8 twitter:card: summary_large_image twitter:site: @dailydotdev og:type: website og:site_name: daily.dev og:title: Classification of Finite Simple Groups Formalized in Lean | daily.dev og:description: A team has produced a complete Lean formalization of the first-generation proof of the classification of finite simple groups, with every step checked by... og:url: https://daily.dev/posts/classification-of-finite-simple-groups-formalized-in-lean-yojto4wq8 og:image: https://api.daily.dev/og/posts/yOJto4wq8.png og:image:alt: Classification of Finite Simple Groups Formalized in Lean og:image:width: 1200 og:image:height: 630 og:locale: en --- > ## Documentation Index > Fetch the complete documentation index at: https://daily.dev/llms.txt > Use this file to discover all available pages before exploring further. # Classification of Finite Simple Groups Formalized in Lean **[Hacker News](https://daily.dev/sources/hn)** · 3 min read · 0 upvotes · 0 comments ## Summary A team has produced a complete Lean formalization of the first-generation proof of the classification of finite simple groups, with every step checked by Lean's kernel. The theorem states every finite simple group is cyclic of prime order, alternating, of Lie type, or one of 26 sporadic groups. The project totals 43.1 million lines of Lean code, 2.05 million declarations, and 100 milestones. While formalizing the proof, the team found counterexamples to a closure assertion used in a published argument for the Unbalanced Group Theorem, and developed an alternative route based on Solomon's 1976 theory of maximal 2-components. ## Full article daily.dev links to this article rather than hosting it. Read it at the original source: ## Questions this post answers ### What is the classification of finite simple groups theorem statement? Every finite simple group is a cyclic group of prime order, an alternating group on five or more points, a group of Lie type, or one of 26 sporadic groups. This classification, one of the great collective achievements of mathematics, has now been formalized in Lean with every logical step checked by Lean's kernel, following the original first-generation proof spanning thousands of journal pages. _daily.dev surfaces milestones like this for developers tracking formal verification and proof assistant progress._ ### Did formalizing the classification of finite simple groups in Lean uncover any errors in the original proof? Yes, the formalization team found counterexamples to a closure assertion used in a published route to the Unbalanced Group Theorem. They built an alternative argument for the simple-group case based on Solomon's 1976 theory of maximal 2-components, with the key step being Theorem 2.3, the preservation of simple tops, detailed in a 35-page paper. _Researchers verifying decades-old math proofs can follow formalization errata and fixes via daily.dev._ ### How large is the Lean formalization of the classification of finite simple groups? The formalization spans 43.1 million lines of Lean code, 2.05 million declarations, and 100 completed milestones, covering case divisions including odd order and small 2-rank, component type, quasithin groups, characteristic 2 type, groups of Lie type, and sporadic and alternating groups. _daily.dev helps developers interested in large-scale Lean projects keep pace with formal proof engineering efforts._ ## Community take How the wider developer community reacted, aggregated from 1 discussion and 40 comments across hackernews (as of 2026-10-28). **TL;DR:** Commenters are largely impressed that a complete Lean-checked formalization now confirms the classification of finite simple groups, especially given the proof's history of gaps, while debate centers on whether formalization itself can be fully trusted and how the work was produced. **Sentiment:** 55% positive · 35% mixed · 10% skeptical **The case for** - Having the kernel verify the whole proof dispels lingering doubts left by the proof's extreme length and complexity. - It's reassuring that the effort caught and fixed a real flawed argument (the Unbalanced Group Theorem issue) rather than just rubber-stamping the existing literature. - Some see this as a strong template for large-scale, AI-assisted formalization projects going forward. **The pushback** - Some question whether verifying a formalization is truly trustworthy, since it still depends on the correctness of the Lean kernel itself. - One commenter questions the practical mathematical usefulness of the result. - A commenter raised concern that using many source texts this way could amount to appropriating others' work, though another pushed back noting math itself isn't copyrightable. **By community** - hackernews (positive): Most reactions treat the formalization as a meaningful, trust-restoring milestone, with side debates about verification soundness, authorship credit, and future auto-formalization of math. **Hottest debate:** Whether the formalization meaningfully increases trust in the result given it still relies on the correctness of Lean's own kernel. **Open questions** - Could a frontier model realistically auto-formalize large swaths of existing math textbooks into reusable libraries? - Would humans alone, without AI assistance, have been able to complete this formalization by 2100? - Will the resulting formalization be usable by other mathematicians without extensive hand-holding? **Highlights** > Indeed, this formalization effort spotted a flawed argument in one of the original publications and worked around it to repair the result. > — [cvoss on hackernews](https://news.ycombinator.com/item?id=50266387) > In [1] they claim: >However, there were 34 noteworthy deviations from the published record that needed to be resolved, the most substantial of which related to the Unbalanced Group Theorem. [1]https://axiommath.ai/research/the-enormous-theorem-formalize... > — [bamb008 on hackernews](https://news.ycombinator.com/item?id=50263183) > In general checking that the definitions are correct isn't that hard and assuming at least one of the lean kernels you verify with is correct (which tbf is an assumption, the implementations are based on each other so could have a common bug) that's all you need to verify. In this case the statement is unusually complicated but still much much easier to verify than the proof itself. > — [sebzim4500 on hackernews](https://news.ycombinator.com/item?id=50264424) > Well, the point of the _computer_ formalization is that it's checkable. An error in the formalization would be a bug in lean. Which, as we know, certainly seems plausible (I've mused on if these giant proofs are incentivizing LLMs to find lean bugs to exploit), but at least it's a smaller surface area. > — [kenferry on hackernews](https://news.ycombinator.com/item?id=50266648) > They didn't discover a missing sporadic group. The big gap in the proof (the quasithin case) happened because it was covered in a 600-page unpublished manuscript that under further investigation turned out to be incomplete. > — [QuesnayJr on hackernews](https://news.ycombinator.com/item?id=50262722) **Source threads** - [hackernews](https://news.ycombinator.com/item?id=50261647) · 150 points · 40 comments ## Similar posts on daily.dev - [Tutorial: Introduction to Formal Verification with Lean \(Part 1\)](https://daily.dev/posts/tutorial-introduction-to-formal-verification-with-lean-part-1--blrhdrqdt) · Hacker News · 0 upvotes · 0 comments - ["Why not just use Lean?"](https://daily.dev/posts/why-not-just-use-lean--5cqfy7h3y) · Hacker News · 0 upvotes · 0 comments - [Introduction to Lean for Programmers](https://daily.dev/posts/introduction-to-lean-for-programmers-zyd84tuax) · Towards Data Science · 0 upvotes · 0 comments --- Tags: [#math](https://daily.dev/tags/math) [View this post on daily.dev](https://daily.dev/posts/classification-of-finite-simple-groups-formalized-in-lean-yojto4wq8) ```json {"@context":"https://schema.org","@graph":[{"@type":"Organization","@id":"https://daily.dev/#organization","name":"daily.dev","url":"https://daily.dev","logo":{"@type":"ImageObject","url":"https://daily.dev/apple-touch-icon.png","width":180,"height":180},"sameAs":["https://twitter.com/dailydotdev","https://github.com/dailydotdev","https://www.linkedin.com/company/daily-dev-ltd"]},{"@type":"WebSite","@id":"https://daily.dev/#website","url":"https://daily.dev","name":"daily.dev","publisher":{"@id":"https://daily.dev/#organization"},"potentialAction":{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https://daily.dev/search?q={search_term_string}"},"query-input":"required name=search_term_string"}}]} {"@context":"https://schema.org","@type":"TechArticle","headline":"Classification of Finite Simple Groups Formalized in Lean","url":"https://daily.dev/posts/classification-of-finite-simple-groups-formalized-in-lean-yojto4wq8","mainEntityOfPage":{"@type":"WebPage","@id":"https://daily.dev/posts/classification-of-finite-simple-groups-formalized-in-lean-yojto4wq8"},"datePublished":"2026-10-27T18:02:41.744Z","dateModified":"2026-10-28T01:50:32.837Z","description":"A team has produced a complete Lean formalization of the first-generation proof of the classification of finite simple groups, with every step checked by...","image":"https://media.daily.dev/image/upload/f_auto,q_auto/v1/posts/9b63420c31a05c3144fb6c94652a467b?_a=AQAEuop","thumbnailUrl":"https://media.daily.dev/image/upload/f_auto,q_auto/v1/posts/9b63420c31a05c3144fb6c94652a467b?_a=AQAEuop","isAccessibleForFree":true,"articleSection":"Hacker News","inLanguage":"en","publisher":{"@type":"Organization","name":"daily.dev","url":"https://daily.dev","logo":{"@type":"ImageObject","url":"https://daily.dev/apple-touch-icon.png","width":180,"height":180}},"author":{"@type":"Organization","name":"Hacker News","logo":"https://media.daily.dev/image/upload/t_logo,f_auto/v1/logos/hn","url":"https://daily.dev/sources/hn"},"commentCount":0,"discussionUrl":"https://daily.dev/posts/classification-of-finite-simple-groups-formalized-in-lean-yojto4wq8","interactionStatistic":[{"@type":"InteractionCounter","interactionType":{"@type":"LikeAction"},"userInteractionCount":0},{"@type":"InteractionCounter","interactionType":{"@type":"CommentAction"},"userInteractionCount":0}],"keywords":"math","timeRequired":"PT3M"} {"@context":"https://schema.org","@type":"BreadcrumbList","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https://daily.dev"},{"@type":"ListItem","position":2,"name":"Hacker News","item":"https://daily.dev/sources/hn"},{"@type":"ListItem","position":3,"name":"Classification of Finite Simple Groups Formalized in Lean"}]} {"@context":"https://schema.org","@type":"FAQPage","@id":"https://daily.dev/posts/classification-of-finite-simple-groups-formalized-in-lean-yojto4wq8#faq","mainEntity":[{"@type":"Question","name":"What is the classification of finite simple groups theorem statement?","acceptedAnswer":{"@type":"Answer","text":"Every finite simple group is a cyclic group of prime order, an alternating group on five or more points, a group of Lie type, or one of 26 sporadic groups. This classification, one of the great collective achievements of mathematics, has now been formalized in Lean with every logical step checked by Lean's kernel, following the original first-generation proof spanning thousands of journal pages. daily.dev surfaces milestones like this for developers tracking formal verification and proof assistant progress."}},{"@type":"Question","name":"Did formalizing the classification of finite simple groups in Lean uncover any errors in the original proof?","acceptedAnswer":{"@type":"Answer","text":"Yes, the formalization team found counterexamples to a closure assertion used in a published route to the Unbalanced Group Theorem. They built an alternative argument for the simple-group case based on Solomon's 1976 theory of maximal 2-components, with the key step being Theorem 2.3, the preservation of simple tops, detailed in a 35-page paper. Researchers verifying decades-old math proofs can follow formalization errata and fixes via daily.dev."}},{"@type":"Question","name":"How large is the Lean formalization of the classification of finite simple groups?","acceptedAnswer":{"@type":"Answer","text":"The formalization spans 43.1 million lines of Lean code, 2.05 million declarations, and 100 completed milestones, covering case divisions including odd order and small 2-rank, component type, quasithin groups, characteristic 2 type, groups of Lie type, and sporadic and alternating groups. daily.dev helps developers interested in large-scale Lean projects keep pace with formal proof engineering efforts."}}]} ```