Below the Ice — No Sorry Allowed: How AI Is Learning to Prove Math
Two papers dropped today showing AI helping formally verify mathematics in Lean 4 — one framing it as a strategy game, one building a full agentic pipeline called OpenProver. Tonight we go below the headline and explain why the convergence matters for builders.
The headline is something like "AI helps prove a century-old physics equation." It sounds impressive and a little abstract. We go below it.
Because what happened today is actually two things at once — and together they sketch an outline of something that could matter a lot for how we build AI systems we can trust.
Listen to the Below the Ice podcast episode for the full audio version of this deep-dive.
What formal proof actually means
Mathematicians write proofs in papers. They are meant to be airtight — every step following from the last — but in practice they are written for human readers, and human readers can fill in gaps, hand-wave over a tricky lemma, and generally let the argument breathe a little.
A proof assistant like Lean 4 does not breathe. It is a programming language where your proof is code, and the compiler checks every step. If a step is missing — if you skip over a lemma because it "should be obvious" — you have to write the word sorry and Lean will let you continue, but it will also flag the whole file as containing unproven claims.
Zero sorries means the proof is machine-verified. Every implication checked, every quantifier unpacked, every step confirmed by software that does not get tired or take shortcuts.
That is the win condition.
The strategy game
The first paper (arXiv:2607.08986) takes a real research result — the mean-field derivation of the Vlasov equation, a piece of kinetic physics — and turns its formalization into a game with a simple win condition: get it to compile in Lean 4 with zero sorries.
The setup: a mathematician calls the high-level moves. "We need a compactness argument here. Split the sum into these two cases." The AI handles the low-level Lean 4 tactics — the actual code that tells the compiler what the mathematician meant.
Think of it like a chess match where a grandmaster dictates strategy from across the room and a computer does the board calculations. The grandmaster cannot type Lean; the computer cannot decide which direction the proof needs to go. Together, they finish the game.
The result compiles. No sorries. The theorem holds.
The agentic pipeline
The second paper (arXiv:2607.09217) goes further. OpenProver is an open-source system that tries to automate the whole loop without needing a mathematician in the chair.
It has three roles working together:
- Planner — maintains a running scratchpad of proof state and calls the high-level strategy moves.
- Workers — multiple parallel agents, each attempting specific Lean 4 tactics to close one sub-goal.
- Verifier — checks every attempt against the Lean compiler and routes feedback back to the Planner.
The loop runs until the proof closes — or until it runs out of budget. The architecture is deliberately transparent: every step is logged, every tactic attempt recorded. You can watch it think, which is unusual for an AI system doing hard work.
Why this matters right now
Three things came together at once.
First, large language models have gotten good enough to generate plausible Lean 4 tactics. Six months ago they mostly failed; now they succeed often enough to be useful in a loop.
Second, the Lean 4 ecosystem has hit a critical mass. Mathlib — the community-maintained library of formalized mathematics — is large enough that a prover can lean on it instead of rebuilding everything from scratch.
Third, and this is the one that should make AI safety researchers pay attention: if you can get an AI to produce machine-checkable reasoning, you have a new kind of reliability layer. One that does not require you to trust the model's word for it.
Software has had this for decades. A type checker is a machine that says "yes, this code does what you claim it does, at least regarding types." Formal verification says the same thing about the logic inside the code. The question being quietly explored in both papers is: could something similar apply to AI reasoning chains?
What is overhyped
AI is nowhere near replacing mathematicians. The strategy game paper requires a mathematician to call every high-level move. OpenProver needs the Planner to understand proof structure at a level current LLMs only occasionally manage.
What is actually happening is more modest and more useful: AI is absorbing the tedious mechanical translation work. Taking a LaTeX proof that a human already understands and re-expressing it as Lean code the compiler can check. That is still genuinely hard, and doing it well at scale would save mathematicians hundreds of hours.
The headline "AI proves math" is easier to say than "AI helps encode already-understood math in a format that a compiler can verify." But the second version is more accurate, and it is the one worth building on.
What to watch
Three concrete threads to follow from here.
The Lean 4 community. If you want to understand the ecosystem these tools live in, the Lean Zulip chat is where the action is. The mathlib4 repository on GitHub is the living library both papers depend on — its growth rate is a reasonable proxy for how much surface area automated provers can cover.
OpenProver on GitHub. The paper ships with an open-source release. If you have ever wanted to see an agentic system with a real correctness oracle (the Lean compiler does not lie), this is a working example of that pattern in the wild.
The verified-reasoning question. The open question underneath both papers is whether formally verified reasoning could become a reliability layer for production AI systems — the way type systems became a reliability layer for software. Not soon. But the infrastructure for asking that question is now being built in public.
The win condition stays the same: zero sorries.
Find us at penguinalley.com and catch tomorrow's Cold Open for the morning's biggest story.
Sources: