Remix.run Logo
▲ aseipp 3 hours ago

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.