Lean 4: Interactive Theorem Prover

• Lean 4 is a state-of-the-art interactive theorem prover featuring advanced dependent type theory, fast elaboration, and a versatile tactic framework for automation and metaprogramming.
• Its architecture comprises a trusted kernel, a high-performance elaborator, and an optimized runtime that together ensure robust type checking and efficient proof execution.
• The system underpins LLM integration and extensive dataset research, driving innovative formal verification workflows and interactive educational tools.

Lean 4 is a state-of-the-art interactive theorem prover and functional programming language featuring a powerful dependent type theory, fast elaboration, and an extensible tactic framework. It has become the de facto standard for large-scale interactive theorem proving and formalized mathematics, integrating performance, usability, and proof automation in a single, industrial-strength system (Tang, 28 Jan 2025).

1. Architectural Foundations

Lean 4 is structured in three primary layers:

• Kernel: Implements a variant of the Calculus of Inductive Constructions (CIC) with quotient and classical axioms. It is responsible for type-checking fully elaborated terms and term normalization. The kernel’s core data type is Expr, a dependently-typed AST supporting universes, applications, binders (λ, Π), metavariables, and lets.
• Elaborator: A high-performance, non-trusted component that processes user syntax into kernel terms. Elaboration handles type-class inference, unification, implicit argument insertion, universe inference, and coercions using a constraint-solving engine. It is implemented in Lean itself and benefits from monadic structuring for compositional extensibility.
• Runtime/VM: Delivers high-performance execution of Lean programs and metaprograms. Lean 4 compiles core definitions to an intermediate representation, performing closure conversion, lambda lifting, inlining, and dead-code elimination before emitting bytecode or LLVM code. This achieves substantial speedups in large projects relative to Lean 3.

Recent work has developed a self-hosted, purely Lean 4 external kernel (Lean4Lean) that replicates all core kernel functionality in Lean. This enables formal verification of the kernel, full bootstrapping, and reliability checks during the evolution of the language (Carneiro, 2024).

2. Type Theory, Elaboration, and Metaprogramming

Lean 4’s type system is based on predicative universes, support for higher universes, and full dependent type theory:

• Universes: Each Type u resides in a possibly higher Type v for $u \le v$, with cumulativity and automated universe inference.
• Dependent Function Types (Π-types): The core language allows arbitrary dependence in function types, realized in the AST.
• Typing Rules: The system implements standard formation, introduction, and application rules:
  • Π-formation:

  $$\frac {\Gamma \vdash A : \mathrm{Type}_u \;\; \Gamma, x : A \vdash B : \mathrm{Type}_v} {\Gamma \vdash (\Pi x : A . B) : \mathrm{Type}_{\max(u,v)}}$$ - λ-introduction/application rules as standard in dependently typed λ-calculi.

Lean 4’s elaborator manages full synthesis from user-facing syntax with holes and implicit arguments to kernel terms, combining typeclass search, overloading, and constraint propagation. Pseudocode for application elaboration exemplifies the “first infer the head, then process arguments, then apply” pattern (Tang, 28 Jan 2025).

Metaprogramming is natively supported. The tactic monad exposes the kernel state, supports backtracking, combinators, and term and goal manipulation. Syntax and elaborator macros allow safe user extensions to both term and tactic languages.

3. Proof Automation and Tactic Language

Automation is central to performance and usability:

• Tactics: Lean 4 supports typed tactics (TacticM) with explicit state including lists of goals, contexts, local declarations, and unification context. Key built-in tactics include:
  • simp: a completion-based, dependency-tracked simplifier.
  • ring: decision procedure for commutative rings.
  • linarith: a bound-propagation linear arithmetic solver.
  • auto, aesop, and custom automation combinators.

Automation is extensible; users and library developers routinely implement custom meta-programmed tactics, macro rules, and automation heuristics suited to domain-specific proof patterns (Tang, 28 Jan 2025).

Lean 4’s elaborator-aware tactic framework (e.g. typed-simp) prunes rewrite search using partial dependence information, yielding better performance and more informative error messages, particularly in large-scale developments.

4. Dataset, LLM Integration, and Formal Reasoning Benchmarks

Lean 4’s usability and performance have made it a major target for LLM-based proof automation research. Recent developments have leveraged large-scale curated Lean 4 corpora for LLM training (Wu et al., 2024):

