Lecture 1: Introduction

`L∃∀N`-verified Quantum Information Theory

RRS to QIC891, Fall 2026
Lecture 1, 2026-09-15

`\Gamma ⊢ t : T`

Lecture logistics

Some change of rooms. Space Room from today (15th) to September 22
24th in Sky, 29th in Time, and 1st of October in Sky again
A repository with these slides and Lean code will be made public
PSI Room Office hours

Learning outcomes

Create a Lean project repository from scratch
Understand math in a Lean way
Be able to assess the quality of AI-written code

Assignment: one project at the end

Overarching Goal: Make a contributing Pull Request to the Github repository of Physlib, Quantumlib, Lean-QuantumInfo, or Mathlib.
- Meaning: your work is also an actual citable contribution!
- (Of course, it will not be judged by whether the PR was accepted)
A list of suggestions will be posted on the course webpage
- This includes non-QI options
- Projects that are not exactly formalization are also welcome. Maybe you want to build your own kernel? Let's teach each other!

Maths under a different guise

Set theory and the Zermelo--Frankel axioms, with the axiom of choice
Type theory

What kind of differences do we expect to find? Is \mathbb{R} a set or a type, in Lean?

variable {x : ℝ}
#checkx : ℝ x -- as declared above, x is of type ℝ

/- type judgment is defined to output the RHS -/
x : ℝ
#checkx : ℝ (x : ℝ)

x : ℝ
#checkSet ℝ : Type (Set ℝ)
-- the set built from type ℝ is another data term in Type
Set ℝ : Type

Maths as code

import Mathlib.Tactic
-- import Mathlib.Topology.Basic

import VersoSlides
import Verso.Doc.Concrete

open VersoSlides
/- Preamble of this exact slide you're reading -/

Are these two things different after all?

Propositions as Types paradigm

Theorem-proving code

-- Check definition of a topological space in mathlib
#checkTopologicalSpace.{u} (X : Type u) : Type u TopologicalSpace

-- Check that √2 is irrational
TopologicalSpace.{u} (X : Type u) : Type u
#checkirrational_sqrt_two : Irrational √2 irrational_sqrt_two

-- Verify a simple identity using the ring tactic
irrational_sqrt_two : Irrational √2
example (a b : ℝ) : (a + b)^2 = a^2 + 2*a*b + b^2 := byx:ℝa:ℝb:ℝ⊢ (a + b) ^ 2 = a ^ 2 + 2 * a * b + b ^ 2 ringAll goals completed! 🐙

-- Or a numeric check
#reduce4 (2 : ℕ) + 2 -- should print 4

/- from PatrickMassot/GlimpseOfLean -/
4
def continuous_at (f : ℝ → ℝ) (x₀ : ℝ) :=
∀ ε > 0, ∃ δ > 0, ∀ x, |x - x₀| ≤ δ → |f x - f x₀| ≤ ε

#checkcontinuous_at (f : ℝ → ℝ) (x₀ : ℝ) : Prop continuous_at
continuous_at (f : ℝ → ℝ) (x₀ : ℝ) : Prop

Quantumlib and Physlib more broadly

Coding, mathematics, and possibly theoretical physics without context-switching

In what do we trust?

The main source of trust: the Lean KERNEL
- It's a folder on Github for all to see.
The "flow of trust". What else should we rely on?
- Lean elaborator: what you're writing is being translated honestly to the kernel
- Hardware
- Possibly, the Lean compiler
- Possibly, external type-checkers
The Lean Kernel Arena (LKA) 🏟️
- def: Ongoing adversarial multi-implementation conformance suite.

Lean@leanprover announcement on Twitter of the LKA

The diversity is the point. A bug that lets one kernel accept an invalid proof would have to exist in every kernel at once to go undetected.

🏟️

arena.lean-lang.org

The Lean Kernel

Soundness
- def: a kernel is sound iff it never accepts a proof term of False. By ex falso, proving False implies anything can be proven. Catastrophic ⚠️
- Accepting an incorrect proof.
Completeness
- def: Rejecting a correct proof.

LKA Tutorial Test Cases

List of test cases

What if the Lean Kernel has bugs?

The landscape is rapidly changing. A fully trusted kernel, and thus a fully trusted Lean should pass an audit.
First bugs have been reported as early as a month ago!
Two Postmortem.

Wikipedia definition:

Post-mortem is debugging of the program after it has already crashed.

Postmortem, 2026-08-01

Kernel Soundness Bug #14576

nanoda external checker in Rust
lean4lean external checker in Lean

The bug (quote): "when the kernel eliminates a nested occurrence under an inductive type T with parameters Ds, and these parameters are phantom (not mentioned in constructor fields), they disappear" — i.e. ill-typed arguments slip through, undetected.
How it was found (quote): "On July 25, Ramana Kumar published a repository containing a sorry-free 'disproof' of the Collatz conjecture, produced with AI assistance."
Wikipedia, Collatz conjecture: iterate n → n/2 if even, 3n+1 if odd; conjecture says every positive integer eventually reaches 1 — verified up to 2.36×10^21, but no general proof exists.
Fast turnaround (quote): "On July 28, Kiran Gopinathan reduced it to a small proof of False... We pushed a fix one hour after the report."
Root cause (quote): "This is an implementation bug, not a hole in Lean's meta-theory."
Why the frontend didn't catch it (quote): "The bug is only reachable through metaprogramming, by sending the inductive declaration to the kernel directly. The frontend checks the arguments and catches the ill-typed term."
The lesson (quote): "The kernel has to reject ill-typed declarations on its own, in its own process." — trust the kernel, not the frontend.

Postmortem, 2026-08-24

Kernel Soundness Bug Hunt

lake check --paranoid
- lean4checker
lean-inductive-models
- “Lean's theory of inductive types is well understood”

Setup (quote): "Daniel used OpenAI internal models to discover new soundness issues in the official Lean kernel and runtime." (following #14576, a ~3-week hunt, July 30 – August 20.)
Why bother (quote): "We consider AI-generated proofs a potential source of malicious proofs."
Notable find, runtime bug (quote): "It found a way to overflow the reference counter of a Lean object used by the kernel, corrupt the memory, and then prove False."
Same root-cause pattern as before (quote): "The soundness bugs in this area were implementation mistakes, not gaps in the theory."
Methodology, the gold standard (quote): "The gold standard is comparator and external checkers when you want to protect against a seriously malicious proof." — compiling ≠ verifying.
Hardening response (quote): "We are planning to ship Lean with two versions of lean4checker: one compiled using GMP and another using mpn." — defense in depth, diversify implementations.
Big picture: AI-driven adversarial proof search is now a genuine security concern, not hypothetical — the fix is diversified/verified kernels, not one-off patches.

The role of Lean in view of AI

Autoformalization of Fermat's Last Theorem (Lean FRO project)

Years-long project led by Kevin Buzzard.

Autoformalization of Fermat's Last Theorem

Accelerated by Anthropic.
“Sorries are not the hard part”

“On the Navier-Stokes Millennium Prize Problem”

Reported controversy (as of 15th of September, ~10:30):

And the solutions themselves: