Formal proofs, explained — the machinery that makes AI math believable
A formal proof is written as code a computer verifies step by step — closing the door on plausible-but-wrong AI reasoning
The three lines
- Formal proofs encode every logical step in languages like Lean for mechanical checking
- Human review takes months and misses things; a passing formal proof has no logical gaps
- It answers the AI-trust question — which is why OpenAI published Lean code with its claims
Key questions
- How does a formal proof differ from a normal one
- A normal proof is prose for humans to read; a formal proof is code for a computer to check. Every logical step is written in a proof assistant's language — Lean, Coq, Isabelle — and a verifier mechanically confirms the chain from axioms to conclusion. The 'this step is obvious, moving on' of human proofs is structurally impossible: even obvious steps must compile.
- Why did this suddenly become important
- Because AI's chronic failure is confident nonsense. An AI-generated proof can look impeccable and hide a logical hole that humans lack the time or patience to find. Formal verification delegates that checking to a machine: a proof that passes is logically true regardless of who — or what — wrote it. That is why OpenAI shipped its math claims as Lean code on GitHub.
- Will all mathematics go formal
- Direction yes, cost historically no — formalizing a paper proof takes several times the effort, so only a sliver of mathematics ever was. The twist: AI turns out to be good at exactly that tedious translation work. If AI proves, AI formalizes, and machines verify, the bottleneck of mathematical verification itself disappears.
Today's OpenAI story called formal proofs "the load-bearing layer" of the announcement. This reference examines that layer. Formal proof was a back-room specialty of mathematics until AI started doing math — at which point it moved to center stage, because it is the sturdiest answer yet to the question of the era: how do you trust an answer a machine produced?
1. The concept — from proofs you read to proofs that get checked
A mathematical proof has traditionally been prose: colleagues read the paper, follow the logic, and vouch for it. That process takes months, and it misses things — famous theorems have had holes surface in their proofs years after publication.
A formal proof changes the medium. Every logical step is written in the language of a proof assistant — Lean, Coq, Isabelle — and a verification program mechanically checks that the chain from axioms to conclusion uses only permitted inference rules. The human reviewer's "this part is obvious, we move on" cannot exist: even the obvious steps must be filled in for the proof to compile.
2. Side by side — and the calculation AI changed
| Aspect | Traditional proof (human review) | Formal proof (machine check) |
|---|---|---|
| Form | Natural-language paper | Proof-assistant code |
| Verifier | Peer mathematicians | A checking program |
| Time | Months to years | Compile-time |
| Error risk | Reviewers can miss holes | Passing = no logical gaps |
| Writing cost | Low | Very high — the historic bottleneck |
| After AI | — | AI begins doing the formalization |
The last two rows are the live story. Formal proof's one weakness was cost: formalizing a paper proof by hand takes several times the effort, so only a small fraction of mathematics was ever formalized. The twist is that this meticulous translation work is exactly what AI does well. If AI generates proofs, AI formalizes them, and machines verify them, the loop removes verification itself as mathematics' bottleneck. OpenAI publishing its open-problem results as Lean code on GitHub is that loop's public demonstration.
3. What remains — using this document
For every future "AI solved a math problem" headline, one check suffices: was a formal proof published? If yes, anyone can run the verifier — no trust in the announcer required. If only natural-language proofs exist, park judgment until peer review concludes. That single test separates achievement from press release. This week's case runs in "An AI touched ten open math problems"; the other axis of AI verification — safety — in "Thirty days before launch."