• LEAN-GitHub Dataset: Comprising 147 Lean 4 repositories and 28,597 extracted theorems with 218,866 tactic steps, it enables transformer-based models to be fine-tuned for proofstep prediction and tactic synthesis. The proof-state extraction pipeline leverages Lean’s metaprogramming API to collect goal states, hypotheses, and tactics at each step, with aggressive normalization and deduplication.
• Fine-Tuning Protocol: Models such as InternLM-math-plus-7B are fine-tuned by exposing the declaration, the current normalized proof state, and requiring the next tactic step as output. Byte-pair encoding over Lean and natural language tokens, with appropriate special tokens (DECL, GOAL, PROOFSTEP), enables mixed-sequence learning (Wu et al., 2024).
• Benchmarks: State-of-the-art models are evaluated on:
  • miniF2F (test/validation, high-school to undergraduate problems),
  • ProofNet (undergraduate pure mathematics),
  • PutnamBench (Putnam Competition problems).

Tree search with parallel tactic candidate expansion and state deduplication (by hashing normalized goals and hypotheses) is standard; this reduces redundancy by over 50% (Wu et al., 2024). The best current models achieve:

• miniF2F test: Pass@1 = 48.8%, Pass@64 = 54.5%,
• ProofNet: 18.1%,
• PutnamBench: 5/640 problems solved (at Pass@1) (Wu et al., 2024).

5. Workflow Integration and Ecosystem Impact

Lean 4 is tightly integrated into research and mathematical workflows:

• IDE and CI: VSCode plugin surfaces model-suggested tactics interactively. Provers can be invoked on-pull requests for Mathlib or other repositories, enabling formal verification as part of continuous integration.
• Retrieval-Augmented Proof Search: Retrieval systems index large corpora to supply relevant lemma statements to LLM-driven proof search. State de-duplication enables scalable tree search.
• Proof Reconstruction: Model-suggested proof scripts or tactic proposals can be inserted into proof development sessions, facilitating both automation and human-in-the-loop refinement.
• Periodic Updates and Expansions: The dataset and models are updated by periodic crawling of new repositories and incorporating improved metadata, ensuring coverage of newly formalized domains (Wu et al., 2024).

Educational and research applications are broad:

• Large domain libraries (e.g., Mathlib4 with over 80,000 definitions and theorems) have matured, fueling both mathematical formalization and programming language verification.
• Systematic comparison with Coq, Isabelle, HOL Light, and Agda demonstrates Lean 4’s distinctive balance of modern type theory, tactic-driven automation, and performance (Tang, 28 Jan 2025).
• Courses and web-based notebooks enable interactive teaching and logic exercises, leveraging Lean’s automation and feedback.

6. Future Directions and Open Research Problems

Active areas of investigation and future development include:

• Dataset Expansion: Ongoing mining and integration of Lean 4 repositories, Lean 3 to Lean 4 code migration, and curation of richer metadata (author, style, commit history).
• Model/Objective Improvements: Joint training for informal–formal autoformalization, multi-task objectives (statement generation plus tactic prediction), and longer context windows (>8K tokens) to accommodate larger proof contexts (Wu et al., 2024).
• Cross-Assistant Generalization: Porting extraction and fine-tuning pipelines to Coq, Isabelle, and supporting cross-assistant proof translation models.
• Premise Selection and Enhanced Retrieval: Further scaling of retrieval-based augmentation, refined premise selection, and leveraging multi-hop dependency chains to bridge the gap between repository-centric verification and mathdiv-centric (Mathlib) reasoning (Xin et al., 20 Feb 2026).
• Human–AI Collaboration: Enhanced integration of proof suggestion into mainstream workflows, support for retrieval-augmented collaborative proving, and new educational tools.
• Formal Verification of the Kernel: Ongoing formalization of the core algorithms and metatheory of Lean 4’s kernel in Lean itself (Lean4Lean), bridging from foundations to complete toolchain verification (Carneiro, 2024).

Lean 4 thus occupies a central position in contemporary formal methods and automated reasoning, combining a sophisticated core system with rapidly evolving LLM-powered automation, large-scale formal corpus development, and systematic integration into mathematical and software verification workflows (Tang, 28 Jan 2025, Wu et al., 2024).