[anneal][reference] Evaluate proof-producing compilation: 144 research questions

Open
#3,867 0 comments 0 reactions 0 assignees View on GitHub

Maintainers usually reply within 1 day

Nobody has claimed this yet.

Assessment

Difficulty
5/5
Estimated time
Over a week
Newbie friendliness
8/100
Issue type
Documentation
Clarity
Mostly clear
Activity status
Active
Tech stack
rust
Domain
documentation

Research direction

This is a research agenda, not a code change. Start with the linked report reports/proof-producing-versus-validating-translations-1997-2022/REPORT.md on the reference branch, and with the coordination agenda in issue #3865. Pick one assigned question ID, such as P024, and publish an evidence-backed report on reference. Done means the report names its theorems and artifacts and covers the required sections.

Written by the indexing model from the issue text.

Description

Track the research questions proposed for future Anneal development. Each item retains its stable identifier and explains why it is included. These are open research assignments; no item is considered complete until an evidence-backed report covering it is published on reference.

Related agenda: https://github.com/google/zerocopy/issues/3865. A provisional many-to-many grouping and a coverage ledger will coordinate execution across these issues. Group boundaries may change as research discovers better divisions; original question IDs remain stable.

Proof-producing compilation looks like a strong candidate for reducing Anneal’s internal TCB, especially around extraction, abstraction, and verification-condition generation. The closest precedents are tools that produce proofs connecting existing imperative code to easier-to-reason-about models, and verifier frontends that certify their own translations. AutoCorres, Viper frontend certification.

I would extend the reference branch’s existing proof-producing versus validating translations report with the 144 reports below. These are research assignments, rather than claims that the named systems already solve Anneal’s problems. Together they cover the literature, transferable mechanisms, Rust-specific obligations, experiments, and architecture decisions.

The central distinction is what the certificate proves. Different systems establish target-code safety, conformance to a translation relation, semantic preservation, implementation of a specification, or preservation of a particular property. Those guarantees support different conclusions. For example, Plutus’s translation relations provide a useful certificate architecture, but the 2024 paper explicitly separates those certificates from the still-incomplete semantic verification of the pipeline. Plutus certification paper.

For Anneal, the essential implication is approximately:

Checked correspondence(original Rust, generated model)
∧ Checked safety proof(generated model)
∧ Explicit, justified initial-state conditions
⇒ Safety(original Rust)

Ordinary compiler correctness does not automatically provide this implication. A transformation may preserve behavior whenever the source behaves correctly while erasing a source operation that causes undefined behavior. Anneal needs a relation that transfers safety back to the source, a separate source-safety certificate, or another justified combination. The Viper certification work is particularly relevant: its simulation explicitly requires source failures to have corresponding failing target executions. Viper certification methodology.

The PR stack makes representation correspondence another central concern. Its layout, memory, bytes, and storage libraries establish mathematical facts while leaving provenance, access permissions, runtime storage events, and frontend correspondence as separate obligations. A compilation certificate could discharge some of those connections, but a layout theorem alone cannot discharge them. Shared Rust models README.

Every report should identify the exact theorem and artifacts involved; explain certificate generation and checking separately; account for remaining trusted components; distinguish implemented, proved, assumed, and proposed capabilities; include a successful example and a rejected incorrect example; and explain its consequences for Anneal. Implementation reports should pin versions and measure generation time, checking time, certificate size, and memory use. This would preserve the evidence discipline of the reference corpus.

The first thirty reports establish the literature and its distinct mechanisms.

  • P001 — Necula’s Touchstone and “Compiling with Proofs.” Study how compiler analyses and annotations support target-safety proofs, including the supported memory and arithmetic models; this establishes the original certifying-compiler approach. Thesis.
  • P002 — Foundational proof-carrying code. Examine how type-system and safety-policy reasoning becomes checked foundational evidence; this helps distinguish moving trust into a checker from actually reducing it. FPCC project.
  • P003 — Typed assembly and staged certifying compilation. Study type-preserving transformations and certificates for runtime-generated code; these offer alternatives to explicit semantic-equivalence proofs when the desired guarantee is narrower. Typed assembly, runtime code generation.
  • P004 — Certifying code generation with proof schemas. Examine reusable Isabelle proof structures, representation mappings, and global side conditions; schemas may make Anneal’s generated correspondence proofs practical. Blech and Poetzsch-Heffter.
  • P005 — Extensible proof-producing compilation in HOL. Study Myreen’s generation of machine code and subsequent correctness proofs; this demonstrates extensions through proved facts rather than a trusted compiler implementation. Paper.
  • P006 — CakeML’s translation of pure logical functions. Examine certificates connecting shallow logical definitions to deeply embedded programs, including representation invariants; this directly informs how Anneal might certify generated Lean models. Pure and stateful translation.
  • P007 — CakeML’s stateful, exceptional, and I/O synthesis. Study separation-logic framing, local-state encapsulation, and composable effects; these mechanisms matter when a pure interface hides imperative implementation details. Monadic synthesis.
  • P008 — AutoCorres’s proof-producing abstraction. Examine control-flow, machine-word, and heap abstraction from existing C code; this is a close precedent for making unsafe Rust easier to verify without trusting abstraction algorithms. Paper.
  • P009 — Cogent’s certifying compilation. Study the correspondence among pure models, value semantics, update semantics, and C implementations; this addresses the functional-to-imperative connection that Anneal needs. Cogent paper.
  • P010 — Dargent’s certified data-layout refinement. Examine how representation choices change refinement relations while preserving high-level specifications; this is especially relevant to zerocopy’s packed, byte-oriented representations. Dargent paper.
  • P011 — Fiat/Facade’s proof-generating imperative extraction. Study extensible extraction with manually managed memory and separately verified foreign functions; this offers mechanisms for connecting abstraction to existing low-level libraries. Paper and artifact information.
  • P012 — Rupicola’s relational compilation. Examine proof search that constructs both an imperative program and its correctness proof; this could support generating Anneal models, helpers, or checkers through proved compilation lemmas. Thesis.
  • P013 — Sepref and Isabelle-LLVM. Study automated data refinement and separation-logic compilation, including the remaining trust in embeddings and text generation; this exposes the boundary between verified refinement and executable artifacts. LLVM generation paper.
  • P014 — Plutus’s per-pass translation certificates. Examine inductive translation relations, intermediate AST bundles, and certified decision procedures; this offers an incremental architecture for certifying a changing extraction pipeline. Journal paper.
  • P015 — Crellvm’s instrumented LLVM compilation. Study compiler-emitted hints and a formally justified relational checker; this provides a concrete example of certifying actual optimization runs without verifying the optimizer. Paper, artifact.
  • P016 — Certificate translation through optimizations. Examine transporting source-property proofs to transformed programs, including evidence from static analyses; this differs from proving full translation correctness and may reduce Anneal’s required proof burden. Certificate translation paper.
  • P017 — PotPie’s specification-preserving proof compilation. Study compilation of programs, specifications, and proofs when full behavioral preservation is unnecessary; this tests whether Anneal can certify selected properties while independently preserving their meaning. ITP 2024 paper.
  • P018 — CairoZero’s proof-producing compiler. Examine generated specifications, modular proofs, and connection to machine instructions; this illustrates combining generated semantic interfaces with separately authored higher-level specifications. Paper.
  • P019 — Œuf’s validated reflection and serialization. Study how logical functions become compiler inputs with checked correspondence and preserved serialization; this addresses gaps that can remain before an otherwise verified compiler starts. Œuf paper.
  • P020 — Verified compilers using verified validators. Examine the coexistence of verified passes and untrusted optimization algorithms behind verified validators; Anneal may benefit from the same mixed architecture. Instruction-scheduling validators.
  • P021 — CertiCoq/CertiRocq, MetaRocq, and certified extraction. Compare reification, erasure, compilation, printing, and foreign interfaces; these systems help evaluate whether Anneal’s checker implementation can inherit stronger guarantees. CertiRocq, MetaRocq.
  • P022 — Boogie’s proof-producing verification pipeline. Study certificates for loop elimination, passification, and VC generation; these are precedents for certifying Anneal’s obligation-generation machinery. Boogie certification paper.
  • P023 — Certification of Viper-to-Boogie translation. Examine failure preservation, heap encoding, generated axioms, and non-local proof dependencies; this directly addresses verifier translation soundness across a substantial semantic gap. Frontend certification paper.
  • P024 — Proof-generating Rust specification DSLs. Study Verdict’s generation of specifications, executable code, and proofs, including the binding to the original DSL; this informs future Anneal annotations and specification compilation. Verdict paper.
  • P025 — CryptOpt’s untrusted search and verified checking. Examine optimization by randomized search behind a verified equivalence checker; this shows how expensive or unpredictable generation can remain outside the trusted core. CryptOpt paper.
  • P026 — Automatically deriving certified relation checkers. Study generation of checkers and their correctness proofs from inductive relations; this could reduce the effort needed to maintain certificates for many extraction passes. Computing Correctly with Inductive Relations.
  • P027 — Trivet’s Lean-based LLVM validation. Assess proof scaffolding, automated discharge, LLM-assisted proof construction, and the exact supported semantics; this is an emerging candidate for reducing correspondence-proof engineering costs. 2026 preprint.
  • P028 — EquiVM’s post-hoc artifact refinement. Study proofs relating concrete bytecode to independently stated specifications, including interaction with unknown code; this tests an architecture that needs little cooperation from the original compiler. 2026 preprint.
  • P029 — Owlang and compositional open safety. Examine cooperation between verified compilation, ownership checking, and heterogeneous modules; this helps connect safe-language guarantees with separately proved unsafe components. Open-safety paper.
  • P030 — RustCompCert’s developing Rust compilation chain. Assess its source fragment, semantics, borrow-checking guarantees, and remaining gaps; this determines what Rust-oriented verified compilation could contribute to Anneal. 2026 preprint.

