[anneal][reference] Execute remaining experiments and discharge source, memory and assembly proof goals

Đang mở
#3,876 0 bình luận 0 reaction 0 người được giao Xem trên GitHub

Maintainer thường phản hồi trong vòng 1 ngày

Chưa có ai nhận issue này.

Đánh giá

Độ khó
5/5
Thời gian dự kiến
Hơn một tuần
Mức phù hợp với người mới
5/100
Loại issue
Tính năng
Độ rõ ràng
Cần làm rõ
Mức độ hoạt động
Sôi nổi
Công nghệ
rust
Lĩnh vực
compilers, security

Hướng nghiên cứu

This is a tracking issue for research, proof and experiment milestones, not a code change. Start from the linked synthesis REPORT.md and coverage-matrix.json, which hold the starting evidence, and pick a single milestone that names a concrete artifact. Done means a recorded execution or checked theorem with its commands, inputs, outputs and controls published, not a report.

Do mô hình lập chỉ mục viết ra từ nội dung của issue.

Mô tả

Execute the remaining Anneal experiments and proof goals

The research reports in #3873/#3874 are published. This issue tracks the additional execution, prototype and mechanized-proof work requested afterward. The published synthesis and its 52-question frontier crosswalk provide the exact starting evidence. All 52 MR/AS topics remain represented below. R095/P127/P131 also remain in #3865/#3867.

Why this work remains

Existing model proofs, bounded native/compiler experiments and literature findings leave separate source/import, logic adequacy, resource/ABI, ISA/access and executable-identity connections. Each milestone names an actual execution or theorem that can close one of those gaps. Backend alternatives remain separately evaluated; compatible theorem domains and assumptions must be established before comparison or composition.

Acceptance and execution discipline

An experiment requires actual recorded execution and appropriate controls; a proof requires a checked theorem at the stated source/model/resource/artifact domain. Partial results, failed runs and research reports do not close stronger proof milestones. If a goal is false or inaccessible, preserve evidence and keep its required resolution explicit; do not silently weaken it.

Keep actual upstream execution, owned models, source inspection, native observations and checked theorems distinct. Record immutable subjects, full commands/statuses and useful inputs/outputs, exact theorem directions/quantifiers/axioms, negative controls, scope and revalidation. Publish reviewed coherent results to reference. Mark individual milestones only after authoritative evidence is published and read back. A missing tool, inaccessible artifact or failed proof is not successful completion. Retain the original broader goal when a narrower prototype succeeds.

Execution milestones

  • E01 — Restore and verify required pinned toolchains and build environments. (experiment; MR03, MR05, MR19, MR20, AS01, AS18, AS19, AS20, AS21, AS22) Record exact component/source identities and successful version/build checks in isolated environments, with disk/build limits and no silent version substitution.

  • E02 — Obtain previously inaccessible exact formal artifacts. (experiment; MR03, MR11, MR12, MR19) Acquire Specr2, lambdaTB and relevant Simuliris artifacts at identified revisions; inspect actual theorem statements/dependencies. An access failure remains open, separately recorded.

  • E03 — Replay selected existing mechanizations and assumption closures. (experiment; MR01, MR12, MR18, MR19, AS01, AS19, AS22) Freshly check the actual modular-effects/Rust logic/ISA proof artifacts, recording kernels, imports, axioms, admissions and scope. Source Qed and successful builds alone do not meet theorem-replay acceptance.

  • E04 — Implement independently bound configured-source capture. (prototype; MR05, MR21, MR22, AS06, AS12, AS24) Bind source, target, features, resolved implementations/instances, expanded and compiler-generated owners, constants and reachable dependencies; wrong-item/configuration/instance and omitted-owner controls reject.

  • E05 — Run the actual pinned minimize pipeline on paired source cases. (experiment; MR02, MR03, MR05, MR07, MR16, MR17, MR20) Preserve Rust, MIR/pass settings, generated MiniRust and actual outcomes for representation, aliasing, library and cleanup cases; include erasure/omission controls and classify operational failure separately.

  • E06 — Run real MiniRust/Miri disagreement comparisons. (experiment; MR08, MR11, MR13, MR14, MR20) Execute matched cases with recorded model/target/options and outcome interpretation, covering retags, protectors, provenance, allocation reuse, zero-sized/dead ranges and races; bounded execution is not universal equivalence.

  • E07 — Execute a-mir-formality judgments and code generation. (experiment; MR05, MR21, MR22) Exercise generic dispatch/normalization, safe/unsafe calls and trusted-body versus codegen rejection; retain feature/generated-body census and actual accepted/rejected judgments.

  • E08 — Extend real target and layout observations. (experiment; MR09, MR10, MR21) Run a big-endian target and relevant integer, FP, DST, niche, vtable and mask cases; bind compiler/layout/target identities and distinguish emulation, compilation and native execution.

  • E09 — Execute selected standard-library and environment routes. (experiment; MR05, MR16, MR17, MR22) Inspect actual minimize for unaligned access, copies, allocation/reallocation, required constants and Drop; exercise allocation failure and foreign callback cases with safe bounds and explicit environment contracts.

  • E10 — P127: certify a real minimal Rust-source-to-model fragment. (proof; MR02, MR05, MR21, MR24) Check a theorem for the actual independently selected pre-optimization Rust fragment and its translation, including first-bad-prefix/source-safety reflection and exact artifact/claim binding. A hand-imported model premise does not close this goal.

  • E11 — Provide a verified Specr elaboration/import route. (proof; MR02, MR03, MR19) Specify accepted source/recursive definitions, resolution and supported effects; check translation correctness/coverage with unsupported constructs rejected. Rust typechecking of generated code is insufficient.

  • E12 — Exercise actual exposed-provenance and mixed-choice cases. (experiment; MR04, MR08, MR20) Run the real implementation where supported and preserve unsupported predict behavior explicitly; test bad demonic branches, continuation-sensitive angelic witnesses and empty behavior without conflating sampling with validity.

  • E13 — Give predictive mixed-choice semantics and adequate checking. (proof; MR03, MR04, MR08) Mechanize the required game/continuation semantics, UB/divergence/empty behavior distinctions and sound certificate rules over all required choices.

  • E14 — Instantiate modular handlers for MiniRust state and effects. (proof; MR12, MR14, MR19) Check concrete handlers, coupled byte/alias/race state invariants, composition and adequacy; preserve environmental/nondeterministic quantifiers.

  • E15 — Establish general representation/copy laws with justified invariants. (proof; MR06, MR07, MR10) Prove scalar/array/enum/union codec and typed/byte-copy laws over the selected full semantic fragment; justify enum tagger/discriminator and wide-pointer chunk invariants from actual imports.

  • E16 — Verify dynamic layout, niches and validity extraction. (proof; MR06, MR09, MR10, AS06) Relate compiler layout/vtables and recursive DST/niche/mask facts to accepted model definitions, including initialization, padding and invalid values.

  • E17 — Prove joint provenance/alias/allocation correspondence. (proof; MR08, MR10, MR11, AS07) Handle wildcard/exposed provenance, liveness, deallocation/reuse, address bounds and zero-size behavior without deriving authority from numeric equality.

  • E18 — Prove unbounded Tree Borrows and memory simulation. (proof; MR11, MR12, MR13) Connect actual selected MiniRust/Miri/calculus transitions, trees, retags, ranges and protectors; finite table transcriptions do not discharge operational equivalence.

  • E19 — P131: connect an actual memory operation to storage and initialization. (proof; MR06, MR07, MR17, MR24, AS07) Prove the selected Rust load/store/copy operation implements byte/storage/provenance/initialization laws under independently justified live-resource premises; pure encoding equality alone is insufficient.

  • E20 — Construct a byte- and alias-sensitive MiniRust lifetime logic. (proof; MR01, MR12, MR13, MR18) Mechanize state interpretation, resources, protectors, UnsafeCell masks and adequacy for the required MiniRust fragment, identifying every imported model relation.

  • E21 — Establish alias/race composition and machine adequacy. (proof; MR11, MR14, MR15) Prove race access completeness/commutation or the appropriate replacement relation, including implicit alias effects and complete widths.

  • E22 — Construct the required relaxed-memory resource logic. (proof; MR14, MR15, AS25) Extend byte/alias semantics with views, atomicity, interference and synchronization; justify Rust-specific premises and a reclamation example rather than transferring C11 theorems by name.

  • E23 — Port real allocation, splitting and interior-mutability APIs. (experiment; MR01, MR12, MR13, MR18, MR22) Check concrete allocation, split/recombine, recursive-reborrow, Cell/callback and returned-reference proofs in the selected logic; preserve underlying implementation identities and failed ports.

  • E24 — Establish functional/spatial proof transport and safe-client soundness. (proof; MR01, MR18, MR22, MR24, AS15) Prove the selected API abstraction for every permitted safe client, lifetime and implementation/trait instance; provide the actual operational/resource relation between adopted semantics.

  • E25 — Prove source Drop/unwind and exceptional resource restoration. (proof; MR13, MR16, MR17, MR22, AS13) Cover generated cleanup, protector exits, normal return, panic/abort and double-panic/runtime policy for the declared fragment; restore caller invariants on every permitted exit.

  • E26 — Extend source elaboration and library coverage. (proof; MR02, MR05, MR16, MR17, MR21, MR22) Mechanize required traits/GATs, macros/configuration, temporaries/patterns, closures/generated async/drop, intrinsics, allocator/runtime and safe/foreign caller contracts; explicit partial support does not close broader claims.

  • E27 — Replay Kraken on its requested toolchain and extend ISA validation. (experiment; AS01, AS04, AS08, AS17, AS28) Check selected actual proofs on the recorded requested nightly, and extend independent/reference/native validation to motivated X64/A64 forms, faults, overlaps and SIMD with exact supported scope.

  • E28 — Build checked assembly parsing/layout/byte certificates. (proof; AS02, AS03, AS16, AS17) Prove the admitted source/parser/preprocessor/printer and AST/encoding/decoding/layout relations; bind exact entry, ranges, labels and unsupported syntax. Data/directive erasure must not silently change subjects.

  • E29 — Connect selected Kraken instructions to a reference ISA. (proof; AS01, AS04, AS18, AS19) Prove the required universal instruction-state relation, including flags, access/fault outcomes and widths; finite native agreement does not meet this proof goal.

  • E30 — Prove complete access production and permissions. (proof; AS05, AS07, AS09, AS24) Connect every actual memory operation to full trace/permission spans and frames; repair or reject vector-width mismatches and relate modeled authority to the chosen Rust/page resources.

  • E31 — Execute generated-model and cross-foundation proof ports. (experiment; AS18, AS19, AS20, AS21, AS22, AS23, AS28) Build a selected Sail model and proof, inspect generated dependencies; run relevant Isla/Islaris, Jasmin, Vale/F*/Dafny, HOL/s2n and selected ACL2/K/Bedrock/HOL ports on comparable claims, recording real unsupported cases and costs.

  • E32 — Check compiler/configuration and trace-coverage bridges. (proof; AS18, AS19, AS20, AS21, AS22, AS23) Discharge adopted generator/backend/support assumptions, feasible-path coverage, compiler pass/external-call premises and lifting guards. An upstream theorem must be instantiated at the actual configuration.

  • E33 — Implement and validate ABI witnesses/classification. (prototype; AS06, AS11, AS12) Export actual FnAbi/layout/attributes or independently check named C ABI classification, including hidden results, stack, varargs, vector and shadow-space facts where required; reject stale target/instance evidence.

  • E34 — Prove inline operand/options/continuation contracts. (proof; AS08, AS09, AS10, AS12) Cover universal legal register allocations and overlap, subregisters, implicit state, effects, stack, flags, labels, nonreturn, duplication/motion and unwind restrictions for the supported domain.

  • E35 — Construct the actual MiniRust/machine ABI-resource relation. (proof; MR23, AS06, AS07, AS11, AS12, AS13, AS15) Relate values, live allocations, provenance, initialization, borrows and stack/return resources at entry, every execution prefix and each permitted exit, including pointer returns.

  • E36 — Prove behavioral/contextual Rust-assembly replacement. (proof; MR23, AS10, AS13, AS14, AS15) Establish the declared refinement/equivalence directions and observations for pure Rust versus assembly, including overflow, safety, failure, divergence and permitted contexts/callbacks.

  • E37 — Bind final deployed bytes, relocations and dispatch paths. (proof; AS03, AS16, AS17, AS24) Verify the adopted decoder/loader or explicit checked boundary, relocations, symbol ranges and selected dispatch branches; prove fixed-fragment and required host/loop/escape composition with stale/changed-code rejection.

  • E38 — Run actual weak-memory model and concurrent-wrapper controls. (experiment; MR15, AS09, AS25) Execute pinned herd/rmem and rustc atomic mappings, missing-fence/effect annotation controls and an actual selected concurrent assembly wrapper; record model configurations and observed graph/outcome evidence.

  • E39 — Prove Rust/compiler/hardware weak-memory compatibility. (proof; MR15, AS09, AS25) Connect byte-range race/access rules, LLVM/compiler effects, atomic/RMW/fence events and selected hardware consistency/refinement; discharge complete-wrapper and mixed-width premises.

  • E40 — Exercise actual permitted platform unwind/callee chains. (experiment; MR16, AS11, AS13, AS27) Run selected valid helper/callback and native unwind cases, bind final metadata/registration and cleanup; retain metadata-only negatives without executing undefined Rust.

  • E41 — Prove platform recovery, personality and cleanup contracts. (proof; MR16, AS13, AS27) Verify relevant partial prologues/body/epilogues, metadata production/loading, callee/callback composition and restored Rust resources on each permitted exceptional exit; forced unwind/nonlocal jumps require their own justified scope.

  • E42 — Establish required security properties. (proof; AS14, AS26) Prove selected two-run leakage/constant-time claims for the actual pilot; develop explicit speculation, physical side-channel and fault models for any advertised stronger guarantees.

  • E43 — Establish required platform/environment extensions. (proof; AS10, AS13, AS23, AS27) Implement and prove motivated interrupt/signal/TLS/context-switch/probe/VM/MMIO/syscall/DMA/self-modification/control-flow-protection contracts and Rust ownership transfer, with omitted-effect controls.

  • E44 — Build an actual small proof-evidence consumer. (prototype; MR24, AS09, AS24) Separate untrusted producer/search from consumer-owned program/property/domain/assumption selection and complete checking; reject malformed, changed-subject, omitted-premise and weakened-domain artifacts.

  • E45 — Prove certificate acceptance soundness and binding. (proof; MR03, MR24, AS24) Connect the executable/parsed certificate checker to its logic and actual consumer claim; justify import/definition/axiom/computation policy, complete dependency checking and resource semantics.

  • E46 — Extend the complete shared pilot corpus. (experiment; MR23, MR24, AS04, AS11, AS14, AS28) Perform multiply/carry/byte-swap/load/store/copy/pointer-return/inline-label/C-ABI/helper and justified SIMD cases on both architectures, with real zerocopy operations and negative controls.

  • E47 — R095: finish strict SMT acceptance of all four original byte laws. (proof; MR06, MR24, AS24) Obtain complete accepted certificates for unchanged guarded IntoBytes/write/Boolean/array laws with exact root/domain binding and all invalid variants rejected; no holes, admissions or replacement by frame-only projections.

  • E48 — Measure matched proof production/checking/reuse/repair and select conditionally. (experiment; MR24, AS24, AS28) Compare viable routes on the same claim/domain/observations; separately measure capture/import, search/generation, certificates, kernel/checker/dependency work, warm/cold reuse and controlled source/ABI/model upgrades. Publish residual TCB and justified adoption decisions.

  • E49 — Establish target-parametric numeric and floating-point semantics. (proof; MR09, MR10, MR21) Mechanize bounded integer/shift/cast/overflow rules and the required full MiniRust floating-point extension, including IEEE choices, NaNs and target parameters; prove the declared all-target semantic laws and importer correspondence. Compiler observations and layout classification do not discharge this goal.

Initial dependencies and resource use

Start real frontend/Miri work, strict byte-certificate completion and a checked scalar assembly adapter in isolated scratch spaces. Restore only necessary exact toolchain components; share read-only inputs and serialize large builds under current disk limits. Then use the first complete byte/alias and assembly paths to drive logic ports, extended domains and matched measurements. Grouping may change while retaining stable milestone/question identities and the stated acceptance goals.

Published execution result: E47/R095

The strict four-law certificate report is published on reference at 5347bc8bb7eb1d6b8a3ff23b32864c80c21a97a8. Untrusted local expansion of five actual cvc5 rewrite names produces proofs accepted by unchanged native Carcara against all four original whole-law roots. Independent replay reproduced twelve whole-law acceptances, ten rejection controls and five SAT-to-Lean refutations. Raw unexpanded exports still fail for three laws; the native checker and Rust-to-model correspondence remain explicit obligations. E47 is complete for its fixed finite subject. At this publication, the other 48 milestones remain open.

Published scalar assembly and requested-toolchain progress

The checked byte-leaf/resource adapter proves exact byte decoding, the actual two-step Kraken effect tree, complete scalar accesses and the separated byte/full-modeled-state frame. Four object/linked slices match the certified leaf; both native builds passed 16,640 valid-reference calls. Independent proof and byte/control review passed. This is partial E28/E30 progress and an E35 machine endpoint; the verified importer/loader, Arm reference and actual Rust/MiniRust resource connections remain open. Enabled-GCS RET behavior is an explicit hardware counterconfiguration to a blanket no-extra-access claim.

