{"slug": "the-lean-theorem-prover-design-evolution-and-impact", "title": "The Lean Theorem Prover: Design, Evolution, and Impact", "summary": "The Lean Theorem Prover, an open-source proof assistant and programming language, has reached 280,000+ formalized theorems and 2.4M+ lines of code with 750+ contributors as of July 2026, according to Kim Morrison. Lean 4.0, released officially in September 2023, features a small trusted kernel and extensible design, enabling AI-assisted formal verification that makes AI trustworthy and cost-effective. The Lean FRO, a nonprofit with 20 engineers launched in July 2023, has shipped 32 releases and merged 9,000+ pull requests, with the project featured in NY Times, Quanta, and Scientific American.", "body_md": "Formal verification makes AI trustworthy.\n\nAI makes formal verification cost-effective.\n\n[Hex](https://github.com/leanprover/hex) is a [Lean](https://lean-lang.org) library for computational algebra: LLL lattice reduction, Gram–Schmidt, matrix row reduction, polynomial factorization.\n\nEvery algorithm is proved correct in Lean.\n\n**Specifications written by hand. Implementations and proofs written by AI.**\n\n[Kim's blogpost](https://kim-em.github.io/blog/2026-7-7-lattice-basis-reduction-using-the-hex-lean-library/) demonstrates how to use Hex to perform Coppersmith's attack on RSA, recovering a 400-bit secret from a 2048-bit modulus.\n\n*Kim Morrison, July 2026.*\n\n\"You have written my favorite computer game\" — Kevin Buzzard, Prof. of Mathematics, Imperial College\n\n```\ndef odd (n : Nat) : Prop := ∃ k, n = 2 * k + 1\ntheorem square_of_odd_is_odd : odd n → odd (n * n) := byn:Nat⊢ odd n → odd (n * n)\nintro ⟨k₁, e₁⟩n:Natk₁:Nate₁:n = 2 * k₁ + 1⊢ odd (n * n)\nsimp [e₁, odd]n:Natk₁:Nate₁:n = 2 * k₁ + 1⊢ ∃ k, (2 * k₁ + 1) * (2 * k₁ + 1) = 2 * k + 1\nexists 2 * k₁ * k₁ + 2 * k₁n:Natk₁:Nate₁:n = 2 * k₁ + 1⊢ (2 * k₁ + 1) * (2 * k₁ + 1) = 2 * (2 * k₁ * k₁ + 2 * k₁) + 1\nliaAll goals completed! 🐙\n```\n\nThe \"game board\": you see goals and hypotheses, then apply \"moves\" (tactics).\n\n**Each tactic transforms the game board.**\n\nThe kernel checks the final proof term.\n\nReleased January 2017, with a tutorial at POPL 2017.\n\nFirst Lean version with a real tactic framework.\n\n**Tactics are written in Lean itself.**\n\n[\"A Metaprogramming Framework for Formal Verification\"](https://dl.acm.org/doi/10.1145/3110278) — ICFP 2017.\n\nThis design made community automation possible: `linarith`\n\n, `ring`\n\n, `omega`\n\n, and hundreds more.\n\nThe community implemented several linters in Lean.\n\nCreated in July 2017, in Lean 3 during [Big Proof](https://www.newton.ac.uk/event/bpr/). An open-source, community-driven library. **Today**:\n\n**280,000+** formalized theorems.\n\n**2.4M+** lines of Lean. **50,000+** lines of extensions.\n\n**750+** contributors.\n\n**1,500+** type classes, **20,000+** instances.\n\n\"I'm investing time now so that somebody in the future can have that amazing experience.\" — Heather Macbeth, Prof. of Mathematics, Imperial College\n\n[Sebastian Ullrich](https://sebasti.a.nullri.ch/) and I started development from scratch in April 2018. *At the time, Mathlib was just ~55K LoC.*\n\n**Goal: Implement compiler, elaborator, parser, tactic framework, and build system in Lean.**\n\nOctober 2020: Lean 4 compiles Lean 4.\n\nJanuary 2021: First pre-release. **Mathlib is ~450K LoC.**\n\nSeptember 2023: **Lean 4.0 official release with Mathlib fully ported (~1.1M LoC).**\n\nLean 4 is very **extensible**.\n\nNovember 2020: Peter Scholze posed a formalization challenge.\n\n\"I spent much of 2019 obsessed with the proof of this theorem, almost getting crazy over it. I still have some small lingering doubts.\" — Peter Scholze\n\nJohan Commelin led a team that verified the proof, with only minor corrections.\n\n**They verified and simplified the proof without fully understanding it.**\n\n\"The Lean Proof Assistant was really that: an assistant in navigating through the thick jungle that this proof is.\" — Peter Scholze\n\nNonprofit. **20 engineers.** Open source. **Controlled by no single company.**\n\n[Sebastian Ullrich](https://sebasti.a.nullri.ch/) and I launched it in July 2023.\n\nLean is not a research project anymore. We run the Lean FRO as a startup.\n\n**32 releases and 9,000+ pull requests merged since launch.**\n\nMission focus: scalability, usability, proof automation, documentation.\n\nThe Lean project was featured in NY Times, Quanta, Scientific American, Wired, and others.\n\n*A programming language and a proof assistant.*\n\nLean is implemented in Lean. **Very extensible**.\n\nLean is **scalable**.\n\nSmall **trusted** kernel. Proofs can be exported and independently checked.\n\n**285,000+** unique installations: [VS Code](https://marketplace.visualstudio.com/items?itemName=leanprover.lean4) (161K) + [Open VSX](https://open-vsx.org/extension/leanprover/lean4) (126K).\n\n```\ndef reverse : List α → List α\n| [] => []\n| x :: xs => reverse xs ++ [x]\ntheorem reverse_append (xs ys : List α)\n: reverse (xs ++ ys) = reverse ys ++ reverse xs := byα:Type u_1xs:List αys:List α⊢ reverse (xs ++ ys) = reverse ys ++ reverse xs\ninduction xs with\n| nil =>α:Type u_1ys:List α⊢ reverse ([] ++ ys) = reverse ys ++ reverse [] simp [reverse]All goals completed! 🐙\n| cons x xs ih =>α:Type u_1ys:List αx:αxs:List αih:reverse (xs ++ ys) = reverse ys ++ reverse xs⊢ reverse (x :: xs ++ ys) = reverse ys ++ reverse (x :: xs) simp [reverse, ih]All goals completed! 🐙\n#eval\n````[3, 2, 1]`\n\nreverse [1, 2, 3]\n`[3, 2, 1]`\n\nInstructions to build Mathlib, measured for every commit by [radar](https://radar.lean-lang.org), our performance-tracking server.\n\n**Compared with January 2025: 44% more code, 10% fewer instructions to build.**\n\nGreen: Lean releases. The sharp drops correspond to compiler and automation improvements.\n\nSix Fields Medalists engaged: Tao, Scholze, Viazovska, Gowers, Hairer, Freedman.\n\n[Carleson's Theorem](https://florisvandoorn.com/carleson//) (completed) — van Doorn\n\n[Liquid Tensor Experiment](https://www.nature.com/articles/d41586-021-01627-2) (completed) — Commelin\n\n[The Polynomial Freiman-Ruzsa Conjecture](https://github.com/teorth/pfr), Tao (completed)\n\n[Equational Theories Project](https://teorth.github.io/equational_theories/), Tao (completed)\n\n[Sphere Packing](https://thefundamentaltheor3m.github.io/Sphere-Packing-Lean/) — Birkbeck, Hariharan, Lee, Ma, Mehta, Viazovska\n\n[Fermat's Last Theorem](https://leanprover-community.github.io/blog/posts/FLT-announcement/) — Buzzard\n\n[Inter-Universal Teichmüller Theory](https://aitpm.github.io/slides/Mochizuki.pdf) — Mochizuki\n\nAt this scale, mathematics needs build systems, dependency graphs, code review, release engineering, and a precise medium for communication.\n\n**It is easier to read formal math than write it.**\n\nFormal math is easier to read than LaTeX.\n\nYou can click through, inspect definitions, check types.\n\nAI can explain formal proofs and is making the writing part easier.\n\nFuture math papers will embed type-checked Lean code.\n\nLecture notes, papers, and slides in one tool.\n\nThese slides are written in [Verso](https://verso.lean-lang.org/).\n\nEvery example is checked by Lean.\n\n[lean-lang.org](https://lean-lang.org/) is written in Verso.\n\n[My homepage](https://leodemoura.github.io/) is written in Verso.\n\n**Verso is a domain-specific language embedded in Lean.**\n\nBuilt by David Thrane Christiansen at the Lean FRO.\n\nVerso Blueprint is the next generation of [Massot's Lean Blueprints](https://github.com/PatrickMassot/leanblueprint), which are widely adopted in the Lean community.\n\nLarge projects like FLT and Sphere Packing need more than proofs.\n\nIt tracks definitions, lemmas, and dependencies.\n\nThe blueprint is a Lean document with inline code that is type-checked.\n\nBuilt by Emilio Jesús Gallego Arias at the Lean FRO.\n\nEmilio ported major projects onto it: FLT, Carleson, Sphere Packing.\n\nLean Verbose provides natural-language tactics to teach mathematics using Lean 4.\n\n**Playing the Lean game using mouse clicks and natural language.**\n\n[Lean Verbose](https://github.com/PatrickMassot/verbose-lean4) is implemented in Lean by Patrick Massot.\n\n**Zero installation.** Manage Lean and Verso Blueprint projects in your web browser.\n\nPre-configured with AI.\n\nGreat for teaching. Students can focus on the course instead of the technology.\n\nInstructors can ensure students use the correct libraries for the course.\n\nBuilt by Jason Reed at the Lean FRO.\n\n**Machine-checkable proofs enable a new level of collaboration.**\n\nIt is not just about proving but also *understanding* complex objects and proofs, getting new insights, and navigating through structures beyond our cognitive abilities.\n\nFormal math is more maintainable: auto-refactoring and generalization for free.\n\n\"We had formalized the proof with this constant 12, and then when this new paper came out, we said, 'Okay, let's update the 12 to 11.' And what you can do with Lean is that you just in your headline theorem change a 12 to 11. You run the compiler and... of the thousands of lines of code you have, 90% of them still work.\" — Terence Tao, Lex Fridman interview\n\nLean checks them.\n\nAlexeev & Mixon resolved a **$1000 Erdős prize problem**.\n\n\"We used ChatGPT to vibe code a Lean proof.\" — Alexeev & Mixon\n\n**The proof is machine-checked.** [Paper](https://borisalexeev.com/pdf/erdos707.pdf)\n\nEvery medal-level IMO AI with formal proofs uses Lean.\n\n**AlphaProof** (Google DeepMind) — silver medal, IMO 2024\n\n**Aristotle** (Harmonic) — gold medal, IMO 2025\n\n**Seed Prover** (ByteDance) — silver medal, IMO 2025\n\nAI plays the Lean game.\n\n*The moves in this game are tactics from automated reasoning.*\n\nSome moves played by **AlphaProof**:\n\n```\nsimp_all [Finset.sum_range_id]\nzify [*] at *\nnorm_num at *\nnlinarith [(by norm_cast : (c:ℝ) ≥ A*(l-⌊_⌋)+⌊_⌋+1),\n           Int.floor_lex, Int.lt_floor_add_one x]\n```\n\nEven the most advanced AI relies on the same tactics we use every day.\n\nBetter tactics make more powerful AI.\n\n**Leanstral** (Mistral): the first open-source code agent designed for Lean 4.\n\n**Axiom:** solved 12/12 problems on Putnam 2025.\n\n**DeepSeek Prover-V2:** 88.9% on miniF2F. Open-source, 671B parameters.\n\n**Harmonic:** built the Aristotle AI — gold medal, IMO 2025.\n\n**Sidharth Hariharan** and collaborators describe how Viazovska's Fields Medal-winning [sphere packing proofs were formally verified in Lean](https://thefundamentaltheor3m.github.io/Sphere-Packing-Lean/).\n\n[\"They Spent Years on a Math Problem. Then They Were Scooped by A.I.\" — NY Times](https://www.nytimes.com/2026/06/08/science/ai-scoop-young-mathematicians.html)\n\n\"We've gotten Gaussed.\" — Maryna Viazovska\n\nThe effort culminated in the **autoformalization** of the 24-dimensional sphere packing proof,\n**over 200,000 lines of code, in just two weeks**.\n\n**AI converted zlib (a C compression library) to Lean.**\n\n```\ntheorem zlib_decompressSingle_compress (data : ByteArray) (level : UInt8)\n    (maxOutputSize : Nat) (hsize : data.size ≤ maxOutputSize) :\n    ZlibDecode.decompressSingle (ZlibEncode.compress data level) maxOutputSize = .ok data\n```\n\n\"The Lean library isn't just tested and validated, it's proved correct. This allows us to let AIs loose optimizing the code, requiring that they update the proof whenever the implementation materially changes. This gives us the confidence to allow them to work autonomously in a way that would be unthinkable in other languages.\" — Kim Morrison,\n\n[Why Lean is faster than Rust]\n\n10 AI agents built a **verified embedded DSL** with proved optimizations in **a single weekend**.\n\n52 theorems.\n\n5 verified compiler optimizations.\n\nDeterminism, type safety, memory safety.\n\nInterpreter correctness — sound and complete.\n\n27 modules, ~7,400 lines of Lean.\n\nI did not touch the code. Zero lines. Full agent autonomy.\n\nA [Mathlib Initiative](https://mathlib-initiative.org/formal-frontier/) project.\n\nDefines community standards for trustworthy, maintainable **autoformalization**.\n\nReleases open-source tooling for scalable AI-driven formalization workflows.\n\nProduces high-quality Lean artifacts that **fill important gaps in Mathlib**.\n\nProvides prerequisites for **research-level** formalization.\n\n**AI-authored Lean mathematics, directed by a human-owned roadmap and gated by open, adversarial review.**\n\nHumans own the roadmap: mathematicians choose the targets.\n\nAIs write and review the code.\n\nOn the roadmap: universal covers, the Jacobian challenge, reductive algebraic groups, PDEs.\n\nTo turn any computer into a Tau Ceti contributor:\n\n```\nuv tool install git+https://github.com/kim-em/TauCetiWorker\ntauceti work --loop\n```\n\nAI is not just changing who uses Lean. It changed how **I** work.\n\nKim Morrison (Lean FRO) showed me a major refactoring step: more than 10,000 lines changed across Mathlib, implemented by AI.\n\nSince then, **AI has removed the pain of developing software.**\n\nI used to believe my superpower was that I could tolerate a lot of pain. That superpower is no longer relevant.\n\n**AI now isolates issues, tries new ideas, runs experiments, analyzes performance, and much more.**\n\nPublic results on a benchmark of **hard** Lean formalization problems.\n\nSubmission-based leaderboard.\n\n[Erdős's unit-distance conjecture is one of the problems](https://lean-lang.org/eval/problems/erdos_unit_distance_conjecture_false/).\n\nOpenAI showed this 80-year-old conjecture to be false.\n\nBoris Alexeev submitted a ~1.2M-line Lean formal proof.\n\n[\"Human mathematicians are being outcounterexampled\" — Kevin Buzzard](https://xenaproject.wordpress.com/2026/07/20/human-mathematicians-are-being-outcounterexampled/)\n\n[Feit–Thompson odd-order theorem](https://lean-lang.org/eval/problems/feit_thompson/) — 4 submissions\n\n[Jacobian of a compact Riemann surface (Buzzard challenge)](https://lean-lang.org/eval/problems/jacobian_challenge_diffgeo/) — 4 submissions\n\n[Formal Conjectures](https://google-deepmind.github.io/formal-conjectures/) (Google DeepMind): curated, human-verified formal statements of open problems.\n\n\"It's really important with these formal proof assistants that there are no backdoors or exploits you can use to somehow get your certified proof without actually proving it, because reinforcement learning is just so good at finding these backdoors.\" — Terence Tao\n\nLean has **multiple independent kernels**. You can build your own and submit it to [arena.lean-lang.org](https://arena.lean-lang.org).\n\n[Validating a Lean Proof](https://lean-lang.org/doc/reference/latest/ValidatingProofs/#validating-proofs) ∣ [Who Watches the Provers?](https://leodemoura.github.io/blog/2026-3-16-who-watches-the-provers/)\n\n[arena.lean-lang.org](https://arena.lean-lang.org) benchmarks independent proof checkers on the same proofs.\n\n[Comparator](https://github.com/leanprover/comparator) is a judge for Lean proofs. [comparator.live.lean-lang.org](https://comparator.live.lean-lang.org/)\n\nAvoids metaprogramming / unsafe exploits. Exports proofs. Sandboxed.\n\nA **challenge** is a Lean file with `sorry`\n\ns to be filled.\n\n```\ndef large : Nat := sorry\ntheorem large_lt : 37 < large := sorry\n```\n\nA **solution** replaces the `sorry`\n\ns with Lean terms and proofs.\n\n```\ndef large : Nat := 38\ntheorem large_lt : 37 < large := by⊢ 37 < large decideAll goals completed! 🐙\n```\n\nComparator checks whether the solution is valid.\n\nA challenge asks for a proof of `False`\n\n.\n\nA candidate tries to smuggle one past the kernel with a metaprogramming trick that exploits a missing check in the official kernel.\n\nReal [GitHub issue](https://github.com/leanprover/lean4/issues/14484). **Comparator rejects it.** The proof is exported and re-checked independently, defeating the exploit.\n\n**Nanoda** (Lean kernel written in Rust) and **Lean4Lean** reject it too.\n\n\"I thought AI would prove all theorems for us now.\"\n\nTactics are like **game moves**.\n\nBetter tactics = shorter proofs.\n\nBetter tactics = more powerful AI.\n\nCompact proofs = better training data = better AI provers.\n\n`grind`\n\n?New proof automation, shipped in Lean v4.22. Kim Morrison and me.\n\nA **virtual whiteboard**, inspired by modern SMT solvers.\n\nWrites facts on the board. Merges equivalent terms.\n\nCooperating engines: **congruence closure**, **E-matching**, **constraint propagation**, **guided case analysis**.\n\nSatellite theory solvers: **cutsat** (linear integer arithmetic), **commutative rings** (Gröbner), **linarith**, **AC**.\n\n**Native to dependent type theory.** No translation to FOL.\n\nProduces ordinary Lean proof terms. **Kernel-checkable.**\n\nTalk at IJCAR (Monday July 27 at 11:50 am).\n\n**5,000+ grind uses in Mathlib.**\n\n`grind`\n\n— Theory Combination```\nexample [CommRing α] [NoNatZeroDivisors α]\n(a b c : α) (f : α → Nat)\n: a + b + c = 3 →\na^2 + b^2 + c^2 = 5 →\na^3 + b^3 + c^3 = 7 →\nf (a^4 + b^4) + f (9 - c^4) ≠ 1 := byα:Type u_1inst✝¹:CommRing αinst✝:NoNatZeroDivisors αa:αb:αc:αf:α → Nat⊢ a + b + c = 3 → a ^ 2 + b ^ 2 + c ^ 2 = 5 → a ^ 3 + b ^ 3 + c ^ 3 = 7 → f (a ^ 4 + b ^ 4) + f (9 - c ^ 4) ≠ 1\ngrindAll goals completed! 🐙\n```\n\nThree solvers meet at the E-graph:\n\n**Ring solver** derives `a^4 + b^4 = 9 - c^4`\n\n.\n\n**Congruence closure** lifts it to `f (a^4 + b^4) = f (9 - c^4)`\n\n.\n\n**Linear integer arithmetic** closes `2 * f (9 - c^4) ≠ 1`\n\n.\n\nThe Nelson-Oppen playbook. **Inside dependent type theory.** No SMT translation layer.\n\n```\nexample {α} [CommRing α] [IsCharP α 0] [NoNatZeroDivisors α]\n(d t d_inv : α)\n(Δ40 : d * (d + t + d * t) = 0)\n(Δ41 : d^2 * (d + d * t - 2 * d * t^2 + d * t^4 + d^2 * t^4) = 0)\n: d * d_inv = 1 →\nt + 2 * t^2 - t^3 - 2 * t^4 + t^5 = 0 := byα:Type u_1inst✝²:CommRing αinst✝¹:IsCharP α 0inst✝:NoNatZeroDivisors αd:αt:αd_inv:αΔ40:d * (d + t + d * t) = 0Δ41:d ^ 2 * (d + d * t - 2 * d * t ^ 2 + d * t ^ 4 + d ^ 2 * t ^ 4) = 0⊢ d * d_inv = 1 → t + 2 * t ^ 2 - t ^ 3 - 2 * t ^ 4 + t ^ 5 = 0\ngrindAll goals completed! 🐙\n```\n\nQuantum algebra example from \"Categories generated by a trivalent vertex\" — Morrison, Peters, Snyder.\n\nWhen `grind`\n\ncloses a goal in one step instead of fifty, **the AI search tree shrinks dramatically**.\n\n**Autoformalization is already effective.**\n\nAI is getting better and better at explaining Lean code.\n\nAI can already synthesize code from specifications.\n\n[Software Foundations in Lean](https://github.com/plclub/sf-in-lean): translated by humans. The AI translation is good, but making it **great** takes more effort than writing from scratch.\n\nIn 2019, the IMO was posed as a [Grand Challenge](https://imo-grand-challenge.github.io/) for AI. Five years later, it feels routine.\n\n**AI is exceptional at the nerd-sniping tasks: isolating and diagnosing bugs, optimizing code, translating code, writing complex proofs, and metaprogramming.**\n\nBut it is **not** good at system-level engineering and design, novel implementation and design ideas, or long-running contexts.\n\n*Lean is not only for mathematics.*\n\n[Cedar](https://www.cedarpolicy.com/en) — open-source authorization policy language. Used by **AWS Verified Permissions** and **AWS Verified Access**.\n\n[Cedar spec](https://github.com/cedar-policy/cedar-spec): the model is written in Lean.\n\nThree examples of verified components: **evaluator, authorizer, validator.**\n\n`forbid_trumps_permit`\n\n— if any forbid policy is satisfied, the request is denied.\n\n`allowed_only_if_explicitly_permitted`\n\n— a request is allowed only if at least one permit policy is satisfied.\n\n`typecheck_is_sound`\n\n— if the validator accepts a policy, evaluation produces a boolean.\n\nExecutable Lean model alongside Rust production code. **Lean model ~10× smaller than Rust.**\n\n**~100M differential random tests nightly.** Lean: 5 μs/test. Rust: 7 μs/test.\n\n**Release gate**: no Cedar version ships unless model, proofs, and differential tests are current.\n\n\"We've found Lean to be a great tool for verified software development.\" — Emina Torlak\n\nAn **open-source** Lean library of formally **verified differential privacy primitives.**\n\nThe implementation is not only verified, but it is also **twice as fast as the previous one.**\n\nSampCert is software, but its verification relies heavily on Mathlib.\n\nThe verification of code addressing practical problems in data privacy depends on the\nformalization of mathematical concepts, from **Fourier analysis** to **number theory** and **topology**.\n\n**Deployed in AWS Clean Rooms Differential Privacy.**\n\nPLDI 2025: \"Verified Foundations for Differential Privacy.\"\n\n“For SampCert, I started using Lean because of Mathlib, but I realized that Lean isn't just an excellent proof assistant, it's also a very pleasant and efficient programming language with a great ecosystem.” — Jean-Baptiste Tristan\n\n[Strata](https://strata-org.github.io/Strata/): extensible platform for formalizing language syntax and semantics. Built in Lean. Open source.\n\nKey idea: **dialects** (inspired by MLIR). Orthogonal, composable building blocks for modeling programming constructs.\n\nCore, C_Simp, Laurel, SMTLib, Python, Boole.\n\nLaurel pipeline: Python/Java/JavaScript → Laurel → Strata Core → VCG → SMT.\n\n**Dialect Definition Mechanism (DDM)**: embedded DSL in Lean for defining syntax and typing rules.\n\nBoogie/Dafny-style verification infrastructure, built in Lean and extensible via Lean's metaprogramming.\n\nCompCert-style verified compiler for AWS Trainium, Amazon's custom AI accelerator chip. **~500,000 lines of Lean code.**\n\nThe ISA specification changes **several times per week**. Not a fixed ISA like x86.\n\nLean provides an up-to-date simulator that hardware and verification engineers share.\n\nLean + AI keeps the team in sync with hardware changes. Several hundred instructions per generation.\n\nUsed to find hardware and simulator bugs and **prove the correctness of subtle hardware optimizations**.\n\nLong-term goal: end-to-end compiler verification — source program compiles to Trainium machine code, with a proof that compilation preserves semantics.\n\n\"Lean is a fantastic functional programming language.\" — Sean McLaughlin\n\n[SymCrypt](https://www.microsoft.com/en-us/research/blog/rewriting-symcrypt-in-rust-to-modernize-microsofts-cryptographic-library/) — Microsoft's core cryptographic library, rewritten in Rust.\n\nAeneas: translates safe Rust to pure functional Lean code.\n\nThe first release includes complete proofs for **ML-KEM** and **SHA-3** code running in Windows Insider builds today.\n\n\"We are verifying code faster than we can write it.\" — Son Ho, SymCrypt, Microsoft\n\n[Veil](https://veil.dev/): verification of distributed protocols. Built on Lean as a library using Lean metaprogramming.\n\n\"Multi-Modal Verification of Distributed Systems in Lean\" — Ilya Sergey\n\nAuthors: George Pîrlea, Vladimir Gladshtein, Elad Kinsbruner, Qiyuan Zhao, and Ilya Sergey.\n\nPush-button verification via SMT (cvc5/Z3) for decidable fragments.\n\nFull interactive proofs in Lean when automation falls short.\n\nSeamless transition between the two modes.\n\n**Foundational**: Veil's VCG is proven sound w.r.t. the specification language semantics.\n\n16 distributed protocol case studies. **All 16 verified.** Ivy failed on 2. **87.5% verified in under 15 seconds.**\n\n[Jonathan Protzenko](https://jonathan.protzenko.fr/) and [Andres Erbsen](https://andres.systems/)\n\n[Kraken](https://github.com/AeneasVerif/kraken): the x64 model is intended for verifying sequential software that performs computations using common registers and memory.\n\nA semantics optimized for proof automation.\n\nUses lessons learned from Bedrock2 — the interpreter either computes a WP or a final state.\n\nCurrently supports x64, arm64 (WIP), and RISC-V (on the roadmap).\n\nCurrent status: pre-alpha; tactics still need Lean support to get to the level required to prove non-trivial programs.\n\nProject started after the [Lean@Google Hackathon](https://sites.google.com/view/lean-at-googl-2025/home) in December 2025.\n\nIlya Sergey (VERSE lab) formalized and verified Move's borrow checker in Lean. **39,000 lines** of mechanized metatheory in **27 working days**, using Claude as an AI coding assistant.\n\n**Move**: smart contract language for the Sui and Aptos blockchains. Rust-like ownership discipline. References are access paths rooted in local variables. No lifetime annotations.\n\n**The borrow checker**: tracks reachability between references using regular expressions over field paths.\n\nFormalized in Lean:\n\nRelational type system encoding\n\nExecutable algorithmic type checker\n\n**Soundness proof**: the algorithmic checker is sound w.r.t. the relational rules\n\nRuntime semantics as a definitional interpreter\n\n**Type soundness**: progress + preservation. Any function accepted by the type checker never reaches a preventable error across all execution paths.\n\n[CSLib](https://www.cslib.io/) aims to be a foundation for teaching, research, and new verification efforts, including AI-assisted.\n\nSteering committee: Clark Barrett, Swarat Chaudhuri, Jim Grundy, Pushmeet Kohli, Leo de Moura, Fabrizio Montesi.\n\n[Iris](https://iris-project.org/) is a higher-order concurrent separation logic framework implemented in Rocq.\n\nVery popular. 150+ papers since 2015.\n\n[Iris Lean](https://leanprover-community.github.io/iris-lean/) is a port of Iris to Lean. **Progress (last week): 70.3%**\n\nStarted as Lars König's master's thesis (2022). Maintained by Mario Carneiro until 2025; then Markus de Medeiros and many others got interested.\n\n[Introduction to Iris-Lean by Zongyuan Liu](https://www.youtube.com/watch?v=1TPmpuRaTvc). Why port Iris to Lean? Zongyuan's answer:\n\n[Signal Shot](https://www.beneficialaifoundation.org/blog/signal-shot) is a public moonshot to verify the Signal protocol and its Rust implementation using Lean.\n\nIt is a joint effort of Signal (Rolfe Schmidt), the [Beneficial AI Foundation](https://www.beneficialaifoundation.org/) (Max Tegmark), and the Lean FRO.\n\nThe pieces:\n\nAeneas\n\nMathlib and [CSLib](https://www.cslib.io/)\n\nSymbolic proof automation (`grind`\n\n) and scalable verification generation (`SymM`\n\n)\n\nAI\n\nA **VC generator** turns code and specifications into proof obligations. Lean-based VC generators:\n\n**Aeneas** — Rust verification via translation to Lean.\n\n**Velvet** — a Dafny-style verifier built in Lean.\n\n**vcgen** — Lean's VC generator for monadic programs.\n\n**Issue: Verification condition generation with proof assistants has not scaled so far.**\n\nAdam Chlipala's group documented this for Rocq. The same story held in Lean until a few months ago.\n\n** Andres Erbsen** — Google ISE Formal. Bedrock2. Fiat Cryptography.\n\nA Rocq veteran distilled the scaling problem into a minimal challenge at [Lean@Google Hackathon](https://hackmd.io/sjPWIMP9TIuKW5tuWUfxXA).\n\nA [parametric example](https://github.com/leanprover/lean4/blob/master/tests/bench/sym/add_sub_cancel.lean) for a small deeply embedded imperative language.\n\nWith Lean's default tactic framework, `MetaM`\n\n, this is **superlinear**.\n\nA **VC generator** turns code and specifications into proof obligations.\n\nLean-based VC generators: **Aeneas**, **Velvet**, **vcgen**.\n\nAll three share the same idiom — and need:\n\nEfficient `apply`\n\n.\n\nEfficient metavariable management.\n\nPreserve term sharing.\n\nReuse `simp`\n\nand `grind`\n\nresults across proof obligations and across simulation steps.\n\nDo not traverse the same subterms over and over.\n\n`SymM`\n\n: new monadic framework for high-performance software verification. Born after the [Lean@Google Hackathon](https://hackmd.io/sjPWIMP9TIuKW5tuWUfxXA).\n\nDesigned for tools like Aeneas, vcgen, and Velvet that need to *discharge thousands of verification conditions efficiently*.\n\n**Without this, verifying something as large as Signal is slow and painful. With it, verification conditions get discharged efficiently.**\n\n`SymM`\n\nLean's VC generator for monadic programs. Ported to `SymM`\n\nby **Sebastian Graf** (Lean FRO).\n\nAndres' Challenge using Lean monadic code. **Linear** out to n=1000.\n\n`SymM`\n\nA Dafny-style verifier in Lean. Ported to `SymM`\n\nby ** Vova** (VERSE lab and Lean FRO intern). Preliminary results.\n\n**Before**: Velvet ran ~3× slower than Dafny.\n\n**After**: Faster than Dafny on 24 of 27 benchmarks; competitive on the other 3 (`differenceMinMax`\n\n, `findEvenNumbers`\n\n, `mergeSorted`\n\n).\n\n**The new version beats Dafny on 24 of 27. Dafny has a vast TCB.**\n\nA Lean framework by Théophile Wallez for proving the security of cryptographic protocols.\n\nThe proof methodology builds on (and improves) DY*.\n\nDyLean leverages `grind`\n\nto discharge preconditions: automation on par with DY* / F* (which use Z3).\n\n`SymM`\n\n+ incremental `grind`\n\nin the VC generator led to a 50× speedup.\n\n`bv_decide`\n\n— Ported to `SymM`\n\nLean's bit-vector decision procedure. Ported to `SymM`\n\nby **Henrik Böving** (Lean FRO).\n\nBenchmarked against Bitwuzla on **46,191** SMT-LIB bit-vector problems.\n\n** bv_decide solves 45,046 (97.5%) — kernel checking included.** Bitwuzla solves 45,817.\n\n**Identical sat/unsat verdicts on every problem both solved.**\n\nTotal CPU time within 2.3× of Bitwuzla.\n\nAccelerate Lean’s development as both a software verification platform and a programming language.\n\n**The single largest donation in the Lean FRO's history.** Substantial, long-term support.\n\n\"It's easier to trust a proof when the tools that check it are open.\" — Byron Cook and Shawn Bice\n\nCommunity-governed tools can be inspected and validated independently by customers, auditors, and regulators.\n\n**The Automated Reasoning Group at AWS is hiring!**\n\n[Lean](https://lean-lang.org/) is **extensible**, **scalable**, and **trusted**, with **great tooling**.\n\nThe Mathlib community is changing how mathematics is done.\n\n**Lean is not only for mathematics. Software verification is now a major use case.**\n\nSpecification-oriented development is within reach.\n\nNew libraries: [CSLib](https://www.cslib.io/), [Physlib](https://physlib.io/).\n\nAI is bringing formal verification to everyone.\n\nThe Lean FRO Year 4 roadmap is coming soon: many new features and optimizations in the pipeline.\n\nAI changes how we build proof assistants. It does not change what makes them good.\n\nFormal methods has never been more relevant.", "url": "https://wpnews.pro/news/the-lean-theorem-prover-design-evolution-and-impact", "canonical_source": "https://leodemoura.github.io/static/floc26/", "published_at": "2026-07-27 07:29:15+00:00", "updated_at": "2026-07-27 07:52:39.218020+00:00", "lang": "en", "topics": ["artificial-intelligence", "ai-tools", "developer-tools", "ai-research", "ai-safety"], "entities": ["Lean Theorem Prover", "Kim Morrison", "Lean FRO", "Sebastian Ullrich", "Kevin Buzzard", "Heather Macbeth", "Peter Scholze", "Johan Commelin"], "alternates": {"html": "https://wpnews.pro/news/the-lean-theorem-prover-design-evolution-and-impact", "markdown": "https://wpnews.pro/news/the-lean-theorem-prover-design-evolution-and-impact.md", "text": "https://wpnews.pro/news/the-lean-theorem-prover-design-evolution-and-impact.txt", "jsonld": "https://wpnews.pro/news/the-lean-theorem-prover-design-evolution-and-impact.jsonld"}}