Reports P031–P042 determine the guarantees Anneal actually needs before choosing a certificate technology.

  • P031 — A taxonomy of certificate conclusions. Separate target safety, translation conformance, equivalence, refinement, specification preservation, and source safety; otherwise seemingly comparable approaches may answer different questions.
  • P032 — Safety reflection from model to Rust. Formulate the precise relation under which model safety implies source safety; this is the central requirement for replacing trusted extraction.
  • P033 — Certificates for the first invalid source operation. Investigate preserving every execution prefix up to its first failure; this may establish source safety without assuming the entire source execution is defined.
  • P034 — Initial-state and input-domain correspondence. Determine which source states have model representations and prove coverage of permitted inputs; this prevents safety proofs from silently excluding legitimate callers.
  • P035 — Undefined behavior, unsupported constructs, and translation failure. Define their distinct meanings and acceptance consequences; a certificate must never turn missing semantic support into a successful safety claim.
  • P036 — Nondeterministic abstraction. Compare exact models with conservative sets of possible executions; overapproximation may simplify certification while increasing the burden of proving properties.
  • P037 — Choosing semantic relations. Compare forward simulation, backward simulation, bisimulation, logical relations, and contextual refinement against Anneal’s required direction of reasoning.
  • P038 — Composition of heterogeneous pass certificates. Establish how relations compose across changing state and language representations; individually sound passes need a justified end-to-end theorem.
  • P039 — Correspondence for open modules. Study behavior under arbitrary compatible callers and callees; function proofs must survive integration into safe Rust contexts.
  • P040 — Adequacy of the final proof language. Connect generated Lean terms, program logic, and execution semantics; checking a theorem requires knowing what that theorem says about Rust.
  • P041 — Property-specific correspondence. Determine when UB freedom, functional correctness, resource bounds, or security require different relations; one certificate interface may not support every future Anneal property.
  • P042 — Preventing circular semantic assumptions. Track the origins of safety, typing, ownership, and representation premises; the property Anneal is proving cannot also justify its translation.

