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 _ _ _ => Truetypechecks 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 grepover 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
anyGeometrydefinition, theGeoClconstructors, theplugAllstatement, 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.leanchain toevery_character_of_literature_of_vWinbut did not complete the transitive dependency analysis to theanyGeometrybundle. 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).
Top comments (2)
Hey Frank,Thanks for looking into this and for the careful checks! Happy to clarify the points you raised.
The geometry predicate actually used by the concluding construction is exactly
anyGeometry : GeoP := fun _ _ _ => True
(in OverIx.lean). It is not a non-vacuous geometry that has been mislabeled; the code defines it that way, and that is the term that is supplied. In EveryCharacterE.lean, hypsE constructs the Nonempty (Hyps ...) inhabitant required by plugAll and passes geoCl anyGeometry. The inductive wrapper GeoCl does not add any content: its base constructor accepts any proof of the underlying predicate, so GeoCl.base trivial works for every input once the predicate is True. That is the geometric field of the witness.The objects that assemble the divisor datum are named in a way that signals their degeneracy. The release itself uses the identifiers geoDegenerate, algDegenerate, padDegenerate, and mdlJunk (along with the related geoDegenerateNoTau, algJunk, padJunk, etc.). These appear in
src/Formalism/LocalToGlobal/LatticeGeometry/Inhabited.lean.
They are not neutral labels. In the definitions the positivity predicates are set to True, the index types for levels/components/surfaces are empty or PUnit, volumes and norms are zero, and the lattice-to-sections map iMj is the zero map. The lattice-side conditions (MjAre, LamAre, the constant match) hold by rfl / HEq.rfl because the seed was defined as a copy of the row-side data. The extraction lemmas that would pull non-trivial content from a genuine geometry (geoOf_surf, GeoTiedP.geoTied, GeoTiedP.formsTieX, degree_value_of_determinant, etc.) appear only at their own declarations; they are never called.The dependency that actually reaches the top-level theorem is direct:
riemannHypothesis is rhOfAll
which is Formalism.VW.rh_of_every allChi
allChi is UpperTheory.FinalTheorems.everyCharacter
which is everyCharacter_of_row applied to the Galois-representation statement
which calls every_character_of_literature_of_vWin
which calls every_character_of_theta_integrals_local_matching
which obtains the character statement from plugAll
and plugAll takes as its essential input the hypothesis bundle built by hypsE with geoCl anyGeometry.
The height equation through which the divisor side enters (div.h u = hExpl6 ...) holds by rfl because setDiv overwrites the height function with the explicit formula itself. The geometric layer that was supposed to supply an independent height is the vacuous one, and the lemmas written to extract content from it are never invoked. The row-side geometry (InGeo on the GeoHalf datum) and the divisor-side geometry are never identified by a non-vacuous bridge; the pieces that would do the identification are the zero map, the certificate built on the degenerate model, and the unused tying lemmas.What the kernel checkers accept is therefore a closed term whose structural geometric and lattice witnesses are vacuously true. The formalization does not establish the geometric realization, or the lattice identification, that its own named structure calls for. The argument requires two independent sides; in the release the divisor side is the row side under another name, mediated by an assigned formula rather than by an independent geometric object.
Happy to point to the specific files and lines if you want to walk any part of the chain further.
I have published a reproducible compiled-dependency audit addressing the geometry concerns raised by Jenny Lorraine Nielsen and Frank Chu.
I independently compiled the pinned release on my Ubuntu server, then ran an AI-assisted dependency audit against all five headline RH/Dirichlet-GRH theorems.
Audited source commit:
753431bfe28701f6f3937f664fcaf08daa139c03, using Lean 4.33.1.The findings:
anyGeometry, several degenerate-model constructions, the zero-map constructiondivXFl, and the constructed height are reachable in all five stored dependency closures.hypsE₂andplugAllis also absent. The final proof follows the newernonempty_hyps_definite_side_of_closed_boundroute, which still passesgeoCl anyGeometry.propext,Classical.choice, andQuot.sound. The combined graph contains 1,478,243 declarations, with no missing referenced declarations.These results establish syntactic reachability. They do not establish that every referenced declaration is indispensable, or that a mathematical inference is invalid. They confirm several concrete observations in the criticism while correcting the proposed dependency route.
My standalone Nanoda check passed. My Comparator run remains pending.
The report, inspection code, and complete evidence are public:
I welcome independent review of both the dependency walker and the interpretation of these findings.