💻 computer science

From Lecture Notes to Lean: Formalizing a Textbook on Probability Theory

This paper reports on an ongoing project to formally verify the textbook "Measure-Theoretic Probability" in the Lean theorem prover, aiming to create a machine-checked companion that bridges textbook statements with the Mathlib library to enhance mathematical verification, clarify assumptions, and support reliable AI-assisted mathematics.

Original authors: Shuo Deng, Kenneth W. Shum

Published 2026-07-31

📖 7 min read🧠 Deep dive

CC BY 4.0

Original authors: Shuo Deng, Kenneth W. Shum

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 walking through a vast, magical library where every book contains the secrets of the universe. For centuries, humans have been the only ones reading these books, writing proofs, and checking each other's work. But recently, a new kind of librarian has arrived: a super-smart robot that can read, write, and argue about math faster than any human. This robot can generate thousands of mathematical arguments in the time it takes you to brew a cup of tea. The problem? The robot is a bit of a show-off. It can write arguments that sound perfect and look very convincing, but sometimes, they are built on invisible cracks or made-up facts. It's like a magician who pulls a rabbit out of a hat, but the rabbit is actually a very realistic drawing.

This is where the concept of "formalization" comes in. Think of it as a magical spell-checker for math. Instead of just reading the words, this spell-checker forces the author to write down every single rule, assumption, and step in a language so precise that a computer can check it line by line. If the logic has a single gap, the computer refuses to accept it. The paper you are about to read explores what happens when we try to use this spell-checker on a very important math textbook about probability—the study of chance, risk, and how likely things are to happen. It asks: Can we take a book written for human students, translate it into this super-precise computer language, and use it to teach the next generation how to spot the difference between a real proof and a robot's hallucination?

The Project: Turning a Textbook into a Computer-Checked Treasure Map

The authors, Shuo Deng and Kenneth Shum, are on a mission to take a specific university textbook called Measure-Theoretic Probability: With Applications to Statistics, Finance, and Engineering and turn it into a "Lean" project. Lean is a computer program that acts like a strict, unblinking referee for mathematics. The book they chose is a tough one, covering 14 chapters of advanced math, from calculating areas under curves to predicting how random events behave over time. It contains 81 definitions, 127 theorems, 107 examples, and 134 problems.

Their goal isn't just to type the book into a computer. That would be like taking a recipe for a cake and just typing the words into a word processor. Instead, they are rebuilding the cake from scratch using a new set of ingredients (the computer's logic) to make sure the cake actually rises. They want to create a "machine-checked companion" for the book. Imagine if, while you were reading a chapter on probability, you could click a button and see the computer verify, step-by-step, that the author's logic is 100% solid. If the author skipped a step or made a hidden assumption, the computer would scream, "Wait a minute! You didn't prove that!"

The Big Challenge: Speaking Two Different Languages

The authors found that the textbook and the computer's library (called Mathlib) speak two very different languages. The textbook is written for humans; it uses shortcuts, familiar names, and steps that feel natural to a student. The computer's library, however, is built for maximum power and reuse. It uses very abstract, general terms that can apply to almost anything in math.

To bridge this gap, the authors had to act like translators. Sometimes, the textbook's definition of a concept was slightly different from the computer's. Instead of forcing the textbook to change its style, the authors wrote "bridge lemmas." Think of these as little adapters or connectors. They take the textbook's familiar idea, plug it into the computer's powerful engine, and prove that the two are actually saying the same thing. This is crucial because if the computer version is too abstract, students won't understand it. If it's too simple, the computer won't accept it. The authors had to find the perfect middle ground.

The Robot's Role and the Human's Safety Net

Here is where the story gets interesting. The authors didn't do all the typing themselves. They used an "agentic workflow," which is like having a team of AI robots do the heavy lifting. These robots read the textbook pages and tried to write the Lean code. But the authors learned a vital lesson: you cannot just trust the robots.

The robots are great at generating code, but they can be tricky. They might prove a slightly easier version of a theorem, or they might sneak in an extra rule that makes the proof too easy. To catch this, the authors set up a two-step check. First, the computer checks if the code compiles (does it run without errors?). Second, a human reviewer looks at the code to see if it actually says what the textbook said. It's like having a robot write a story, but a human editor has to read it to make sure the plot makes sense and the characters aren't doing impossible things.

Surprises and Mistakes Found

This process of translation actually helped the authors find a mistake in the original textbook! In one chapter, the book claimed that if a function works on two smaller pieces of a timeline, it must work on the whole timeline. The robot, trying to translate this into Lean, flagged it as a problem. When the human authors looked closer, they realized the textbook was missing a hidden assumption. The theorem was only true if you added a specific condition that the book forgot to mention in that specific sentence. This is a superpower of formalization: it forces you to be honest about every single rule. It's like finding a crack in a dam that you didn't know was there until you tried to build a perfect model of the water flow.

Another example involved "variance," a way to measure how spread out numbers are. The textbook gave a simple formula. The robot tried to use it, but the computer pointed out that the formula only works if the numbers are "integrable" (a fancy way of saying they behave nicely). The textbook assumed this was obvious, but the computer demanded it be written down explicitly. The authors had to fix the code to make sure the computer knew exactly when the formula was safe to use.

Why This Matters for the Future

The authors aren't just building a cool project; they are building a foundation for the future of math in an AI world. As robots get better at writing math, we will need better tools to check if that math is real. This project shows that we can take a standard textbook, translate it into a computer language, and use it to teach students how to think clearly. It turns the textbook from a static book into an interactive playground where students can see exactly why a proof works.

