Pinned Tweet
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?
93
Follow live and even run it yourself ...
I'm running RH against my Java, .NET and Haskell Lean Kernels.
github.com/keithadler/rh-tri…
25
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.
39
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
76
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.
83
My three independent Lean 4 kernels are ready for Lean 4.37.
Tenet (C#) v0.11.4, tenet-hs (Haskell) v0.1.4 and tenet-jvm (JVM) v0.1.5 now check against Lean 4.36.0 and 4.37.0-rc1. All three are updated in the Lean Kernel Arena.
The 4.37 kernel changes are small but real, and every outside checker has to match them:
- Proof irrelevance is tried before whnf (lean4#15103)
- A recursor's major premise is left alone when it's a proof (lean4#15371)
- Structure eta now covers partially applied constructors (lean4#15373)
- add_inductive checks for loose bound variables (lean4#16512)
The .olean format moved to version 4 with the same layout as 3, so the readers needed only a version bump.
I also moved my other Lean projects to 4.36.0 and built every one on 4.37.0-rc1. Only one needed a fix: lean-linter 0.5.4, because the environment's constant table is now a trie.
Credit to the Lean FRO for the kernel work and for the Arena, which keeps independent checkers honest.
github.com/keithadler/tenet
github.com/keithadler/tenet-…
github.com/keithadler/tenet-…
1
38
If you grew up on Tecmo Bowl, this is for you.
🏈 THE FULL SNAP is a free arcade football game that plays like a 16-bit Sunday afternoon, wrapped in an entire fake ’90s TV broadcast.
• Two announcers calling every play, over 11 hours of original commentary and commercials
• Big hits, comic-book sacks, instant replay, snow and night games
• Starting lineups, anthems, and refs with grudges
• Run a franchise: seasons, the draft, a record book and a Hall of Fame
• Four difficulty levels, and a defense that reads you if you call the same play every down
Play it on an Xbox controller, keyboard, phone or tablet, right in your browser.
Free. No ads. No download. No sign-up.
👉 thefullsnap.com
1
142
This Is Disclosure, on the record.
My claims, word for word, are fingerprinted and locked in Bitcoin block 975,791 (Nov 14, 2026).
SHA-256: ad74b6f6366e5d2cbe8994f79d5521edacc4c67b10c63b2d7a304ec8a86739b1
Check it yourself: github.com/keithadler/thisis…
thisisdisclosure.com
73
Interesting update on leanzempic:
It’s a Haskell backend for Lean 4.
It prints Lean’s compiler output as Haskell shaped like GHC Core, so GHC’s optimizer runs your program instead of Lean’s C backend.
That cuts instructions: 9 of 13 programs I measured retire fewer than C.
Fewer instructions isn’t always faster, but there are compelling cases: red-black maps run 2.4x faster, binary trees 1.4x.
2
121
leanzempic update:
my Haskell backend for Lean 4 (it compiles Lean’s output to Haskell so GHC can optimize it) is now at parity or better with Lean’s own C backend on most of the real programs I’ve tried, with a few dogs.
The dogs: arrays that are shared and mutated in a loop (about 5x slower), qsort, and memory use, which is higher on everything. I’m working on getting at least parity on each one, not just overall.
Once the dogs are fixed: algebraic rewrite fusion, deforestation, supercompilation and partial evaluation.
In a world where we’re writing, testing and even predicting with code, the ability to execute faster is an edge.
github.com/keithadler/leanze…
2
182
leanzempic: a Haskell backend for Lean 4. GHC fuses and unrolls your Lean code.
Up to 10x faster than Lean’s C on numeric loops. Up to 21x slower on shared arrays. A proved AES-256 matches OpenSSL. Every number is in the chart.
It's still early, but I believe there's nothing like GHC for this problem.
#GHC #Lean4 #Haskell
Apache-2.0: github.com/keithadler/leanze…
Hit a “deterministic timeout” in Lean and can’t tell which tactic did it?
Lean Studio shows the cost on every line (here: omega, 462 of 481 ms) with a flame graph of Lean’s own trace. And leanstudio --profile-check fails your CI when a change makes a declaration slower, no editor switch needed.
github.com/keithadler/leanst…
72
For anyone looking at solving Problem 1, here's something I found in Rule 30 that I can't explain. I'm looking for collaborators.
The prize question: does the center column of Rule 30 ever become periodic? Nobody has proved it either way.
What I found: take a finite starting pattern of width w and force its center column to follow a repeating pattern. It can only keep that up for a short while past its own edge, then it breaks. That gap grows extremely slowly: about 9 steps for widths 29 to 37, 10 at w=38, and 12 to 13 at w=55 to 56. A random-like continuation would give a gap of about w. I checked about 540 billion seeds at w=38, and every repeating pattern I tried up to period 10.
Why it matters: I proved in Lean that if every finite seed eventually breaks from every repeating pattern, then the center column of the single-cell pattern can never become periodic. That would settle Problem 1.
What it is not: a proof. It's numerical evidence, and I don't know if it's new. One caveat: other simple rules also show small gaps for repeating patterns, so the slow growth alone may be generic. What's special to Rule 30 is that even constant patterns can't be followed forever (Condrey's result).
What I need: someone to check whether this is already known, someone to replicate the numbers independently, and anyone who can explain why. Math, cellular automata, Lean, or plain skepticism are all welcome. Everyone who contributes is credited.
Code, data, Lean and open questions: github.com/keithadler/rule30…
Credit: David Condrey's paper states the related open question, and Eric Rowland's work on Rule 30's edge structure is likely relevant. The computing and the Lean were done with Claude (Anthropic) under my direction.
@stephen_wolfram @davidcondrey
#Rule30 #CellularAutomata #Wolfram #OpenProblem #Math #Lean4 #ExperimentalMath
1
112
Hi David, I read your constant-trace paper: arxiv.org/abs/2609.09431
Working with Claude, I independently re-derived the w+2 horizon bound and wrote a complete Lean 4 proof of the upper bound (core Lean, no Mathlib, standard axioms only). Your Lean file is partial, so this may be a useful cross-check: github.com/keithadler/rule30…
Separately, SAT searches over finite seeds give exact first-impossible horizons for periods 2 to 16. They assume no pre-period, so they only bound your H(p, w) from below. I can share them if useful. All credit for the result is yours.
127
Looked at what’s missing from OpenAI’s 722 math papers: applied math, optimization, statistics.
Pure speculation, but I’d guess the stuff that could make money (crypto, ML theory) stayed in-house.
Not saying anything’s broken.
Whoever picks the problems decides what’s valuable.
62
Every level in this game is a theorem.
I built HeartGrid, a Lolo-style puzzle game: push emerald blocks, bridge the water, collect the hearts, dodge ghosts that patrol and hunt. Then I asked Lean 4 to prove things about it.
For each of the 12 rooms, Lean proves:
✅ it can be solved
✅ it can’t be solved in fewer moves (the exact minimum)
✅ and across the set, the minimums strictly increase: 15 < 27 < 33 < 38 < 47 < 61 < 67 < 84 < 98 < 107 < 110 < 114
So the difficulty curve isn’t a designer’s hunch or a playtest average. It’s a statement a machine checked.
To be clear: Lean is a serious tool. Mathematicians and engineers use it to verify real theorems and real software.
This is the playful end of the same idea. But it shows something genuinely useful. Once the rules are written down precisely, “is this puzzle fair?”, “is it too easy?” and “does the next level actually get harder?” stop being opinions and become things you can check, for every level, again and again, even after you change the rules.
How it works: random corridor mazes go to an exact solver; Lean re-checks every solution and proves the search itself is sound, so “no shorter solution exists” is a proof, not a claim.
Honest footnote: the game you play is JavaScript, a second implementation of the rules that I keep in sync with tests rather than proof. And for 11 of the 12 rooms the exhaustive search runs as compiled code (native_decide), so that part also trusts Lean’s compiler.
Play it, free, in your browser:
keithadler.github.io/heartgr…
Code and proofs (MIT):
github.com/keithadler/heartg…
3
131
San Francisco’s whistleblower hotline is getting busier. Reports to the Controller’s Whistleblower Program jumped 31% in the second half of 2025, 398 vs 304 a year earlier. That’s the second-highest stretch in the program’s ten years.
Full-year reports have doubled since 2015, from 325 to 661. These cover misuse of city funds, improper conduct by city employees, poor service and waste.
A report isn’t proof of wrongdoing: about a third of investigated reports end in corrective action. But more people are raising their hand.
Source: SF Controller’s Whistleblower Program updates, Aug 2025 and Feb 2026.
73