The requested-nightly replay builds the exact Kraken library with its requested Lean nightly and checks six selected proof files. All 61 owned/pilot declarations have only foundational axioms. The 11 upstream audits retain two admissions and one native-evaluation axiom. This completes E27's requested-toolchain subtask; its broader ISA-validation criteria remain open. At this publication, 48 milestones remain unchecked.

Published frontend execution and pure consumer results

Formality execution completes E07's selected experiment: twenty actual parse/check/query/codegen/model cases cover generic dispatch, normalization, safe/unsafe judgments, trusted-body reachability and feature/generated-owner observations. Independent replay reproduced every expected status, all 112 non-metadata capture files and four model outputs/termination counts. Four retained upstream direct tests also pass. The Cargo compilation remains disk-stopped; no complete suite, Rust frontend theorem or P127/P131 result is inferred.

The consumer-bound scalar checker completes E44 as a bounded pure Lean prototype. It parses a closed 19-byte certificate language, binds the consumer-selected complete image/entry/PC/model/full-frame claim structurally, and derives the actual Kraken conditional resource/step/trace contract for every admitted input. Independent replay checks 69 package declaration closures plus four request/literal controls. The caller must own the expected request; acceptance cannot invent runtime resources. This is a universal E45 proof reduction, while broader compiled-checker, import, file/loader and Rust/MiniRust resource obligations remain open.

