# DeepMind's AlphaProof Code writes 3 million lines of Lean proofs for Signal's encryption

> Google DeepMind says AlphaProof Code agents wrote three million lines of Lean proofs verifying Signal's core encryption.

- Status: official (From the company, authors or authority themselves, with a link to their own page.)
- Topic: Safety & Security
- Published: 2026-11-10T12:02:28+00:00
- Updated: 2026-11-12T07:27:03.941979+00:00
- Web page: https://ai-news.ikangai.com/story/deepmind-s-alphaproof-code-writes-3-million-lines-of-lean-proofs-for-signal-s-en/
- Seen in: Google DeepMind, Latent Space
- Change: research (Research)
- Applies to: libsignal

## What changed

DeepMind's AlphaProof Code agents produced machine-checked Lean proofs of security properties of libsignal, Signal's reference implementation of its protocol, including the PQXDH handshake and Triple Ratchet.

Google DeepMind says its AlphaProof Code framework used AI agents to mathematically prove key security properties of the code behind Signal's encryption. The two sources disagree on the size of the output. The blog post says the agents generated over six million lines, while the accompanying technical paper says about 6.5 million lines of machine-checked proof code.

The target was libsignal, Signal's reference implementation of its protocol, not the protocol as described on paper. According to the paper, the agents proved properties of a binary compiled from the unmodified Rust code with the stock compiler for AArch64 Linux, linked into a small command-line harness. The proofs cover the post-quantum PQXDH handshake and the Triple Ratchet, and claim forward secrecy, authentication, post-compromise security and handshake secrecy. The blog post says this is the first time a widely deployed protocol implementation has been formally verified by any method, with or without AI. Earlier formal work on Signal, the paper says, used abstract models, reimplementations, modified code or narrower properties such as crash-freedom.

The division of labour is the core of the method. Humans write a specification in Lean, a formal statement of what the code must guarantee. That specification is the part that has to be trusted. A specification-writer agent drafts it, reviewer agents critique it, and the user approves it. Prover agents then produce the proofs. A gatekeeper accepts one only if Lean's kernel checks it and a comparator confirms it proves exactly the approved statement. Because Lean checks every step, a mistake in a proof gets rejected, so the reliability of the result does not depend on the reliability of the agents. It does depend on the specification being correct. The paper says human review is not expected to catch every bug in a large specification, which is why the team added reviewer agents, mutation tests and proofs that the theorems are not vacuous.

The trust boundary also extends below the specification. The paper calls the Lean semantics of the AArch64 machine code a trusted definition. It covers 467 instructions and 31 system calls in 7,578 lines, and does not model threads, signals, dynamic linking or files outside the current directory. Programs relying on those cannot be verified. The cryptographic primitives are not proved secure. They enter the results as assumptions or as trusted contracts that replace the code with a model. The paper also says the semantics cannot be proved sound against real hardware and kernels. Instead, the team tested it against emulators and qemu-aarch64. The symbolic proofs idealise the cryptography as black boxes, and handshake secrecy against a future quantum attacker is claimed only in that symbolic model.

The timing and effort claims are the most striking part of the announcement, and they come from DeepMind. The blog post says the verification took four weeks, a task it says historically takes expert teams years. The agents audited their own proofs and flagged about one percent of the codebase for a human second look, with Lean checking the rest. The post presents this as the reason human reviewers could focus on the parts where judgment matters. Neither source measures how long comparable expert work takes. The years figure is an estimate, not a measurement.

To test whether the specification could tell good code from bad, the team reintroduced two previously fixed libsignal bugs into an isolated copy of the code. In both cases the system produced a machine-checked proof that the buggy version was insecure. The paper also describes a mutation test in which agents skipped the ciphertext MAC verification in Signal and proved the security theorem false for the mutated binary. These results show the specification rejects these two bugs and the mutated binary. They do not show that no other bugs remain outside the stated properties and trust boundary.

Signal's chief technology officer, Ehren Kret, is quoted in the post praising the work as a significant expansion beyond earlier formal verification of smaller scopes. DeepMind says it is open-sourcing the formal verification artifacts, and the paper links a code repository and a Lean development. The post also argues the approach could later apply to medical device firmware and power grid software. Combined with its CodeMender agent, it could also support automated defence against cyber threats.

## Why it matters

If the claim holds, AI agents could make formal proof of large, security-critical codebases a practical option for companies that depend on such software.

## What you can do

Teams responsible for security-critical code could ask their vendors whether formal verification is available for the components they rely on.

## How the story developed

- 2026-11-12: Adds the compiled-machine-code scope and a figure of over 6 million lines of proofs, versus 3 million in the earlier report, plus the four-week, five-person timeline.

## Original source

- [Formal Verification of Signal’s Protocol with Gemini — Google DeepMind](https://deepmind.google/blog/introducing-alphaproof-code/)
- [AlphaProof Code: Verifying Signal’s Security at the Machine-Code Level](https://google-deepmind.github.io/code-verification/)
- [GDM](https://link.mail.beehiiv.com/ss/c/u001.r2tkAX6RdgQsMKMmEZrF6GRZlJ8AAQ9IGoz2q83cMItQW_8X3nsx3vnRFA00ER0Nt804sA_OO_9_pn_UKTv5rNdwz6fZvGozf0T6BFXvJmE7vcCP5pKgz_hSFFBrshZB0ZvtHBxroJQJepBv27ThDw/4vo/Quur_GHNTtmqSP4759bvOg/h44/h001.7JugqZhRuw1nNOY3mPcv3-_CMzxi6zkFJIMno-Fovtc)

## Further reporting

- [@omarsar0](https://link.mail.beehiiv.com/ss/c/u001.r2tkAX6RdgQsMKMmEZrF6LfzwOLJP3GDa3E_YvIcF9SUlnIjKldQqRJcTOymposM69Sk-RrzrkVuLKWyaaw_G4ORmTzzPbXKRG2v2f9dbTamywiUWZQ1fKoqaLNZZz1bqX4INn0wXfL6kqCFujdAjA/4vo/Quur_GHNTtmqSP4759bvOg/h46/h001.5_ED1d2NCexl6dIaT_50jcZ2OZ_k-qqNPDA9Axar80U)

---

AI wrote this summary from the sources listed, and nobody reviewed it individually before publication. Check the original source before you rely on it.

Cite as: IKANGAI AI News, "DeepMind's AlphaProof Code writes 3 million lines of Lean proofs for Signal's encryption", 2026-11-10, https://ai-news.ikangai.com/story/deepmind-s-alphaproof-code-writes-3-million-lines-of-lean-proofs-for-signal-s-en/
