How the claimed proof of the Riemann Hypothesis is put together
On November 20, 2026 Levent Alpöge announced that he and Claude had proved the Riemann Hypothesis, and the generalized version for Dirichlet L-functions, and published only a Lean formalization: 175,187 files and about 1 GB of source with no comments. These pages follow the argument from the final theorem downward.
The argument in six levels
Each level is proved from the one below it. The top three are short and classical. Almost all of the source sits under the bottom one.
Where to go
- The idea explains, without Lean, why a one-sided inequality is enough and where one might come from.
- Primes as waves draws the classical part from real numbers: the prime staircase, the waves that build it, and what the ceiling rules out.
- The proof chain walks the six levels with the actual Lean statements and file paths.
- Key objects is a glossary of the names that recur.
- Source map shows what the eight libraries hold and how to find things.
- What is checked separates what has been verified from what has not.
The idea, without Lean
The proof turns a statement about zeros of a complex function into a single inequality about primes, and then claims to get that inequality from the geometry of lattices.
Primes and zeros
Count primes up to x with a suitable weight and you get a main term plus an error. Each zero ρ of the zeta function adds a wave of size xRe ρ to that error. The Riemann Hypothesis says every such zero has real part ½, which is the same as saying the error is never much bigger than √x.
The formalization uses a smoothed count, called Gz in the source:
Gz(x) = Σ_{n ≤ x} Λ(n)·(x/n − 1) − x·log x + (1+γ)·x
Λ(n) is log p when n is a power of a prime p and zero otherwise, so the sum is a weighted count of primes. The other two terms are what the sum would equal if primes were perfectly regular. Gz is the leftover.
One side is enough
You would expect to need the error small in both directions. A theorem of Landau says you do not. A zero with real part β > ½ makes the error swing above and below by about xβ. So if you can show the error stays under a ceiling of x½+ε, on one side only, no such zero can exist.
This matters because one-sided inequalities are the kind of thing arithmetic can produce. A nonzero whole number is at least 1 in size. A lattice cannot be more divisible than its volume allows. Facts like these give a bound in one direction and say nothing about the other.
The model: Stepanov's argument
Over finite fields the analog of the Riemann Hypothesis is a theorem. One elementary proof, due to Stepanov, builds an auxiliary polynomial that vanishes to high order at every point being counted. A polynomial cannot have more zeros, counted with multiplicity, than its degree, so there cannot be too many points. That is a one-sided bound.
The obstacle to copying this for ordinary primes is “vanishing to high order”. That needs a derivative, and whole numbers have no derivative. The announcement says this is the gap the new argument fills.
The claimed new step
According to the announcement, a theta lift can play the role of one order of vanishing. A theta lift is a standard way to transfer an automorphic form from one group to another. The proof chains lifts between a sequence of unitary groups of growing size, and each lift in the chain gains one unit of “multiplicity”.
The announcement gives the striking number: to control the prime sum up to X, the chain has about √X lifts. The source agrees. One of its size conditions requires the chain length m to satisfy x½−ε ≤ m.
From a chain to an inequality
The replacement for “a polynomial has no more zeros than its degree” is a slope inequality for lattices, in the style of Bost. The source records, for each lattice in the chain, numbers called slopes and heights. Two conditions then pin the same quantity from both sides:
- Divisibility (
DIV) bounds it from above. The lifted objects are divisible by many primes, and the logarithms of those primes are where Λ(n) enters. - The slope inequality (
SlopeIneq) bounds it from below.
Putting the two together leaves an inequality whose main terms cancel against the main terms of the prime sum, and what remains is the one-sided bound on Gz.
Ranks structure, and the length condition x½−ε ≤ m from RestSize.Primes as waves, drawn from the numbers
These charts are computed in your browser from the definitions, using the primes up to 20,000 and the first 30 zeros of the zeta function. They show the classical picture the proof starts from. Nothing here depends on the new argument.
The staircase and the waves that build it
The function ψ(x) adds log p each time x passes a power of a prime p. It is a staircase that climbs roughly like x. The explicit formula rebuilds it from the zeros: start with the straight line and subtract one wave for each pair of zeros.
ψ(x) = x − Σ_ρ x^ρ / ρ − log 2π − ½·log(1 − x⁻²)
Smoothing removes the ringing
The proof does not bound the staircase. It bounds Gz, which weights each term by (x/n − 1). That weight is the same as integrating the staircase, so the jumps disappear and the curve is continuous. The waves change too: their sizes now fall off like 1/γ², where γ is the height of the zero, so a handful dominate.
Gz(x) = log 2π − Σ_ρ x^ρ / (ρ(ρ−1)) − (a tiny term)
if every zero has real part ½:
Gz(x) = log 2π + √x · Σ_{γ>0} 2·cos(γ·log x) / (¼ + γ²)
The chart divides by √x so the waves keep a fixed height. The blue curve is computed directly from the primes. The orange one uses only zeros.
What the ceiling rules out
If every zero is on the line, the heights of all the waves add up to 2 + γ − log 4π ≈ 0.046, so the scaled error can never leave a band of that half-width. Up to 20,000 it stays within 0.019. A zero with real part β above ½ would add a wave that grows like xβ−½ on this chart, and sooner or later it leaves any band.
The proof chain, level by level
Each level shows the Lean statement, a plain reading of it, and where it lives. Paths are relative to src/ in the repository.
0Five theorems, one factproof read
All five headline theorems are one-line consequences of a single statement, EveryCharacter.
def UpperTheory.EveryCharacter : Prop :=
∀ (N : ℕ) [NeZero N] (χ : DirichletCharacter ℂ N) (s : ℂ),
1 / 2 < s.re → (χ ≠ 1 ∨ s ≠ 1) → DirichletCharacter.LFunction χ s ≠ 0
theorem allChi : UpperTheory.EveryCharacter := UpperTheory.FinalTheorems.everyCharacter
theorem rhOfAll : RiemannHypothesis := Formalism.VW.rh_of_every allChi
theorem riemannHypothesis : RiemannHypothesis := rhOfAll
In words: for every modulus N and every Dirichlet character χ, the L-function has no zero with real part greater than ½. The one exception is the pole of the trivial character at s = 1. The zeta function is the case N = 1.
Main.lean · Supplements/Kernels/MainTheorems.lean · Development/AutomorphicArithmetic/CharacterBoxes/EveryCharacter.lean
1Reflect across the lineproof read
The completed L-function satisfies a functional equation relating s to 1 − s. A zero to the left of ½ would reflect to a zero to the right, which level 0 forbids. So zeros in the strip 0 < Re s < 1 lie exactly on the line. For zeta the same reflection also accounts for the trivial zeros at −2, −4, ….
This uses Mathlib's existing lemmas for the functional equation and the Gamma factor. It is ordinary, readable Lean.
Formalism/GammaFactorNonvanishing/CritLine.lean · Development/AutomorphicArithmetic/CharacterBoxes/ClaimStrip.lean
2Primitive characters sufficeproof read
Every character is induced from a primitive one, and their L-functions differ by finitely many factors of the form 1 − χ(p)p−s. Those factors cannot vanish when Re s > 0. So it is enough to prove ZeroFreeAll, the statement for primitive characters.
def PChar.ZeroFreeAbove (ψ : PChar) (θ : ℝ) : Prop := ∀ s : ℂ, θ < s.re → DirichletCharacter.LFunction ψ.χ s ≠ 0 def ZeroFreeAll : Prop := ZeroFreeOn fun _ => True -- every primitive ψ is zero-free above 1/2
Development/AutomorphicArithmetic/CharacterBoxes/Imprimitive.lean · Formalism/SharpRestriction/RamificationFrobenius/TotientGaloisClasses/ExplicitFormulaErrorOfHostConditions.lean
3A one-sided bound on a prime sum is enoughstatements read
The source defines the smoothed prime error Gz and states Landau's criterion for it. The sign s₀ may be +1 or −1: a bound from either side works.
def Sz (x : ℝ) : ℝ := ∑ n ∈ Finset.Icc 1 ⌊x⌋₊, Λ n * (x / n - 1) def Gz (x : ℝ) : ℝ := Sz x - x * Real.log x + (1 + Real.eulerMascheroniConstant) * x def ZetaLandau : Prop := ∀ s₀ : ℝ, (s₀ = 1 ∨ s₀ = -1) → ∀ θ : ℝ, 0 < θ → θ < 1 → (∃ C x₀ : ℝ, ∀ x : ℝ, x₀ ≤ x → s₀ * Gz x ≤ C * x ^ θ) → ∀ s : ℂ, θ < s.re → riemannZeta s ≠ 0
The version the final proof uses works with a set of characters at once. For each primitive ψ it forms a Level, a finite set of characters containing ψ, and a combined error Gm: the zeta error plus weighted character-twisted errors.
def Gm (y : ℝ) : ℝ := Formalism.Gz y + ∑ ψ ∈ Λ.Nt, Λ.wt ψ * (An.gChi ψ.χ y).re
The bound is only needed on “windows”, a sparse set of scales x, as long as consecutive windows are not too far apart. The theorem zeroFreeOn_of_tiedWin_cyc assembles this: a bound Gm x ≤ x^(1/2 + c·ε) on windows, for every small ε, gives a zero-free half-plane for every character in the level.
Formalism/Statement.lean, StatementOC.lean, StatementU.lean, ZetaRealNonvanish.lean · Formalism/SharpRestriction/RamificationFrobenius/TotientGaloisClasses/TopWin.lean
4A tied chain gives the boundstatements read
This is the theorem that produces the inequality. Given a package of arithmetic data at scale x satisfying a long list of conditions (CoreAtH), the combined error is below the ceiling.
theorem core_gm :
∀ (Λ : Level) (eD eL K cHH eK C eps : ℝ), 0 < eps → ∃ x1 : ℝ, ∀ x ≥ x1,
∀ (φ : Frame) (H : HostAx φ) (TT : Finset φ.A),
EAtH Λ H.toHostRaw TT x eps C → CoreAtH H.toHostRaw TT eD eL K cHH eK eps x →
Λ.Gm x ≤ x ^ ((1 : ℝ) / 2 + (eD + eL + 7) * eps)
Its proof has two named halves. ch_top turns the chain's conditions into a bound for each component. ch_core turns those bounds into the inequality on Gm.
The conditions include size requirements. This one forces the chain to be about √x long:
def RestSize (ε x : ℝ) (n nT nT2 m : ℕ) (b k aE : ℝ) : Prop := aE ≤ 2 * x * b ∧ x ^ (-(ε / 8)) * n / 2 ≤ nT ∧ x ^ (-ε) ≤ (nT2 : ℝ) / n ∧ x ^ ((1 : ℝ) / 2 - ε) ≤ m ∧ -- chain length m is at least x^(1/2 − ε) k ≤ (n : ℝ) ^ 2 * x ^ ((1 : ℝ) / 2 - ε)
And these two pin one lattice quantity, muCC, from above and from below:
def DIV : Prop := -- divisibility: an upper bound on muCC
∀ u0 (u : W u0), D.muCC u0 + D.h u0 u - D.Fo u0 ≤
(∑ t, ((m : ℝ) * (ph (D.aT t) - D.aT t * D.logOm) - D.aT t * Real.log (D.T u0 u))) + …
def SlopeIneq : Prop := -- slope inequality: a lower bound on muCC
∀ u0, … → D.s u0 - Real.log (Fintype.card (W u0) : ℝ) - (error terms) ≤ D.muCC u0
Here ph(y) = y·log y − y, the same shape as the main term of the prime sum. The data comes from a structure called D7, described under Key objects.
Development/AutomorphicArithmetic/PrimitiveCosets/CoreGm.lean, CoreAtH.lean, WindowInequalityOfArtinInputs.lean · Formalism/SizeWindowBrackets/SChain.lean · Formalism/RankGapBounds/MeanBoundSecondForm.lean · Development/AutomorphicArithmetic/DedekindLFunctions/LandauTheorems/ChTop.lean, ChCore.lean
5Such chains existsignatures only
The last step needs a tied chain at every large scale and for every small ε. The top-level theorem takes three inputs.
theorem UpperTheory.Top.every_character_of_green_v_win
(hG : GlobalTheory.GLq.Green) (hV : UpperTheory.Top.VWin)
(h : Nonempty (GlobalTheory.Fc.HypsAlt … DefiniteSideCondition)) : UpperTheory.EveryCharacter
Greenis J. A. Green's 1955 classification of the cuspidal characters of GLd over a finite field.VWinbounds the sizes of certain Galois cohomology groups over number fields in a tower of cyclotomic fields. The announcement calls this “a significant weakening of Vandiver”. It is derived from base change, complex multiplication, and Galois representations.- The hypotheses bundle is filled from about 195 named results from the literature, among them Deligne–Ribet, base change for definite unitary groups, Bhatt–Scholze, the local Langlands correspondence for GLn, and Casselman–Wallach.
The literature results are written as depending on a hypothesis OpenLiteratureStatements with three fields. The final theorem supplies all three from proofs in the tree, so nothing is left assumed. The key one is the existence of Galois representations attached to automorphic forms over CM fields, which the project derives from its own theta lifts:
theorem galoisLocalGlobalStrong_recParameter : UpperTheory.GalStar.Row0b recT := galoisRepresentations_of_thetaLift UpperTheory.TP.K.tLiftK theorem UpperTheory.FinalTheorems.everyCharacter : UpperTheory.EveryCharacter := UpperTheory.FinalTheorems.everyCharacter_of_row UpperTheory.Gal.Int.galoisLocalGlobalStrong_recParameter
Development/AutomorphicArithmetic/CharacterBoxes/MainConclusion.lean, ZeroFreeAllOfTopG.lean, ExistsPageN.lean · Development/AutomorphicArithmetic/ThetaCorrespondence/ThetaPairLifts/ThirdPlaceSeries/TopPlug.lean, EveryCharacterOfLiteratureOfVWin.lean, SiegelEisensteinSecondTermHypotheses.lean · Development/AutomorphicArithmetic/Foundations/GaloisRepresentations/IntegralStructures/RowSrc.lean
Key objects
Names that recur in the chain, with a plain description and where each is defined. Many short names are reused in other namespaces, so the path matters.
Analytic side
- Gz
- The error in the smoothed count of primes: the weighted sum of Λ(n) minus its expected main terms.Formalism/StatementOC.lean
- Gchi, GchiC
- The same error twisted by a Dirichlet character, real and complex versions.Formalism/StatementOC.lean, StatementFL.lean
- PChar
- A primitive Dirichlet character packaged with its modulus.Formalism/SharpRestriction/…/TotientGaloisClasses/
- Level
- A finite set of primitive characters handled together, with weights.
Level.cyc ψis the level built around one character ψ.…/TotientGaloisClasses/ExplicitFormulaErrorOfHostConditions.lean - Gm
- The combined error for a level:
Gzplus weighted twisted errors. This is the quantity the proof bounds.same file - ZeroFreeAll
- No primitive Dirichlet L-function has a zero with real part above ½.same file
- FormB
- Landau's criterion for a level: a bound on
Gmat window scales gives a zero-free region.…/TotientGaloisClasses/Window.lean
The chain
- Scale
- The sizes at one step: x, ε below 1/52, and derived quantities such as b = exp(xε) and a = x·b.Formalism/LocalRingCardinality/DataParams₂.lean
- Ranks
- Three integers k, m, t fixing the sizes of the spaces. The j-th space has rank k + j(t+1), growing by one step per lift.Formalism/LocalRingCardinality/Params.lean
- D7
- The full package at one scale: a CM field E over a totally real field, Hermitian spaces and self-dual lattices over E, a column chain with Harish-Chandra parameters, a period map, and divisibility data.Formalism/LocalRingCardinality/RhoDetPrimeEqMuTildeMulChiPow.lean
- FamCore, FamP
- A family: for each scale x in a set of windows, a collection of
D7packages.Formalism/SharpRestriction/FamCore.lean, ParConsts.lean - Data
- The numbers extracted from a chain: slopes (
muN,muM,muCC), heights, sizes, and error terms.Formalism/RankGapBounds/MeanBoundSecondForm.lean - ChainTied
- The statement that a family member's data satisfies every condition the inequality needs: identification with the arithmetic, sizes, slopes, divisibility, error windows.Formalism/SharpRestriction/GlobalSchurBounds/TieGlobal.lean
- ChainCore, CoreAtH
- The same conditions with the family stripped away, as consumed by
core_gm.Formalism/SizeWindowBrackets/SChain.lean · …/PrimitiveCosets/CoreAtH.lean
Existence inputs
- TopG
- For any supply of host fields with the right cohomology bound, a connected class of tied families exists.Development/AutomorphicArithmetic/CharacterBoxes/ZeroFreeAllOfTopG.lean
- VWin
- For each character and each scale, the fields in the tower have small enough Galois cohomology groups (
shaLen), summed over primes with log weights.Development/AutomorphicArithmetic/CharacterBoxes/ExistsPageN.lean - WinPair
- The two auxiliary primes at a scale: q ≡ 3 mod 8 and d ≡ 7 mod 16, with q dividing d + 1 and prescribed sizes.same file
- Green
- Green's classification of cuspidal characters of GLd over a finite field.Development/AbelianVarietyTheory/Definitions/NonGaloisDescent/LabelDatum.lean
- Row0b
- For a CM field and a suitable automorphic form on GLa, a Galois representation exists with the expected local behavior and weights.Development/AutomorphicArithmetic/Foundations/GaloisRepresentations/TypeConditions/WeightsConjBis.lean
- OpenLiteratureStatements
- A three-field hypothesis the literature results are stated against. The final theorem fills it from in-tree proofs.…/ThirdPlaceSeries/EveryCharacterOfLiteratureOfVWin.lean
Source map
Eight libraries, 175,187 files, 17.4 million lines. Every file is imported, directly or not, by Main.lean.
| Library | Files | Lines | What it holds, by its largest parts |
|---|---|---|---|
| Development | 141,928 | 12,232,663 | AbelianVarietyTheory (99,187 files), AutomorphicArithmetic (18,431), AutomorphicSpectrum (15,147), WeilBound (7,051), EtaleCohomology, ResolutionOfSingularities. The top of the proof chain is in AutomorphicArithmetic. |
| Formalism | 18,254 | 3,200,748 | The core vocabulary: the prime sums, Landau statements, the chain and its slope conditions. Largest parts are LocalToGlobal, PeriodIntegrals, SharpRestriction, HermitianCurvature. |
| GroundTheory | 8,507 | 1,119,138 | HeightsAndTheta (6,410 files), automorphic forms, profinite cohomology, local and global fields, p-adic Hodge theory. |
| ReciprocityTheory | 3,845 | 563,016 | ReductiveGroups (2,799 files), class field theory, Chebotarev, geometry of numbers. |
| CompanionTheory | 2,027 | 194,218 | SpectralGeometry, AutomorphicTheory, real groups and Harish-Chandra modules. |
| PositivityTheory | 449 | 55,130 | Arithmetic positivity results such as Hilbert–Samuel and Moriwaki bigness. |
| Lemmata | 167 | 9,232 | Small standalone lemmas, one per folder. |
| Supplements, BuildAid, Main, Statements | 10 | 70 | The five final theorems and the three files that assemble them. |
File and line counts are from the mirror's verification notes. The largest-part counts are from my own count of the local clone.
Reading conventions
- Statements are separate from proofs. A typical file defines
def Something : Prop := …, and a theorem elsewhere proves it. The filesFormalism/Statement*.leanare the clearest examples. - Folder names do not describe contents. The central
D7structure is inLocalRingCardinality/RhoDetPrimeEqMuTildeMulChiPow.lean. Navigate by declaration name. - Short names repeat.
Frame,Scale,Ident,formBand others are each defined several times in different namespaces. Check theopenlines at the top of the file you are in. - There are no comments anywhere in the submission.
Finding a declaration
A search over the whole tree takes about two seconds with ripgrep. From src/:
rg -n -g '*.lean' '(theorem|def|structure) (\S+\.)?core_gm\b' .
The optional prefix matches both styles the source uses: fully qualified names and short names inside a namespace block.
What is checked, and what is not
Three different questions get mixed together: whether Lean accepts the proof, whether independent checkers accept it, and whether anyone understands it.
Machine verification, as of 20 November 2026
| Check | State | Detail |
|---|---|---|
| Statements match Mathlib's | read by hand | The headline theorem is Mathlib's own RiemannHypothesis. The mirror restates all five in a file importing only Mathlib. |
| Text scan for shortcuts | clean | No axiom, sorry, native_decide, unsafe or similar. A text scan is not a proof. |
| Full build on Lean 4.33.1 | in progress | Estimated 7 to 10 hours on 48 cores with 503 GB of memory. |
| Judging by Lean 4.36.0 and nanoda | not yet run | This is the check that counts. Three other checkers cannot read the project for unrelated reasons. |
Reasons for care
- The pinned Lean version is old. Lean 4.33.1 lacks later runtime fixes that its release notes say could be turned into a proof of a false statement with crafted input. That is why the judging uses a newer kernel and an independent one.
- Some proofs bypass the usual front end. The source defines tactics,
kexactBandkcopy, that hand a proof term to the goal without the elaborator checking it, used in 67 files. That is sound only because the kernel checks everything, so the kernel replay carries all the weight. - No human-readable proof exists yet. The author says he has not mastered much of the argument and that parts of his own summary “might make zero sense”.
What these pages rest on
| Part | Basis |
|---|---|
| Levels 0 to 2 | proof read I read the Lean proofs. They are short and use standard Mathlib lemmas. |
| Level 3 | statements read I read the definitions and the assembling theorem. I did not read the proofs of the Landau statements. |
| Level 4 | statements read I read core_gm, its hypotheses and the slope conditions. The account of why they give the bound is my reading of their shapes plus the announcement. |
| Level 5 | signatures only I read the types of the top theorems. I have not looked at how theta lifts, Galois representations or the cohomology bound are proved. |
Open questions for a next pass
- Inside
ch_topandch_core: exactly how do divisibility and the slope inequality combine, and where does each prime contribute its log p? - What do the 195 literature statements say in full? Are they the real theorems or weaker forms sufficient for this use?
- How is
VWinproved, and how strong is it compared with Vandiver's conjecture? - What is the “toy setting” the announcement mentions? The single-character statements in
Formalism/Statement.lean, using the quadratic characters mod 3, 4 and 7, look like its remains.
Sources
- Announcement: alpo.ge/remark.pdf
- Mirror and verification notes: github.com/Deicyde/riemann-hypothesis
- Declaration-level trace by another reader: issue #3