| ▲ | CapmCrackaWaka a day ago |
| If his proof is 250,000 pages, then I am extremely dubious. Just today, I was working with about 1000 lines of code and asked opus 5.4 to make a change. It introduced an obvious bug, that actually ended up doing the exact opposite of what I asked to do( print out less lines of logging, instead of more).. even if he has access to some kind of super LLM, I am extremely skeptical that it can output a 250,000 page document that is coherent and bug free, no matter what this guy says. |
|
| ▲ | chunky1994 a day ago | parent | next [-] |
| Its a formally verified proof. Its the same thing as saying your code compiled successfully (for a compiled language). If opus made a change and your code still compiled, you would certainly still say, my code compiled. The statement being asserted in lean is analogous to my code compiled. Lean works based on this: https://en.wikipedia.org/wiki/Curry%E2%80%93Howard_correspon... |
| |
| ▲ | YeGoblynQueenne a day ago | parent | next [-] | | >> The statement being asserted in lean is analogous to my code compiled. No, it's not. https://xenaproject.wordpress.com/2026/11/12/and-the-proof-i... | | |
| ▲ | chunky1994 a day ago | parent | next [-] | | This article is saying the same thing I said with more words. To someone who does not understand what formal verification is, this detail is unnecessary. Lean certificates of this magnitude come with comparator. They are checked independently on different kernels to avoid kernel bugs. See the zulip thread: https://leanprover.zulipchat.com/#narrow/channel/113488-gene... This is exactly analogous to my code compiles (albeit with some extra flags on the compiler). | | |
| ▲ | YeGoblynQueenne 8 hours ago | parent [-] | | I want to write a sorting predicate in Prolog (sorry, that's what I'm using now). I write it like this: sort(Xs, Ys) :-
sort(Xs, Ys, [], Ys).
sort([], [], Ys, Ys).
sort([X|Xs], [_|Bound], Rs, Ys) :-
sort(Xs, Bound, [X|Rs], Ys).
My code compiles. I try my predicate at the repl: 110 ?- sort([2,3,1,5,6], Sorted).
Sorted = [6, 5, 1, 3, 2].
What went wrong? | | |
| ▲ | chunky1994 6 hours ago | parent [-] | | This is a false equivalence, you seem to be missing the analogy. There is no specification in your prolog example, in lean we explicitly check that the expression in lean is GRH (and this is about half a page of lean and has been checked by many many mathematicians), and then can arrive at a formal proof for that specification. You are confusing the issue for people who don't understand what a formal proof means with this non-sequitur. |
|
| |
| ▲ | tkz1312 a day ago | parent | prev [-] | | in lean proof checking and type checking are exactly one and the same. | | |
| ▲ | YeGoblynQueenne 8 hours ago | parent [-] | | In Lean, as in anything else, the program you write can do something else than what you think it does. "Your program" in Lean is a proof. | | |
|
| |
| ▲ | smallnix a day ago | parent | prev | next [-] | | Until opus exploits a bug in my compiler to smuggle in invalid code | | |
| ▲ | mofeien a day ago | parent [-] | | I wish, but the proof is verified by another kernel ("con-leche") that is itself formally verified, Lean's own kernel, and two other kernels ("nanoda", "pestka") so far.
Joachim Breitner who's a Lean developer: "The high level summary is that this proof is now very very thoroughly checked." | | |
| ▲ | grumple 13 hours ago | parent [-] | | It’s turtles all the way down here. At some point you’re trusting a program and some human or bootstrapped verification of it. And then you’re trusting that the lean proves what it set out to prove and not something else. That’s another thing you have to prove… |
|
| |
| ▲ | CapmCrackaWaka a day ago | parent | prev [-] | | Yes, my code compiled too, but there was still a bug in it. | | |
| ▲ | chunky1994 a day ago | parent | next [-] | | I'll try to make it simpler, in formal verification (at the most base level): code compiles = the proof of the statement you have posed is correct, by definition. The statement you are trying to prove is: This is compilable code.
Since your code compiled, you know your code is compilable code.
Therefore your initial statement is correct. That's at the very basic level what a formal proof does. The expression you want to prove (in this case GRH) is stated in such a way that if your code compiles, you have proved the statement. | | |
| ▲ | shric a day ago | parent | next [-] | | Genuine question: if I make 250k pages of lean that compiles, how do we know what it proved? If it was as trivial as stating the expression and compiling then there would be easy verification and consensus as soon as it compiles on multiple kernels? | | |
| ▲ | thesmtsolver2 20 hours ago | parent | next [-] | | The result proved is not 250k pages. The theorem should be much smaller and a formal version of RH. | |
| ▲ | icepush a day ago | parent | prev [-] | | Among those who have experience with lean there is consensus that it is correct and the Riemann theorem is proven. | | |
| ▲ | roenxi a day ago | parent [-] | | The "there is a consensus" standard of proof isn't strong when it comes to maths. People are generally looking for a rigorous argument why something must be true. | | |
| ▲ | PierceJoy 21 hours ago | parent [-] | | > The "there is a consensus" standard of proof isn't strong when it comes to maths. Says who? I don't mean that in a rude way, it's a genuine question. Is that the opinion of the community of mathematicians who are capable of understanding these type of proofs, or software engineers who believe nothing can be true unless you can read the code yourself and understand it? |
|
|
| |
| ▲ | myk9001 a day ago | parent | prev [-] | | I'll try to make it simpler: code compiles = the proof of the encoded statement is correct, by definition. Whether the encoded statement and the one you have posed are the same -- at 250k pages that remains to be seen. | | |
| ▲ | geertj a day ago | parent [-] | | No. The lean statement itself is maybe half a page (I don’t know the exact amount but in this order). Checking that the lean statement is the GRH is elementary. The 250K pages are a ‘path’ from the statement (GRH) to the axioms encoded in Lean. The fact that is ‘compiles’ means the path is correct. | | |
| ▲ | myk9001 a day ago | parent [-] | | Yep, fair point. Someone else has posted a link to the GRH statement. It's complete gibberish to me but for someone qualified checking half a page of code should be straightforward. |
|
|
| |
| ▲ | baq a day ago | parent | prev [-] | | It doesn’t matter because you don’t run it. If it type checks it is proven, by definition. | | |
| ▲ | myk9001 a day ago | parent [-] | | > If it type checks it is proven, by definition. Try to explicitly spell out what "it" is and you might learn something -- just for the hell of it, ya know. |
|
|
|
|
| ▲ | ThePhysicist a day ago | parent | prev | next [-] |
| I would assume they do not produce the proof at once, and Lean is different from programming language (as far as I understand) in the sense that you can check if a program is correct or not within the Lean model, so it seems ideally suited for AI as they can experiment and extend the proof without ever producing a bug. I assume the real difficulty is checking that what you have proven is actually what you wanted to express but I would assume this is easier. Makes me wonder if general programming languages are too expressive for AI making it too easy to express conflicting or incorrect ideas, we might need something like Lean but for general purpose programming. I'm aware there are some formal systems for that but I think more along the lines of general purpose programming. |
| |
| ▲ | lheck a day ago | parent [-] | | I‘m doing a PhD in software verification right now and I agree. I’m not sure whether it’s about the power of the programming languages but more about their interfaces. Proof checkers like Lean are already what you describe, as Lean is also a programming language, but yes, there will be more general purpose tools for writing code that is correct by construction. The remaining hurdle is that you cannot actually verify correctness of many programs as you don’t know their full spec. But that is a very different problem to what we had before. |
|
|
| ▲ | a day ago | parent | prev | next [-] |
| [deleted] |
|
| ▲ | redbluered3 a day ago | parent | prev | next [-] |
| You don't have access to the secret model the labs keep for themselves. Neither can you spin up thousands of subagents and burn billions of tokens a day. Proof can be total bunk but underestimating the labs is silly. |
|
| ▲ | gehsty a day ago | parent | prev | next [-] |
| I’m not sure I could drive Lewis Hamilton F1 car round a track as quick as he could either. Clearly people are better at using these tools than others, hopefully we can decipher these proofs and actually benefit from it. |
|
| ▲ | cakeface a day ago | parent | prev [-] |
| Did you deliberately pick Opus 5.4 over Opus 5.5? That was the biggest thing that stood out to me in your comment. Opus 5.5 has been an all time banger for me. |
| |
| ▲ | plorkyeran a day ago | parent [-] | | Opus 5.4 doesn't exist, so they presumably meant either GPT 5.4 or Opus 5.5. |
|