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
- –
What Lean says the theorems depend on
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
Files per hour
Memory (limit 26 GB)
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.
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.