Loading

Checking the Riemann Hypothesis Proof on My Home Server

On 20 November 2026 a four-page note showed up on Levent Alpöge's website. I found out about it from the math subreddit. There is no paper yet. The only thing released is a Lean formalization, split into 14 archive parts. Alpöge says the slop Claude produced was 250k pages (of course he says it differently) so I think GRH will always be a mystery for humankind. We will never see a video by 3blue1brown explaining the proof or help us see the interesting visuals of the methods used.

I'm not a mathematician and I can't read the proof (sadly nobody can). But at least compiling code is something I understand and Lean proof has one nice property: you just compile it and it's valid (I think). So I'm compiling it on my home server (it's name is Maxwell btw, and the network is named aether:)), below is the live progress.

Live build

Loading the latest report from Maxwell…

Files compiled
–
Running for
–
Pace
–
Time left at this pace
–
Lean CPU time so far
–
Errors so far
–
Memory
–

Proof map

The whole proof as 1,000 squares, about 175 files each, grouped by folder (biggest first). Filled squares are compiled.

By folder

Files compiled over time

Just finished

    Slowest files so far

      Maxwell reports every five minutes. Last report: –

      What the Riemann Hypothesis is, roughly

      Primes look random one by one, but how many there are below a number is very predictable. There's a formula for it, and it's always a little off. Riemann found in 1859 that the size of that error is controlled by the zeros of one function, the zeta function, and guessed that all the interesting zeros sit on one straight line. If they do, the primes are as well-behaved as they could possibly be.

      What I downloaded

      • 14 parts from alpo.ge, 239,275,554 bytes in total.
      • 175,187 Lean files and 17,374,215 lines, on Lean 4.33.1 and a pinned Mathlib.

      SHA-256 of the joined archive, if you want to compare with your own download:

      9631b4f020199e580ba86178cb56c6e9b09f690c2369a80dc4334aa93f49c7fc
      

      Also searched for sorry, admit, new axioms, native_decide. Zero hits.

      The whole proof funnels into a 12-line Main.lean. The headline theorem is

      theorem riemannHypothesis : RiemannHypothesis := rhOfAll
      

      and that RiemannHypothesis is apparently Mathlib's own definition. So I think it can't prove something easier and call it RH.

      Development12,232,663 lines Formalism3,200,748 GroundTheory1,119,138 ReciprocityTheory563,016 CompanionTheory194,218 PositivityTheory55,130 Lemmata9,232 Main + kernel50 lines
      Where the 17 million lines are. Almost half of everything is one subfolder, Development/AbelianVarietyTheory (8.1M lines). The part a human has to read to know what was proved is about 50 lines.

      How I'm running it

      Lean code can run programs while it compiles, so I didn't want 175,000 files from the internet anywhere near my home folder. The build runs in a Docker container with networking switched off, no extra privileges, 10 of Maxwell's 12 cores and a hard 26 GB memory limit. The only network step was downloading Mathlib's prebuilt cache before the build started.

      When it finishes, the container runs #print axioms on the five main theorems. A clean proof should only lean on Lean's three standard axioms, propext, Classical.choice and Quot.sound. Anything else in that list means something was assumed instead of proved.

      What a green build means, and what it doesn't

      If it compiles and the axiom list is clean, then every one of the 17 million lines follows from the one before, and the last line is the Riemann Hypothesis as Mathlib defines it. Unless Lean itself has a bug, that's it, it's true.

      Also, to be honest, I'm not first. Andrew Sutherland at MIT reported a finished compile the same day the files appeared, with only the three standard axioms (Scientific American).

      Notes

      • I'll update this post when the build finishes, with the axiom output and a look at how the proof is put together. (Checking the slop with the slop generator itself)
      • Terence Tao points to the Lean Zulip as the best place to follow the verification.