💻 computer science

ZFLean: a framework for set-level mathematics in Lean

The paper introduces ZFLean, a Lean 4 library that integrates core ZFC set theory into the Mathlib ecosystem with improved ergonomics, canonical constructions, and bridges to native types to facilitate mixed set-level and typed proofs.

Original authors: Vincent Trélat

Published 2026-04-28

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Vincent Trélat

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to build a house. You have two different sets of blueprints and tools:

The "Typed" Tools (Lean's Native System): These are like high-tech, laser-guided robotic arms. They are incredibly precise, but they only work if every brick is perfectly labeled with its specific type (e.g., "Red Brick," "Blue Brick"). If you try to use a "Red Brick" where a "Blue Brick" is required, the robot stops and refuses to work. This is great for safety, but sometimes math feels like it needs to be more flexible.
The "Set" Tools (ZFC): These are like a giant, messy pile of raw clay. In this world, everything is just "stuff." You can mold a piece of clay into a cup, a ball, or a square, and it's all just "clay." This is how traditional mathematicians often think about sets: everything is an element of a collection, and you can mix and match freely.

The Problem:
For a long time, if you wanted to do math using the "Set" tools inside the "Typed" robot workshop, it was a nightmare. You had to constantly translate your clay shapes into robot-friendly labels, prove that your translation was correct, and then translate the results back. It was slow, boring, and prone to errors. Most people just avoided the clay pile entirely and stuck to the robots.

The Solution: ZFLean
Vincent Trélat created ZFLean, which is like building a universal translator and a set of custom tools right inside the robot workshop.

Here is how it works, using simple analogies:

1. The "Clay" Workshop (The ZFC Model)

ZFLean sets up a special zone inside the robot workshop where the "clay" rules apply. Here, you can define sets, relations, and functions just like a traditional mathematician would, without worrying about the strict "types" the robot usually demands. It's a safe space where you can say, "This is a set of numbers," without the robot asking, "Is it a Nat or an Int?"

2. The "Smart Translator" (The Relational Calculus)

The biggest headache in the old days was the "boilerplate"—the repetitive, boring paperwork required to prove that your clay shapes were actually valid.

The Old Way: You had to manually prove, "Yes, this relation is a function," and "Yes, this domain is valid," for every single step.
The ZFLean Way: The framework comes with smart little assistants (called tactics like zrel, zpfun, and zfun). Think of these as auto-fill forms. When you write a proof, these assistants automatically check the boring details and fill in the paperwork for you. You write the math; the assistants handle the administrative burden.

3. The "Bridge" (Interoperability)

This is the magic part. Usually, the "clay" world and the "robot" world were separate. ZFLean builds bridges between them.

If you build a set of natural numbers in the clay world, ZFLean can instantly say, "Hey, this is actually the same as the robot's Nat type."
This means you can do your messy, flexible set-theory math, and then seamlessly cross the bridge to use the robot's powerful, pre-built tools (like algebra solvers) to finish the job. You don't have to choose one or the other; you can use both in the same proof.

4. The "Lego Kit" (Canonical Constructions)

To make life easier, ZFLean comes with a pre-built kit of standard Lego pieces.

Need a set of True/False values? Here is a Boolean set.
Need a set of counting numbers? Here is a Natural Number set.
Need a way to handle "maybe" values (like an option)? Here is an Option set.
These aren't just raw clay; they are pre-molded, tested, and come with instructions on how to use them (like "how to add two numbers" or "how to flip a switch").

5. The "Test Drive" (The Case Study)

To prove this system works, the author tested it with a classic math puzzle called the Currying Isomorphism.

Imagine this: You have a machine that takes two inputs at once (like a sandwich maker taking bread and meat). "Currying" is the process of turning that into a machine that takes one input (bread) and then gives you a new machine that takes the second input (meat).
The author used ZFLean to prove that these two ways of thinking about the machine are actually the same thing. The proof script looked almost exactly like a human mathematician writing it on a chalkboard, with the "smart assistants" quietly handling all the technical glitches in the background.

The Bottom Line

ZFLean is a framework that lets mathematicians work in the flexible, intuitive style of traditional set theory (the "clay") while living inside a modern, rigorous computer proof system (the "robots"). It removes the friction of translation, automates the boring paperwork, and builds bridges so you can use the best tools from both worlds without getting stuck in the middle.

The result is a library of about 8,300 lines of code that makes doing "set-level" math in Lean feel as natural and smooth as writing it on paper.

1. Problem Statement

Modern formalization in proof assistants like Lean is predominantly based on type theory (specifically dependent type theory), where mathematical objects are constructed types. While powerful, this approach can be cumbersome for set-level mathematics (ZFC), which is often preferred for:

Extensional reasoning: Reasoning about equality based on elements rather than construction.
Partiality: Handling partial functions naturally via relations rather than encoding them with Option types or dependent types.
Category-style reasoning: Working "up to isomorphism" rather than strict definitional equality.

The Challenge: Working directly in a set-theoretic model within a typed assistant (like Lean's Mathlib ZFC model) introduces significant friction:

Boilerplate: Users must constantly manage "side conditions" (e.g., proving a relation is well-defined, proving a function is total) manually.
Brittleness: Crossing the boundary between set-theoretic objects (ZFSet) and native Lean types (Type) is manual and error-prone.
Lack of Automation: Existing tools often lack the specific rewriting hints and tactics needed to make set-theoretic proofs as fluid as typed proofs.

2. Methodology

The author presents ZFLean, a Lean 4 library built on top of Mathlib's existing ZFC model. The methodology focuses on creating a uniform relational calculus and interoperability bridges to make set-level development ergonomic.

Core Design Choices:

Foundation: Leverages Mathlib's implementation of ZFC, which constructs sets as the extensional quotient of inductive "pre-sets" (PSet).
Relational Calculus: Instead of treating functions as first-class total objects (as in standard type theory), ZFLean treats them as functional relations. It introduces a calculus for binary relations, partial functions, and total functions.
Automation via Tactics: The framework introduces three lightweight tactics (zrel, zpfun, zfun) designed to automatically discharge well-formedness side conditions (e.g., proving a composition is a relation or a function).
Bridges: The library constructs explicit isomorphisms (bridges) between canonical ZFC objects (e.g., ZFBool, ZFNat) and Lean's native types (Bool, Nat), allowing properties to be transported between the two worlds.

3. Key Contributions

A. Relational Calculus and Automation

Definitions: Formalizes converse, identity, composition, domain, range, and image for relations.
Functionality: Distinguishes between partial functions (IsPFunc) and total functions (IsFunc).
Tactics:
- zrel: Discharges goals proving a set is a relation ( $R \subseteq A \times B$ ).
- zpfun: Discharges goals proving a set is a partial function.
- zfun: Discharges goals proving a set is a total function.
- These tactics use attribute-tagged lemmas (e.g., @[zfun]) to recursively solve side conditions, hiding boilerplate from the user.
Notation: Introduces convenient syntax for function application (@zf(x)) and $\lambda$ -abstraction, with theorems for $\beta$ -reduction, $\eta$ -expansion, and extensionality.

B. Canonical Constructions

The library provides a suite of standard mathematical objects defined within ZFC, complete with their universal properties:

Booleans: A two-element set $B$ with algebraic structure (conjunction, disjunction, negation) and a case eliminator.
Natural Numbers ( $\mathbb{N}$ ): Defined as the smallest inductive set (von Neumann ordinals). Includes a recursor, induction principle, and arithmetic operations. Crucially, it is equipped with a CommSemiring structure to leverage Lean's ring tactic.
Integers ( $\mathbb{Z}$ ) and Rationals ( $\mathbb{Q}$ ): Constructed as quotient types of pairs of naturals/integers, with operations lifted from representatives.
Coproducts and Options: Set-theoretic definitions of sum types and option types.

C. Isomorphisms and Transport

Embeddings and Isomorphisms: Defines set-level embeddings ( $A \hookrightarrow_z B$ ) and isomorphisms ( $A \cong_z B$ ) via injective and bijective functions.
Cantor-Schröder-Bernstein Theorem: Formalized within the framework.
Transport: Proves that ZFC constructions are isomorphic to Lean's native types (e.g., ZFBool $\simeq$ Bool). This allows users to "transport" theorems from the rich Mathlib type-theoretic library into the set-theoretic context seamlessly.

D. Case Study: Currying Isomorphism

The paper demonstrates the framework's utility by proving the Currying Isomorphism: $C^{A \times B} \cong (C^B)^A$ .

The proof defines curryz and uncurryz as set-level functions.
It proves they are mutual inverses using the framework's automation to handle side conditions (well-definedness of compositions and images).
The proof script closely mirrors standard mathematical arguments, with the automation layer handling the "boring" set-theoretic verification.

4. Results

Artifact Size: The library consists of 8,324 lines of Lean code and 706 proved theorems.
Component Breakdown:
- Relational Calculus: ~2,534 LoC (172 theorems).
- Naturals: ~1,260 LoC (199 theorems).
- Embeddings/Isomorphisms: ~1,626 LoC (31 theorems).
Usability: The case study demonstrates that the framework successfully reduces the friction of set-level formalization. Users can write proofs that look like standard set-theoretic arguments without manually proving that every composition of relations is a valid relation.
Interoperability: The ability to switch between ZFSet and native Type allows for the reuse of Mathlib's algebraic tactics (like ring) on set-theoretic objects.

5. Significance

Bridging Foundations: ZFLean effectively reconciles the "set-theoretic" and "type-theoretic" views of mathematics within a single proof assistant. It allows mathematicians to choose the most natural foundation for a specific problem (extensional sets vs. constructive types) without losing access to the ecosystem's automation.
Ergonomics: By automating the tedious side conditions inherent in set theory (membership proofs, relation well-definedness), it makes ZFC development in Lean viable for non-experts and practical for large-scale formalization.
Extensibility: The modular design (relational calculus + canonical objects + bridges) allows for easy extension. Future work includes formalizing real numbers (via Cauchy sequences or Dedekind cuts) and basic analysis.
Comparison: Unlike Isabelle/ZF (where set theory is a separate object logic) or Rocq's set-theoretic developments (which often lack deep integration with type-theoretic automation), ZFLean offers a hybrid approach that keeps proofs at the set level while leveraging Lean's native type-theoretic infrastructure.

In conclusion, ZFLean provides a robust, ergonomic, and interoperable framework for doing core mathematics in ZFC within Lean 4, successfully lowering the barrier to entry for set-theoretic formalization while maintaining compatibility with the broader Mathlib ecosystem.