GRH proof's geometry is fun _ _ _ => True, in 24 files

Yesterday the Lean and Mathlib communities certified Alpöge's 17.4-million-line GRH proof as correct. Today a paper says the certification proves nothing — because the geometry predicate the proof runs on is defined as fun _ _ _ => True. I opened the source. The definition is exactly where the paper says it is.

What got certified, in numbers

The joint statement from the Lean and Mathlib communities (November 21) says: "We have full confidence that Alpöge's proof of the Riemann Hypothesis is correct." Andrew Sutherland's verification page at MIT is the receipts. The checks that finished:

175,187 modules compile (Lean v4.33.1, Mathlib v4.33.1) pass, zero errors #print axioms for the five theorems propext, Classical.choice, Quot.sound only leanchecker kernel replay of every module 175,187 / 175,187, zero rejections nanoda (independent Rust kernel) on the full export accepts, 27 min 42 s on 80 threads con-leche master on the full export 1,468,418 declarations accepted, 3 min 15 s on 64 threads con-leche --compare (statement vs challenge) all five theorems "justified by the solution" lean4lean on every compiled module 175,187 / 175,187 (5 hit the default step limit, passed on rerun) exported proof 61,570,595,788 bytes unpacked 

That is a serious verification effort, run in about a day, and it is worth saying so before the rest of this article. The page also lists its caveats honestly: the build ran on cloud machines without a sandbox, the per-file .olean hashes depend on the build directory (/home/ubuntu/grh/src/lean), and the export was not compared against one produced by a sandboxed lake build.

