Latest news regarding the Riemann Theorem …
Joint statement by the Lean FRO and the Mathlib Initiative.
[…]
We have full confidence that Alpöge’s proof of the Riemann Hypothesis is correct, and we congratulate him on this achievement.
Our rationale is outlined below.
https://leanprover-community.github.io/blog/posts/riemann-hypothesis/
Wow they solved the most famous math problem just 2 days after their IPO flopped??!?!
What a coincidence lol. I can’t wait for the verification…
Appreciate the good discussion here.
Are there any proofs this large created by competent mathematicians, or is a real proof typically significantly more distilled than 1.3GB?
The proof, expanded into text, spans 250k pages. Suffice it to say that no proof by a human is that large.
Press “X” to doubt.
X
doubt
It’ll be another hallucinated solution, most likely. With very little press given when some actual mathematician debunks it a month later.
What do you mean “another”? Did it hallucinate a famous proof recently?
That’s what I’m guessing. The LLM - in a hapless attempt to please - will have shat out a Lean “proof” that does check out, but that is utterly uncorrelated to the claim.
The proof uses Lean’s built-in definition of the Riemann hypothesis. It’s just a few lines long, and has been agreed to be correct for many many years.
Have you looked at it? It uses the Mathlib formulation of the Riemann hypotheses.
No (and nobody else has either). However, somebody vastly more qualified did and barely got started digging before the first sinkholes appeared:
Jenny Lorraine Nielsen: “Invalidity of the Alpoge Proposed Proof of the Riemann Hypothesis”
On 20 November 2026 Levent Alpöge announced a proof of the Riemann Hypothesis and of the Generalized Riemann Hypothesis for Dirichlet (L)-functions, released only as Lean 4 code. The archive holds 175{,}187 Lean files. Inspection of the source shows that the construction supplying the final hypothesis bundle rests on witnesses whose required properties are vacuously true. The geometry predicate is defined to be (\mathtt{True}). The geometric witness is built from a model the code itself names degenerate. The lattice witness has its required properties by definition. A statement that fixes a line-bundle degree holds only because its hypothesis cannot be satisfied. The lemmas written to extract content from these witnesses are never called. The pieces that would identify the row-side geometry with the divisor-side witness are the vacuous ones, so the chain between them is broken. On the path to the conclusion the height equation holds by (\mathtt{rfl}), because the height is assigned to be its own formula. The formalization therefore does not establish the geometric realization or the lattice identification that its own structure names. The proposed proof is invalid: what has been checked is a term whose structural witnesses are vacuously true, not the argument those witnesses stand for.
Source: https://philarchive.org/rec/NIEIOT-2
Existence of a Lean4 “proof” means very little in and of itself.
somebody vastly more qualified
No kidding. They have their own proof of Riemann, as well as a complete gauge theory.
Anyway, keep up the critical thinking.
This doesn’t matter as long as there is a term inhibiting the type corresponding the Riemann hypothesis and which is built following the accepted axioms (so no
sorry). This has been checked. Using different Lean kernels, so the probability that a bug in Lean might have been exploited is very low as well. Of course, there might be some intermediate statements/lemmas that hold vacuously, but as long as their correctness is not required for the proof to hold it doesn’t matter. They might just be dead code or helpers that are not required (The lean file is ~17million lines of code, so that is expected). If you are actually interested in things you have to pay attention to when verifying lean code, take a loot at a recent blog post by Kevin Buzzard: https://xenaproject.wordpress.com/2026/11/12/and-the-proof-is-checked-in-lean/I really don’t understand the Lemmy LLM stance, dismissing all of its achievements. I am not “Pro-AI”, but it’s very dangerous to ignore the societal changes that will follow from its existence.
Verification progress: https://math.mit.edu/~drew/grh/
I can’t speak for anyone else, but in my case (and in this context) it’s based on a history of overinflated claims. See, for example:
https://www.argmin.net/p/faster-fourier-transforms
https://www.argmin.net/p/galactus-the-devourer
Of course, that has no direct baring on this result, and it’s good to hear different kernels were used as that addresses one of my other immediate concerns.
Thanks for the link. I’ll be following this with some interest.
Regarding the overinflated claim examples: I think this a misunderstanding between complexity theory and “everyday notion” of fast. In Complexity Theory, one is usually, interested in the asymptotic behaviour, i.e., how does the “performance” (number of steps) of an algorithm scale with the size of its input. In particular, an algorithm that runs for 10³⁰⁰ · |x| steps on an input of size |x| scales in the same way (linearly) as does an algorithm that runs for |x| steps, despite being massively slower. So the notion of “fast” or “efficient” that is sometimes used in complexity theory is not the same as one might expect if not familiar with the field.
For example, concerning the exponential time hypothesis (ETH your second link), OpenAI did in fact find an algorithm that scales subexponentially (instead of exponential), thereby disproving the hypothesis, which was very unexpected to say the least. Of course, the algorithm (as noted in that post) is not practical, but that was never the goal (here the AKS primality test comes to mind, which checks whether its input is a prime, showing that primality checking can be done scaling polynomial in the input size).
Actually, the ETH hypothesis has been considered as a way to tackle the P = NP millenium problem as ETH directly implies that P ≠ NP. Again, for these problems the question only lies in how an algorithm solving them scales with the input (i.e. asymptotic complexity) and not if the algorithms are practical. But people tend to describe/explain P as “problems which permit fast algorithms” conflating the complexity theory notion of fast with its everyday counterpart.
tl;dr: There are different notions of “fast”. From a theoretical point of view, these algorithms are not practical. But that was never the goal as the problems are not concerned with practical algorithms but rather with an abstract notion of “fast”
Hank green has a good video about this topic
The point is AI companies use mathematical proofs as a way to evaluate and improve their models. Its not about the proofs themselves, they are a side effect. They are also completely useless for the math community because nobody can understand them. The value of a proof is in the math you used to get there and usually a proof like this involves new math that can then be used to solve other problems. The AI proofs provide none of this. Mathematicians now know something is true or not but can not use that knowledge for anything.
Mathematicians now know something is true or not but can not use that knowledge for anything.
look, i hate the slop machine built on stolen knowledge of humanity as much as the other person, but if you can be sure something is true or not, you can definitely use that knowledge, even if you do not understand the proof.
I think they mean that mathematicians cannot themselves use this proof to prove other things, or gain new insights.
The Riemann hypothesis itself isn’t very useful. It says something about the distribution of primes. But we’ve known for some time that all known primes fit the hypothesis, out to over a trillion of them.
Yea but it is still FAR less valuable than a proof where we actually understand the math behind it and know how to apply it to other problems. For many proofs just knowing they are true isn’t all that useful.
Yea but it is still FAR less valuable than a proof where we actually understand the math behind it and know how to apply it to other problems.
there is no argument there
In this case, it was something that for all practical purposes was already presumed to be true, but not formally proven.
If it found an unexpected result, that could be useful knowledge, but this case is of no practical use compared to before the proof.
Looking at it, it COULD be deconstructed to an actual, usable proof. If you had nothing but time on your hands. And that it held absolutely no bugs (1.3gb of code? Absofuckinglutely unlikely)
The bigger problem is that its confusing as all hell to the uneducated public. Its a proof in the sense that it technically proves the theorem. Its not a proof in that it must be able to be peer-reviewed. AI modeled proofs are intended for the AI. They cannot be peer-reviewed, thusly they are useless.
It is, however, fun to entertain the idea that a proof does exist, we just have more work to do to get there.
My son explained it to me. Basically those files are automatic proof files, and they are syntactically correct. But if you ever wrote a program, you’ll know that getting it through the compiler without error messages does only get you so far.
According to him, they already found serious issues with the actual logic.
When AI writes code, especially large code bases, it tends to be quite disorganized and unintelligible. It takes you all but 5 minutes to pick out 10 things that piss you off like, “why the fuck would it do that?” It’s complicated code, much more so than the domain is complex in its own right.
The “proof files” is just the codebase containing the code which in theory proves the theorem.
Nobody has the time to proof read that gargantuan piece of shit.
But the bigger point is: If a human had done it, then other humans would have been able to use the result. At least other field experts would find the text legible.
I think it is just as likely that it exploits the Lean theorem prover. IIRC, its evaluation model itself is known to have logic holes for convenience reasons.
It appears the future of math might be reviewing AI proofs. It’s one of the last fields that manage keep automation at bay. That’s over now.
Not the last field:

I am mad at this proof. Someone that did not understand what was going on (by his own public admission in his post) got a swarm of mechanical monkeys to try random things until they worked, and now we have an unreadable proof that the community needs to work to understand while getting no credit for doing the dirty and boring work
How do we know the proof is correct if nobody understands it?
Why should anyone spend the time verifying unreliable machine vomit?
Because the proof as presented is a Lean program. Lean is a proof checking program, that means that this type of code runs only if the logic used is correct.
For example, you can write a proof of pythagora’s theorem and the code would run. But if you write a faulty proof (even if the final theorem is correct), the code doesn’t run.
About your second question, I agree with the sentiment, I will still answer the question unironically. Because if it’s in Lean it’s supposed to be reliable, and because we mathematicians are suckers for proofs, even obscure, poorly written stuff. We assume that a cool proof open the gate to new understanding of math.
Because the proof as presented is a Lean program. Lean is a proof checking program, that means that this type of code runs only if the logic used is correct.
and how do we know that the lean (i am hearing the word for the first time - this is not a sarcasm, but genuine question) is correct, in its design, lack of logical flaws and the implementation?
lot of the software where the exploit was found was considered reliable, because it worked on known and proven mathematical principle, until the exploit was found.
I’ll just whip up a proof in lean to prove lean is correct
(I’m absolutely unqualified to have any opinion on any of this)
The exported raw proof has been checked by several proof checkers, including Lean’s official kernel, the con-leche and con-ron checkers, and several independent checkers contributed by third parties and implemented in different programming languages. The checkers con-leche and con-ron come with a formal proof, relative to set theory, that they cannot accept a false proof, thus addressing concerns that Lean’s logic itself might have flaws that the proof could exploit. An extensive overview is available at https://math.mit.edu/~drew/grh/. These checks ran on an inert export of the proof, out of reach of hypothetical malicious code in the Lean proof sources.
Valid point, but we should be able to trust something at some point I guess.
disclaimer; I have no acting knowledge of anything here.
deleted by creator
People are managing to make sense of the ideas in the proof. Example. Of course I don’t understand that comment and I don’t understand Wiles’ proof of FLT. But, there are some theorems that I do understand, that are proved conditional on RH. So now I can say those theorems are proved unconditionally, and in principle could come up with such theorems of my own.
Look, if I know anything about math, it’s that you can take that proof and divide it by, uh … something … and, uh, you can work your way back to what the working out stuff was!
I can’t wait to hear about this guy smearing his shit on the walls of an IHop bathroom while he screams about how right he was.
Or the AI stole the credits from this guy: https://news.ycombinator.com/item?id=50579568 “It is all human, with no AI”
Seems like that proof might be incorrect. Holes have been poked at it.
Numberphile published a quick reaction video: https://www.youtube.com/watch?v=sMZMpsHeFKc
“Anthropic mathematician” 🤣🤣🤣
I mean yes? Anthropic does employ mathematicians.
Levent Alpöge, a mathematician who works at Anthropic. He’s been involved with several other results like this.
Man, mathematic proofs sure have changed since I was in college.
1.3GB seems a lot
It’s encoded as Morse.
What’s more likely, that the Riemann hypothesis was proven, or that there’s some bug in the Lean prover they used that this 1.3GB of code manages to run into? I’m placing my bets on the latter…
If a coding agent produced 1.3GB of code and claimed it solved my problem, it would sure have bugs.
More so as Lean itself has logical issue, as many formal logic people say.
The proof is probably valid but as other people have mentioned, it’s being run through a bunch of different Lean implementations to make sure.
Lean is more of a proof checker than a proof finder. Checking proofs is much easier than finding them, so people generally aren’t too worried about Lean. An Anthropic AI model found this RH proof and it’s checked out according to at least one Lean installation so far, but they’re repeating the checks as extra precaution.
The details of the proof aren’t very comprehensible to humans right now, but the overall strategy apparently has been examined and makes sense.
I just assumed it was using proofs already 90% there honestly. These things have been worked on and written about for awhile.
I don’t think so, unless you mean the “quasi-RH” proved by OpenAI a few weeks ago. Other than that, RH hasn’t seen serious progress anytime recently. Just some small increments here and there.
Nah I mean that thousands of papers have been done over the years. I mean finding these conjectures are the initial big thing and then work is done on solving it. One thing computers are good at is going through a lot of material. A PhD math student maybe reads over 100 papers as they work on their own solution.
The Lean experts are running the Lean code in different Lean kernel versions to avoid this problem. Some of the kernel versions are verified themselves - if I remember correctly by earlier proof checkers.
If they succeed in running it, it’s as trustworthy as humanly checkeable
There are multiple kernel implementations of Lean. The proof will likely be checked against every kernel implementation available. It’s unlikely that it’s exploiting soundness bugs in all kernels at the same time.
I wonder if the Lean proof could somehow be automatically morphed into a Rocq or HOL proof and checked by those. (Rocq and HOL are proof checking systems unrelated to Lean, but with the same general idea).
Interestingly, one of HOL’s software self-tests involves a large cardinal hypothesis. Explaining what that means would be a bit messy, but if you already understand it, it’s sort of a lolwut moment.
Theft theft theft
Yup.
This guy: say you solved this theorem
AI: I solved this theorem
This guy:
Are we ignoring that the proof is posted? Doesn’t mean it doesn’t have issues, but so did Andrew Wiles’ proof.
People used AI to analyze it and found issues, but I can’t comment
Wiles proof was a human readable white paper that went through the peer review process.
The anthropic proof is 1.3 GB of lean. It will take some time to go through and at the end of the day its code. There might be bug in the interpreter. The anthropic engineer admits he doesn’t understand it.
Its not really a good comparison. But the anthropic proof might end up being right all the same.
Yes, that’s why I said there might be issues, but it doesn’t mean the proof is wrong