The nineteen-source MiniRust/Miri report preserves completed execution evidence without resuming the interrupted work: seventeen actual models yield sixteen agreements and one valid wide-pointer-union false positive; two lowering ICEs have no model result. E05/E06 remain partial. No repair or optimized-MIR erasure experiment is claimed.

At this publication, 46 of 49 milestones remain unchecked. All seven new execution-initiative packages (including its agenda) are persisted in the validated reference corpus, now 782 total packages.

Published weak-memory experiment: E38

The actual AArch64 model/mapping/wrapper report completes E38's selected experiment. Independent replay reproduced all ten complete herd state sets, verdicts and counts (six Sometimes, four Never), with binary/input/CAT identities checked before and after. Actual compiler output distinguishes Acquire LDAPR from SeqCst LDAR; compiled-only incorrect memory annotations expose load-folding consequences. Six concurrent assembly wrappers account for 60,000 native rounds, all model-allowed. No weak target outcome was observed; absence in those bounded runs is not model prohibition or universal hardware evidence. Neither incorrect annotation control was linked or executed.

E39's Rust/FFI, compiler and hardware refinement theorem remains open. At this publication, 45 of 49 milestones remain unchecked. The validated reference corpus contains 783 packages, including eight from this execution initiative.

Published modular replay and paired target experiment

The modular-effects/HeapLang/Islaris replay freshly compiles the selected original artifact and recursively checks 542 libraries. Independent replay reproduced the checker result and all 28 actual type/assumption observations: the 25 selected results split into six closed, three strong-bisimulation equality, twelve UIP plus bisimulation, and four additionally functional choice. Explicit handler, relation, resource and finite-execution premises remain. The imported global context's 62 declarations are distinct from each theorem's assumption closure. E03 remains open for its other Rust-logic/ISA replays; no concrete MiniRust handler, source bridge or Rust/ISA adequacy is inferred.

The matched AArch64/s390x report completes E08 for the preserved valid cases. The same Rust 1.89 sources pass all 78 finite checks on native Linux AArch64 and emulated big-endian s390x; independent existing-executable replays reproduce both complete outputs. Native integer bytes reverse as expected. Layout/dispatch, integer/FP, readiness-mask and valid wide-union/normal-Drop observations retain their finite domains. NaN payload agreement is an observation, masks supply no Rust resource authority, and trait-object calls establish no general vtable ABI. E49 remains open for all-target semantic laws and importer correspondence.

At this publication, 44 of 49 milestones remain unchecked. All ten execution-initiative packages are persisted in the validated reference corpus, now 785 packages.

Published native unwind experiment: E40

