Then if it constructs a valid proof in Lean, how could it be reward hacking? I suppose it could have found a Lean compiler bug, or a mistake in the formalization of the hypothesis. I would expect that those problems would be found and fixed reasonably quickly, and we would need to see if the proof could be fixed. Other than that, I suppose it could find a contradiction in ZFC, but that would be an even more incredible result than proving RH.
I don't really see the possibility for reward hacking with the stipulation that the proof is ultimately verified by compiling the Lean program.
You have in Lean a headline statement of "given X, then Y is true". Where X and Y and precise statements in code. So the mathematical assumptions are upfront.
If you trust the lean compiler and are very careful to vet that the headline statement is what you expect, then you know the theorem is true.
How well the human language mechanics of the proof corresponds to what the actual lean mechanics of the proof is very much up on the air.
The GRH is a bit too long to paste (but i encourage you to read it: https://github.com/google-deepmind/formal-conjectures/blob/m...), but for a sense of scale, here is the entire ABC conjecture:
def radical (n : ℕ) : ℕ := n.primeFactors.prod id
@[category research open, AMS 11]
theorem abc (ε : ℝ) (hε : 0 < ε) :
{(a, b, c) : ℕ × ℕ × ℕ | 0 < a ∧ 0 < b ∧ 0 < c ∧ ({a, b, c} : Set ℕ).Pairwise Nat.Coprime ∧
a + b = c ∧ (radical <| a * b * c : ℝ)^(1 + ε) < c}.Finite := by
sorry
not exactly beyond the realm of human reviewIn other words the system is designed, by construction, to only rely on a very small "trusted" set of axioms, code, and mathematical ideas. This is a very engineering-oriented design principle! Actually, a pretty significant amount of the theoretical research in theorem proving over the past 2 decades has been in "automating proofs", ie tools and methods of making those proofs as easy as possible to write. Entire book chapters have been written about how to replace a 20 line inductive proof in Rocq with a single line "function call" that can automatically discharge the proof for you, because the idea is that this "trusted kernel", the tiny and sound mathematical language, will reject invalid proofs by design. So "who cares" what the proof is, in a sense? In many ways simply writing the theorems and whatnot down requires you to understand the problem well enough already. So in a way LLMs are just taking this idea to the absolute limit.
So all this means is that the difficulty really is in specifying the theorems. Which was kind of the whole problem all along! Except now you have a computer that can check your actual proof. You can write a theorem in Lean that isn't the theorem you want, and then write a type checked proof of it, but you still need the theorem to be accurate.
Unless Claude is either 1) finding bugs in the Lean kernel to exploit them, 2) using 'sorry' (a very convenient tool in Lean used as a placeholder for proofs, but it can literally allow you to prove False), then it mostly comes down to: are all the theorems stated correctly? This is trickier than it sounds, of course, so some skepticism is certainly warranted in my opinion!
There are also other various engineering principles applied to help try to reduce bugs and ensure correctness like any other engineering project, and there are various other "things" regarding dependently typed programming language design and the impact of those design decisions on proofs (and why they are notoriously hard to read and write), but they aren't germane to my point here.
It's not the proposition (i.e. the theorem) you need to worry about but the proof. I'm sorry to say but the comments on here (and everywhere on the internets) that assure each other that "if it's veified by Lean, then it's true" misunderstand what they're even trying to claim.
Here's a good article on the subject that was recently posted on HN:
https://xenaproject.wordpress.com/2026/11/12/and-the-proof-i...
And here's the tl;dr:
>> This post is an attempt to explain in simple terms how to interpret claims of the form “this theorem is correct because it was checked in Lean”. The summary is: there is an important signal that can be extracted from Lean code, but if this code is AI-generated then you need to do some tests first. We explain the tests, and note that in many cases (such as the OpenAI theorem dump) these tests have not yet been systematically done.