# We checked DeepMind’s AlphaProof Code release

Abe, part of the Honesty Tools team | Honesty.Tools | 10 November 2026

We checked [DeepMind’s AlphaProof Code](https://deepmind.google/blog/introducing-alphaproof-code/) against the public repo [google-deepmind/code-verification](https://github.com/google-deepmind/code-verification) at commit `808b4b7ffef198e6a91f71ed776d641a1c236882`.

The release holds **11,323 Lean files** and **7,528,293 raw Lean lines** — about 7.5 million, which fits “over six million lines,” not the “three million” going around. We read the released files. Here’s what the proofs actually cover.

This note is a **static scan only**. We have not run the kernel build, we make no kernel-checked claim, and we report no planted-bug results.

[Watch the 6-second motion card (MP4)](/media/blog/alphaproof-code-signal-reading-note/c18_card_16x9-loop.mp4 "A real Lean artifact. Not Signal on your phone. 11,323 Lean files and about 7.5M raw lines; 37 hooks; static scan only, no kernel check. Honesty.tools reading note · google-deepmind/code-verification @ 808b4b7. Silent loop.")

## What the release claims

The DeepMind blog says the proofs reach “down to the exact code running on devices.” The [paper](https://google-deepmind.github.io/code-verification/) is more careful: what’s verified is their AArch64 Linux `libsignal-cli` build, “not Signal’s own applications.” The README describes “two AI-generated proofs of security for compiled AArch64 machine code of `libsignal` … in a CLI harness (with hooked cryptographic primitives).”

Android and iOS are covered only “as long as we trust” those builds preserve the behavior of the protocol code as exercised by the `libsignal-cli` binary.

## What is hooked

37 routines are hooked: swapped for contracts instead of run. 23 are crypto primitives (SHA-2, AES-CBC, HMAC, X25519, Curve25519 point and scalar ops, Kyber1024, ML-KEM-768), which the paper says it idealizes. That’s standard practice, and it means the result is conditional on those primitives being secure.

The other 14 hooks aren’t crypto: libc `memmove`, `bcmp`, and `strlen`; the two output writes; Rust-std leftovers including `memrchr`, UTF-8 conversion, and error-message formatting; a fixed clock; an optimization barrier; and zeroizing secrets on drop. The paper says these contracts “are not proved against the real routines,” though DeepMind checked that its test scenarios give the same outcomes as on the real binary. Key generation is out of scope.

| Hook class | Count | What that means |
|---|---:|---|
| Cryptographic primitives | 23 | Idealized; results are conditional on their security |
| Non-crypto contracts | 14 | “Not proved against the real routines” |
| Total hooked | 37 | Replaced by contracts at the binary boundary |

## What we checked

Ford’s light receipts pass (America/Denver, Nov 10, 2026) pinned the repo at `808b4b7…882` and ran a Lean-aware masked scan (comments/strings masked) over the tracked `.lean` corpus.

| Gate | Result |
|---|---|
| Pinned corpus | 11,323 `.lean` files; 7,528,293 physical newlines; toolchain `leanprover/lean4:v4.34.0`; Rust `1.98.1`; libsignal v0.105.4 / SPQR v1.6.0 |
| Hook table | 37 hooks in `cliHookTablePlaced` (23 cryptographic, 14 non-crypto) |
| `sorry` in headline theorem folders | None in `Computational/Theorems/`, `Symbolic/Theorems/`, or `LibsignalBinary/` |
| `TRUSTED_BASE.md` | Missing — cited as the trust-banner target, absent from the tree at this commit |
| Key generation | Out of scope; theorems cover `init` / `send` / `recv` and quantify over provisioned keys |
| `lake build` / `#print axioms` | **NOT RUN** — static pass only |

The scan did find **43 `sorry` hits in 22 files**, all outside those headline folders (testing fixtures, challenge stubs, and other non-headline trees). A static scan does not show that the headline theorems are sorry-free under a kernel check.

## What we are and are not saying

We are saying the released artifact is large and checkable, that 11,323 Lean files and about 7.5 million raw lines fit “over six million” rather than “three million,” that 37 routines are hooked (23 idealized crypto primitives and 14 non-crypto contracts “not proved against the real routines”), that a static scan at `808b4b7` found no `sorry` in the headline theorem folders, that key generation is out of scope, and that `TRUSTED_BASE.md` is missing from the repo.

A fair summary is a Lean security proof for a compiled CLI build of libsignal with modeled crypto (we haven’t rebuilt it ourselves yet). That’s a real step, and it’s not “Signal on your phone.”

We are **not** saying we kernel-checked the proofs, that the contracts match the real routines, that the result applies to Signal’s Android or iOS apps without the extra trust assumption, or that we reproduced any planted-bug result. Line counts describe the corpus we scanned; they are not a measure of verified mathematics.

## Sources and pinned receipt

- DeepMind blog: <https://deepmind.google/blog/introducing-alphaproof-code/>
- Repo: <https://github.com/google-deepmind/code-verification> @ `808b4b7ffef198e6a91f71ed776d641a1c236882`
- Paper / reviewers’ site: <https://google-deepmind.github.io/code-verification/>
- Toolchain: `leanprover/lean4:v4.34.0`; Rust `1.98.1`; libsignal v0.105.4 / SPQR v1.6.0

---

*Receipts: Ford’s `RECEIPT.md`, `hooks_extracted.json`, `sorry_hits.json`, and `scan_out.json` for the C18 AlphaProof Code static pass (Nov 10, 2026, America/Denver). Verdict: static scan only; no `sorry` in headline theorem folders; kernel build not run; no planted-bug results. Ford interest: 8/10.*
