Lean 4: Scalable Theorem Proving

• Lean 4 is a dependently typed system that integrates interactive theorem proving and functional programming for rigorous formal reasoning.
• Its architecture features a trusted kernel, reengineered elaborator, and high-performance runtime, achieving significant speedups in benchmarks.
• The extensible metaprogramming and rich library ecosystem, including mathlib4, enable advanced applications in mathematics, programming language theory, and more.

Lean 4 is a dependently typed interactive theorem prover and functional programming language designed for both interactive and automated formal reasoning at scale. Building on the foundations of dependent type theory, Lean 4 introduces a high-performance core, a reengineered elaborator and metaprogramming infrastructure, a rich standard library (mathlib4), and modern system tooling, making it an advanced tool for mathematical formalization, proof engineering, and computational mathematics (Tang, 28 Jan 2025).

1. Architectural Foundations

Lean 4’s architecture is organized into three principal layers (Tang, 28 Jan 2025):

• Kernel: A small, trusted logical core implementing type checking for the Calculus of Inductive Constructions (CIC) extended with cumulative universes, inductive families, Σ-types, quotient types, and (optionally) additional classical axioms. The kernel maintains formal judgments

$$\Gamma \vdash e : T \qquad \text{and} \qquad \Gamma \vdash e \equiv e' : T$$

for definitional equality and typing, respectively.

• Elaborator: Parses high-level Lean syntax into fully explicit, type-correct kernel terms through metaprogram-controlled processes including implicit argument inference, overloading and notation resolution, type-class synthesis, and universe inference. The elaborator exposes an API in the MetaM monad, which is extensible at the user level.
• Runtime/Codegen: Compiles definitions to an explicitly-typed intermediate representation (IR) optimized for both proof checking in the Lean VM and numerical code generation via optional LLVM integration. The runtime supports closure conversion, lambda-lifting, inlining, specialization, and dead-code elimination.

Lean 4’s system-level innovations improve on Lean 3 by dramatically increasing performance in both elaboration and code execution. Benchmarks indicate that the mathlib4 build completes in ~2300s (Lean 4) vs ~5400s (Lean 3) and >10,000s (Coq), while individual kernel tasks (such as Flyspeck subtheory checking or large context simplification tactics) show similar or greater speedups (Tang, 28 Jan 2025).

2. Type Theory and Core Language

Lean 4 is based on a cumulative version of dependent type theory supporting (Tang, 28 Jan 2025):

• Universes:

$$\mathrm{Type}_0 : \mathrm{Type}_1 : \mathrm{Type}_2 : \cdots, \qquad \forall u\leq v,\,~\mathrm{Type}_u \hookrightarrow \mathrm{Type}_v$$

enabling sophisticated polymorphism and universe-polymorphic library design.

• Dependent Pi-types and Sigma-types:

$$\Gamma \vdash (\Pi x:A,\ B) : \mathrm{Type}_{\max(u,v)},\quad \Gamma \vdash (\Sigma x:A,\ B) : \mathrm{Type}_{\max(u,v)}$$

with full support for introduction, elimination, and β/η conversion rules.

• Quotient Types:

$$\mathrm{Quot}~(\alpha:\mathrm{Sort}_u)\,(r:\alpha\to\alpha\to\mathrm{Prop})$$

for set-quotients, supporting classical and constructive fragments.

• Axioms: Noncomputable constants for the axiom of choice, function/propositional extensionality, etc., marked by the kernel to control trust boundaries.

Lean 4 syntax closely tracks dependent type theory, with facilities for structures/classes (e.g., group theory hierarchies), universe annotation, and tactic blocks:

theorem add_comm (a b : α) : a + b = b + a := by simp only [add_comm]

This allows concise and direct encoding of advanced mathematics while supporting proof automation and metaprogramming idioms (Gulati et al., 2024).

3. Metaprogramming and Tactic Framework

Metaprogramming in Lean 4 is fully integrated into the language and its environment (Tang, 28 Jan 2025):

