Software assurance | November 15, 2026

AlphaProof Code makes proof generation cheap. Proof acceptance is now the hard part.

Millions of Lean lines are not the release boundary. Accept the approved theorem, exact machine code, processor and OS semantics, hooked routines, cryptographic assumptions, replay environment, negative controls, and expiry as one versioned evidence package.

Exact binary Reviewed specification Hook inventory Reproducible replay Sources checked Nov 15
A theorem specification, machine-code binary, semantics, assumptions, and Lean checker converging on a versioned proof receipt

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.

EvidenceWhat it supportsWhat it does not support
Exact static AArch64 binaryTheorems refer to the modeled instructions in that ELFEvery other build, architecture, client, or future commit
Lean kernel accepts proof termsThe theorem follows from the encoded definitionsThe theorem statement is complete or operationally sufficient
Human-approved specificationsThe claim boundary is explicit and reviewableHumans chose every necessary property or modeled it correctly
Hook contractsSelected calls satisfy their specified abstract behaviorThe hooked implementation itself is correct in deployment
Two reintroduced historical bugs failThe specifications are not vacuous for those negative controlsEvery possible bug will violate a checked theorem
Four-week project durationAI assistance changed the proof-construction cost in this caseAny 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

BoundaryRelease evidenceReopen trigger
TheoremStable ID, exact statement, reviewer rationaleClaim wording or dependent definition changes
ExecutableELF digest, architecture, linked objects, build recipeAny byte, flag, compiler, or dependency changes
SemanticsInstruction/syscall coverage and validation reportNew instruction, syscall, loader, memory, or OS behavior
HooksRoutine, contract, implementation owner, validationContract or hooked implementation changes
CryptographyIdealizations, algebraic laws, randomness assumptionsPrimitive, parameter, key flow, or failure behavior changes
EnvironmentFiles, identity setup, memory floor, concurrency restrictionsDeployment exceeds modeled scenario
CheckerLean version, lake manifest, dependency digests, clean replayKernel, 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.

  1. Change detection. Registry policy rejects promotion because the ELF digest and build-recipe hash no longer match the receipt.
  2. Claim review. The theorem statement and specification tree are unchanged, so human claim review may be reused if dependent definitions are identical.
  3. 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.
  4. Replay. The proof is rerun against the new machine code in the pinned checker environment. Every required theorem must check.
  5. 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.
  6. Negative controls. The two historical bug binaries and one project-specific identity-binding mutant still fail as expected.
  7. Deployment comparison. Architecture, linking mode, system-call surface, identity setup, and file restrictions remain inside the modeled scenario.
  8. 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

FailureWhy the proof may stay greenRelease control
Wrong theoremThe kernel checks the encoded claim, not product intentPlain-language claim mapping and independent specification review
Overbroad hookImplementation behavior is replaced by a trusted contractHook inventory, owner, contract tests, and shrink plan
Binary substitutionThe proof still checks for the reviewed ELFDigest-bound registry promotion and runtime attestation
Unmodeled deployment pathThreads, dynamic linking, UI, storage, or network behavior sits outside scopeEnvironment diff and complementary verification
Specification driftOld proof remains valid for old definitionsSpec-tree digest, dependency graph, mandatory reapproval
Checker supply-chain driftMutable dependencies change the checking environmentPinned toolchain, offline replay, image and lockfile digests
Vacuous or weak propertyA theorem can be true without rejecting meaningful bugsHistorical bugs, mutants, falsifiers, coverage review
Marketing scope inflationTechnical artifact says less than public wordingApproved 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

Related guides: AI-generated research release contracts, embedded evaluator independence, AI contribution policy enforcement, and artifact adoption contracts.