ResearchPublished ExplainedAll news from that day
Ongoing case: AI-written mathematics and how it is checked 6 storiesWhat Lean's proof checks establish, and what they leave to people
Lean's manual sets out escalating checks, the strictest for cases such as unaligned AI, and says Lean cannot show a proved statement is the intended one.
Check our sources · 19 facts from 6 sources
Drawing: notis. No AI in this picture.
Key points
- Lean's reference manual presents an escalating sequence of checks, from blue double check marks in the editor to comparator, which it calls the gold standard.
- Comparator establishes that theorem statements match exactly, and with the --paranoid flag it checks proofs with several independently written kernels instead of only Lean's built-in kernel.
- The manual says: "Lean can establish that a statement has been proven, but not whether it is the intended statement."
What happened
Levent Alpöge writes in a PDF remark that he believes he has, working with Claude, discovered a proof of the Riemann hypothesis, and that he decided "to only present Lean".
Lean is an open-source programming language and proof assistant. Its home page says: "Define it, prove it, and let Lean check every step."
Lean checks proofs with a kernel. Its reference manual says the project combines the trust of "a small, independently-implementable logical kernel" with the convenience of automation, and that proof terms are "sufficient evidence of the truth of a theorem and are amenable to independent verification."
The claim a Lean proof makes is a precise statement written in code. Mathlib, Lean's mathematics library, defines the Riemann hypothesis as the statement that every zero of the zeta function, other than the negative even integers and the point 1, has real part 1/2. Its documentation adds that "constructing a term of this type is worth a million dollars." Mathlib has over a million lines of formalized mathematics.
The reference manual lists an escalating sequence of checks. The first is the blue double check marks in the editor, which show that the statement was elaborated and the kernel accepted a proof of it.
The second is printing the axioms the proof depends on: only propext, Classical.choice and Quot.sound are standard, `sorryAx` means the proof is incomplete somewhere, and any other axiom means the theorem holds only if that axiom is sound.
The next check, `lean4checker`, replays the stored proofs through the kernel again. The last, `comparator`, is the one the manual calls the gold standard.
A trusted file states the theorem with `sorry` in place of every proof, the submitter supplies the proofs, and the tool checks that the statements match exactly and that several independently written kernels accept the result. The toolchain ships these kernels: Lean's own, `con-leche`, `con-ron`, `lean4lean` and `nanoda`.
The manual says this last level is for high-risk settings such as proof marketplaces, high-reward proof competitions and unaligned AI. It describes a malicious proof as including "un-reviewed AI-generated proofs and programs."
The limits are stated in the same place. "Lean can establish that a statement has been proven, but not whether it is the intended statement." Even after the gold-standard check, the manual lists remaining assumptions, among them the soundness of Lean's logic and "no human error or misleading presentation of the theorem statement in the trusted challenge file."
So when someone says a result is "formalized in Lean", the questions to ask are which statement was proved, which axioms it uses, and which of these checks it has passed.
Underlined sentences link to the facts we checked. Dotted words open a short explainer.
Fact 1 of 19 · from Levent Alpöge, personal site, 20 Nov 2026
Levent Alpöge writes in his PDF "remark" that he believes he has, working with Claude, discovered a proof of the Riemann Hypothesis, and that he decided "to only present Lean".
Fact 2 of 19 · from Lean FRO
Lean is an open-source programming language and proof assistant that enables correct, maintainable, and formally verified code
Fact 3 of 19 · from Lean FRO
Define it, prove it, and let Lean check every step.
What it means for you
Our viewWhen someone says a result is formalized in Lean, as Levent Alpöge says of the Riemann hypothesis proof he believes he found with Claude, the manual's levels show how much that phrase can mean.
A check mark in the editor and a comparator run with several kernels give different assurance, and the manual reserves the strongest level for high-risk cases, including unaligned AI. None of them settles whether the statement is the intended one.
Before you rely on such a claim, find out which statement was proved, which axioms it depends on, and which of the checks it has passed.
It adds no new facts.
Your reaction
We count reactions per story and day, never who reacted. The counts help us choose what goes in the monthly issue. If you are signed in, your own page shows yours too.
We count reactions per story and day, never who reacted. They help choose what goes in the monthly issue.
Check our sources
Every sentence above is checked against these 6 sources.
1 remark (Levent Alpöge)
Open the source archived copy-
Levent Alpöge writes in his PDF "remark" that he believes he has, working with Claude, discovered a proof of the Riemann Hypothesis, and that he decided "to only present Lean".
cite
2 Lean programming language and theorem prover
Open the source archived copy-
Lean describes itself as an open-source programming language and proof assistant.
citeLean is an open-source programming language and proof assistant that enables correct, maintainable, and formally verified code
-
Lean's home page says: "Define it, prove it, and let Lean check every step."
citeDefine it, prove it, and let Lean check every step.
-
Lean's home page describes Mathlib as Lean's comprehensive mathematical library containing over a million lines of formalized mathematics.
citeMathlib is Lean's comprehensive mathematical library containing over a million lines of formalized mathematics
3 The Lean Language Reference: Introduction
Open the source archived copy-
The Lean Language Reference says the goal of the Lean project is to combine the high level of trust provided by "a small, independently-implementable logical kernel" with the convenience and automation of tools like SMT solvers.
cite
4 The Lean Language Reference: The Type System
Open the source archived copy-
The Lean Language Reference says proof terms "are sufficient evidence of the truth of a theorem and are amenable to independent verification."
cite
5 Mathlib.NumberTheory.LSeries.RiemannZeta
Open the source archived copy-
Mathlib's documentation defines RiemannHypothesis as a Prop, "A formal statement of the Riemann hypothesis", stated as: for every complex s with riemannZeta s = 0, if s is not of the form -2 * (n + 1) for a natural number n and s is not 1, then s.re = 1 / 2.
citedef RiemannHypothesis : Prop A formal statement of the Riemann hypothesis ... RiemannHypothesis = ∀ (s : ℂ), riemannZeta s = 0 → (¬∃ (n : ℕ), s = -2 * (↑n + 1)) → s ≠ 1 → s.re = 1 / 2
-
Mathlib's documentation says of RiemannHypothesis: "constructing a term of this type is worth a million dollars."
citeA formal statement of the Riemann hypothesis – constructing a term of this type is worth a million dollars.
6 The Lean Language Reference: Validating a Lean Proof
Open the source archived copy-
The Lean Language Reference's section "Validating a Lean Proof" presents an escalating sequence of checks, with instructions, what each entails and the mistakes or attacks each guards against.
citeBelow, an escalating sequence of checks are presented, with instructions on how to perform them, an explanation of what they entail and the mistakes or attacks they guard against.
-
The Lean Language Reference says blue double check marks in the editor indicate that the theorem statement was successfully elaborated and that the Lean kernel accepted a proof of it from the definitions, theorems and axioms declared in the current file and its imports.
citeThe blue ticks indicate that the theorem statement has been successfully elaborated, according to the syntax and type class instances defined in the current file and its imports, and that the Lean kernel has accepted a proof of that theorem
-
The Lean Language Reference says that after the theorem, `#print axioms` should report only the built-in axioms propext, Classical.choice and Quot.sound; sorryAx means the theorem or a dependency uses sorry or is otherwise incomplete; and any other axiom means the theorem is only valid relative to the soundness of that axiom.
citecheck that it reports only the built-in axioms propext, Classical.choice, and Quot.sound ... If sorryAx is reported, then this theorem or one of its dependencies uses sorry or is otherwise incomplete. ... Any other axiom means that a custom axiom was declared and used, and the theorem is only valid relative to the soundness of these axioms.
-
The Lean Language Reference says the lean4checker tool reads the declarations and proofs as stored in .olean files during building and replays them through the kernel.
citeThe lean4checker tool reads the declarations and proofs as they are stored by lean during building (the .olean files), and replays them through the kernel.
-
The Lean Language Reference calls comparator the gold standard: a challenge file written in a trusted environment states the theorems with sorry for each proof, a possibly malicious party submits a solution file with the proofs, and comparator establishes that the theorem statements match exactly, that all configured kernels accept the proofs, and that no axioms beyond the permitted ones are used.
citeGold Standard: comparator and external checkers ... a positive judgment by comparator establishes the following facts: The theorem statements of the challenge and solution match exactly, including all transitively used definitions. ... The proofs in the solution are accepted by all configured kernels. ... The proofs in the solution do not use any axioms other than the permitted ones.
-
The Lean Language Reference says that in a malicious situation comparator should always be invoked with the --paranoid flag, which checks the result using several independently written kernels instead of only Lean's built-in kernel.
citeIn a malicious situation it should always be invoked with the --paranoid flag, which checks the result using several independently-written kernels, as opposed to just Lean's built-in kernel.
-
The Lean Language Reference says the Lean toolchain ships with the following kernels: the official Lean kernel, the verified kernels con-leche and con-ron, the external, partially verified checker lean4lean and the external checker nanoda.
Toned down to what the source says
citeThe Lean toolchain ships with the following kernels: The official Lean kernel. The verified kernels con-leche and con-ron, implemented in Lean and Rust, respectively. The external, partially verified checker lean4lean ... The external checker nanoda
-
The Lean Language Reference says the comparator level should only be necessary for high risk scenarios, listing proof marketplaces, high-reward proof competitions and unaligned AI.
citeThis should only be necessary for high risk scenarios (proof marketplaces, high-reward proof competitions, unaligned AI).
-
The Lean Language Reference says "malicious" proofs include "un-reviewed AI-generated proofs and programs."
citewe use malicious to describe code that goes out of its way to trick or mislead the user, exploit bugs or compromise the system. This includes un-reviewed AI-generated proofs and programs.
-
The Lean Language Reference says: "Lean can establish that a statement has been proven, but not whether it is the intended statement."
citeLean can establish that a statement has been proven, but not whether it is the intended statement.
-
The Lean Language Reference lists remaining assumptions after the comparator check, including the soundness of Lean's logic and "No human error or misleading presentation of the theorem statement in the trusted challenge file."
citeWhen following the gold standard of checking proofs using comparator, some assumptions remain: The soundness of Lean's logic. ... No human error or misleading presentation of the theorem statement in the trusted challenge file.
Every sentence above is checked against these 6 sources. Each fact has its own address you can cite.
Source 1 · Levent Alpöge, personal site · 20 Nov 2026
remark (Levent Alpöge)
Levent Alpöge writes in his PDF "remark" that he believes he has, working with Claude, discovered a proof of the Riemann Hypothesis, and that he decided "to only present Lean".
Source 2 · Lean FRO
Lean programming language and theorem prover
Lean describes itself as an open-source programming language and proof assistant.
Lean is an open-source programming language and proof assistant that enables correct, maintainable, and formally verified code
Lean's home page says: "Define it, prove it, and let Lean check every step."
Define it, prove it, and let Lean check every step.
Lean's home page describes Mathlib as Lean's comprehensive mathematical library containing over a million lines of formalized mathematics.
Mathlib is Lean's comprehensive mathematical library containing over a million lines of formalized mathematics
Source 3 · Lean FRO
The Lean Language Reference: Introduction
The Lean Language Reference says the goal of the Lean project is to combine the high level of trust provided by "a small, independently-implementable logical kernel" with the convenience and automation of tools like SMT solvers.
Source 4 · Lean FRO
The Lean Language Reference: The Type System
The Lean Language Reference says proof terms "are sufficient evidence of the truth of a theorem and are amenable to independent verification."
Source 5 · Lean community (Mathlib docs)
Mathlib.NumberTheory.LSeries.RiemannZeta
Mathlib's documentation defines RiemannHypothesis as a Prop, "A formal statement of the Riemann hypothesis", stated as: for every complex s with riemannZeta s = 0, if s is not of the form -2 * (n + 1) for a natural number n and s is not 1, then s.re = 1 / 2.
def RiemannHypothesis : Prop A formal statement of the Riemann hypothesis ... RiemannHypothesis = ∀ (s : ℂ), riemannZeta s = 0 → (¬∃ (n : ℕ), s = -2 * (↑n + 1)) → s ≠ 1 → s.re = 1 / 2
Mathlib's documentation says of RiemannHypothesis: "constructing a term of this type is worth a million dollars."
A formal statement of the Riemann hypothesis – constructing a term of this type is worth a million dollars.
Source 6 · Lean FRO
The Lean Language Reference: Validating a Lean Proof
The Lean Language Reference's section "Validating a Lean Proof" presents an escalating sequence of checks, with instructions, what each entails and the mistakes or attacks each guards against.
Below, an escalating sequence of checks are presented, with instructions on how to perform them, an explanation of what they entail and the mistakes or attacks they guard against.
The Lean Language Reference says blue double check marks in the editor indicate that the theorem statement was successfully elaborated and that the Lean kernel accepted a proof of it from the definitions, theorems and axioms declared in the current file and its imports.
The blue ticks indicate that the theorem statement has been successfully elaborated, according to the syntax and type class instances defined in the current file and its imports, and that the Lean kernel has accepted a proof of that theorem
The Lean Language Reference says that after the theorem, `#print axioms` should report only the built-in axioms propext, Classical.choice and Quot.sound; sorryAx means the theorem or a dependency uses sorry or is otherwise incomplete; and any other axiom means the theorem is only valid relative to the soundness of that axiom.
check that it reports only the built-in axioms propext, Classical.choice, and Quot.sound ... If sorryAx is reported, then this theorem or one of its dependencies uses sorry or is otherwise incomplete. ... Any other axiom means that a custom axiom was declared and used, and the theorem is only valid relative to the soundness of these axioms.
Show all 11 factsShow fewer facts
The Lean Language Reference says the lean4checker tool reads the declarations and proofs as stored in .olean files during building and replays them through the kernel.
The lean4checker tool reads the declarations and proofs as they are stored by lean during building (the .olean files), and replays them through the kernel.
The Lean Language Reference calls comparator the gold standard: a challenge file written in a trusted environment states the theorems with sorry for each proof, a possibly malicious party submits a solution file with the proofs, and comparator establishes that the theorem statements match exactly, that all configured kernels accept the proofs, and that no axioms beyond the permitted ones are used.
Gold Standard: comparator and external checkers ... a positive judgment by comparator establishes the following facts: The theorem statements of the challenge and solution match exactly, including all transitively used definitions. ... The proofs in the solution are accepted by all configured kernels. ... The proofs in the solution do not use any axioms other than the permitted ones.
The Lean Language Reference says that in a malicious situation comparator should always be invoked with the --paranoid flag, which checks the result using several independently written kernels instead of only Lean's built-in kernel.
In a malicious situation it should always be invoked with the --paranoid flag, which checks the result using several independently-written kernels, as opposed to just Lean's built-in kernel.
The Lean Language Reference says the Lean toolchain ships with the following kernels: the official Lean kernel, the verified kernels con-leche and con-ron, the external, partially verified checker lean4lean and the external checker nanoda.
Toned down to what the source saysThe Lean toolchain ships with the following kernels: The official Lean kernel. The verified kernels con-leche and con-ron, implemented in Lean and Rust, respectively. The external, partially verified checker lean4lean ... The external checker nanoda
The Lean Language Reference says the comparator level should only be necessary for high risk scenarios, listing proof marketplaces, high-reward proof competitions and unaligned AI.
This should only be necessary for high risk scenarios (proof marketplaces, high-reward proof competitions, unaligned AI).
The Lean Language Reference says "malicious" proofs include "un-reviewed AI-generated proofs and programs."
we use malicious to describe code that goes out of its way to trick or mislead the user, exploit bugs or compromise the system. This includes un-reviewed AI-generated proofs and programs.
The Lean Language Reference says: "Lean can establish that a statement has been proven, but not whether it is the intended statement."
Lean can establish that a statement has been proven, but not whether it is the intended statement.
The Lean Language Reference lists remaining assumptions after the comparator check, including the soundness of Lean's logic and "No human error or misleading presentation of the theorem statement in the trusted challenge file."
When following the gold standard of checking proofs using comparator, some assumptions remain: The soundness of Lean's logic. ... No human error or misleading presentation of the theorem statement in the trusted challenge file.
Topics
The morning email
On the mornings we publish: the three top stories and up to four short ones. Free.
We email you a link to confirm. An issue may include one sponsor, always labelled Sponsored · Advertisement. Our emails count opens and clicks, not who made them. Unsubscribe in one click. What we keep