The AArch64 C-unwind callback/metadata report completes E40's selected valid experiment. A whole assembly function and pure Rust bounce each handle normal return and an exact typed Rust panic. All four cases produce the expected callback count, destructor counts and callback-before-outer cleanup. Exact object/final bytes bind the frame to its active linked DWARF FDE; live platform walks contain the expected return PC and image-relative offsets. Independent source/ABI/metadata review and one unchanged-image replay reproduce those invariants, including the complete relative trace vectors.

Three actual-image metadata negatives remain non-executable data and preserve the instructions. Public image-data copies project only declared equal-length N_OSO path prefixes; they are distinguished from the unchanged executed image. E41 remains open: finite cleanup counters and recovery snapshots do not prove the unwinder, personality/LSDA protocol, loader/registration or universal Rust-resource restoration.

At this publication, 43 of 49 milestones remain unchecked. All eleven execution-initiative packages are persisted on reference, now 786 packages.

Published configured-source capture and selected Simuliris replay

The caller-bound Rust capture report completes E04 for its declared pinned compiler/configuration and finite source domain. A consumer-owned request fixes source, target, cfg, root and tool profile. The consumer independently observes resolved instances, constants, expanded/local/generated owners and dependencies, then compares the complete candidate. Independent replay reproduces all 34 expected outcomes (five captures, six accepted pairs, 23 rejections), including changed operations, coherent Drop/glue removal and omitted owners, plus all 1,280 existing native results. The macro-owner control removes the macro-expanded generated-function owner; it does not separately delete the macro declaration. Loader placement and the accepted raw versus projected display packet are explicitly distinguished. The added explicit-observer replay helper is source-reviewed and CLI-checked; its complete matrix was not executed. E10/P127/P131 remain open: rustc, its post-lowering projection, opaque renderings, observer and reader remain trusted.

The selected Simuliris replay freshly compiles six original proof seeds and recursively checks 517 libraries. Independent observation-only audits reproduce all 24 exact types/assumption blocks, and the independent recursive checker trace is byte-identical. Nineteen selected constants are closed; five use excluded middle and constructive indefinite description. The checker-global context additionally contains dependent functional extensionality, which is absent from those selected closures. Source-safety, calculus-context, resource and scalar-slot premises remain. E03 remains open for the remaining artifact collection; E18/E20/E23/E24 remain open for correspondence, byte-sensitive logic, actual API ports and safe-client transport. The diagnosed namespace failure and forced rebuild remain separate evidence.

The matched Rust/assembly/zerocopy shared pilot completes E46's bounded experiment. The unchanged Rust1.89 corpus covers multiply/carry/byte-swap/load/store/copy/pointer-return/inline-label/C-ABI/helper and justified 16-byte SIMD cases with actual zerocopy operations on native AArch64 and emulated x86-64, at optimization0/3. All four original runs pass 4,617 harness checks each (18,468 total). Independent review separately reproduces AArch64 O0 and x86-64 O3 (9,234 checks, no added input-domain coverage), rederives the oracles and reconciles selected bytes, callers and frame metadata. All 24 receipt/status mutations reject; 28 retained-header data controls behave as specified. These controls never execute invalid Rust or changed machine code. Optimized zerocopy copy16 repeats byte3 despite a 16-byte interval union; equal final values do not establish equal access events. E29/E30/E34–E37 remain open for the stronger ISA, access/permission, inline, MiniRust resource, replacement and deployment proofs.

Published configured ABI witnesses and selected HOL/s2n replay

The configured Rust ABI witness report completes E33 as a bounded prototype. Four Darwin profiles and one Windows profile export actual pinned-compiler FnAbi/layout/attribute observations; consumer-owned fresh references reject selected stale target/instance and whole-field counterclaims. Complete retained MachO/COFF text and relocations separately bind hidden results/callers, stack arguments, mixed varargs and Windows shadow space. Experimental host vectors retain their FFI warnings and identity-body interpretation limits. Independent review checks all retained instruction/range/relocation evidence and repeats correct Darwin/Windows candidate checks. FnAbi equality, physical placement, classifier soundness and Rust resource transfer remain distinct; E34–E37 and the broader compiler/source obligations remain open.

