A computer checked proof certifies that a formal statement follows from the definitions and earlier results that statement uses. Matching that formal statement to an English theorem is a second job. A person does it by reading the definitions in force. The checker does that reading only in the sense that it sees the formal definition. It does not see the sentence you meant.

On 26 October 2026, Axiom published Formalizing the Enormous Theorem. Axiom says it formalized the classification of finite simple groups in the Lean proof assistant, and Axiom describes that release as the first complete computer checked proof of the classification. Axiom says the project produced approximately 43.1 million lines of Lean code. In the same note, Axiom says people inspect the statement and the definitions to confirm that they express the intended classification, while Lean checks the formal deductions. This page reports those sentences as Axiom's claim. It has not rerun the repository, and it has not reviewed the formal statement. The arithmetic below is the same split, small enough to finish by hand. Educational only: see the disclaimer.

Four layers, kept apart

A beginner proof and a classification proof fail in the same place when these four layers get glued together. The quantifiers and negation page is the human version of the third row: a formal statement is a nest of "for all" and "there exists", and the order is the meaning.

LayerThe even sum, in this page's exampleWho can check it
English theoremThe sum of two even integers is evenA person, using the ordinary meaning of even
Definition in forceEven a means there exists an r with a = r + rA person, reading the definition the file actually uses
Formal statementEven a and Even b imply Even (a + b), when addition is commutativeA kernel, once a proof term of that statement exists
Independent checkAnother checker on the same term, and a fresh reading of the statementA second program, and a person. Different jobs.

The definition mathlib actually uses

The mathlib page on squares and even elements, checked 21 November 2026, defines Even a for a type with addition by the existence of an r such that a = r + r. The same page records the theorem Even.add: if the type is an AddCommSemigroup, then Even a and Even b imply Even (a + b). "AddCommSemigroup" is the library's name for a set with an addition that is associative and commutative. Integers with ordinary addition are one example. The hypothesis is part of the formal statement. Drop it, and you are looking at a different statement.

The page also notes that an older definition asked for an element c with a = 2 * c. The current file lists a lemma, even_iff_exists_two_nsmul, that Even a is equivalent to the existence of an r with a equal to twice r, for an additive monoid. That equivalence is itself a formal statement. A course that uses the words "divisible by 2" and a file that uses r + r can agree, and the agreement is a lemma someone has to prove. Sharing the English word even does not create the lemma.

The sum, written out

Take integers a and b with Even a and Even b in mathlib's sense. Then there are integers r and s with a = r + r and b = s + s. The sum is (r + r) + (s + s). Associativity regroups that as r + ((r + s) + s). Commutativity swaps the inner r past s, giving r + ((s + r) + s), which regroups as (r + s) + (r + s). Set t = r + s. Then a + b = t + t, which is Even (a + b) under the same definition.

The swap is the step that spends the commutative hypothesis. A proof term that rearranges r and s has to cite commutativity, or some earlier lemma that already cited it. A kernel that accepts the term has accepted that citation. It has also accepted that "Even" in the goal is the Even from the imported file.

Numbers, so the regrouping is an equality you can recompute. Let r = 3 and s = 5. Then a = 6 and b = 10. The sum is 16. And t = 8, with 8 + 8 = 16. One intermediate value: 3 + ((3 + 5) + 5) = 3 + 13 = 16. Same integer after the swap: 3 + ((5 + 3) + 5) = 16.

Student desk with graph paper, pencil, and scientific calculator

Proof by induction

A base and a step. A checker can certify them only after both are formal statements.

A chalkboard of handwritten limit notation in a quiet study

Epsilon delta proofs

The written argument for a limit. A table of samples is a different object from that argument.

A correct proof of a different statement

Define OnlyZero a to mean a = 0. Then OnlyZero a and OnlyZero b imply OnlyZero (a + b), because 0 + 0 = 0. A kernel that accepts a proof of that implication has certified a fact about zero. Suppose the comment above the proof still says "the sum of two even integers is even". The comment is for a person. The formal statement is about OnlyZero. Both of the following can be true at once: the proof term checks, and the English comment describes a theorem the file did not state.

That is the mismatch to practice on, because the arithmetic is obvious. The milder version is already in the mathlib note. A file that defines Even by r + r, and a reader who remembers a = 2 * c, are talking about two formal statements. The lemma that connects them is extra. Until that lemma is the thing being checked, a success mark on Even.add is a success mark for r + r.

What the kernel checks

The Lean language reference, in the section on elaboration and compilation, checked 21 November 2026, describes the trusted kernel as a small type checker for the core theory. It says the kernel's job is to check proof terms. The reference overview, checked the same day, says each tactic produces a term in that core theory, and the kernel checks the term, so a bug in a tactic threatens a confusing error rather than an accepted proof of the wrong statement. The elaboration section adds that the kernel is written in C++, and that separate implementations exist in Rust and in Lean, so the implementations can be checked against each other.