Reports P043–P054 compare ways to produce certificates while keeping the production machinery untrusted.

  • P043 — Compiler-instrumented certificate generation. Evaluate emitting hints, witnesses, and intermediate programs from existing passes; this may provide the best access to transformation decisions.
  • P044 — Independent post-hoc certifiers. Evaluate reconstructing correspondence from input and output artifacts alone; this reduces coupling to compiler internals and supports multiple compiler versions.
  • P045 — Constructive translation through proof search. Investigate generating a model together with its correspondence proof; this makes successful translation a consequence of proof construction.
  • P046 — Transporting property proofs instead of proving full equivalence. Determine which Anneal obligations can survive translation through narrower certificates; this may substantially reduce proof complexity.
  • P047 — Conservative embedding followed by certified abstraction. Compare a literal low-level model with proof-producing simplification; this concentrates trust in a simpler import boundary.
  • P048 — Inductive specifications of admissible transformations. Design relations describing acceptable pass outputs without reproducing the pass algorithm; this allows implementation changes behind stable semantic rules.
  • P049 — Proof schemas and explicit side-condition witnesses. Compare reusable templates with expanded proof terms; schemas may reduce certificate size while keeping difficult global conditions visible.
  • P050 — Deriving checkers from transformation relations. Assess automatic generation of sound decision procedures and completeness proofs; this could make certification affordable across a large pass inventory.
  • P051 — Reflection and computation during checking. Compare kernel reduction, proved Boolean checkers, and native execution; these choices change both checking performance and the remaining trusted execution path.
  • P052 — Decompilation and symbolic execution as certifiers. Investigate recovering semantic descriptions from generated artifacts; this can validate outputs without reproducing the original translation strategy.
  • P053 — Certificates for compiler analyses. Study checked range, alias, liveness, ownership, and invariant information; transformations often depend on analysis results that also need justification.
  • P054 — Extensible proof-producing translation rules. Design extension interfaces for lemmas, tactics, solvers, and staged specialization; new capabilities should require checked evidence rather than new trusted algorithms.

Reports P055–P066 address the boundary between actual Rust compilation and Anneal’s first formal program representation.

  • P055 — Selecting the first certified Rust representation. Compare source syntax, elaborated syntax, promoted MIR, and later MIR; the choice determines which frontend transformations remain trusted.
  • P056 — Parsing, preprocessing, and conditional compilation. Establish correspondence for the exact configured source; certification of the wrong feature-selected program provides the wrong guarantee.
  • P057 — Macros, procedural macros, and generated source. Determine how expansion artifacts enter the certified subject and dependency closure; executable generated code must receive the same coverage as handwritten code.
  • P058 — Resolution, typing, and implementation selection. Investigate certificates for names, overloads, traits, and instantiated types; semantic identity depends on which declarations were actually selected.
  • P059 — Borrow-checking and ownership-checking evidence. Separate compiler acceptance from a checked semantic safety theorem; Anneal needs explicit accounting for guarantees inherited from Rust’s static checks.
  • P060 — Elaboration of implicit Rust behavior. Inventory coercions, autoref/autoderef, lifetimes, and compiler-inserted operations; hidden elaboration can change the obligations attached to source expressions.
  • P061 — Importing versioned MIR into logic. Specify syntax schemas, well-formedness, and semantic interpretation; silently misreading a changed compiler representation must be impossible.
  • P062 — Certification before UB-sensitive optimization. Determine which snapshots retain the source’s safety obligations; late optimized artifacts may omit operations Anneal needs to analyze.
  • P063 — Compiler-inserted assertions, drops, and cleanup. Study correspondence for operations absent from surface syntax; source safety includes behavior introduced during elaboration.
  • P064 — Constant evaluation and promoted allocations. Certify values, allocation contents, failures, and initialization assumptions; compile-time execution affects the runtime program being proved.
  • P065 — Complete executable dependency closure. Include intrinsics, compiler-generated functions, vtables, destructors, and inline assembly boundaries; omission of reachable behavior invalidates an aggregate claim.
  • P066 — Target configuration and ABI correspondence. Bind pointer widths, endianness, layouts, target features, and calling conventions; proofs must apply to the selected compilation environment.

