Mathlib: Formalized Mathematics Library for Lean

Updated 15 June 2026

Mathlib is a community-driven, dependently typed library for Lean that formalizes mathematics using classical logic and rigorous type theories.
It covers diverse fields such as algebra, analysis, topology, and probability with an extensible typeclass hierarchy and powerful automation tactics.
Its collaborative open-source model, coupled with automated CI and documentation tools, enables sustainable research-level formalization.

Mathlib is a community-driven, dependently typed library for the Lean proof assistant, providing a comprehensive and rigorously structured repository of formalized mathematics. It is characterized by its foundation in classical logic, a deep and extensible typeclass hierarchy, pervasive automation, and a collaborative open-source development model. Mathlib underpins a growing body of formalized mathematical results spanning algebra, analysis, topology, number theory, probability, geometry, and more, while also serving as the infrastructure for emerging research in automated reasoning, AI-driven formalization, and scalable mathematical workflows.

1. Logical Foundations and Scope

Mathlib is built atop Lean’s version of dependent type theory—a variant of the Calculus of Inductive Constructions with a noncumulative universe hierarchy ( $\mathsf{Prop}$ , $\mathsf{Type}$ , $\mathsf{Type}1$ , …). The core logic is irreducibly classical: the axioms of choice and propositional extensionality are admitted by default, and quotient types are available natively, eliminating the need for pervasive setoid infrastructure (Community, 2019). The library is organized topically, with directories for algebra, linear algebra, topology, analysis, set theory, category theory, measure theory, combinatorics, probability, and more. By mid-2024, mathlib exceeded 1.9 million lines of code, with over 30 active maintainers and more than 100 core reviewers (Baanen et al., 29 Aug 2025).

The scope of mathlib is broad and research-oriented, covering:

Algebra: From basic group theory up to commutative algebra and Galois theory, including full module hierarchies and categorical constructions.
Analysis: Metric, normed, and topological vector spaces, Fréchet and analytic differentiation for general scalar fields, spectral theory, infinite products, and measure theory.
Number Theory: Zeta and $L$ -functions, formal Dirichlet theorem on primes in arithmetic progressions, orthogonality of Dirichlet characters, and formal Riemann Hypothesis statement (Loeffler et al., 2 Mar 2025).
Probability: Product measures, the Ionescu–Tulcea theorem, conditional expectations, martingale theory (Doob’s theorems), and advanced constructions for stochastic processes (Ying et al., 2022, Marion, 23 Jun 2025).
Geometry and Topology: Formalizations of the isoperimetric inequality, manifold theory, and major results in combinatorics and graph theory (Samarakkody, 15 Mar 2026, Gusakov et al., 2021).
Advanced algebraic objects: Clifford and Lie algebras, universal divided power algebras, polynomial laws (Wieser et al., 2021, Nash, 2021, Chambert-Loir et al., 5 Dec 2025).

Mathlib is the formal backbone for ongoing projects in $p$ -adic Hodge theory, Lie theory, perfectoid spaces, and more, often providing APIs that serve as both a repository of mathematics and a formal basis for new research-level formalizations (Nash, 2021, Chambert-Loir et al., 5 Dec 2025).

2. Typeclass Hierarchy, Structure, and Instance Patterns

Mathlib’s architecture depends critically on a semibundled, deeply interconnected typeclass hierarchy. Algebraic structures are introduced as Lean classes—e.g., add_group, monoid, module, vector_space—and layered to maximize inference and code reuse (Community, 2019). The basic scalar action is given by

1 2	class has_scalar (M : Type) (α : Type) := (smul : M → α → α) infixr ` • `:73 := has_scalar.smul

with progressively enriched properties in mul_action, distrib_mul_action, module, and algebra. Notational classes (has_add, has_mul) regulate operator overloading. Typeclass instance parameters (in [ … ]) are leveraged throughout to automate inference of algebraic structure, which is especially critical in environments with many overlapping or parameterized structures (e.g., modules and algebras over noncommutative bases) (Baanen, 2022, Wieser, 2021).

Key design strategies to manage performance and coherence at scale include:

Bundled vs. Unbundled Hierarchy: Bundled morphisms (linear_map, monoid_hom, etc.) provide both the function and structural proofs, reducing duplication and complexity of tactics operating on morphisms.
Out-Param and Functional Dependency Pattern: Avoids dangerous instances and loops in the inference graph for multi-parameter classes such as module R M (Baanen, 2022).
Definitional Equalities and Diamonds: Explicit fields (e.g., nsmul in add_monoid) enforce that distinct inference paths yield definitionally equal structures, critical for tactic reliability (Wieser, 2021).
Canonical class patterns: Abstractions such as fun_like, monoid_hom_class, set_like allow general rules to be stated once and propagate to all concrete types, avoiding combinatorial explosion of similar lemmas.

This framework underlies the rapid extensibility of mathlib while preventing the combinatorial explosion and unification pathologies common in naïvely composed hierarchies (Baanen, 2022, Wieser, 2021).

3. Automation, Tactics, and Metaprogramming

Mathlib includes powerful automation at all levels:

Big tactics: simp for conditional rewriting, ring and abel for algebraic normalization, linarith for linear inequalities, finish for first-order proof search, and tidy for heuristic proof search across a default list of tactics (Community, 2019).
Custom tactics: norm_cast, norm_num, pi_instance, and more, handling domain-specific reasoning for coercions, numerals, or instance lifting.
Attribute-driven rewriting: The use of attributes (@[simp], @[mono], @[trans], @[reassoc], @[priority]) modulates tactic behavior and search order.
Library-wide linters and static analysis: The #lint command and an extensive suite of semantic linters enforce style, catch performance pitfalls, and flag subtle errors (such as non-terminating simp sets, unreachable instances, or misplaced documentation) (Doorn et al., 2020, Baanen et al., 29 Aug 2025).
Documentation and Discovery: Automatically generated HTML documentation, tactic index pages, and library notes ensure reproducibility and rapid onboarding for contributors, while also facilitating tactic discovery and cross-linking (Doorn et al., 2020).