Put next to the even sum, those sentences stay small. The proof term is evidence that Even.add, with mathlib's Even and with the commutative hypothesis, follows in the theory. The tactic script is a way of building that term. A second implementation that accepts the same term is evidence about the checker. The English sentence "the sum of two even integers is even" is still waiting for a person to compare it with r + r.

Three jobs that share the word check

  1. Accepting a term. The kernel of the implementation you ran says the term has the type of the formal statement. That is the check Lean's reference assigns to the kernel.
  2. Agreeing checkers. A separate implementation accepts the same term. The reference says those implementations exist so they can be checked against each other. Agreement is about the checker.
  3. Reading the statement. A person opens the definitions and says whether the formal statement is the theorem they meant. On this page that reading is the table. Axiom's note says this is the human part of their classification project. This site has not done that reading for Axiom's repository.

Axiom's own wording already separates the third job from the first. Reporting that wording is the claim. Treating the announcement as the third job, completed, would erase the separation the note is careful about.

Checkpoints

  1. For a = 8 and b = 6, name r and s with a = r + r and b = s + s. Then name t = r + s and check a + b = t + t.
  2. Which hypothesis of Even.add does the swap of r with s use?
  3. The comment above a proof says "sum of two evens". The definition in the file is OnlyZero. What statement did a successful kernel check certify?

Answers, so the check is a comparison rather than a guess. For the first, r = 4 and s = 3, so t = 7, and 8 + 6 = 14 = 7 + 7. For the second, commutative addition. For the third, the kernel certified the OnlyZero implication. The comment is still a comment.

Common mistakes

  • Reading a success mark as a reading of the textbook sentence. The mark says a term inhabits the formal statement. The textbook sentence joins the story when a person has compared the two.
  • Editing the definition and keeping the comment. OnlyZero with an even comment is the small version. A larger project has the same failure mode whenever a definition drifts and the surrounding prose stays put.
  • Treating the tactic script as the object that was checked. The Lean reference says the kernel checks the term the tactic builds. A script that fails to build a term has not produced a proof, even if the script looks plausible in a text editor.
  • Calling a second kernel a review of the meaning. Two implementations that agree can raise confidence in the checker. They share the formal statement. They do not supply the English reading.
  • Promoting a company's announcement into that reading. Axiom says it completed a Lean formalization of the classification, and Axiom says people inspected the statement. This page can cite that note. Citing it is the whole of what this page has done with it.

Where this sits in the proof pages

Proof by induction is the next template to formalize once the even sum feels small: the base and the step are two statements, and a checker certifies each one that has a term. Contrapositive versus contradiction is about the first and last lines of a human argument. Intro to proofs is the pathway that asks you to write those lines. The cluster map is real analysis and proof habits. A limit written with epsilon and delta is the analysis course's version of "the definition in force is the definition you must use", which is why the epsilon delta page belongs next to this one even though no Lean file appears there.

Sources and further reading

  • Lean language reference, overview: tactics produce terms, and the kernel checks those terms. Lean language site (accessed 21 November 2026)
  • Lean language reference, elaboration and compilation, the kernel: a small type checker whose job is to check proof terms; written in C++; separate implementations in Rust and in Lean. Lean language site, kernel section (accessed 21 November 2026)
  • mathlib, squares and even elements: Even a means there exists r with a = r + r; Even.add assumes an AddCommSemigroup; the page notes an older definition a = 2 * c and lists even_iff_exists_two_nsmul. mathlib docs site (accessed 21 November 2026)
  • Axiom, Formalizing the Enormous Theorem, 26 October 2026. Axiom's claim that it formalized the classification of finite simple groups in Lean, including Axiom's description of the human reading of the statement and Lean's check of the deductions. Reported here as Axiom's claim. axiommath.ai (accessed 21 November 2026)

Last reviewed: 21 November 2026.

Common questions

What does a computer checked proof actually prove?

It certifies that a formal statement follows from the definitions and earlier results that statement uses. A person still has to read those definitions to see whether the formal statement matches the English theorem.

What does mathlib mean by even?

The mathlib page on squares and even elements defines Even a as the existence of an r such that a equals r + r. The theorem Even.add adds a hypothesis: addition is a commutative semigroup. Under that hypothesis, Even a and Even b imply Even (a + b).

What does Lean's kernel check?

The Lean language reference says the kernel checks proof terms. Tactics build those terms. A separate implementation of the kernel can check the same term again. Reading the English sentence is a person's job.

Has this site checked Axiom's classification claim?

No. On 26 October 2026 Axiom said it had formalized the classification of finite simple groups in Lean, and Axiom described that work as a complete computer checked proof. This page reports that as Axiom's claim. It does not rerun the repository or review the formal statement.

Related reading

An open mathematics book and handwritten notes for learning proofs

Intro to proofs

The writing pathway: quantifiers, an epsilon delta argument, and the habit of naming what was proved.

A scientific calculator used as a numerical check beside handwritten limits

Epsilon delta finder

A sampled window for one epsilon. Useful as a picture, and a different object from a proof term.