proof checked in lean => proof of statement requires only that the statement is specified correctly (generally very easy to do) and that no lean kernel bugs were abused
code compiles => code satisfies requirements requires checking that all (inputs, outputs) of your program match the expected behaviour which is wildly intractable to verify in general
Fresh today, I asked llm to fix a unit test for me, it replaced the test with no-op.
There is no fundamental reason why mathematics should be formalized using concepts that are alien to most mathematicians, in the way that type theory is.
(I guess Isabelle/HOL is the Java of formalized mathematics, in the sense that for reasons that are difficult to understand, memory safety of Java-implemented technology does not count.)
You can proof a logic, but it does not proof that it is the logic that would keep the program secure and bug-free, only that it is internally consistent. So it helps, but by no means a silver bullet !
It's more like assuming that because your code is formally proven correct the client will be happy with it.
The code can be right but it may still do the wrong thing.
Formally proven correct is a much stronger guarantee that the code meets its spec than a successful compilation.
That it's the equivalent of saying it's full moon tonight because I wrote this program.
And he states that you have to check that:
1. The statement the author is making corresponds to the statement in the lean program.
2. The lean program compiles.
3. There is no shenanigans hidden in the lean program to disguise a trivial proof as the one stated.
4. The program does not exploit bugs in lean.
Example bug
A verified network program ensures that "data from two addresses are never commingled", but it does not verify that the NIC can't overwrite control flow memory opening up RCE attacks/other memory reads.
It certainly is harder to make bugs in formally verified software than the alternative, but it is not bug free.
Yes, Lean verifies the algorithm being verified, not hardware or someone else's software.
1. Yes.
2. Yes.
3. This is “you took 10 KLOC to do what 1 could have.”
4. Yes.
Being fairly naive to Lean in general, this always seemed to me like a clear flaw of using Lean solutions as proof of hypotheses
To be clear, this is basically a case of bad defaults in Lean. As Buzzard says, the fix is literally one command.
> The one-line answer: `lake comparator`.
It is worth noting that of the 290 OpenAI theorems which come with Lean code, around 38 of them have the property that the Lean code does not even state, let alone prove, the main theorem of the paper.
So even if LEAN is 100% bug-free, its still on the programmer to correctly express the logic and proofs, or they could be proving completely unrelated facts.
OpenAI no longer needs to do anything to get publicity. There are some organizations that are so famous that everything they do is newsworthy and anything they do will be covered whether they like it or not. Remaining low-profile is no longer an option.
The people claiming that everything is marketing haven’t come to grips with the inequality of fame.
You have to watch out for
1. Translation. Do the author’s claims about the program/theorem match the actual code?
2. Do you employ “shenanigans” to circumvent the checker? Bugs, unsafe operations. — Lean is a very strict checker as compilers go. Some compilers intentionally say “buyer beware.” It’s annoying to check for integer overflow in every operation. Lean doesn’t. But that still doesn’t mean it has zero bugs, in the framework or axioms.
Sure, the code works, but does it work at doing what you want?
Sure, the proof is valid, but does it prove what you set out to prove?