The paper concludes that while AI can generate proofs, it cannot yet replace the human judgment needed to decide if a proof is right for the context. The computer can check the steps, but a human (or a very careful process) must decide if the steps are the ones we actually wanted. This project is a step toward a future where AI helps us learn, but we still hold the reins to make sure the math is true. It's not about replacing the teacher; it's about giving the teacher and the students a super-powered magnifying glass to see the truth behind the numbers.

Technical Summary: From Lecture Notes to Lean: Formalizing a Textbook on Probability Theory

Problem Statement
The paper addresses the shifting landscape of mathematical research and education in the era of Large Language Models (LLMs). As AI models become increasingly capable of generating plausible mathematical arguments, the primary bottleneck is shifting from the scarcity of proofs to the verification, exposition, and integration of these proofs into reusable infrastructure. While LLMs can generate text, they often produce logically invalid arguments or rely on hallucinated facts. The authors identify a pressing need for systematic expansions of formal mathematical corpora to support both human formalizers and AI agents. Specifically, there is a gap in formalizing advanced undergraduate probability theory in a way that is not only machine-checked but also pedagogically aligned with standard textbook structures, bridging the gap between general library abstractions (like Lean's Mathlib) and textbook-specific formulations.

Methodology
The authors document an ongoing project to formalize the textbook Measure-Theoretic Probability: With Applications to Statistics, Finance, and Engineering [25] using the Lean proof assistant. The project covers 14 chapters, encompassing 81 definitions, 127 theorems, 107 examples, and 134 problems.

The methodology relies on an agentic AI-assisted workflow inspired by the APOLLO framework [20], structured around three distinct artifacts:

Source Artifacts: Textbook excerpts and errata assigned to specific formalization tasks.
Mathematical Artifacts: The resulting Lean files, imports, and the pinned Mathlib environment.
Process Artifacts: A history of candidate statements, auxiliary lemmas, build results, review verdicts, and repairs.

The workflow proceeds in stages:

Translation: An AI agent proposes Lean statements and proofs based on source passages, utilizing existing Mathlib theorems where possible.
Bridging: When textbook interfaces differ from Mathlib's general abstractions (e.g., specific definitions of integrals or variance), the agent introduces "bridge lemmas" to connect the two.
Verification: A two-stage review process ensures validity. First, a Lean build checks compilation and axiom usage. Second, a human reviewer performs a "source-fidelity" check to ensure the formal statement matches the intended mathematical meaning of the textbook, rather than a weakened or strengthened variant.
Iterative Repair: If a candidate fails, the workflow routes the failure based on its nature (e.g., proof gap, interface mismatch, or source error), ensuring that the history of failures and repairs remains inspectable.

Key Contributions and Results
The paper presents several specific technical contributions and findings:

Interface Design and Bridging: The project establishes a design principle where highly general Mathlib theorems are brought down to the level of abstraction found in textbooks. For instance, the formalization connects the textbook's step-by-step construction of the Lebesgue integral (simple functions $\to$ non-negative functions $\to$ general functions) with Mathlib's lintegral and Bochner integral interfaces via specific lemmas.
Handling Totality and Integrability: The authors highlight a critical divergence between informal mathematics and Lean's total functions. In a case study regarding the variance of a discrete distribution, an initial AI-generated formulation was technically valid in Lean but failed to enforce the necessary integrability hypotheses required by the textbook's finite-mean assumption. The repaired version explicitly required integrability witnesses before exposing the variance, demonstrating the necessity of making domain conditions explicit.
Error Detection: The formalization process identified a logical gap in the textbook itself. Theorem 1.2, concerning the additivity of the Riemann–Stieltjes integral, was found to incorrectly conclude integrability on a whole interval based solely on sub-interval integrability. The formalization flagged this by producing a counterexample, illustrating how formalization forces hidden assumptions to be made explicit.
Agentic Workflow Validation: The project demonstrates that a workflow combining AI generation with rigorous human "source-fidelity" review is effective. It distinguishes between a valid Lean artifact (one that compiles) and a faithful textbook translation (one that captures the intended mathematical content).

Significance and Claims
The authors position this work not as a test of AI capability in isolation, but as a systematic effort to build a coherent, reusable library for probability theory that serves as a machine-checked companion for education.

Pedagogical Value: The formalized textbook serves as an interactive companion for upper-level undergraduate courses. It allows students to inspect omitted details in lecture proofs, experiment with variants, and verify the precise logical content of results.
Infrastructure for AI: By creating a structured corpus of formalized probability theory, the project contributes to the infrastructure needed for reliable AI-assisted mathematics. It provides the "canonical theory" into which AI-generated proofs can be incorporated and verified.
Methodological Insight: The paper argues that successful formalization is not a mechanical transcription of prose into code. It requires reconstructing mathematical interfaces and making explicit the translations between textbook exposition and library abstractions. The authors claim that while compilation and the absence of sorry are necessary, they are insufficient for faithful formalization; human judgment remains essential to verify that the formal statement aligns with the intended theorem.

The project concludes that as the generation of mathematical arguments becomes easier, the roles of verification and understanding become more central, and computer formalization will play an increasingly vital role in both mathematical research and education.

Technical Summary: From Lecture Notes to Lean: Formalizing a Textbook on Probability Theory

More like this