# Formal verification: what it is and why AI made it news

> Proof assistants such as Lean check every step of a proof. AI now writes those proofs, including 43 million lines of Lean for one of math's longest theorems.

URL: https://claudegpt.si/news/what-is-formal-verification  
Published: 2026-11-20T06:58:10.313Z  
Author: ClaudeGPT Si Newsroom  
Section: Research  
Topics: Formal verification, Lean, AWS, Axiom Math, Claude, Research  
Publisher: ClaudeGPT Si

## Key takeaways

- Formal verification proves a program or theorem correct with a proof that a small, trusted checker verifies step by step.
- It already backs the seL4 microkernel, the CompCert C compiler and AWS services such as IAM Access Analyzer and the Nitro Isolation Engine.
- Axiom Math says its AI agents wrote about 43.1 million lines of Lean in about 24 days to formalize the Classification of Finite Simple Groups.

Formal verification means proving that a program, a chip design or a mathematical statement is correct, and having a computer check every step of that proof. Testing shows that something works on the cases you tried. Formal verification shows it works on every case its specification covers, and a machine-checked proof leaves no step to trust on faith. It is in the news this week because AI models have started writing these proofs at a scale no team of humans could, from [Amazon's experiments with Claude and the Isabelle proof assistant](https://www.amazon.science/blog/mathematical-proof-powered-by-ai-and-no-hallucinations) to [Axiom Math's 43-million-line proof](https://axiommath.ai/research/the-enormous-theorem-formalized/) of one of the longest results in mathematics.

The pairing matters because each side covers the other's weakness. Language models write fluent proofs but sometimes invent steps. A proof checker never invents anything, but writing proofs for it by hand is slow, expert work. Put them together and the model does the writing while the checker catches every mistake.

## How formal verification works

You start with a precise statement of what should be true. For a program, that is a specification: "this function always returns a sorted list" or "no process can read another process's memory." For mathematics, it is the theorem itself, written in a formal language instead of prose.

Then you write a proof in that same language, and a program called a proof assistant checks it. Lean, Isabelle/HOL and Rocq (formerly Coq) are the best known. The [Theorem Proving in Lean 4](https://lean-lang.org/theorem_proving_in_lean4/Introduction/) book draws the line between two styles. Automated provers search for proofs on their own but can trade away guaranteed soundness for speed. Interactive provers require every claim to rest on a proof in a fixed set of axioms and rules, which takes more human effort and yields stronger guarantees.

The trust comes from keeping the checker small. [Lean](https://lean-lang.org/) describes itself as an open-source programming language and proof assistant with a "minimal trusted kernel." Tactics, automation and now AI can generate a proof any way they like, but the final proof has to pass that small kernel. If the kernel accepts it, the proof is correct relative to the axioms and the statement. The weak point moves to the statement itself: a perfect proof of the wrong specification proves the wrong thing, so people still have to read the definitions carefully.

Lean also hosts [Mathlib](https://leanprover-community.github.io/), a community library that lean-lang.org says holds more than a million lines of formalized mathematics. Each new proof builds on what is already checked there.

## Where formal verification is used today

It started in research labs and now runs in systems people rely on.

- **seL4.** An operating system microkernel whose [proofs](https://sel4.systems/Verification/) run from a high-level specification down to the binary code, covering properties from functional correctness to absence of information leakage. The first functional correctness proof was completed in 2009, in Isabelle/HOL. The proofs still assume that the hardware, boot code and some assembly behave as described.
- **CompCert.** A C compiler from Inria with a machine-checked proof, in Rocq, that the code it generates "behaves exactly as prescribed by the semantics of the source program." That rules out bugs introduced by the compiler. According to [compcert.org](https://compcert.org/), it was qualified in March 2026 for an avionics computer on ATR 42/72 aircraft.
- **AWS.** Amazon's Automated Reasoning Group, launched in 2016, uses proofs and logic solvers across its cloud, [according to Byron Cook](https://www.amazon.science/blog/a-decade-of-mathematical-certainty-reflections-on-the-automated-reasoning-group). Its Zelkova engine powers S3 Block Public Access and IAM Access Analyzer, which analyze what a permissions policy allows, including access nobody intended. AWS also proved the [Nitro Isolation Engine](https://www.amazon.science/blog/isabelle-hol-the-proof-assistant-behind-the-nitro-isolation-engine), which it calls the first formally verified cloud hypervisor, with a proof of about a quarter of a million lines in Isabelle/HOL. Lean itself was created by Leo de Moura, now a senior principal scientist on that team, and lean-lang.org lists Cedar, AWS's authorization policy language, among Lean's uses.

## Why AI makes formal verification news now

On November 18, Hanno Becker and Larry Paulson of AWS's Automated Reasoning Group [described](https://www.amazon.science/blog/mathematical-proof-powered-by-ai-and-no-hallucinations) connecting an AI agent to Isabelle through the Model Context Protocol. With tools from AWS's open-source [AutoCorrode](https://github.com/awslabs/AutoCorrode) suite, Claude Opus 4.6 wrote every formal proof in their post. In one test the authors gave it a flawed argument about runs of consecutive composite numbers. Claude noticed the argument only produced N−1 numbers and fixed the theorem. The authors' point is that checking works best when it runs alongside generation, keeping the agent "on the right track."

The bigger result came from Axiom Math. On October 26 the startup [announced](https://axiommath.ai/research/the-enormous-theorem-formalized/) what it calls the first complete computer-checked proof of the Classification of Finite Simple Groups, a result that fills about 15,000 pages across more than 500 journal articles. A swarm of AI agents, directed by engineers and mathematicians, produced about 43.1 million lines of Lean in about 24 days. Axiom split the work into 108 milestones and published the [code](https://github.com/AxiomMath/CFSG). Along the way it logged 34 deviations from the published literature, mostly typos and dropped hypotheses, plus at least one false lemma and one false claim inside an older proof. [IEEE Spectrum reports](https://spectrum.ieee.org/enormous-theorem-ai) that nine days later Axiom also formalized the 7,500-page Stacks Project in about 16 million lines of code.

These claims come from Axiom itself. Lean checks the steps, but Axiom's own page says humans still have to review the formal statements and definitions, and it describes no independent audit yet. Colva Roney-Dougal of the University of St Andrews told Spectrum she values the errors the work found, but worries that a fully automatic proof gives mathematicians little insight to take from it.

## What to watch

The cost of writing proofs was always what held formal verification back. If AI keeps pushing that cost down, expect it to spread from kernels, compilers and cloud permissions to ordinary application code, and to AI-written code in particular, where a checked proof is a guarantee that review alone can't give. The open question is the specification. A machine can now check a proof, but people still have to decide what the proof should say.

## Frequently asked questions

### What is formal verification in simple terms?

It is proving that a program or mathematical statement meets a precise specification, with a computer checking every step of the proof. Testing covers the cases you try; a verified proof covers every case the specification describes.

### What is an example of formal verification?

The seL4 microkernel has machine-checked proofs, in Isabelle/HOL, running from its specification down to its binary code. The CompCert C compiler has a proof in Rocq that its output behaves as the source program's semantics prescribe.

### How is AI used in formal verification?

AI models write the formal proofs and a proof assistant such as Lean or Isabelle checks them, so invented steps get rejected. AWS researchers used Claude Opus 4.6 with Isabelle, and Axiom Math used a swarm of agents to write a 43-million-line Lean proof.

### Is formal verification used in hardware?

Yes. Lean describes its trusted kernel as suited to proofs about software and hardware, and seL4's proofs state which hardware behavior they assume.

## Sources

- [Mathematical proof, powered by AI. And no hallucinations!](https://www.amazon.science/blog/mathematical-proof-powered-by-ai-and-no-hallucinations), Amazon Science
- [Formalizing the Enormous Theorem](https://axiommath.ai/research/the-enormous-theorem-formalized/), Axiom Math
- [AxiomMath/CFSG](https://github.com/AxiomMath/CFSG), Axiom Math
- [Lean](https://lean-lang.org/), Lean FRO
- [Theorem Proving in Lean 4: Introduction](https://lean-lang.org/theorem_proving_in_lean4/Introduction/), Lean FRO
- [seL4 verification](https://sel4.systems/Verification/), seL4 Foundation
- [seL4 proofs](https://sel4.systems/Verification/proofs.html), seL4 Foundation
- [CompCert](https://compcert.org/), Inria / AbsInt
- [A decade of mathematical certainty: Reflections on the Automated Reasoning Group](https://www.amazon.science/blog/a-decade-of-mathematical-certainty-reflections-on-the-automated-reasoning-group), Amazon Science
- [Isabelle/HOL: The proof assistant behind the Nitro Isolation Engine](https://www.amazon.science/blog/isabelle-hol-the-proof-assistant-behind-the-nitro-isolation-engine), Amazon Science
- [Startup makes headway towards formalizing all of math with AI](https://spectrum.ieee.org/enormous-theorem-ai), IEEE Spectrum