Reports P067–P078 focus on certifying Charon/Aeneas-style transformations and the resulting Lean model.

  • P067 — A certificate inventory for every extraction pass. Map actual input/output boundaries and required semantic lemmas; this identifies where incremental certification can begin and where gaps remain.
  • P068 — Renaming, substitution, and binding. Certify variable identities and capture avoidance; apparently administrative transformations can silently alter program meaning.
  • P069 — Control-flow reconstruction. Connect MIR blocks and jumps to structured conditionals and loops; correctness must account for every exit and exceptional edge.
  • P070 — Local-state elimination and SSA-like transformations. Certify tuple-passing, fresh variables, and state updates; generated pure functions must retain dependencies between imperative operations.
  • P071 — Loop-to-recursion translation. Compare invariants, recursive equations, fuel, and divergence semantics; bounded execution or accidental termination cannot substitute for the original loop.
  • P072 — Function extraction, closures, and captured environments. Certify extracted helpers and closure representations; code movement must preserve captured state, call behavior, and identity where observable.
  • P073 — Borrow abstraction and backward functions. Establish correspondence for Aeneas-style borrow elimination and returned updates; this is a distinctive semantic obligation rather than ordinary value translation.
  • P074 — Machine scalars to mathematical values. Certify word widths, signedness, overflow, and conversions; abstract arithmetic must expose every required machine-level side condition.
  • P075 — Algebraic data and pattern-match lowering. Connect Rust discriminants and representations to model constructors; exhaustive mathematical matches can conceal invalid concrete representations.
  • P076 — Primitive replacement and external contracts. Require checked correspondence for each replaced operation; a convenient specification cannot become a trusted substitute for an unproved implementation.
  • P077 — Generated Lean definitions and their denotation. Connect emitted definitions to the intended program semantics, including monadic failures; syntactically valid Lean is only the final representation step.
  • P078 — Certified simplification and optimization rules. Study constant folding, dead-code removal, inlining, loop transformations, and rewriting; every rule needs the side conditions appropriate to safety reflection.

Reports P079–P090 address the concrete memory and representation facts that unsafe Rust adds to compilation correspondence.

  • P079 — Pointer provenance across representation changes. Determine how certificates retain allocation identity and provenance when pointers become addresses, indices, or abstract references.
  • P080 — Ownership, permissions, and separation. Connect source memory access rights to model assertions; numerical bounds alone do not justify reads or writes.
  • P081 — Compiler realization of mathematical layouts. Relate actual Rust sizes, alignments, and offsets to the shared layout model; this supplies the bridge deliberately absent from pure geometry proofs.
  • P082 — Packed fields and unaligned access. Certify distinctions among addresses, raw accesses, and reference formation; layout agreement does not establish legality of typed access.
  • P083 — Initialization, padding, and uninitialized bytes. Preserve which bytes may be observed and when; abstract encodings must not accidentally manufacture initialized storage.
  • P084 — Value validity, niches, and discriminants. Connect byte representations to valid Rust values; decoder success must establish the validity conditions required by subsequent typed operations.
  • P085 — Typed moves, copies, reads, and writes. Certify runtime storage events and their effects on initialization and ownership; pure byte concatenation does not model these operations.
  • P086 — Allocation, deallocation, and reallocation. Track object lifetimes, address reuse, allocation failure, and ownership transfer; correspondence must remain sound as the heap changes.
  • P087 — Pointer casts, arithmetic, and integer exposure. Determine which operations preserve semantic information and which require additional obligations; arithmetic equalities cannot recover discarded provenance.
  • P088 — Slices, DST metadata, and zero-sized values. Certify length, metadata, bounds, and special address behavior; these cases challenge simple one-value/one-memory-region correspondence.
  • P089 — Heap abstraction and alias identity. Compare byte heaps, typed heaps, and pure collections; abstraction must preserve relevant overlap and aliasing relationships.
  • P090 — Interior mutability and memory-state projections. Establish which mutations remain observable through shared references and abstract views; projecting away state must not remove required safety obligations.

