upvote
That’s the purpose of Lean. It’s kind of like asking: how do you know your CPython is running all the correct binary?

Well, you kind of don’t, as it’s beyond human comprehension (in theory you could trace everything down to a certain level) but there are layers and layers of build abstraction that you assume are correct, compilers, runtime environments, and mature libraries that are checked and validated. Not a perfect analogy but that’s kind of the gist of it.

reply
OK, but if I write code, I can verify it in a few simple steps. What about 250k pages of proof? How can I verify that page 133,432 has the correct assumptions and that it isn't reward hacked just to make lean code pass? How it's done?
reply
You don't need to! That is the beauty of Lean. You only need to check the problem definition (which is no where near 250k pages) and then Lean checks the proofs it self by checking whether each next line can be derived from previous lines. And for this problem, there are many validated problem definitions in Lean. So it is probably true.
reply
> and then Lean checks the proofs it self by checking whether each next line can be derived from previous lines

Ah, so it's similar to something like Merkle trees, where each leaf must be cryptographically valid up to the root otherwise the whole branch is invalid?

So you start with a simple definition that then evolves?

reply
The core idea is that you can map the types and terms of a type theory to the propositions and proofs of a formal logic

Different type theories correspond to different systems of formal logic with different levels of power and expression.

Simply Typed Lambda Calculus corresponds to intuitionistic propositional logic. If you lay out the typing judgements of STLC in natural deduction style and then physically erase the terms (leaving the types) then you literally have the rules of intuitionistic propositional logic.

So if you can write a term that typechecks at a type, that term is a proof of the corresponding proposition.

The easiest example is modus ponens, which is exactly the typing rule for function application:

  G |- M : A -> B     G |- N : A
  -------------------------------- (App)
            G |- M N : B
"Given a function from A to B and a value of A, you get a value of B."

So then in a proof checker you prove the proposition P => (P => Q) => Q by writing a program of that type:

  apply :: a -> (a -> b) -> b
  apply x f = f x
`apply` is demonstrated in haskell which does not have a rich enough type theory to give you more then an intuition (no pun intended) for how this all works. Things like `undefined` and general recursion let you "prove" any type, so it isn't a consistent logic. Languages like Lean and Agda are built on richer dependent type theories that give you far more expressive power for writing proofs (quantifiers, induction, etc.), and they won't let you cheat the type theory.

So to answer your question, no not a merkle tree but a tree none-the-less. You end up with a literal computer program which is a tree of expressions all of which must type check. If they type check then program itself is a proof for whatever proposition is encoded in the type of the program.

reply
You must write very small programs.
reply
You can personally verify every binary digit of your code in a few simple steps?
reply
So Lean itself is proved? With what... Lean?

A 250k pages proof is massive, even if correct, there is almost certainly something extremely inefficient or weird in there.

I cannot imagine that a fundamental proof like this will require hundred of thousand of logic steps.

Unless some part of the proof is about brute-force checking that something holds for a huge number of literal cases.

reply
> I cannot imagine that a fundamental proof like this will require hundred of thousand of logic steps.

It's pretty easy to imagine that, given a starting language, there are facts that require an arbitrary minimum number of words to prove. The only reason the proofs most people learn are short is because:

- There isn't time in a math course to teach arbitrarily long proofs

- Humans don't live long enough to construct arbitrarily long proofs.

- Human minds are turning out to be pretty feeble and they probably couldn't reliably construct and verify anything more than trivially short proofs in the era before computer assistance.

reply
> So Lean itself is proved? With what... Lean?

Yes, actually! Well, one of the kernels is, con-leche: https://github.com/leanprover/con-leche

"This is an external checker for the Lean theorem prover that is proven (in Lean) to be consistent in that it does not accept a proof of False."

reply
You are proving something with the same thing you set out to prove?

Or you mean one implementation is used to prove another? In that case, you have a mutual (or circular) recursion of proofs

reply
In theory, if you formulated your proposition correctly, and Lean says it is proved, then the proposition is true. This works because of the Curry-Howard correspondence -- proofs can be represented as computation.
reply
OK, so if I understand correctly, I formulate a proposition in natural language, then an LLM creates 250k pages of proof based on it, then it takes those 250k pages/lines of proof and creates 15 million lines of code to prove those 250k pages. Is that correct? If so, how can I be sure that my proposition is correctly translated into those 250,000 pages? Isn't it possible that the LLM can reward hack here in the same way I've seen it do in some cases where it struggles to pass the test and get its reward? For example, it tries to change assumptions without telling me because something doesn't work or it removes something or changes the test etc.
reply
What assumptions could it change? The model should not be able to alter the definition of the RH, and if you want to prove to yourself that that definition is accurate, you just have to read through it and build a mental model of the Lean code: https://github.com/bhgomes/lean-riemann-hypothesis

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.

reply
> For example, it tries to change assumptions without telling me because something doesn't work or it removes something or changes the test etc.

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.

reply
The 250k pages is the 15M LOC of lean proof. The code is the proof.
reply
deleted
reply
I see, so there is one step less, then how I can know if that 250k pages describe my proposition correctly and not something else? Lean code was written by LLM, correct?
reply
Assuming Lean kernel is correct (and there are multiple independent implementations of it, some proved in other ways themselves), the only part up for debate is whether the Lean-translated theorem (roughly half a page of code, maybe a bit more if you fully expand all the libraries it uses) accurately models the original GRH

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 review
reply
250k pages describe the proof, not the proposition. You have to prove to yourself that the proposition is correctly described: https://github.com/bhgomes/lean-riemann-hypothesis
reply
In formal proof verification the only thing you need to verify is the problem statement expressed in lean, you don't need to check the lean code that is the proof. If the lean code that is the proof compiles, its a verification of the proof.
reply
In theorem proving environments like Lean, you are equipped with a standard set of axioms and statements (eg set theory). Most people, as far as I am aware, agree with Set Theory. From these basic fundamentals, you can build up all of mathematics, just like a normal mathematician can. The trick is that in systems like Lean, proofs are properly type checked, like a programming language; and just like a programming language, those types help stop bugs in the proofs, but the types here are far richer, able to encode all of mathematics, and far more strict. To prove a mathematical statement, you must write a proof that is accepted by the type checker. Beyond that, the core "language" itself is generally specified to be "sound" -- that is, there is a very small subset of Lean, a tiny "kernel language", that is shown to be incapable of proving False, and thus any proof which is well typed in said language (ie it typechecks) is also sound.

In 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.

reply
>> If so, how can I be sure that my proposition is correctly translated into those 250,000 pages?

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.

reply