Google DeepMind's AlphaProof Code Verifies Signal Encryption Down to Machine Code — 6.5M Proof Lines in Four Weeks

Google DeepMind has mathematically proven that the Signal Protocol's encryption holds — not just at the design level, but all the way down to the compiled machine code that actually runs on your phone. It took an AI system four weeks to generate roughly 6.5 million lines of formal proof that would have taken expert cryptographers years.

DeepMind published the results and released the proof artifacts on GitHub on November 11, 2026. The work used a new agentic framework called AlphaProof Code — an extension of the AlphaProof system that previously made headlines for solving competition-level mathematics.

Why Formal Verification Matters

Most software security relies on a mix of code review, penetration testing, and auditing — humans looking for bugs. These methods are thorough but not exhaustive. A formal verification is different: it's a mathematical proof, written in a proof assistant language (here, Lean 4), that a specific set of security properties holds under all possible inputs. If the proof is correct, there's no edge case where the guarantee breaks.

The challenge is that writing formal proofs at scale is slow, expert-intensive work. The Signal Protocol — the encryption standard underlying Signal, Google Messages, WhatsApp, and many other apps — is well-regarded in the cryptography community but had never been verified all the way to machine code. That gap between "we believe the design is secure" and "we've proven the compiled code is secure" is where real-world vulnerabilities sometimes hide.

What AlphaProof Code Did

DeepMind's system worked through a four-week automated process:

• Scope: The verification covers the core cryptographic guarantees of the Signal Protocol — specifically, the properties that ensure messages can only be read by their intended recipients and that session keys cannot be reconstructed after the fact (forward secrecy).
• Scale: 6.5 million lines of Lean 4 proof code. For context, the entire Linux kernel is roughly 30 million lines of C.
• Depth: The proof chain runs from the high-level protocol specification down through implementation code and into the compiled machine code that executes on hardware — a full-stack verification that is essentially unprecedented at this scale.
• Openness: All proof artifacts are published on GitHub, allowing independent cryptographers to audit the work.

The Signal Protocol encrypts messages for both Signal and Google Messages, meaning this verification covers communications for hundreds of millions of people.

What It Doesn't Prove

DeepMind and the researchers were explicit about the limits, and those limits matter.

This is not a proof that Signal the app is bug-free. It proves that the specific cryptographic properties specified — message confidentiality, forward secrecy — hold for the protocol as implemented and compiled. A vulnerability in Signal's UI code, its key management UI, its backup system, or its metadata handling is outside the scope of this proof.

The proof is only as good as the specification. If the security properties were written incorrectly — if someone forgot to include a property that matters — the proof won't catch that. Formal verification proves what you asked it to prove, not what you should have asked.

That said, what it does prove is a substantial and previously unverified chunk of the security stack that billions of people rely on.

Why This Changes the Security Landscape

For enterprises: Organizations that mandate Signal or Google Messages for sensitive communications now have a stronger basis for that policy than "the cryptographers we trust say the design is sound."

For regulators: Formal verification of widely-deployed encryption infrastructure is exactly the kind of evidence that policymakers asking for "proof that encryption works" have been demanding. This sets a precedent.

For the security research community: AlphaProof Code generating 6.5 million lines of verified proof in four weeks — a task that would have taken a team of expert proof engineers years — signals that AI is becoming a practical tool for formal methods at scale. That changes what's economically feasible to verify.

The bigger question is whether this model gets applied to other critical infrastructure: the cryptographic libraries in TLS, the kernel code that handles memory permissions, the firmware in network hardware. Those have historically been unverifiable at scale. That ceiling just moved.

What to Watch

DeepMind has not announced whether AlphaProof Code will be made available to other organizations or applied to other protocols. The natural next targets are TLS (the encryption layer for most of the web) and the cryptographic modules in widely-used operating systems. Watch for whether NIST or government cybersecurity agencies incorporate formal machine-code verification into their standards frameworks.