The HOL Light/s2n-bignum report runs the complete unchanged selected x86 bignum-add proof under its CI-pinned HOL Light/OCaml native LCF boundary. An independent repetition reproduces all 71 full theorem observations, all 181 decode slots, ordered 47/83 source ledgers, three complete global axioms and all policy/completion markers. Both object inputs are ELF; the AArch64 program executes the proof, not the x86 objects. Eight separate native controls plus data observers distinguish literal/text/architecture rejection, importer acceptance of a renamed symbol, separate symbol binding, numeral conversions, global-policy rejection, copied-log completeness and operational missing-file failure. Independent source/control/final review passes. Global axiom policy does not compute per-theorem dependencies; the one-limb specialization retains code/ABI/alias/stack/frame premises, output-memory sum and RAX carry. E03 and E31 remain open for the remaining artifacts, generated models, proof ports and comparable domains.

Published configured Sail proof and Islaris dependency study

The Sail RV64D integration and proof report preserves successful generation of the full configured model, two disclosed integration repairs and the complete selected 143-module Lean import build. Four checked theorems bind actual top-level ADD execution to its exact effects, universal modulo-2^64 result and full sequential-state frame. Independent trust-zero replay reproduces the proof artifact; all 13 control theorems also independently replay. Four accepted semantic refutations accompany rejection of the corresponding well-typed false claims. The individual main/control/audit axiom lists each retain 78 names, including data/computation hooks and Lean foundations, with no sorryAx. This is an instruction-AST theorem; fetch/decode/step, generator/support adequacy, hardware, ABI and Rust-resource relations remain open. E03/E31/E32 remain open for their broader acceptance criteria.

The Islaris dependency report fixes the inspected Lithium–Iris–stdpp family and historical Dune 3.9.1 metadata, explains bbv 1.4's exclusion of Coq 8.19 and identifies bbv 1.5 as a metadata-compatible candidate. It preserves exact proposed solver inputs and the genuine upstream ADDI trace-origin proof target. No full dependency solve, installation or proof replay is claimed.

Both complete packages were independently reviewed, validated with the candidate corpus, published by normal fast-forward and read back at exact commit/tree/report/manifest identities. The separate stopped MiniRust work has not resumed. Work continues on the remaining milestones; this publication does not narrow their original acceptance goals.

Published supplied-word decoding proofs and offline Islaris solution

The Sail decoding-domain report extends the AST proof with actual encoding and supplied-word decoding. Sixteen checked diagnostic theorems formally refute universal decode→execute success with only x1/x2 present: the actual decoder first reads privilege, even for this ADD word. A distinct four-theorem positive module covers every 64-bit operand pair and every mseccfg value under explicit Machine-privilege/CSR presence assumptions. Its exact decoder certificate has two reads, and the composed result changes only x3 to the modular sum. Both modules independently replay at trust level zero with identical artifacts and disclosed individual axiom closures, without sorryAx. The counterexample is admitted by the model's partial register map; it does not claim that hardware ADD intrinsically needs this CSR. Memory fetch, full step/PC advancement, generator/support adequacy, hardware, ABI and Rust-resource correspondence remain open.

The Islaris offline-solution report executes the previously proposed metadata gate: opam returns a 74-package solution containing all 35 exact roots, with network disabled and empty actual installed/pin sets afterward. A separate executable CUDF satisfaction audit checks 240 dependency clauses, 104 conflict atoms and 35 requests; removing required dated Iris rejects. Independent package review repeats that audit and verifies complete metadata/source-coordinate bindings. The host checker is unproved; opam metadata/filter translation remains trusted. No package sources were acquired, installed or built, and no Islaris proof replay occurred. Modern transitive Menhir/Lem/Yojson compatibility, old-Sail Z3, source realization, trace coverage and theorem closure remain separate gates.

Both follow-ups were independently reviewed, validated in the complete candidate corpus, published by normal fast-forward, and read back at exact commit/tree/report/manifest identities. E03/E31/E32 remain open under their original broader acceptance criteria.

Published Islaris acquired-source audit and Jasmin verified inputs

The Islaris acquired-source report records successful download-only acquisition of the exact 74-package/35-root selection and an offline audit of all 43 deduplicated source artifacts. All 63 declared HTTP checksum comparisons, eight fixed Git commits, 21 Git source copies and 41 archive consumers were reconciled; complete before/after inventories were stable. Archive comparisons cover file bytes, owner-execute bits and symlink targets, while full no-extra-entry coverage is limited to Git copies. The public evidence explicitly omits six raw external extra-source bodies while retaining their exact identities and check records; historical project notices and the projection ledger are preserved. This report's endpoint precedes installation and establishes no dependency compatibility, Z3 compatibility or theorem result.

