Quick Answer: Levent Alpöge has announced a Lean 4 proof of the Riemann Hypothesis, and a GitHub mirror now hosts the code. It's a claim, not a checked result: as of mirroring, nobody had published an independent build or review. To verify it, build the Main target and run #print axioms on the headline theorems.

The Riemann Hypothesis has been open since Bernhard Riemann proposed it in 1859, and it's one of the Clay Mathematics Institute's Millennium Prize problems. So when a repository says a complete formal proof exists, your first instinct should be suspicion, and your second should be to check. This mirror makes that checking possible. Whether the claim holds up is a separate question, and the answer is not in yet.

What the Claim Actually Says

The announcement, dated 2026-11-20, says Alpöge, working with Claude, found a proof that extends to the Generalized Riemann Hypothesis for Dirichlet L-functions. The repository states the argument is formalized in Lean without assumptions. The author's announcement remark is the primary outline.

The headline statements are short. src/Main.lean contains five theorems. Four of them use definitions from src/Statements.lean, which is 16 lines and imports only Mathlib. The fifth, riemannHypothesis, uses a definition that lives outside the repository:

  • RiemannHypothesis is Mathlib's own definition, found in Mathlib/NumberTheory/LSeries/RiemannZeta.lean at the pinned commit. It quantifies over zeros of riemannZeta that are not trivial zeros or s = 1, and asserts each has real part 1/2.
  • RiemannZetaZerosOnLine restates that condition inside the repo.
  • DirichletLNonvanishingRightOfHalf, DirichletLZerosOnLine, and PrimitiveDirichletLZerosOnLine cover the Dirichlet L-function cases.

Here's the counter-intuitive part. Most people assume the hard work is in the proof. In a formal project, the statement is the part you most need to check. If a definition is subtly wrong, a flawless proof of the wrong thing still compiles.

Why a Compiling Proof Isn't Automatically a Proof of RH

Lean's kernel checks that a proof term matches the stated type. It does not check that the stated type means what you think it means. Three failure modes deserve attention:

  1. Definitional drift. If a hypothesis is weakened, a theorem can be "proved" that's easier than the real claim.
  2. Hidden assumptions. A theorem can depend on an axiom or an unproved lemma. The compiler will accept it without complaint unless you ask which axioms it uses.
  3. Environment trust. If the elaborator or a custom tactic misbehaves, the result can look valid while the kernel-level term is not what you expect.

That's why the repository's authors pushed the verification burden onto the reader. The compile step is necessary but not sufficient.

The Scale Problem: 17 Million Lines

The codebase is large. The repository contains 175,187 .lean files totaling roughly 17.4 million lines on top of Mathlib. Nobody reads that line by line in a week. Here's how the bulk breaks down by directory:

Directory.lean filesLines
src/Development/141,92812.2 M
src/Formalism/18,2543.2 M
src/GroundTheory/8,5071.1 M
src/ReciprocityTheory/3,845563 K
src/CompanionTheory/2,027194 K

The archive is also large. The merged lean.tar.gz is 239,275,554 bytes, and its SHA-256 should be 9631b4f020199e580ba86178cb56c6e9b09f690c2369a80dc4334aa93f49c7fc. Verify that hash before you build anything. The author's original 14 parts are the most trustworthy source, because they come directly from alpo.ge rather than a second copy.

The lakefile pins Mathlib, the toolchain is leanprover/lean4:v4.33.1, and the global options raise maxHeartbeats to 4,000,000. That's a sign of a heavy proof load, not a red flag by itself.

What the Static Scan Does and Doesn't Tell You

The mirror's maintainers ran a text search across all files. The results look clean at first glance:

  • sorry: 0 files
  • admit: 0 files
  • axiom declarations: 0 files
  • native_decide: 0 files
  • unsafe, implemented_by, @[extern], opaque: 0 files