• MetaM Monad: Provides effectful access to the internal state of the elaborator, including the metavariable context, error handling, type inference, and tactic manipulation. Essential combinators include getMainGoal, inferType, unify, and mkFreshExprMVar.
• Macros and Custom Tactics: Macros allow users to introduce new syntactic forms, tactic combinators, and domain-specific DSLs. For example,

  macro_rules | `(myand %%%%2%%%%q) => `(by have h₁ : $p := by decide have h₂ : $q := by decide show %%%%3%%%%q from And.intro h₁ h₂)

• Extensible Elaboration: The pipeline supports user-programmable parsing, elaboration, and macro expansion, granting fine control over both proof engineering and library extension (Tang, 28 Jan 2025).
• Custom Proof Automation: The system supports both high-level proof search tactics (e.g., Aesop, Duper, Lean-auto) and fine-grained, user-authored tactics for specialized automation across mathematics and computer science domains (Qian et al., 20 May 2025). This includes ATP integration (Lean-auto), RL-based proof search (Kimina, LeanTree), and meta-theoretical tactics (e.g., substitution/cut reduction in programming language metatheory (Ramos et al., 10 Dec 2025)).

4. Ecosystem: Libraries, Benchmarks, and Tooling

Lean 4 supports a rapidly growing and diverse ecosystem (Tang, 28 Jan 2025, Asher, 4 Jun 2025, Gulati et al., 2024):

• mathlib4: A port and extension of Lean 3’s mathlib, now exceeding 60k declarations, with comprehensive support for algebra, analysis, topology, category theory, and algebraic geometry. New developments leverage Lean 4’s modular elaboration and metaprogramming for advanced formalizations (e.g., multi-graded projective schemes (Mayeux et al., 18 Sep 2025)).
• Benchmarking and Autoformalization: Multiple large-scale datasets provide benchmarks for autoformalization and automated proving:
  • FormL4: Natural-language to full Lean 4 statement/proof aligned benchmark (14.5k train, ~2k test) (Lu et al., 2024).
  • Lean Workbook: ~57k natural-language/Lean 4 contest-level problem/proof pairs (Ying et al., 2024).
  • Herald Dataset: 580k+ NL–FL pairs from mathlib4 with dual tactic/informal augmentation (Gao et al., 2024).
• Autoformalization and LLM Evaluation: Lean 4 is the reference target for autoformalization via LLMs. Benchmarks reveal that even state-of-the-art LLMs require nontrivial human correction for advanced topics, with mean correction efforts of 2.238–2.248 (on a scale 0–4); performance is topic-sensitive, being strongest in domains with rich online exposure (logic, information theory) and weakest in category theory or model theory (Gulati et al., 2024).
• Advanced Search and Navigation: The LeanExplore tool employs hybrid semantic + lexical + PageRank search to surface relevant declarations from multiple packages (Mathlib, PhysLean, etc.), supporting both end users and LLM-driven theorem-proving agents via MCP (Asher, 4 Jun 2025).
• Server and Parallelization: Tools such as Kimina Lean Server implement RESTful, parallelized verification and tactic extraction, supporting large-scale RL pipelines and batch formalization (Santos et al., 29 Apr 2025).

5. Applications and Domain-Specific Developments

Lean 4 is deployed in a wide range of research applications, leveraging its core features (Tang, 28 Jan 2025):

