A phone executes the instructions its software was compiled into. Google DeepMind’s AlphaProof Code project made those instructions the subject of a mathematical proof. Researchers took the unmodified library that handles one-to-one sessions for the Signal protocol, compiled it into an Arm Linux test executable, and proved that the executable met specified security properties under a model of how it runs. The team announced the work on Nov. 10. DeepMind’s announcement and the technical report

Which promise did they check?

One promise is forward secrecy. If a key is compromised later, past messages protected by secrets that have since been discarded stay protected under the model. Another is recovery after compromise. The protocol can restore protection once the parties update their keys with fresh secrets that the attacker lacks. For someone sending messages, those are two different questions. What remains private after a compromise, and when is it safe to talk again? The paper spells out the conditions under which the library provides each property. The report’s introduction and verification sections

Those properties had been studied at the protocol level, where the object of study is a design. Here the team used the standard Rust compiler to build a test program around the protocol library, then proved properties about that specific executable. Reasoning directly about its instructions removes the need to trust the compiler’s translation. The paper identifies the library versions, the test program that wraps them, and the model of Arm Linux instructions used to reason about its behavior. The report’s setup and binary-level guarantees

Where human judgment sits

Researchers worked with models to turn descriptions of Signal’s security goals into mathematical statements. Human experts approved those statements before teams of agents set out to prove them. Lean, a proof checker, then checked each proof against the approved statement. DeepMind reports about 6.5 million lines of checked proof code. The report identifies about 26,000 lines of trusted definitions and machine semantics, along with other assumptions such as the behavior of low-level cryptographic routines and the correctness of Lean’s checker. The AlphaProof Code technical report

The division matters because a proof can be right about a claim that a user would find too narrow. The paper studies one-to-one sessions. The authors describe group messaging and server-side protocols as possible extensions. They also distinguish a classical security proof from a separate symbolic result for the secrecy of the initial handshake against a future quantum attacker. Their results leave the ratchet’s post-quantum recovery properties for further work. Those distinctions belong next to any assurance claim that a team carries into a release. The report’s discussion

For practitioners

Start with a promise you can name. A team responsible for a firmware updater might want to prove that it will accept only an image with a valid signature for that device. Ask which bytes the signature covers, how the updater selects a trusted key, and which code decides that the image belongs to the device. The answers make the promise specific enough to review and identify pieces that a proof would have to assume or cover.

Give the specification and the build identity to two people who have different jobs. A security reviewer can read the specification and ask which situations it covers. A release engineer can say which target and library versions the resulting binary uses. If a dependency changes, they have a record to help decide whether the evidence still applies and which checks to repeat. A team experimenting with proof-writing agents can measure the time those two people spend reviewing the claims and assumptions, along with the time it takes to get a passing proof.

Keep the specification, build identifier and checked proof together. If a customer asks what the shipped code guarantees, the team can point to the executable and the property it proved in the same record.