Reports P091–P102 cover effects and execution behavior that can defeat otherwise plausible correspondence proofs.

  • P091 — Partial arithmetic and floating-point operations. Certify division, shifts, overflow modes, and floating-point semantics; equality of successful results does not establish equal failure behavior.
  • P092 — Assertions, panics, and UB as distinct outcomes. Define outcome-preserving certificates; merging these behaviors may invalidate safety conclusions or future behavioral properties.
  • P093 — Evaluation order and short-circuiting. Preserve ordering of effectful and partial operations; rearranging equivalent expressions can introduce or conceal failures.
  • P094 — Divergence and discarded unsafe computations. Investigate UB before nontermination or before an unused result; a return-value theorem provides no coverage of these executions.
  • P095 — Unwinding, cleanup, and destructor execution. Certify exceptional paths and partially initialized objects; normal-return correspondence leaves substantial Rust behavior unaccounted for.
  • P096 — Globals, statics, and thread-local state. Model initialization, persistence, and mutation across calls; function-local models may omit state needed for safety.
  • P097 — Callbacks, reentrancy, and unknown code. Specify environment interactions during a call; temporarily broken invariants can become observable through callbacks.
  • P098 — Atomics and weak memory. Determine what execution relations must preserve when operations have ordering constraints and multiple possible observations.
  • P099 — Data races and shared-memory ownership. Connect concurrency certificates to Rust’s race-freedom obligations; sequential correspondence cannot establish concurrent safety.
  • P100 — Progress and infinite executions. Study stuttering, fairness, blocking, and termination transfer; erased steps require more than finite-result agreement.
  • P101 — Resource failures and execution limits. Account for allocation failure, stack exhaustion, and explicit bounds; finite mathematical models may hide executable failure conditions.
  • P102 — Preservation of security properties. Assess constant-time behavior, information flow, and other properties involving multiple executions; ordinary functional correspondence may be too weak for future extensions.

Reports P103–P114 study modular certificates and the compilation of specifications themselves.

  • P103 — Reusable function correspondence certificates. Define interfaces supporting separate checking and reuse; whole-program certificates may be unnecessarily expensive and difficult to maintain.
  • P104 — Safe APIs and universal caller coverage. Prove that contracts cover every permitted safe caller; narrowing model domains must not introduce hidden caller obligations.
  • P105 — Unsafe preconditions and caller discharge. Separate legitimate unsafe requirements from assumptions that conceal implementation defects; certificates must show where each requirement is established.
  • P106 — Generic and const-generic certificates. Compare parametric proofs with per-instantiation certification; representation and arithmetic obligations may depend on types, constants, and targets.
  • P107 — Trait contracts and selected implementations. Connect abstract method specifications to actual implementations; a trait-level theorem is insufficient without justified implementation correspondence.
  • P108 — Dynamic dispatch and higher-order interfaces. Study certificates for vtables, function pointers, closures, and quantified callback contracts; modularity must account for the actual callable environment.
  • P109 — FFI and separately verified libraries. Relate calling conventions, memory representations, and foreign contracts; cross-language composition needs semantic bridges at each boundary.
  • P110 — Separate compilation, linking, and specialization. Preserve certificates as modules are linked or specialized; locally correct artifacts must remain correct in the assembled program.
  • P111 — Mutual recursion and certificate dependency cycles. Establish sound simultaneous reasoning and invariant dependencies; certificates must not justify each other through circular assumptions.
  • P112 — Binding generated specifications to original specifications. Investigate independent checking when one generator emits both implementation and specification; matching mistakes in both outputs must not pass unnoticed.
  • P113 — Certified obligation and VC generation. Prove that discharged generated obligations imply all required source properties; correct proofs of an incomplete obligation set remain insufficient.
  • P114 — Composition across proof systems and logics. Connect Lean certificates with Iris, Rocq, HOL, Verus, or Creusot results; imported theorems need compatible semantics and explicit assumption accounting.