Mathlib’s metaprogramming layer enables custom analysis of the dependency graph, attribute infrastructure, tactic profiles, and downstream library impact, thus sustaining its rapid development at scale (Baanen et al., 29 Aug 2025, Li et al., 26 Apr 2026).

Mathlib operates as a collaborative open-source project hosted on GitHub, relying on regular code review, issue triage, an integrated Zulip community chat, and continuous integration (CI) with pipeline validation. Contributors open pull requests, subject to automated linting, style checking, review layering (with designated maintainers and reviewers), technical debt tracking, and deprecation systems for both module/file names and declarations (Doorn et al., 2020, Baanen et al., 29 Aug 2025).

Key organizational features:

Scalable review workflow: Reviewer/maintainer separation, bors-based mandatory approvals, sticky PR summaries, and periodic triage dashboards ensure throughput for hundreds of PRs/month.
Deprecation and Migration: Automated warnings, grace periods, and module "staining" for breaking changes enable library-wide refactors without fragmenting downstream projects.
Technical debt monitoring: CI scripts, public metrics, and shared dashboards track technical debt, porting progress, and code health (Baanen et al., 29 Aug 2025).
Inclusive community processes: Rapid onboarding via documentation, style guides, and real-time mentorship on Zulip have enabled exponential growth in contributor numbers and code volume (Community, 2019).

Mathlib’s model has been analyzed in several studies for its impact on productivity and sustainability in formal mathematics (Doorn et al., 2020).

5. Research-Driven Formalization and Cross-Domain Infrastructure

Mathlib functions as both a mathematical library and a platform for research-level formalization:

Coordinate-free constructions: Clifford and exterior algebras, Lie algebras, and their universal properties are developed using quotient-of-tensor-algebra methods, in a fully coordinate-free fashion, leveraging Mathlib’s general APIs for tensor, multilinear, and alternating maps (Wieser et al., 2021, Nash, 2021).
Typeclass-synthesized infrastructure: Formalizations of Engel’s theorem, classification theorems for Lie algebras, and root space theory rest on generic module, lattice, and linear algebra APIs (Nash, 2021, Nash, 2023).
Functional analysis and semilinear maps: Structures such as semilinear maps unify linear, conjugate-linear, and Frobenius-semilinear phenomena, allowing spectral theory, Riesz representation, and applications to $p$ -adic Hodge theory to be handled with a single general API (Dupuis et al., 2022).
Measure theory and probability: Ionescu–Tulcea and infinite product measure construction, the Doob convergence theorems, and the development of a coherent stochastic process library showcase the integration of measure theory, topological vector spaces, and probability (Ying et al., 2022, Marion, 23 Jun 2025).
High-level geometric analysis: Formalizations such as the isoperimetric inequality or the change-of-variables formula in full generality demonstrate mathlib’s capacity to support full analytic toolchains, from advanced measure theory through Fourier analysis to geometric measure theory (Samarakkody, 15 Mar 2026, Gouëzel, 2022).

In all cases, the principle is to internalize the highest possible generality as reusable APIs, maximizing the leverage over subsequent formalizations.

6. Network Structure, Metrics, and Scalability

Recent network analyses of Mathlib’s structure reveal a multilayered, tightly-coupled dependency graph, with:

Over 308,000 declarations and 8.4 million dependency edges across 7,563 modules (Li et al., 26 Apr 2026).
Approximately 50.9% of dependency edges crossing namespace boundaries, underscoring the inadequacy of human-imposed modularizations for capturing logical structure.
A median of only 1.6% of imported scope actually used per module import edge, suggesting routine overimporting as a bottleneck.
High centrality nodes in the graph are typically infrastructural (e.g., language primitives, category theory constructors) rather than deep mathematical theorems.
Formalization flattens traditional semantic hierarchies, and compiler-synthesized (typeclass, coercion) edges dominate the logical structure.

Such macroscopic analyses inform refactoring priorities, import structure hygiene, and AI-driven formalization methodologies (Li et al., 26 Apr 2026).

7. AI Pipelines, Formalization Quality, and Audit

Recent applications of Mathlib in the context of AI-driven, agentic formalization pipelines have surfaced novel issues of semantic fidelity and library coherence. Studies reveal that automated code generation and "compilation success" dramatically overstate formalization quality; recurring anti-patterns include partial theorem restatements, unsound parameter restrictions, and redundant rederivation rather than library reuse (Meek et al., 12 Jun 2026).

A three-pronged audit framework has been introduced:

Semantic correctness: Checking bidirectional implication between source statements and formalizations.
Mathlib reuse metrics: Quantifying library dependency via (provable) re-use of existing theorems.
Cross-file reuse: Analyzing internal dependency graphs and name-mention frequencies to detect fragmentation or redundancy.

Enforcement and monitoring of these metrics—via CI integration and dashboarding—are now central to sustaining Mathlib’s integrity as it absorbs machine-generated contributions (Meek et al., 12 Jun 2026).

In summary, Mathlib represents the leading edge of dependently typed, community-driven formal mathematics. Its design principles, typeclass infrastructure, large-scale automation, and social architecture provide a robust platform both for foundational research and for experimental, AI-accelerated formalization at scale. The continual evolution of its audit, maintenance, and scalability methodologies is essential to sustaining its role as the central research library for the Lean theorem prover ecosystem.