The Jasmin input report records successful native AArch64 evaluation of the pinned environment, acquisition and full offline content/signature verification of 191 cached inputs, and acquisition of the exact normalized Coqword source. Its separate owned offline printf derivation succeeds under the recorded settings; that narrow probe does not establish namespace isolation or general package-build capability. At this report's endpoint, 18 dependency derivations covering 19 named output paths remain unbuilt. The intended compiler output remains explicit x86-64/Linux; no compiler/proof replay, ABI proof or Rust resource bridge is inferred.

Subsequent build attempts are separate, preserved experimental subjects under investigation: Islaris reports 53 successful package installs and 21 Git-fetch failures because opam still refreshes original remotes despite cached objects; the Jasmin dependency request stops at Nix's nonexistent-HOME purity guard. Source inspection identifies opam's cache-versus-fetch distinction and Nix's possible sandbox fallback. The subsequent report below resolves Jasmin's registered-output census; the exact HOME creator and rejected next derivation remain unknown. Neither operational failure is a theorem counterexample, and neither closes the broad E03/E31 goals. Recovery must preserve exact inputs and disclose any transport/environment change.

Published partial Jasmin build and sandbox diagnosis

The Jasmin failed-build report preserves the actual offline dependency request and its status-1 HOME-purity failure after 20.144 seconds. Pinned Nix source explains how sandbox-fallback=true can select an unsandboxed local builder despite sandbox=true; this source-derived explanation is distinct from a binary-build attestation or observed failing namespace syscall. Independent queries of the stopped database establish one registered EasyCrypt output among 19 named paths from 18 derivations; the other 18 output paths are unregistered. Recorded NAR metadata is not independent content verification. HOME has an 11-directory Dune-cache layout and no files; its creator and the rejected next goal remain unknown. Outer container isolation, Nix inner sandboxing and proposed nonroot/strict-probe recovery routes remain distinct. No target theorem, complete dependency build or E03/E31 closure is claimed.

Published offline source recovery and bounded Nix preparation

The Islaris recovery report preserves the partial 53-package installation, the source-cache versus Git-fetch distinction, and the successful local-file transport for the eight fixed source artifacts. The subsequent actual download-only operation returned 0 with exactly 21 successful no-changes retrievals; all 35 requested roots, the full 74-package selection and the protected installation/source/configuration postconditions were retained. Its enclosing controller returned 1 when redundant solver-graph collection exceeded the monitored artifact limit. Independent raw and package reviews retain that overall partial outcome. No remaining package installation, old-Sail/Z3 compatibility or Islaris theorem replay is inferred.

The Nix preparation report records the configured-user ownership behavior of stopped-container archive copying, the corrected numeric-owner and directory-header fixtures, the root-with-capabilities-dropped permission failure, the narrowed census of 2,339 top-level store entries and three existing locks, and complete stopped mutable-state backup acquisition. Public evidence contains header/hash summaries; whole Nix state/log archives and SQLite payloads remain private. Actual ownership conversion, HOME removal, nonroot store/probe execution and the next dependency build remain unperformed proposals.

Both reports passed independent package review and candidate-wide validation, were published in one normal fast-forward, and were read back at the exact remote commit/tree/report/manifest identities. E03/E31/E32 remain open under their existing broader criteria.

Work is now paused at the user's request after publishing this batch and cleanup. All nine task-owned research containers are stopped, with source snapshots, compiled native environments and unique evidence preserved. Reacquirable host distributions and exact duplicate artifacts were retired; no new build/proof batch was started.

9 of 49 milestones are complete; 40 remain unchecked. All twenty-five execution-initiative packages are persisted on reference, now 800 total packages.

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

Ngôn ngữ chính
Rust
Star
2.6k
Fork
194
Merge trung bình
18 giờ 15 phút
Pull request đã merge (30 ngày)
14

Chuẩn bị môi trường

Bắt đầu từ đâu

  1. Đọc hết issue, rồi đọc hướng dẫn đóng góp của dự án.
  2. Bình luận trên issue rằng bạn sẽ nhận — tránh hai người làm cùng một việc.
  3. Fork repository và làm thay đổi trên một nhánh.
  4. Mở pull request có tham chiếu số hiệu của issue.

Issue khác của google/zerocopy

Tất cả issue của google/zerocopy

Issue tương tự

Thêm issue về Rust

Nhận issue mới trong hộp thư của bạn

Bản tóm tắt ngắn những issue GitHub phù hợp với người mới.