• Formalized Mathematics: Full formalization of the multi-graded Proj construction in algebraic geometry (Mayeux et al., 18 Sep 2025), Mason–Stothers theorem and its corollaries in function field arithmetic (Baek et al., 2024), irrationality of $\zeta(3)$ (Liu et al., 28 Feb 2025), and computational paths for homotopy theory (Ramos et al., 24 Nov 2025).
• Programming Language Metatheory: Modular libraries for confluence and normalization proofs (lambda calculi, STLC with products/sums), fully mechanized in Lean 4 (Ramos et al., 10 Dec 2025).
• Physics: Formalized SI unit systems and college-level physics problem sets (Lean4PHYS, PhysLib, LeanPhysBench) with elaborator extensions for units, tactics for dimension analysis, and benchmarks highlighting automation challenges (Li et al., 30 Oct 2025).
• Physics Index Notation and Tensors: Verified index notation and category-theoretic tensor calculus libraries (HepLean) supporting direct formalization of index-level physics, including automated rewriting and group-theoretic infrastructure (Tooby-Smith, 2024).
• DeFi, Economics, and Beyond: Mechanized verification of protocols such as constant-product Automated Market Makers, combining dependent types with legacy proof tactics and domain-specific APIs (Pusceddu et al., 2024).
• LLMs for Formalization: Numerous pipelines for autoformalization, proof generation, and correction loops using LLMs (e.g., Herald Translator, Process-Supervised Verifier, MA-LoT), all targeting Lean 4’s precise syntax and elaborate environment (Lu et al., 2024, Wang et al., 5 Mar 2025, Gao et al., 2024).

6. Challenges, Limitations, and Future Directions

Despite significant advances, Lean 4 poses ongoing research challenges and limitations (Gulati et al., 2024, Lu et al., 2024, Gao et al., 2024):

• Autoformalization: Even best LLMs require substantial correction effort, particularly in underrepresented or highly abstract domains (category theory, advanced model theory), often missing crucial import paths, universe polymorphism, or type-class inference details (Gulati et al., 2024).
• Toolchain Verification: Projects such as Lean4Lean provide verified drop-in kernels for Lean written in Lean itself, achieving reasonable performance overheads (20–50%) and enabling formal consistency arguments, but full bootstrapped, self-hosted toolchains remain an open frontier (Carneiro, 2024).
• Automation and Proof Search: ATP-based automation via Lean-auto extends “hammer” capabilities to Lean 4, but certain translation and proof-reconstruction tasks are still heuristic or rely on unsafely trusted inferences; optimal premise selection and generic automation are open directions (Qian et al., 20 May 2025).
• Scalability & Interoperability: Library cohesion, API design, and module granularity impact both large-scale development and AI-assisted workflows. Design work continues around domain-specific search (LeanExplore), RL/LLM integration, and scalable API/server architectures (Asher, 4 Jun 2025, Santos et al., 29 Apr 2025).
• Educational and Community Resources: Tutorials, live streams, and textbooks now routinely use Lean 4, but onboarding, ecosystem consistency, and cross-discipline adaptation (esp. outside pure mathematics) remain as growth areas (Tang, 28 Jan 2025).
• Future Enhancements: Open problems include automated import/resolve in autoformalization, dataset enrichment (incorporating inherent theorem difficulty), finer SOTA model finetuning, and stronger integrations between proof assistants and LLMs for interactive correction loops and retrieval-augmented workflows (Gulati et al., 2024, Lu et al., 2024, Gao et al., 2024).

7. Summary Table: Lean 4 Core Features and Impact

Core Feature	Technical Description	Impact/Significance
Dependently Typed Kernel	Small, trusted CIC+ with quotient types, universes, Pi/Sigma, etc.	Enables expressive formalization & safe proof checking
Metaprogramming (MetaM)	User-level macros, custom tactics, elaborator extensions	Powerful, domain-specific automation
mathlib4	~60k declarations; advanced hierarchies, formalizations	Foundation for mathematical and scientific knowledge
High-Performance Runtime	Typed IR, VM/LLVM backends, optimized elaborator	Orders-of-magnitude faster builds & proof checking
Autoformalization Benchmarks	FormL4, Lean Workbook, Herald	Dataset and evaluation standard for LLM research
Library/Tooling Ecosystem	LeanExplore, Kimina, Lean-auto, PhysLib	Advanced search, parallelization, domain adaptation

Lean 4 thus represents the state of the art in scalable interactive theorem proving: a performant, trust-minimized core with unmatched metaprogramming, automation, and extensibility—now driving foundational research from pure mathematics to physics and AI-assisted formalization (Tang, 28 Jan 2025, Gulati et al., 2024, Mayeux et al., 18 Sep 2025, Carneiro, 2024, Qian et al., 20 May 2025).