The breakthrough is not that an AI wrote 6.5 million lines
Google DeepMind published AlphaProof Code on November 10, 2026. Guided AI agents produced roughly 6.5 million lines of machine-checked Lean proof for selected security properties of a compiled libsignal command-line harness. The work took four weeks. The more consequential result is architectural: a small human team could separate expensive proof search from a narrow checker that accepts only proof terms satisfying an approved theorem.
That separation changes where engineering effort belongs. Proof generation can be untrusted and massively parallel. The acceptance decision cannot. A valid proof can establish exactly the wrong theorem, rely on an overly generous hook, target a binary that is not deployed, omit an important execution path, or outlive the code and toolchain it describes. “Lean checked it” is useful only after someone can answer what it is.
The published work makes this boundary unusually inspectable. DeepMind released the paper, theorem and specification material, proof artifacts, checks, toolchain files, and an Apache-2.0 repository. Its reviewers’ site says the development rests on about 26,000 lines of trusted specifications and AArch64 semantics. That is a dramatic reduction from millions of proof lines, but it is not zero trust. It is a smaller review target.
The operational lesson extends beyond Signal. As code agents make formal proof construction cheaper, teams will need release discipline for proof-bearing software: immutable binary identity, reviewed claims, assumptions, model coverage, negative controls, reproducible checking, independent sign-off, and automatic invalidation after a relevant change.
The proof generator may be untrusted. The theorem, definitions, exact binary, and release claim cannot be vague.
AlphaProof Code splits specification, search, and checking
The system has three distinct jobs. A human-guided specification agent helps translate the intended security claim into Lean definitions and theorem statements. A prover team decomposes the resulting obligations and searches for proof terms. Lean’s kernel checks those terms against the definitions. An orchestrator can schedule many workers, leads, architects, and integrators, but it does not get to waive a failed theorem.
security claim + scenario
|
v
human-approved Lean specification
|
+-------------------------------+
| |
v v
exact static AArch64 ELF AArch64 + Linux semantics
| |
+---------------+---------------+
v
untrusted prover team
/ | \
workers integrator falsifier
\ | /
v
candidate proof terms
|
v
Lean kernel checks theorem
|
v
versioned proof release receipt
The machine-code layer matters because it narrows a familiar verification gap. A source-level proof says something about a source program or model. The deployed executable also depends on compilation, linking, instruction behavior, system calls, and runtime assumptions. AlphaProof Code targets a compiled static ARM64 ELF, so the theorem speaks about instructions in an exact binary rather than trusting a general claim that the compiler preserved a source-level property.
Its semantics covers hundreds of AArch64 instructions and dozens of Linux system calls. DeepMind reports testing the instruction model in lockstep against the Unicorn emulator and Arm-derived Sail semantics, and testing the loader and system-call model against qemu-aarch64. These tests do not mathematically prove that the semantics is perfect. They are validation evidence for definitions that sit inside the trusted computing base.
Hooks are the other critical mechanism. A call to a hooked routine is intercepted and replaced by a trusted contract. That is how the proof represents cryptographic primitives whose real-world security cannot be proved by executing every possible key and attack. Hooks also cover some ordinary routines, including selected output and file-writing behavior. Each hook shortens the executable path that must be symbolically explored, while increasing the behavior that reviewers must accept as an assumption.
The theorem covers selected libsignal scenarios, not “all of Signal”
The paper presents symbolic and computational developments. The symbolic layer reasons about high-level protocol properties under idealized cryptography, including properties such as authentication and forms of forward and post-compromise security. The computational layer uses games and explicit bounds. Both connect through a model of selected libsignal and SPQR behavior to the compiled harness.
The scope is intentionally narrower than the headline “Signal is secure.” The published semantics does not model threads, Unix signals, dynamic linking, the vDSO, or arbitrary files outside the current directory. The assembly-level scenario assumes pinned authentic identity material rather than exercising every trust-on-first-use path. Some cryptographic and protocol components are represented through assumptions or opaque interpretations. The artifact is a major proof of selected implementation properties, not a blanket warranty for every app, platform, UI, storage layer, network service, build, or future release.
| Evidence | What it supports | What it does not support |
| Exact static AArch64 binary | Theorems refer to the modeled instructions in that ELF | Every other build, architecture, client, or future commit |
| Lean kernel accepts proof terms | The theorem follows from the encoded definitions | The theorem statement is complete or operationally sufficient |
| Human-approved specifications | The claim boundary is explicit and reviewable | Humans chose every necessary property or modeled it correctly |
| Hook contracts | Selected calls satisfy their specified abstract behavior | The hooked implementation itself is correct in deployment |
| Two reintroduced historical bugs fail | The specifications are not vacuous for those negative controls | Every possible bug will violate a checked theorem |
| Four-week project duration | AI assistance changed the proof-construction cost in this case | Any team can verify any system in four weeks |
DeepMind’s team strengthened the result by reverse-applying two previously fixed libsignal bugs. The system could prove that those buggy binaries violated the security theorem. This is more valuable than reporting that the positive proof compiles: it tests whether the specification rejects known-bad behavior. A production acceptance process should preserve that pattern and add project-specific mutants.
The focused last30days scan found the repository at 245 stars with three open issues at scan time, but exact HN and Reddit retrieval was sparse or noisy. Current Reddit discussion consistently asked whether the approved specification captures the right thing. That is a useful review question, not evidence of adoption. The paper, artifact, and repository carry the technical claim.
A checked proof moves trust; it does not eliminate it
The trusted computing base begins with theorem statements and every definition they transitively use. For the published work, that includes symbolic and computational models, event and concretization layers, environment restrictions, the AArch64 instruction and memory model, the Linux process model, loader and system-call definitions, hook contracts, and cryptographic assumptions. Lean’s kernel and the toolchain that parses and checks the development also matter operationally.
Review effort should follow trust concentration. Millions of generated proof lines do not deserve line-by-line human reading if the kernel can check them deterministically. The smaller body of specification and semantics deserves deeper review because an error there can make every accepted proof irrelevant. This is analogous to reviewing a compiler’s trusted base rather than every emitted assembly instruction, except that the claim itself is also code.
Keep three kinds of confidence separate. Logical confidence asks whether the theorem follows from the formal definitions. Modeling confidence asks whether those definitions describe the intended protocol, binary, and environment. Deployment confidence asks whether production is actually running the reviewed binary under compatible conditions. A strong result in the first category cannot silently substitute for the other two.
Require a coverage and assumption matrix
| Boundary | Release evidence | Reopen trigger |
| Theorem | Stable ID, exact statement, reviewer rationale | Claim wording or dependent definition changes |
| Executable | ELF digest, architecture, linked objects, build recipe | Any byte, flag, compiler, or dependency changes |
| Semantics | Instruction/syscall coverage and validation report | New instruction, syscall, loader, memory, or OS behavior |
| Hooks | Routine, contract, implementation owner, validation | Contract or hooked implementation changes |
| Cryptography | Idealizations, algebraic laws, randomness assumptions | Primitive, parameter, key flow, or failure behavior changes |
| Environment | Files, identity setup, memory floor, concurrency restrictions | Deployment exceeds modeled scenario |
| Checker | Lean version, lake manifest, dependency digests, clean replay | Kernel, elaborator, plugin, or dependency changes |
Promote a proof-bearing release, not a PDF
A paper can explain a result, but production needs an immutable release object. Start with the claim: the exact theorem IDs and plain-language interpretation the organization intends to rely on. Attach the frozen specification tree and an independent review record. Bind the claim to the exact executable digest, not a repository branch or product version label.
Next, record the modeled environment. Inventory instructions, system calls, loader behavior, memory assumptions, files, identity setup, networking, concurrency, and every unsupported path. Attach the hook registry with implementation owners and validation evidence. A hook that writes output is not “just plumbing” if the release claim depends on what was written.
Then make replay deterministic. Pin Lean, the repository commit, dependency lockfile, build image, proof-check command, CPU architecture, and expected theorem inventory. Run the check in a clean environment that cannot fetch mutable dependencies. Produce a machine-readable result containing proof hashes, theorem counts, admitted axioms or unsafe declarations, elapsed time, failures, and checker logs.
Finally, bind negative controls. Keep known-bad binaries or intentionally weakened specifications that must fail. Mutate a state transition, identity binding, error path, or hooked contract and confirm that the expected theorem becomes unprovable or the binary no longer matches. A proof suite that cannot distinguish a known violation from the accepted release is not ready to authorize a security claim.
claim review
-> specification review
-> exact binary and build attestation
-> semantics + hooks + assumptions inventory
-> clean Lean replay
-> negative-control failures
-> deployment-boundary comparison
-> independent approval
-> signed receipt with expiry
Make every trusted edge visible in the manifest
proof_release: signal-cli-aarch64-2026-11-15.1
claim:
theorem_ids: [symbolic_authentication, symbolic_post_compromise]
plain_language: "Selected CLI scenario meets approved authentication properties"
scope_review_sha256: 6f9a...
artifact:
source_revision: libsignal-v0.105.4
elf_sha256: 31d8...
architecture: aarch64-linux-static
build_recipe_sha256: 4b72...
specification:
tree_sha256: 9f0e...
trusted_lines_reviewed: 26000
reviewers: [protocol-cryptography, formal-methods, product-security]
semantics:
revision: arm-linux-semantics@0c91...
instructions: 467
syscalls: 31
unsupported: [threads, signals, vdso, dynamic-linking]
hooks:
inventory_sha256: 90b1...
contracts_reviewed: true
checker:
lean_version: "pinned-by-lean-toolchain"
lake_manifest_sha256: af10...
clean_replay_log_sha256: 87ee...
negative_controls:
- binary: historical-bug-a.elf
expected: theorem_failure
observed: theorem_failure
- binary: historical-bug-b.elf
expected: theorem_failure
observed: theorem_failure
decision:
status: approved-with-scope
expires: 2026-12-15
rollback_release: signal-cli-aarch64-2026-10-28.3
Do not let a line count become an approval field. The receipt should record hashes and review outcomes for the trusted material, and machine-check the large generated body. “Trusted lines reviewed” means the organization knows which definitions it accepted; it does not mean a reviewer skimmed 26,000 lines and clicked approve.
Store the receipt beside the binary in an immutable registry. The deployment system should verify the binary digest and receipt signature before promotion. Runtime telemetry should emit the proof release ID so an incident responder can identify the exact claim and assumptions attached to a process.
Fail closed when the claim and release stop matching
def accept_proof_release(candidate, deployed):
require(candidate.theorems == approved_theorem_inventory)
require(hash(candidate.spec_tree) == receipt.spec_sha256)
require(hash(candidate.elf) == receipt.elf_sha256)
require(hash(candidate.build_recipe) == receipt.build_sha256)
require(candidate.lean_version == receipt.lean_version)
require(hash(candidate.lake_manifest) == receipt.lake_manifest_sha256)
require(no_unapproved_axioms(candidate))
require(all_hooks_have_owner_and_contract(candidate))
require(clean_replay(candidate).all_theorems_checked)
require(run_negative_controls(candidate).matches_expected_failures)
diff = compare_environment(deployed, receipt.modeled_environment)
require(diff.unsupported_paths == [])
require(receipt.expires_at > now())
require(receipt.named_approvals.complete)
return sign_promotion(candidate, receipt)
The environment comparison is the control most likely to be skipped. A proof about a single-threaded static harness cannot authorize a dynamically linked, concurrent mobile application merely because both contain libsignal. The correct output is not “probably close.” It is a scoped hold and a new verification or complementary assurance plan.
Complementary evidence remains necessary. Fuzzing, memory-safety analysis, supply-chain checks, code review, side-channel testing, integration tests, deployment attestation, and runtime monitoring answer different questions. Formal verification can give unusually strong evidence about stated properties. It should strengthen the evidence portfolio, not erase its other layers.
Worked release: upgrading the compiler without laundering the old proof
A security team has accepted a proof-bearing ARM64 CLI build. A month later, the product team updates the Rust compiler and a transitive dependency to pick up unrelated fixes. Source code under the verified function appears unchanged. The binary digest changes.
- Change detection. Registry policy rejects promotion because the ELF digest and build-recipe hash no longer match the receipt.
- Claim review. The theorem statement and specification tree are unchanged, so human claim review may be reused if dependent definitions are identical.
- Artifact review. The team records the new compiler, flags, dependency graph, object inventory, and binary. A byte-level diff is expected; semantic equivalence is not assumed.
- Replay. The proof is rerun against the new machine code in the pinned checker environment. Every required theorem must check.
- Hook review. The dependency change touches a hooked cryptographic routine. Its contract owner confirms the implementation still satisfies the approved interface and reruns its independent tests.
- Negative controls. The two historical bug binaries and one project-specific identity-binding mutant still fail as expected.
- Deployment comparison. Architecture, linking mode, system-call surface, identity setup, and file restrictions remain inside the modeled scenario.
- New receipt. Reviewers sign a new binary-bound receipt. The old receipt remains valid only for the old digest and is retained for rollback.
The same logic applies to “small” changes in specifications, hooks, build images, proof dependencies, or environment. Reuse evidence explicitly. Never silently transfer an approval to a new object.
Failure modes that a green proof check will not catch by itself
| Failure | Why the proof may stay green | Release control |
| Wrong theorem | The kernel checks the encoded claim, not product intent | Plain-language claim mapping and independent specification review |
| Overbroad hook | Implementation behavior is replaced by a trusted contract | Hook inventory, owner, contract tests, and shrink plan |
| Binary substitution | The proof still checks for the reviewed ELF | Digest-bound registry promotion and runtime attestation |
| Unmodeled deployment path | Threads, dynamic linking, UI, storage, or network behavior sits outside scope | Environment diff and complementary verification |
| Specification drift | Old proof remains valid for old definitions | Spec-tree digest, dependency graph, mandatory reapproval |
| Checker supply-chain drift | Mutable dependencies change the checking environment | Pinned toolchain, offline replay, image and lockfile digests |
| Vacuous or weak property | A theorem can be true without rejecting meaningful bugs | Historical bugs, mutants, falsifiers, coverage review |
| Marketing scope inflation | Technical artifact says less than public wording | Approved claim language linked to theorem IDs |
Proof-bearing release checklist
- Resolve theorem IDs and exact statements; write the permitted plain-language claim.
- Freeze specification, definition, assumption, and semantics trees by digest.
- Bind the proof to an exact executable digest, architecture, build recipe, compiler, flags, and linked objects.
- Inventory every hook, its contract, implementation owner, independent tests, and planned reduction.
- Record idealized cryptography, randomness, identity, memory, file, concurrency, and operating-system assumptions.
- Pin Lean, dependency lockfiles, plugins, checker image, and the clean replay command.
- Reject admitted, unsafe, or unapproved axioms and unexpected theorem-count changes.
- Run historical bugs and purpose-built mutants that must fail.
- Compare the real deployment with the modeled scenario; hold on unsupported paths.
- Require separate formal-methods, domain-security, product-security, and service-owner approvals.
- Sign a receipt with expiry, monitoring, incident owner, and rollback release.
- Reopen the gate after any relevant binary, spec, hook, toolchain, or environment change.
FAQ
Did AlphaProof Code prove all of Signal is secure?
No. It proves published theorems about selected libsignal command-line scenarios compiled to a static AArch64 binary under explicit models, hooks, assumptions, and environment restrictions. The result is substantial precisely because its scope is inspectable.
Why verify machine code instead of stopping at Rust?
A machine-code theorem binds the claim to executable instructions and avoids trusting a general compiler-correctness bridge for that artifact. It introduces other review targets: instruction and OS semantics, loader behavior, hook contracts, and the exact binary identity.
Can an AI-generated proof be trusted?
Lean can reject invalid proof terms regardless of who generated them. Reviewers still need to trust and inspect the theorem, definitions, assumptions, hooks, kernel/toolchain, and artifact mapping. Generation is untrusted search; acceptance is a controlled release decision.
Should formal verification replace fuzzing and tests?
No. They cover different failure classes. Preserve fuzzing, memory-safety checks, supply-chain controls, integration and side-channel testing, deployment attestation, and runtime monitoring around the formally verified core.
When does the receipt expire?
Set a time-based expiry and event-based invalidation. Any relevant binary, source, compiler, dependency, specification, semantics, hook, Lean toolchain, or deployment-boundary change reopens the affected gate.
Sources and further reading
- Google DeepMind: Introducing AlphaProof Code - checked November 15, 2026.
- Google DeepMind: Formal Verification of Signal at the Machine-Code Level - primary paper, checked November 15, 2026.
- AlphaProof Code reviewers' site - theorem, specification, trust-boundary, and limitation material checked November 15, 2026.
- google-deepmind/code-verification - Apache-2.0 proof artifact and toolchain, checked November 15, 2026.
- Repository comparison of prior protocol proofs and the compiled-binary proof - checked November 15, 2026.
- Beneficial AI Foundation: Signal Shot - broader Signal/Lean initiative, checked November 15, 2026.
- Signal documentation: security and verification evidence labels - checked November 15, 2026.
- From Specs to Apps: Verifying and Monitoring Models of Signal and WhatsApp - implementation-model context, checked November 15, 2026.
- A Generic Methodology for Modular Verification of Security Protocol Implementations - prior implementation-verification context, checked November 15, 2026.
- r/artificial discussion of specification scope and implementation coverage - community interpretation checked November 15, 2026; not used as a product-fact source.
Related guides: AI-generated research release contracts, embedded evaluator independence, AI contribution policy enforcement, and artifact adoption contracts.