The same day, Jenny Lorraine Nielsen posted "Invalidity of the Alpoge Proposed Proof of the Riemann Hypothesis" on PhilArchive. (The same author also posted an invalidity claim against Masullo's all-human proof the same day; that one I did not examine.) Her abstract makes a specific, checkable claim: "The geometry predicate is defined to be True. The geometric witness is built from a model the code itself names degenerate."

I checked the code. Here is what is literally in it.

The definition, verbatim

In Development/AbelianVarietyTheory/Definitions/AutomorphicMembership/OverIx.lean, two definitions sit six lines apart. The first is the real geometry predicate. The second is the one the proof actually uses:

abbrev GeoP : Type 1 := ∀ D : D7, Formalism.L2.Pj.Core D → DivX D → Prop def geoOf (Q : ∀ D : D7, GlobalTheory.ShFam.KitClass D) : GeoP := fun D J X => (∃ c : ℕ, 0 < c ∧ GlobalTheory.ShFam.IsGeoOf (Q D) J c X) ∧ GlobalTheory.ShFam.Pad.HasTrueSurf X def anyGeometry : GeoP := fun _ _ _ => True 

geoOf demands something: some positive c with an actual geometric witness (IsGeoOf), plus a true surface (HasTrueSurf). anyGeometry demands nothing — it returns True for every input. Both have the same type, GeoP, so either one can be slotted in wherever a geometry predicate is expected.

The closure that carries it across divisor changes is in NotGeoClFalse.lean, and it is exactly as the paper describes:

inductive GeoCl (Γ : GeoP) : ∀ D : D7, Formalism.L2.Pj.Core D → DivX D → Prop | base {D : D7} {J : Formalism.L2.Pj.Core D} {X : DivX D} : Γ D J X → GeoCl Γ D J X | step {D : D7} (N : ∀ u, Submodule (𝓞 D.what₂.LL) (D.div.Nu u).V) (h : D.what₂.Word → ℝ) {J : Formalism.L2.Pj.Core D} {X : DivX D} : GeoCl Γ D J X → GeoCl Γ (setDiv D N h) (coreS N h J) (divTr N h X) def geoCl (Γ : GeoP) : GeoP := GeoCl Γ 

With Γ := anyGeometry, the base constructor accepts trivial as a certificate for every input, and step carries that certificate across divisor changes. A certificate that can never fail is not a check.

How far it reaches

I ran git grep over the mirror I cloned yesterday (the same 1.7 GB mirror my previous article audited: 175,187 .lean files, 17,374,215 lines). Counts of files mentioning each predicate:

anyGeometry 24 files geoOf 12 files 

geoCl anyGeometry is passed into the constructions that build the hypothesis bundle — the prmR parameter records, the parametersOfExtension calls, and the HypsAlt bundle paths. A sample from LinkedBundleConstructionExists.lean:

prmR (NEa hL (GlobalTheory.HeightCounting.Up.NEo hL cDep) A) SExt.none (geoCl anyGeometry) 

And plugAll, the theorem Nielsen names, converts an inhabited hypothesis bundle into the all-character zero-free statement:

theorem UpperTheory.Top.plugAll (hG : GlobalTheory.GLq.Green) (hV : UpperTheory.Top.VWin) (h : Nonempty (Hyps (fun 𝒞 => Closed 𝒞 fun Fm _ => LinkN Fm) DRS)) : UpperTheory.EveryCharacter 

The final chain from Main.lean is short enough to read in full:

Main.lean:4 theorem riemannHypothesis : RiemannHypothesis := rhOfAll MainTheorems.lean:9 theorem rhOfAll : RiemannHypothesis := Formalism.VW.rh_of_every allChi MainTheorems.lean:7 theorem allChi : UpperTheory.EveryCharacter := UpperTheory.FinalTheorems.everyCharacter MainConclusion.lean:10 theorem UpperTheory.FinalTheorems.everyCharacter : UpperTheory.EveryCharacter := UpperTheory.FinalTheorems.everyCharacter_of_row ... 

That last step goes through every_character_of_literature_of_vWin, whose own file contains no mention of anyGeometry. I traced the chain this far; I did not establish whether the Main.lean dependency path runs through the anyGeometry bundle constructions or through a different route. That is the open question, and it is the one that decides whether Nielsen's claim touches the final theorem or only a corner of the archive.

Two more checks, for completeness. First, the paper says the geometric witness is "built from a model the code itself names degenerate." I grepped for degenerate across the tree: every hit is the standard mathematical term nondegenerate (nondegenerate trace forms, nondegenerate statements). I could not find a model named degenerate. That part of the claim I could not confirm. Second, the paper says the lemmas that would extract content from the geometric witnesses are never called — I did not verify call counts for those lemmas, so I am not repeating that claim as my own finding.

The crux: what a kernel can and cannot check

Here is the part that makes this story interesting instead of just confusing. Both sides can be right at the same time, because they check different things:

  • The Lean kernel and the independent checkers verify that a proof term has the type it claims — here, Mathlib's own RiemannHypothesis. The comparator verifies the proved statement matches the challenge statement. That is what the MIT page's table establishes, and it is real.
  • Neither the kernel nor the comparator checks whether the definitions inside the proof carry the mathematics their names claim. A predicate defined as fun _ _ _ => True typechecks perfectly. A certificate built from it is a valid term. The kernel verifies derivations relative to the definitions it is given; it does not audit whether those definitions mean what their names suggest.

If the Main.lean dependency path runs through the anyGeometry bundle, then the certification and the invalidity claim are both true: the term has Mathlib's type, and the geometry it claims to establish was never established. If the path does not run through it, then the True predicate is dead weight in a corner of a 17-million-line archive, and the proof stands. The 61 GB export and the four independent checkers cannot distinguish those two cases. Only reading the dependency chain can — and that is work no one has finished yet, a day after release.

As of writing, I found no public response from Alpöge or the Lean community to Nielsen's paper. The author is not a known figure in the field, the paper is on PhilArchive rather than in a math venue, and it is not peer-reviewed. Treat it as a claim with verifiable parts, not a verdict. The verifiable parts check out: the definition is real, the contrast with geoOf is real, and the use is pervasive. The part that would settle it — the full dependency trace from Main.lean down to anyGeometry — is still open.

Yesterday I wrote that the proof had 17.4 million lines and zero sorrys. Both are still true. Today I would add a third number: the geometry predicate is True, in 24 files. A proof with no sorry can still have a definition that says nothing. That is the lesson of this release, whichever way the dependency trace lands.

Limitations, stated plainly

  • I read the source and ran git grep over the mirror cloned November 20; I did not build the project or replay the export. The mirror is byte-identical to the published archive apart from added Comparator files (per the MIT page), and I did not re-verify that hash.
  • I verified Nielsen's central code claims (the anyGeometry definition, the GeoCl constructors, the plugAll statement, the file counts). I did not verify her claims about uncalled lemmas, the height equation, or the lattice witness, and I could not confirm the "degenerate model" wording.
  • I traced the Main.lean chain to every_character_of_literature_of_vWin but did not complete the transitive dependency analysis to the anyGeometry bundle. I am not a number theorist and I am not ruling on whether the proof is valid — I am reporting what is in the code and what the checkers do and do not establish.

Sources: Lean/Mathlib joint statement, "Lean verification of the Riemann Hypothesis" (Nov 21, 2026); Andrew Sutherland, "Verification files for the Lean proof of the Riemann Hypothesis" (updated Nov 21, 2026, 12:55 UTC); Jenny Lorraine Nielsen, "Invalidity of the Alpoge Proposed Proof of the Riemann Hypothesis" (PhilArchive, Nov 21, 2026); Jenny Lorraine Nielsen, "Invalidity of Masullo's Proof of the Riemann Hypothesis". All code quotes are from the 1337isnot1337/riemann-hypothesis-solved mirror of the November 20 release, as cloned November 20, 2026. My earlier repo audit: "17.4M lines, 0 sorry: I opened the GRH proof" (Nov 20, 2026).