Lean's check makes a proof's logic undeniable, but whether its formal statement says what was meant still needs an expert.

This explores why a Lean-checked proof is treated as beyond dispute, and what that guarantee does and doesn't cover. The basic idea is that Lean's small checking program, called the kernel, confirms every logical step mechanically, so no judgment call is involved. The collection doesn't go into how the kernel works internally. It is much more interested in the less obvious point: Lean makes one layer of checking unarguable and leaves the next layer untouched. A Lean check proves that the formal statement follows from its definitions. It cannot tell you whether that formal statement says what the mathematician meant. Does free proof checking actually reduce verification burden? gives a striking number: in one 2026 corpus there were 379 machine-checked proofs for every statement that still needed an expert to confirm its meaning. Free checking doesn't remove the bottleneck. It moves it to the step where you translate the math into Lean.

Compare this with how other checks work. When IMO graders certified Gemini Deep Think's proofs as correct, that was expert human judgment applied to the final output, and the IMO said plainly that it did not vouch for how the system got there (What does correctness of outputs tell us about reasoning?). Checking only final answers is weaker still. Does LLM math reasoning truly generalize or just pattern match? shows that models can get answers right by pattern-matching and then fail when only the numbers change. Training against verifiable rewards makes reasoning steps fit together better locally, but a chain of plausible steps can still be an invalid proof (Does RLVR actually improve mathematical reasoning or just coherence?). Lean is meant to close exactly that gap: either every step goes through or the proof fails.

That is why Terence Tao argues it hardly matters how opaque an AI tool is if its output goes through a reliable validator such as a proof assistant (Can opaque machine learning models help prove new mathematics?). The checker carries the trust, so the generator doesn't need to. The same pattern appears outside mathematics. Can deterministic checks protect LLM judges from failure? recommends running the 'unarguable' mechanical checks before any judgment that could be disputed, and Lean is the purest example of an unarguable check. Where full formalization is too expensive, some research borrows Lean's discipline without its symbols. Structured templates force reasoning to cover every case and support every claim (Can structured templates replace formal verification for code reasoning?), and checking intermediate steps during long tasks catches errors that scoring only the final answer misses (Where do reasoning agents actually fail during long traces?).

The catch is that Lean's certainty depends on everything it is built on. Can autoformalization work on individual statements alone? points out that formalizing even a single theorem requires a consistent body of definitions and lemmas. Today's automatic formalization often works only because it borrows from Mathlib, a large library that humans already built. So 'unarguable' really means unarguable relative to definitions that someone had to get right first.

The less obvious takeaway is that mathematicians are deciding a machine check is not enough by itself. The Leiden Declaration keeps both responsibility for correctness and credit with human authors. It argues that a proof does two jobs, establishing certainty and conveying understanding, and formal verification only does the first (Can AI-generated proofs ever replace human mathematical understanding?). Lean can tell you a proof is valid. It can't tell you whether the statement is the one you intended, or why the result is true.