Update on minifying the claimed Lean proof of the Riemann Hypothesis.
Where we are: 8.6% smaller, 17.37M lines down to 15.88M. Not final until it builds clean; the repair loop is on round 25, with errors down from 2,500 to 34.
What the 8.6% is:
• ~90,700 declarations nothing in the proof uses: 59,712 theorems, 29,806 definitions, plus structures and abbreviations
• 2,873 files that held nothing needed
• 522,000 redundant import lines
• 43,070 repeated theorems now pointing to one identical copy
All dead code. No math was simplified. The proof content itself is ~6.5% smaller.
Even minified, it's ~7x the size of Mathlib (15.9M lines vs 2.3M).
What that means for kernels: almost nothing changes. A kernel checks what the five theorems actually use, 1.47M declarations, and dead code was never in that set. After minifying, the kernel still checks 99.7% of the same work. Tenet does it in 1 hour; Lean's own kernel, single-threaded, takes many hours.
The proof isn't big because of waste. It's big because of what it uses. Shrinking it for real means finding a shorter route through the math, and the biggest target is one theta-correspondence step that owns 38% of the proof by itself.
github.com/keithadler/rh-tri…
21
Hey @dbongino do you think it's possible that when they did the coup on Trump they used Five Eyes to do operational support ... seems logical since the Third-Party rule would create the perfect crime.
I know Bill Barr went to FVEY to find out what they hand in 2019, but Barr saying he found no evidence reminds me a lot of Barr saying the same thing about election fraud in 2020.
8
My Lean kernel just checked the entire claimed proof of the Riemann Hypothesis in 1 hour flat.
Tenet, an independent Lean 4 kernel I wrote from scratch in C#, accepts all of it:
• 1,468,414 declarations
• 0 failures
• 1 hour 0 minutes on one AWS machine (multi-threaded)
Lean's own kernel, single-threaded, has been checking the same export for 5 hours and isn't done yet.
What else I've found on the way:
• The proof rests only on Lean's 3 standard axioms
• 99.35% of it hangs on one claim, allChi
• The five theorem statements depend on just 4,915 declarations, only 5 of them from the project
• I planted ~2,000 single faults in real slices of the proof. Every kernel (Lean, paranoid, nanoda, Tenet, tenet-hs, tenet-jvm) rejected every one.
Still running: my Haskell kernel, tenet-hs. Does it accept the proof, and how does it compare with Lean's?
A kernel accepting a proof says the code checks. It doesn't replace mathematicians reading the math.
Live: github.com/keithadler/rh-tri…
Proof by Levent Alpöge with Claude. nanoda and the latest con-leche have also accepted it (Andrew Sutherland, MIT).
Making big progress in minification of the RH proof follow real-time here at:
So far I've gotten it safely from 17.5 million lines to 13.9, 82% fewer files from 175k to 30k.
I think there's more to get.
github.com/keithadler/rh-tri…
The RH formalization shows scale was a bigger barrier than people thought.
The statements are standard Mathlib.
The proof is 17 million lines, more than any person or committee could survey, and one person working with a model produced it.
If the independent kernels confirm it, we'll know it's true before anyone understands why.
github.com/keithadler/rh-tri…
58
There's a lot of speculation, but I'm 100% sure this is disclosure.
youtu.be/rzWnvMDlB3c
41
I've been working on the claimed Lean proof of RH (Alpöge, with Claude).
Where it stands:
1. Built the original on one AWS machine: all 175,187 files, 0 errors, no sorry. About 21 hours, about $35.
2. Exported what the five main theorems actually use, measured by Lean itself: 1,468,414 declarations including Mathlib and core, resting only on the 3 standard axioms (propext, Quot.sound, Classical.choice).
3. Now racing kernels on that 61.6 GB export: Lean's kernel, paranoid mode, nanoda, and three I wrote from scratch, Tenet (C#), tenet-hs (Haskell) and tenet-jvm. con-leche and con-ron decline it, in both modes: they don't support reflexive inductive types, and the proof uses one.
The goal is minimum-step proofs: cut the source down to exactly what the theorems need, rebuild it, and recheck it with every kernel. That gives the smallest version of the proof that still checks, and a fair test of whether the Haskell kernel can keep up with Lean's.
Live status: github.com/keithadler/rh-tri…
Build it yourself: github.com/keithadler/rh-tri…
49
The claimed Lean proof of the Riemann Hypothesis just built cleanly on my machine.
All 175,187 files, exactly as published. 0 errors. No sorry.
What it took:
• One AWS Spot machine: 192 vCPUs, 768 GB RAM
• About 21 hours, through four Spot interruptions. It resumed by itself every time, nothing lost.
• About $35 total
What I'm doing on top:
1. Export exactly what the proof uses: the five main theorems and everything under them. Running now.
2. Race 8 independent kernels on that export, one at a time, timed. Three of them I wrote from scratch: tenet-hs (Haskell), Tenet (C#) and tenet-jvm. The big question: does the Haskell kernel accept it, and is it faster than Lean's own?
3. List every axiom it rests on.
4. Cut it down to the smallest version of the proof that still compiles, and check that too.
A clean build means Lean's kernel accepted it. It doesn't mean humans have checked the math, which is why more independent kernels matter.
Follow it live, step by step:
github.com/keithadler/rh-tri…
Build it yourself, one script:
github.com/keithadler/rh-tri…
Proof by Levent Alpöge, working with Claude. Mirror: Deicyde/riemann-hypothesis
85
If anyone wonders ... you can run the RH in AWS for $32 (I'm about 75% done and there's instructions).
github.com/keithadler/rh-tri…
I created 3 independent Lean kernels in for the JVM, .NET and Haskell. All of my Kernels are RC ready and I'll be verifying their performance characteristics and reporting it on the above GitHub.
Once I've got run times and details I will then use my other solution leanzempic to emit Haskell instead of C to see if RH is a problem well suited for the Haskell emission. It has shown better performance than the C kernel in certain areas.
2
44
63 years ago this Sunday, at 12:30 PM in Dallas, John F. Kennedy was shot and killed.
25 minutes earlier, a man phoned a newspaper in Cambridge, England, and told a reporter to call the American Embassy for "some big news." Then he hung up.
That is not a theory. It is in a CIA memo that took 60 years to come out.
I don't think this leads to the mob, the FBI, the Secret Service or the CIA. I think it leads to an intelligence alliance kept secret until 2010.
In 1992 Congress named Russia, the KGB and the GRU. For our allies it wrote one vague sentence.
I wrote the book and made a one-hour film from the released files. Every document on screen links to the real record. Check me.
@realannapaulina, Congress said the State Department "should" ask our Five Eyes partners what they hold. Should, not shall. Has anyone ever asked?
124
Follow live and even run it yourself ...
I'm running RH against my Java, .NET and Haskell Lean Kernels.
github.com/keithadler/rh-tri…
44
I'm building the claimed Lean proof of the Riemann Hypothesis from scratch, and you can watch it live.
All 175,187 files, on one AWS machine (192 vCPUs), sandboxed with no network.
Right now:
- 27,500 files compiled (16%)
- 0 errors
- ~200 files a minute
- finish around 14:00 UTC
- about $24 in total
Live chart, per-library progress, machine health, updated every 10 minutes:
github.com/keithadler/rh-tri…
When it finishes:
1. Export the exact proof, only the declarations it really uses
2. Race the kernels on it: Lean's own vs my independent ones, tenet-hs (Haskell), Tenet (C#) and tenet-jvm
Different code, same proof. If they all say yes, that means something.
54
Want to help check the claimed Riemann Hypothesis proof? Here's how to build the reduced version yourself.
One script on one cloud machine:
- AWS c7a.32xlarge spot (128 cores, 256 GB)
- about 4 to 6 hours
- about $9 to $13
It rebuilds the reduced proof (12.0M lines, a third smaller than the original) from the public mirror, checks it byte for byte, then compiles with the network cut off.
If it fails, it tells you exactly which pieces are missing. That's a result too.
Step by step: github.com/keithadler/rh-tri…
1
92
ANYONE running the claimed Riemann Hypothesis proof: please also run this reduced version and share your results. Correction ... RH reduced 5.5 million lines from 17.5 million. My intention was to mention lines reduced.
Overall it's ~ 1/3 smaller with 137k files instead of 175k. One command rebuilds it from the public mirror in about 2 minutes and checks it byte for byte.
Why it's smaller:
- I traced every name the five main theorems actually use, starting from Main.lean.
- 45% of the declarations are never reached by anything the proof needs. I cut them.
- Files left with nothing needed are dropped, and imports are rewired so every remaining file still sees what it saw before.
- Not one line of the remaining proof is changed.
What I found along the way:
- Everything rests on one claim: no Dirichlet L-function vanishes right of Re s = 1/2. RH and GRH follow from it by short textbook arguments.
- Those front-end files compile and lint clean (lean-linter, 18 checks).
- The 162 published results it relies on are proved inside the project, not assumed.
- The Galois representations it needs come from theta lifts, not Shimura varieties.
- 7 theorems reach the key claim: 4 form the one chain the proof uses, 3 are side routes.
Honest caveat: the reduced version hasn't been compiled yet. The trace can't see lemmas simp uses without naming them, so the first build may report a few missing pieces. Every error names what's missing, and that's exactly what I need.
Please share your machine (cores, RAM), build time, any errors in full, and the Comparator verdict if you get there.
Repo: github.com/keithadler/rh-tri…
Issue on the mirror: github.com/Deicyde/riemann-h…
No proof code is redistributed; the original has no license.
106