Reports P115–P126 address whether the certificates actually shrink Anneal’s trusted execution path and remain usable at scale.

  • P115 — Certificate formats and semantic interfaces. Compare proof terms, traces, AST bundles, and relation witnesses; the format determines checker complexity, portability, and evolution costs.
  • P116 — Binding certificates to actual artifacts. Establish how the checker identifies exact source, intermediates, models, and configuration; correspondence about different artifacts provides no assurance.
  • P117 — Verified serialization and deserialization. Preserve the same formal program across files and process boundaries; printing and parsing can otherwise reintroduce trusted translations.
  • P118 — Binding semantic libraries and proof dependencies. Identify the definitions and lemmas used by a certificate; checking against substituted or incompatible semantics changes its meaning.
  • P119 — Assumption and axiom accounting. Audit certificates, imported declarations, and computation mechanisms; a kernel-accepted result may still depend on assumptions Anneal intends to eliminate.
  • P120 — Proof-producing generation of checker implementations. Explore deriving executable checkers from verified logical definitions; this connects compilation research directly to Anneal’s internal TCB.
  • P121 — Checker runtimes, parsers, memory, and I/O. Extend correctness from the logical checking function to its executable wrapper; small logical kernels can still have substantial trusted surroundings.
  • P122 — Certified aggregation of the final Anneal claim. Check function coverage, dependency closure, property selection, and certificate composition; successful individual checks must justify the exact reported claim.
  • P123 — Certificate compression and shared proof structure. Compare DAGs, schemas, abbreviations, and reconstruction; reduced storage must not require trusting a semantic decompressor.
  • P124 — Incremental checking and invalidation. Define safe reuse after source, configuration, library, or semantics changes; stale certificates must never validate changed subjects.
  • P125 — Scaling generation and checking independently. Measure both costs on realistic programs; a tiny checker may still be unusable if certificates are enormous or expensive to produce.
  • P126 — Failure behavior of certificate infrastructure. Specify rejection on unsupported cases, malformed evidence, timeouts, and producer failure; incomplete proof production must preserve Anneal’s fail-closed behavior.

Reports P127–P138 make the alternatives concrete through prototypes and discriminating experiments.

  • P127 — A minimal Rust-to-model certificate prototype. Certify a small pre-optimization fragment end to end; this reveals the minimum semantics, artifact binding, and reusable lemmas required.
  • P128 — Certificates for a real Charon pass sequence. Use actual intermediate artifacts from one zerocopy example; this tests whether per-pass certification fits the existing pipeline.
  • P129 — An Aeneas borrow-translation prototype. Certify one representative borrow/update transformation; this tests a central semantic feature before extending to raw memory.
  • P130 — A layout correspondence prototype using the PR stack. Connect concrete Rust layout observations to shared mathematical theorems; this measures the effort needed to replace current correspondence premises.
  • P131 — A runtime bytes/storage correspondence prototype. Relate an actual memory operation to encoding and initialization models; this tests the gap between pure byte facts and unsafe Rust execution.
  • P132 — Instrumented, post-hoc, and constructive translation comparison. Implement the same task three ways; compare theorem strength, engineering effort, maintenance, and performance.
  • P133 — An optimization and UB-erasure counterexample suite. Include removed failures, reordered partial operations, inlining, and divergence; this distinguishes source-safety certification from ordinary refinement.
  • P134 — Modular certificate substitution experiments. Replace implementations, contracts, targets, and generic instantiations; the checker should reject every semantically mismatched combination.
  • P135 — A safe-wrapper domain-coverage experiment. Use a safe API over unsafe representation operations; demonstrate that certification covers all permitted callers and rejects artificially narrowed models.
  • P136 — A generated checker implementation prototype. Compare kernel checking with a proof-produced executable checker; measure actual trust reduction alongside performance and integration costs.
  • P137 — Certificate mutation testing. Corrupt endpoints, omit callees, weaken assertions, insert assumptions, and reuse stale evidence; this tests the full acceptance path rather than only proof syntax.
  • P138 — A realistic zerocopy case study across targets. Measure certificate generation, checking, reuse, and supported behavior on a meaningful API; this tests whether small-example results survive practical complexity.