Two results need a closer look. Four files set maxHeartbeats 0, which removes the heartbeat limit for those declarations. That doesn't make a proof unsound, but it hides how long elaboration takes. One file uses addDecl to copy existing declarations under new names. That still goes through the kernel, so it's not an escape hatch, but it's the kind of metaprogram you should understand.

Keep the limits in mind. A text search can't see what a dependency does, and it can't tell you whether a definition matches its name. Treat the scan as a starting point.

How to Check It Yourself

Here's the procedure, in order. Each step has a reason.

  1. Verify the archive hash. This confirms you have the author's bytes, not a modified copy.
  2. Run lake exe cache get. This pulls the prebuilt Mathlib cache, so you don't compile Mathlib from scratch.
  3. Run lake build Statements. The statements file is small and fast. A failure here tells you something is wrong before you spend hours on the full build.
  4. Run lake build Main. This builds the full dependency tree. Expect it to take a long time and a lot of RAM. The repository publishes no timing figures yet, so record yours.
  5. Create Check.lean and run #print axioms. Import Main, then print axioms for riemannHypothesis, riemannZeta_eq_zero_re, and LFunction_eq_zero_re_of_isPrimitive.
  6. Optionally replay with lean4checker. This independent kernel checker reduces trust in the elaborator.

A clean result lists only propext, Classical.choice, and Quot.sound. If you see sorryAx, Lean.ofReduceBool, or a custom axiom, the proof depends on something unproved or outside the standard set.

Here's a quick reference for what each output means:

  • Standard three only: no hidden assumptions detected at the axiom level.
  • sorryAx: at least one unfinished proof is in the dependency chain.
  • Lean.ofReduceBool: a native_decide-style computation was used, which trusts the compiler's evaluator.
  • A custom axiom name: the project declared an assumption, and the headline theorem isn't unconditional.

Where the Mathematics Still Needs Human Eyes

Even a clean axiom check doesn't tell you the mathematics is right. The author's remark outlines an approach that uses Stepanov-style multiplicity via chains of theta lifts, Iwasawa towers, the Rallis seesaw, and a Bost slope inequality. Those are serious tools from number theory and arithmetic geometry. I haven't evaluated whether the outline holds, and the repository doesn't claim anyone has.

This is where the time scale matters. Major claimed proofs of long-standing problems typically face extended review by specialists before the community accepts them. Formal verification shortens one part of that process by removing doubt about logical gaps, but it doesn't remove doubt about whether the formal statements are the right ones.

So the honest position is this. The code is public, the statements are short and inspectable, and the checks are concrete. Whether it's a proof of the Riemann Hypothesis is a question that the mathematics community, not a single build, must answer.

Frequently Asked Questions

what is a Riemann Hypothesis Lean proof?

A Riemann Hypothesis Lean proof is a proof of the Riemann Hypothesis written in the Lean 4 theorem prover, so a computer can check every logical step. Lean verifies that the proof term matches the stated theorem. It doesn't verify that the statement matches the real conjecture, so you still need to read the definitions.

has the Riemann Hypothesis been proven in Lean?

Alpöge's repository claims a complete formal proof, announced 2026-11-20. As of mirroring, no independent build or review had been published. Until someone compiles the code and reports the #print axioms output, it's a claim, not an established result.

how do you check a Lean proof with print axioms?

Import the main file in a new Check.lean, then write #print axioms followed by the theorem name. Run it with lake env lean Check.lean. A clean proof lists only propext, Classical.choice, and Quot.sound. Any sorryAx or custom axiom means the result depends on something unproved.

why does a Lean proof compile but still be wrong?

Compilation only shows the proof matches its stated type. If a definition is weaker than intended, or a hypothesis quietly assumes the result, the proof compiles and still proves the wrong thing. That's why the statement files matter as much as the proof code.

Check It Yourself Before You Share It

Clone the repository with --depth 1, verify the archive hash, and run lake build Main. Then run #print axioms on the five theorems and post the exact output in a discussion thread. A single reproducible result from an independent machine is worth more than any headline, so do the check and report what you see.