CEO @ https://xitter.cf/t.co/2scp9eQObc
Dublin, Ireland
Joined September 2012
- Tweets2.4K
- Following528
- Followers724
- Likes4.9K
Pinned Tweet
1/ I used to lecture in CS. Due to AI, I can tell you if I did it now I would not allow any computers in my class room at all. Assignments would be pen and paper. Students need to learn to reason, first and foremost.
Gavin Mendel-Gleason retweeted
Small announcement: ✅ formal-git
As an experiment, over the last 2 months we've modelled ~30% of Git in Lean 4, making heavy use of coding agents, and proved >8000 theorems of varying usefulness about the implementation.
In the process of doing this we've uncovered >100 potential defects in Git v2.55, at least two of which may constitute security vulnerabilities. We've also built a DRT (differential random testing) harness and the biggest corpus of relevant pinned differential test cases for Git implementations with >10k unique tests at the moment.
We've used the test cases to test our own small internal implementation of Git in TypeScript. The next step will be to differentially test all notable public Git implementations against this corpus of tests to help improve their correctness and security 🫡 We'll be reaching out to library maintainers in due course.
If you have a Git implementation you'd like us to help you test, please reach out and let me know. We'll open-source all this eventually, after potential security issues that were uncovered are responsibly disclosed and fixed.
ALT Infographic: Reads: formal-git, Git, rebuilt in Lean 4, with machine-checked proofs
We ported a substantial fragment of libexpat to Lean. We demonstrate that it is significantly higher security than libexpat with both proofs and fuzz testing and check it against known vulns.
Do you need your C surface hardened?
Anthropic is now doing vericoding at scale. This is really the only future that doesn't look like a continuous train wreck of security holes.
New on our Frontier Red Team blog: using Claude to formally verify software at large scale.
Formal verification can prove that code is free of certain bugs, but historically it has only been feasible for small codebases (or required a lot of expert time).
With AI models, however, this is beginning to change. In collaboration with @theoremlabs, we used Claude to prove security properties in over one hundred real-world open-source libraries over the span of a few weeks.
Read our research in full here: anthropic.com/research/forma…
This is what our software verification stack *should* look like. If we did this we could have both highly correct and very fast software with much better security guarantees.
Vericoding is not a panacea which magically provides security, but software verification will be absolutely necessary for surface hardening in a climate where AIs can find vulnerabilities so effectively.
Really bad day for security today, and many of the security failings would not have been there with some basic use of formal methods (very basic in the case of array bounds checking!).
Time to vericode?
Just ported LeanIO, an HTTP toolkit, away from Lean's Std concurrency to LeanIn concurrency library and got a >10x performance boost.
Concurrency library showing parity with Node writen in a theorem prover. Dependently typed programming is ready for prime-time.
Proof assistant languages like Lean are just functional programming languages where you can say almost anything you want in the type system. But you don't have to! If you want to pretend you are in Haskell you can very easily do so!
Gavin Mendel-Gleason retweeted
You're either going all in on AI, tokenmaxxing, automating everything you once did manually, moving from playing the instrument to conducting the entire orchestra...
Or you're going in the complete opposite direction. Learning ceramics, restoring old wooden furniture, bringing theater back (cinema is dead), organizing communal gatherings where nobody touches a phone, rediscovering what it means to be human in a world increasingly run by machines.
I genuinely believe there's no middle ground anymore.
The people caught somewhere in between, neither embracing the machines nor radically reclaiming the human experience, are the ones who will get wiped out.
The middle is where AI will eat everything.
Functional programming languages *not* based on dependent types, no longer make sense. The cost of proof is too low to cripple your type system. All FP should shift to theorem provers.
Can you write a concurrency library directly in a theorem prover?
Can you write real software with it, perhaps a webserver?
Can it be similar in performance to servers used in industrial production?
What language should I use for Vericoding?
Yes, yes and yes! And Lean is demonstrably a viable option.
I have a proof (in Lean) that a type discipline (ownership semantics) in Lean will provide in-place-updates. We can have theorem provers that are as performant as any of our daily languages.
Hot Take: Theorem provers are ready to do most of what you're currently doing with programming languages and they can often do it a lot better.