The final six reports turn the evidence into competing Anneal designs.

  • P139 — A minimal Rust semantics with certified abstraction layers. Evaluate concentrating trust in conservative import while certifying all later simplification; determine whether this creates a manageable foundational boundary.
  • P140 — Incremental certification of the existing extraction pipeline. Plan pass-by-pass coverage of Charon, Aeneas, and model generation; identify useful intermediate milestones and their remaining assumptions.
  • P141 — A compiler-independent correspondence service. Evaluate a standalone certifier accepting versioned Rust and model artifacts; determine whether portability offsets more difficult reconstruction.
  • P142 — Property-specific certificates versus general correspondence. Compare narrower UB-safety certificates with reusable semantic relations; determine where reduced proof effort would constrain future Anneal properties.
  • P143 — A mixed architecture of verified components and proof-producing components. Assign verified algorithms, checked witnesses, interpretation, and untrusted search to appropriate stages; minimize total trust without requiring one technique everywhere.
  • P144 — An adoption plan with explicit trust-reduction gates. Specify prerequisites, prototypes, maintenance costs, and acceptance criteria; each claimed TCB reduction should correspond to a demonstrated discharged obligation.

I would start with P008, P009–P010, P012, P014, and P022–P023, alongside P032–P034. That combines the most relevant precedents with Anneal’s required safety-transfer theorem. Then I would build P127, P130, P133, and P135: a small certified translation, a representation bridge using the existing stack, and two experiments designed to expose inadequate guarantees. Those results should drive the architecture comparison in P139–P143.

Published reports and checklist interpretation

All questions in this issue have published scope assessments in the final all-364 crosswalk, with the 89-report index and acceptance/TCB synthesis. The corpus and its exact committed crosswalk passed validation at 9968d4e4.

Checked boxes mean that the requested bounded research scope has a published answer with explicit evidence and limits. They do not mean that future Anneal implements every proposed design or discharges the 24 acceptance obligations. The three stronger prototype outcomes R095/P127/P131 remain open across the original issues: the complete strict-SMT four-law acceptance and the source/import and physical-memory interpretation bridges were not established. Their experiments/reports were performed and the negative boundaries are retained. No standalone report remains unwritten or unpublished. Named-tool compatibility, compiled proof closure and production cost unknowns remain visible per question.

Authored by an AI agent acting on joshlf's behalf.

Dominant language
Rust
Stars
2.6k
Forks
194
Avg merge
18h 15m
Merged PRs (30d)
14

Getting set up

First steps

  1. Read the whole issue, then the project's contributing guide.
  2. Comment on the issue to say you are picking it up — it saves two people doing the same work.
  3. Fork the repository and make your change on a branch.
  4. Open a pull request that references the issue number.

More from google/zerocopy

All issues in google/zerocopy

Similar issues

More Rust issues

Get new issues in your inbox

A short digest of beginner-friendly GitHub issues.