From 17aea02bbc3c7c1a3553a0a8b9967e7c53c997ef Mon Sep 17 00:00:00 2001 From: Alex Flom Date: Tue, 3 Nov 2026 08:19:21 -0700 Subject: [PATCH 01/13] fix(snapshot): canonicalize structured values without a redundant depth-limited parse --- VERIFICATION.md | 18 ++++++ crates/lexlean/src/artifact/canonical_json.rs | 4 +- crates/lexlean/src/artifact/snapshot.rs | 64 ++++++++++++++++++- 3 files changed, 83 insertions(+), 3 deletions(-) diff --git a/VERIFICATION.md b/VERIFICATION.md index 090cf8165e..da42aa66c0 100644 --- a/VERIFICATION.md +++ b/VERIFICATION.md @@ -39,6 +39,24 @@ Outside `vv`: ## Falsifiability records +### semantic snapshot nesting can fail + +Before the correction for #430, the focused +`artifact::snapshot::tests` library filter ran two cases: existing shallow +snapshot bytes passed, while serializing a 160-level linked value panicked +at `snapshot.rs` with `recursion limit exceeded`. The snapshot DTO had +already been constructed; its redundant byte parse imposed serde_json's +raw-reader nesting limit on that structured value. + +Snapshot serialization now converts its structured value directly into the +canonical JSON domain. The checks excluding null and non-integer numbers +remain shared with raw parsing; raw parsing still checks duplicate keys. +The deep regression round-trips the complete snapshot and its content digest, +and the shallow regression compares exact bytes with the previous recipe. +All 221 LexLean library tests pass on release/v0.4 with ordinary test stacks. +This is library evidence, not a complete `vv` or consuming-app attestation. + + Each gate below was made to fail by planting a defect, running the gate's command, recording the failure, and removing the defect. The observed lines are verbatim gate output (paths abbreviated to the repository root). `cargo xtask release-check` requires a `### can fail` record for every gate and audit named in `repo_model::release::GATES`. ### production bundle inventory can fail diff --git a/crates/lexlean/src/artifact/canonical_json.rs b/crates/lexlean/src/artifact/canonical_json.rs index 7d26a88905..74c326ded0 100644 --- a/crates/lexlean/src/artifact/canonical_json.rs +++ b/crates/lexlean/src/artifact/canonical_json.rs @@ -111,7 +111,9 @@ impl Json { Self::from_serde(&value) } - fn from_serde(value: &serde_json::Value) -> Result { + /// Convert an already structured value while retaining the canonical domain checks. + /// Raw byte inputs must use `parse` so duplicate keys are checked before decoding. + pub(crate) fn from_serde(value: &serde_json::Value) -> Result { match value { serde_json::Value::Null => Err("canonical JSON has no null".to_owned()), serde_json::Value::Bool(b) => Ok(Self::Bool(*b)), diff --git a/crates/lexlean/src/artifact/snapshot.rs b/crates/lexlean/src/artifact/snapshot.rs index aecf0d64d0..5c1c4f3af0 100644 --- a/crates/lexlean/src/artifact/snapshot.rs +++ b/crates/lexlean/src/artifact/snapshot.rs @@ -442,8 +442,9 @@ impl SemanticSnapshot { #[must_use] pub fn to_json(&self) -> Json { let value = serde_json::to_value(self).expect("snapshot DTO serializes"); - let bytes = serde_json::to_vec(&value).expect("snapshot JSON serializes"); - Json::parse(&bytes).expect("snapshot DTO uses the canonical JSON domain") + // The DTO already has unique object keys. Re-parsing its serialization + // imposes the raw JSON reader's nesting limit on accepted linked IR. + Json::from_serde(&value).expect("snapshot DTO uses the canonical JSON domain") } /// Canonical JSON file bytes, including LexLean's single final LF. @@ -594,3 +595,62 @@ impl SnapshotAxiomPolicy { &self.axioms } } + +#[cfg(test)] +mod tests { + use super::*; + + fn nested_snapshot(depth: usize) -> SemanticSnapshot { + let mut linked_ir = serde_json::json!("leaf"); + for _ in 0..depth { + linked_ir = serde_json::Value::Array(vec![linked_ir]); + } + let digest = Sha256Digest::of(b"snapshot fixture"); + SemanticSnapshot { + spec: "lexlean/semantic-snapshot/2".into(), + source_id: digest, + semantic_id: digest, + compiler_semantics_id: digest, + language: "1.2".into(), + modules: vec![SnapshotModule { + name: "Main".into(), + lean_module: "Main".into(), + origin: None, + imports: vec![], + glossary: vec![], + visible_packages: vec![], + source: SnapshotSource { + path: "src/Main.lex.tex".into(), + sha256: digest, + }, + declarations: vec![], + core: None, + semantic: None, + linked_ir, + }], + lexicon_closure: serde_json::json!({}), + } + } + + #[test] + fn canonical_snapshot_preserves_deep_linked_values() { + let snapshot = nested_snapshot(160); + let bytes = snapshot.canonical_bytes(); + let mut reader = serde_json::Deserializer::from_slice(&bytes); + reader.disable_recursion_limit(); + let restored = SemanticSnapshot::deserialize(&mut reader).expect("deep snapshot JSON"); + reader.end().expect("complete snapshot"); + assert_eq!(restored, snapshot); + assert_eq!(restored.canonical_bytes(), bytes); + assert_eq!(snapshot.snapshot_id(), Sha256Digest::of(&bytes)); + } + + #[test] + fn canonical_snapshot_preserves_existing_bytes() { + let snapshot = nested_snapshot(4); + let prior = Json::parse(&serde_json::to_vec(&snapshot).expect("snapshot JSON")) + .expect("canonical domain") + .to_file_bytes(); + assert_eq!(snapshot.canonical_bytes(), prior); + } +} From d0969f4d9c7f00965c6dbccfd372ac76f3fb3cef Mon Sep 17 00:00:00 2001 From: Alex Flom Date: Mon, 9 Nov 2026 19:05:22 -0700 Subject: [PATCH 02/13] test(bootstrap): avoid discarded BS-15 full-library runs Assemble the same ordered evaluator and native corpora directly. Keep the existing full accepted-package recipe assertions, bounded native inputs, all plants, counts and exported-package checks. Add an old/new assembly regression without changing compiler semantics or gate orchestration. Refs #457 --- VERIFICATION.md | 33 ++++ .../src/cases/bootstrap/rust_package.rs | 180 ++++++++++++++---- 2 files changed, 174 insertions(+), 39 deletions(-) diff --git a/VERIFICATION.md b/VERIFICATION.md index 7412633b08..c0e712e2e5 100644 --- a/VERIFICATION.md +++ b/VERIFICATION.md @@ -43,6 +43,38 @@ Outside `vv`: Each gate below was made to fail by planting a defect, running the gate's command, recording the failure, and removing the defect. The observed lines are verbatim gate output (paths abbreviated to the repository root). `cargo xtask release-check` requires a `### can fail` record for every gate and audit named in `repo_model::release::GATES`. +### BS-15 render corpus materialization + +Issue #457 changes only the construction of the two render vectors in +`crates/conformance/src/cases/bootstrap/rust_package.rs`. The previous code +encoded every full-library render, filtered the evaluator vector, then +replaced the large native inputs with their existing 4,096-byte prefixes. +The discarded full runs were inputs to neither differential. The direct +assembler retains the same order: accepted manifests, shaped inputs, then +seeded render mutants. At or below 16,384 bytes it uses the unchanged run and +expected files in both vectors; above that boundary it constructs only the +same native prefix and recipe outcome. The complete-library recipe assertion +against `package::package` in `accepted` is unchanged. + +No corpus generation, seed, count, negative fixture, planted defect, native +comparison, certificate limit, export check, host condition, timeout, or +compiler-semantics input changes. On the base tree's asserted counts, the +native render vector still contains 735 runs and the evaluator vector 241; +494 full-library argument encodings that neither vector consumed are no +longer materialized. This is a work-count deduction, not a measured CI speedup. + +The library unit regression `render_corpora_preserve_inputs_and_outcomes` +compares both vectors with the previous assembler on both profiles, distinct +supplied package outcomes, recipe outcomes, and libraries of 0, 4,096, +16,383, 16,384, 16,385 and 32,768 bytes. Local validation in the authoring +environment passed whitespace checks and an independent assembly model: +24 evaluator and 36 native results were identical in order and bytes across +27 empty/mixed collection cases, and changes to the boundary, prefix and +supplied-outcome routing were detected. That model does not execute Rust or +the package renderer. Rust formatting, Clippy, the library regression and the +complete release gate were not run locally because the environment has no +Rust toolchain; they remain required acceptance evidence on the final tree. + ### Intel host partition custody and complete evidence The three non-Intel auxiliary host legs keep their existing locked, @@ -13607,3 +13639,4 @@ Under separate root admission ca0818e03f221445d77bfab595b64e255f1eb5d0f5cb74df61 The reviewed physical ledger contains 12,551 entries and 10,900 present files, including 8 symlinks. Physical review393 remains detached at c613 with raw index f2a12ce1d4f383096de2ab9913efd25c55a5a3d01913a670429252ea4ee961eb and logical 0328 source tree; the external pre-documentation capture is 6dcf464632e277916cedfacb5656699c89872c47. Current frozen BOTH/probe artifacts, 905 inputs, closed errors, archived selected build metadata, helper ownership and all producer outputs passed entry and terminal preservation guards. The final additive VI is prepared externally, without changing that physical root. This is source/product readiness evidence, not complete combined-head acceptance. The historical281 draft run 41964177567 ran only plan/honesty/rest with seven required host/Atlas groups skipped; repro 41964177626 passed, and the prior ready run 41964083701 was cancelled. None accepts the new currentbase combination. One complete new-head hosted gate, same-run honesty, reproducibility, final review and eventual actual landing/tree equality remain mandatory. Existing d34/WSL PERFORMANCE rows and timing/host/comparison caveats retain their original scope; no new linearity measurement is claimed. Closure scope remains #373 only after its combined proof/BS02 and final gate requirements pass. + diff --git a/crates/conformance/src/cases/bootstrap/rust_package.rs b/crates/conformance/src/cases/bootstrap/rust_package.rs index b10d186835..ae64cebf46 100644 --- a/crates/conformance/src/cases/bootstrap/rust_package.rs +++ b/crates/conformance/src/cases/bootstrap/rust_package.rs @@ -311,6 +311,37 @@ fn render_run(render: &Render, expected: Files) -> Run { ) } +/// The ordered render corpora consumed by the evaluator and rustc. +fn render_corpora( + renders: &[(Render, Files)], + shaped: &[Render], + mutants: &[Render], +) -> (Vec, Vec) { + let mut within = Vec::new(); + let mut compiled = Vec::new(); + let inputs = renders + .iter() + .map(|(render, files)| (render, Some(files))) + .chain(shaped.iter().chain(mutants).map(|render| (render, None))); + for (render, files) in inputs { + if render.library.len() <= EVALUATOR_LIBRARY { + let expected = files.cloned().unwrap_or_else(|| files_of(render)); + let run = render_run(render, expected); + within.push(run.clone()); + compiled.push(run); + } else { + // rustc expands each argument byte into an array element, so + // the native corpus uses the existing 4,096-byte prefix. The + // full-library run feeds neither consumer; accepted() still + // holds its complete library to the package::package recipe. + let mut render = render.clone(); + render.library.truncate(4_096); + compiled.push(render_run(&render, files_of(&render))); + } + } + (within, compiled) +} + /// A manifest the oracle accepts, what `renderPackage` is given for it, and /// the two files `package::package` wrote. fn accepted(manifest: &Manifest) -> Option<(Render, Files)> { @@ -866,45 +897,7 @@ pub(super) fn case() { } render_mutants.push(render); } - let render_runs: Vec = renders - .iter() - .map(|(render, files)| render_run(render, files.clone())) - .chain( - shaped - .iter() - .chain(&render_mutants) - .map(|render| render_run(render, files_of(render))), - ) - .collect(); - let within: Vec = renders - .iter() - .map(|(render, _)| render) - .chain(&shaped) - .chain(&render_mutants) - .zip(&render_runs) - .filter(|(render, _)| render.library.len() <= EVALUATOR_LIBRARY) - .map(|(_, run)| run.clone()) - .collect(); - // rustc compiles each byte of an argument as one array element, and the - // libraries of the committed packages are megabytes together, so a render - // whose library is beyond the evaluator's bound runs under rustc on the - // first 4,096 bytes of it, held to the recipe, which reads it only as - // bytes to digest. - let compiled: Vec = renders - .iter() - .map(|(render, _)| render) - .chain(&shaped) - .chain(&render_mutants) - .zip(&render_runs) - .map(|(render, run)| { - if render.library.len() <= EVALUATOR_LIBRARY { - return run.clone(); - } - let mut render = render.clone(); - render.library.truncate(4_096); - render_run(&render, files_of(&render)) - }) - .collect(); + let (within, compiled) = render_corpora(&renders, &shaped, &render_mutants); eprintln!( "BS-15: {} manifests ({} accepted), {} and {} rule inputs, {} and {} mutants, {} renders under the evaluator ({:?})", manifests.len(), @@ -1034,3 +1027,112 @@ pub(super) fn case() { } eprintln!("BS-15: passed in {:?}", started.elapsed()); } + +#[cfg(test)] +mod tests { + use super::*; + + fn previous_corpora( + renders: &[(Render, Files)], + shaped: &[Render], + render_mutants: &[Render], + ) -> (Vec, Vec) { + let render_runs: Vec = renders + .iter() + .map(|(render, files)| render_run(render, files.clone())) + .chain( + shaped + .iter() + .chain(render_mutants) + .map(|render| render_run(render, files_of(render))), + ) + .collect(); + let within: Vec = renders + .iter() + .map(|(render, _)| render) + .chain(shaped) + .chain(render_mutants) + .zip(&render_runs) + .filter(|(render, _)| render.library.len() <= EVALUATOR_LIBRARY) + .map(|(_, run)| run.clone()) + .collect(); + // rustc compiles each byte of an argument as one array element, and the + // libraries of the committed packages are megabytes together, so a render + // whose library is beyond the evaluator's bound runs under rustc on the + // first 4,096 bytes of it, held to the recipe, which reads it only as + // bytes to digest. + let compiled: Vec = renders + .iter() + .map(|(render, _)| render) + .chain(shaped) + .chain(render_mutants) + .zip(&render_runs) + .map(|(render, run)| { + if render.library.len() <= EVALUATOR_LIBRARY { + return run.clone(); + } + let mut render = render.clone(); + render.library.truncate(4_096); + render_run(&render, files_of(&render)) + }) + .collect(); + (within, compiled) + } + + #[test] + fn render_corpora_preserve_inputs_and_outcomes() { + let mut renders = Vec::new(); + for std in [false, true] { + for length in [ + 0, + 4_096, + EVALUATOR_LIBRARY - 1, + EVALUATOR_LIBRARY, + EVALUATOR_LIBRARY + 1, + EVALUATOR_LIBRARY * 2, + ] { + let render = Render { + scaffold: scaffold::get().expect("the scaffold").clone(), + name: format!("render_{length}"), + version: "1.2.3".to_owned(), + std, + program: "f".repeat(64), + sources: vec!["a".repeat(64)], + effects: vec!["overflow".to_owned()], + exports: vec![("run".to_owned(), 0)], + library: (0u8..=255).cycle().take(length).collect(), + }; + // Distinct supplied files catch replacing the package's + // expected outcome with the recipe for a small library. + let files = ( + format!("package cargo: {std} {length}").into_bytes(), + format!("package provenance: {std} {length}").into_bytes(), + ); + renders.push((render, files)); + } + } + let shaped: Vec = renders + .iter() + .map(|(render, _)| { + let mut render = render.clone(); + render.name = "a\"b\\c".to_owned(); + render.scaffold.library = "A.rs".to_owned(); + render + }) + .collect(); + let mutants: Vec = shaped + .iter() + .map(|render| { + let mut render = render.clone(); + render.exports.reverse(); + render.sources.clear(); + render + }) + .collect(); + let expected = previous_corpora(&renders, &shaped, &mutants); + let observed = render_corpora(&renders, &shaped, &mutants); + assert_eq!(observed, expected, "both ordered vectors are byte-identical"); + assert_eq!(observed.0.len(), 24, "both profiles include the boundary"); + assert_eq!(observed.1.len(), 36, "rustc keeps every render"); + } +} From 5088c0f47d8a15abcb6a2567c857cfa79fd01b39 Mon Sep 17 00:00:00 2001 From: Alex Flom Date: Mon, 9 Nov 2026 19:09:07 -0700 Subject: [PATCH 03/13] style(bootstrap): apply pinned rustfmt to assembly regression --- crates/conformance/src/cases/bootstrap/rust_package.rs | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/crates/conformance/src/cases/bootstrap/rust_package.rs b/crates/conformance/src/cases/bootstrap/rust_package.rs index ae64cebf46..745fcae696 100644 --- a/crates/conformance/src/cases/bootstrap/rust_package.rs +++ b/crates/conformance/src/cases/bootstrap/rust_package.rs @@ -1131,7 +1131,10 @@ mod tests { .collect(); let expected = previous_corpora(&renders, &shaped, &mutants); let observed = render_corpora(&renders, &shaped, &mutants); - assert_eq!(observed, expected, "both ordered vectors are byte-identical"); + assert_eq!( + observed, expected, + "both ordered vectors are byte-identical" + ); assert_eq!(observed.0.len(), 24, "both profiles include the boundary"); assert_eq!(observed.1.len(), 36, "rustc keeps every render"); } From 614c978e4f57d8ece6dae06ec85b0a0ab52d968f Mon Sep 17 00:00:00 2001 From: humuhumu33 <68450279+humuhumu33@users.noreply.github.com> Date: Thu, 12 Nov 2026 12:51:21 +0000 Subject: [PATCH 04/13] docs: proposal for contracts on code LexLean did not generate (external declarations) One closed declaration that binds a foreign function to a stated contract: an opaque constant whose hidden value is a LexLean witness, and one generated contract axiom that every dependent theorem carries in its exact observed set and verify reports with its evidence. Options, a Lean 4.32.1 prototype with its output, an assessment of an Aeneas bridge, and the decisions left to the owners. Proposal only: nothing is implemented. Co-Authored-By: Claude Fable 5.2 --- docs/proposals/external-contracts.md | 260 +++++++++++++++++++++++++++ 1 file changed, 260 insertions(+) create mode 100644 docs/proposals/external-contracts.md diff --git a/docs/proposals/external-contracts.md b/docs/proposals/external-contracts.md new file mode 100644 index 0000000000..84af21cc11 --- /dev/null +++ b/docs/proposals/external-contracts.md @@ -0,0 +1,260 @@ +# Contracts for code LexLean did not generate: design + +Draft for owner acceptance, written 2026-11-12, against `release/v0.4`. Normative text is `SPEC.md`; this document explains and asks. It is a proposal only: this pull request adds this one file. The mechanism it recommends changes the trust model of SPEC §4.2 and §5, which is the owners' decision, so nothing is implemented until they choose. The mechanism was prototyped in the pinned Lean 4.32.1 with scratch files outside the repository; the source and what Lean printed are in section 7. + +This is gap B of three on the way to a verified inference engine written as a LexLean application. Gap A (arrays of fixed-width integers, `SM-39`) is implemented in its own pull request. Gap C (floating point) is a proposal in its own pull request and relies on this one for native execution. + +## 1. Summary + +A fast engine is hand-written code LexLean did not generate: SIMD, WebAssembly, a C kernel. Today a LexLean document cannot mention it. The only choices are to leave it out of the model, so nothing is proved about the system that runs, or to rewrite it in LexLean, so it is no longer fast. + +The proposal is one new declaration, `external`, that names a foreign function, states its contract, and makes the assumption that the function meets the contract a visible, named, audited fact: + +1. The declaration states a signature, a contract (a proposition over the inputs and the output), a **witness** (a LexLean definition with a theorem that it meets the contract), and **evidence** (what discharges the assumption for the real code). +2. Generated Lean declares an opaque constant whose hidden value is the witness, and one axiom, `..contract`, that states the contract of that constant. +3. A caller is proved against the contract and nothing else: the kernel cannot see through the constant. +4. Every theorem that uses the contract has that one axiom in its observed set. LexLean's policy is exact, so the theorem must list it, and `verify` reports it with its evidence. A theorem that does not use the external function does not carry it. +5. No other axiom can be written. The ban on author axioms stands for everything else, and the one axiom this form generates cannot be inconsistent, because the witness proves a function with that contract exists. + +**Prototype result.** In pinned Lean, a caller `score` of an external int8 dot product `dotFast` was proved correct against the contract. `#print axioms` on the caller's theorem printed `[propext, Engine.Main.dotFast.contract]`; on a theorem about the reference alone it printed that it depends on no axioms; and `rfl` could not prove the external function equal to its witness (section 7). + +Decisions that need the owners: + +| # | Decision | Recommendation | +| --- | --- | --- | +| D1 | Whether a document may state an assumption about foreign code at all | Yes, in this one closed form | +| D2 | Mechanism | An opaque constant plus one generated contract axiom (option A of section 5). It is the only option where Lean itself reports every use | +| D3 | Whether a witness is mandatory | Yes. Without it the form is an author axiom under another name | +| D4 | Evidence kinds | `attested` (a content-addressed conformance report bound to the contract's statement ID) first; `proved` (a kernel-checked theorem about a Lean model of the code) when Lean-library imports land (#362) | +| D5 | Project-level opt-in | Yes: `[[external_source]]` in `lexlean.toml`, pinned in the lock, so a reviewer sees every external in the configuration | +| D6 | Emitting `@[extern "symbol"]` so that Lean-compiled C calls the foreign symbol | Not in the first change. Decide the symbol and calling convention with PrismPM first; until then the compiled constant runs the witness | +| D7 | Production (certified Rust) | Formal-only at first, like arrays and text components | +| D8 | An Aeneas bridge | Not now. It is sound in principle and not small (section 8) | + +## 2. What the goal asks and where it stands + +| Asked | Mechanism here | State | +| --- | --- | --- | +| Declare an external function with a stated contract | `external` declaration | Designed; prototyped in Lean; not implemented | +| A model can call it and proofs can use the contract | Ordinary call; `apply` or `simplify` naming `.contract` | Prototyped | +| No hole | Mandatory witness theorem; closed form; no free axiom text | Argued in section 6 | +| Every use visible in the observed axiom or trust set | The exact axiom audit, unchanged | Prototyped: `#print axioms` shows the contract axiom | +| Reported by `verify` | Attestation gains trust records; summary line | Designed | +| Names the evidence that discharges it | `evidence: attested{...}` or `proved{...}` | Designed | +| Does not weaken the ban for everything else | Only this declaration can generate an axiom, of one fixed shape | By construction | +| Example: external int8 dot product, caller proved, trust entry shown | `examples/external-contract` | Prototype in Lean only (section 7) | + +## 3. What exists + +- **Contracts and models** (§17.12). A `contract` has typed input and output and proposition-valued predicates with validators; a `model` binds a contract to a `realization`, which is always a LexLean denotation. `checked_apply` runs validators at run time and returns a `ContractViolation` on refusal. This covers code LexLean generates, and results that are cheap to check. It does not cover a result that is as expensive to check as to compute, which is the case for a dot product. +- **External Lean constants** (§4.1, §13.7). A lexicon entry of kind `lean` names a constant of the Lean workspace with a declared signature, probed at verification. This imports Lean, not foreign code, and the workspace is in the trusted base (§5.1). +- **Lean-library imports** (#362, draft on `release/v0.5`), with a feasibility probe for Aeneas or Hax under #356. +- **The ban** (§4.2): no author-defined axioms, no raw Lean. Every declaration has an exact axiom policy; `verify` refuses a missing, additional or unlisted observed axiom (§17.11, §22). + +## 4. Constraints taken as given + +- §5.4: the axiom audit reports what `#print axioms` returns, nothing more. A mechanism Lean does not report would need a second audit that LexLean alone vouches for. +- §5.3: "verified" is only said of what Lean elaborated, `leanchecker` replayed and the audit accepted. +- AGENTS.md rule 4: a claim about a dependency belongs to that dependency. A claim about hand-written code belongs to whoever attests it, and must be named as such. +- R4: nothing deferred; R5: every failure registered. + +## 5. Options + +**A. Opaque constant and one generated contract axiom (recommended).** Described in section 6. Lean reports every use. One new kind of axiom exists, generated only by this form. + +**B. Parameterised theorems, no axiom.** Every definition that reaches the external function takes the implementation and a proof of its contract as parameters; theorems are quantified over them. Nothing is assumed in Lean at all. The cost: every caller, transitively, changes its signature, a production root cannot be closed, and the "which implementation is running" fact moves entirely outside Lean, where only LexLean's own bookkeeping reports it. + +**C. Check every result at run time.** This is `checked_apply` today. It needs no trust. It is the right answer whenever checking is cheaper than computing, and it is useless for an inference kernel, where the check is the computation. + +**D. Reference body with an unaudited binding.** The external function is defined as the reference, and a compiler attribute (`@[extern]`, `@[implemented_by]`) substitutes foreign code. This is how Lean's own core binds native code. No axiom appears, so `#print axioms` shows nothing: every theorem looks unconditional while the running code is trusted silently. This is the hole the request rules out. + +A is recommended because it is the only one in which the trusted assumption is an object of the logic that the pinned Lean itself tracks through every dependency, with no new audit to trust. + +## 6. Design of option A + +### 6.1 The declaration + +In the authoring notation: + +```text +external{ + name: dotFast, + parameters: [left : array{element: Int8}, right : array{element: Int8}], + result: Int, + contract: DotContract, + witness: {definition: dotReference, theorem: dot_reference_meets}, + evidence: attested{report: dotFastConformance}, + symbol: "engine_dot_i8" +} +``` + +- `contract` names a prior proposition-valued definition whose parameters are the external function's parameters followed by its result. +- `witness.definition` names a prior LexLean definition of exactly the external function's signature. `witness.theorem` names a prior theorem whose statement is exactly the contract applied to the parameters and to the witness applied to them. Linking checks both shapes; Lean checks the theorem. +- `evidence` is one of the closed forms of section 6.4. +- `symbol` is the foreign name, recorded in the build outputs for a host to bind (D6). + +### 6.2 Lowering + +```lean +public opaque dotFast (left : Array Int8) (right : Array Int8) : Int := dotReference left right +public axiom dotFast.contract (left : Array Int8) (right : Array Int8) : + DotContract left right (dotFast left right) +``` + +The hidden value of the constant is the witness. The kernel never unfolds an opaque constant, so nothing about `dotFast` is provable except through the axiom. A document refers to the axiom as the member `dotFast.contract`, in `apply` and `simplify`, exactly as it refers to a theorem. + +The canonical document states the declaration, the contract, the witness and the evidence. The generated-source audit admits `opaque` and `axiom` tokens only at the positions an `external` declaration of the IR accounts for. + +### 6.3 Why this is not a hole + +The axiom says: the constant `dotFast` satisfies `DotContract`. The constant's hidden value is `dotReference`, and `dot_reference_meets` is a kernel-checked proof that `dotReference` satisfies `DotContract`. So the axiom is a true statement about the constant; it is unprovable inside Lean only because the constant is opaque. Replacing `opaque` by a definition turns the axiom into a theorem with the witness theorem as its proof. Any proof that uses the axiom therefore stays valid with the axiom replaced by that theorem: the axiom adds no logical strength. In particular it cannot make `False` provable, whatever contract an author writes, because an unsatisfiable contract has no witness theorem and is refused at verification. + +What remains assumed is not logical. It is the statement that the foreign code, where it runs in place of the constant, computes a function with that contract, and that it is a function: no dependence on anything but its arguments, no effect, termination on every input the contract admits. That statement is what the evidence is for, and it is named in every theorem that needs it. + +### 6.4 Evidence + +- `attested{report: A}`: `A` is an `artifact` declaration of role `conformance`, content-addressed like every artifact. Its bytes are a canonical JSON report that states the statement ID of the external declaration (`SM-38`), the digest of the foreign code tested, the reference it was compared with, the number of cases and the result. Linking refuses a report that names another statement ID. So a change of the contract, the signature or the witness makes old evidence stale by construction. LexLean does not run the foreign code and does not vouch for the report: the attestation records who is trusted for what. +- `proved{theorem: T}`: `T` is a theorem, checked by the pinned Lean, that a Lean model of the foreign code meets the contract. This needs the model to be importable (#362) and belongs to a later change. It does not remove trust; it moves it to whatever produced the model (section 8). + +### 6.5 Policy and reporting + +- A project lists the externals it admits: `[[external_source]]` in `lexlean.toml` with the module, the name and the report digest, pinned in `lexlean.lock`. An `external` declaration without its row is refused. A project with no row accepts no external declaration, so the default is the ban as it is today. +- Each theorem and definition states its exact axioms as now. A theorem that uses `dotFast.contract` lists `Project.Module.dotFast.contract` beside `propext`; a missing or extra one is `LLV7005`, unchanged. +- The attestation gains `trust`: for each contract axiom, its evidence, and the declarations whose observed sets contain it. `verify` prints one line per contract axiom after its summary, for example: + +```text +verified 1 module; attestation +trust: Engine.Main.dotFast.contract, attested by sha256:, used by 1 theorem and 1 definition +``` + +- A status line never says "verified" without the trust lines when any exist. + +### 6.6 Diagnostics + +Malformed declarations are `LLT4001` (contract or witness of the wrong shape, a witness theorem that states something else, a report bound to another statement ID, an external without its configuration row). A witness theorem Lean refuses is `LLV7002`. An unlisted contract axiom is `LLV7005`. No new code is needed for these; whether the missing-row refusal deserves its own code is a detail for the implementation. + +## 7. Evidence: the prototype + +Pinned Lean 4.32.1 (`f054605aea4b840552cca2e725580bffd1e1b704`), Windows x86-64, 2026-11-12, one scratch file outside the repository, written in the shapes the backend emits: + +```lean +@[expose] public def DotContract (left : Array Int8) (right : Array Int8) (result : Int) : Prop := + result = dotList left.toList right.toList + +@[expose] public def dotReference (left : Array Int8) (right : Array Int8) : Int := + dotList left.toList right.toList + +public theorem dot_reference_meets (left : Array Int8) (right : Array Int8) : + DotContract left right (dotReference left right) := rfl + +public opaque dotFast (left : Array Int8) (right : Array Int8) : Int := dotReference left right + +public axiom dotFast.contract (left : Array Int8) (right : Array Int8) : + DotContract left right (dotFast left right) + +@[expose] public def score (left : Array Int8) (right : Array Int8) (bias : Int) : Int := + dotFast left right + bias + +public theorem score_correct (left : Array Int8) (right : Array Int8) (bias : Int) : + score left right bias = dotList left.toList right.toList + bias := by + have h := dotFast.contract left right + simp only [DotContract] at h + simp only [score, h] +``` + +What Lean printed: + +```text +'Engine.Main.score_correct' depends on axioms: [propext, Engine.Main.dotFast.contract] +'Engine.Main.reference_only' does not depend on any axioms +'Engine.Main.dot_reference_meets' does not depend on any axioms +``` + +and, for `example (l r : Array Int8) : dotFast l r = dotReference l r := by rfl`: + +```text +error: Tactic `rfl` failed: The left-hand side + Engine.Main.dotFast l r +is not definitionally equal to the right-hand side + Engine.Main.dotReference l r +``` + +So the caller is proved against the contract, the trust entry is exactly one named axiom in the caller's observed set, a theorem that does not use the external function does not carry it, and the kernel cannot reach the witness through the constant. + +This is a Lean prototype of the lowering. It is not `lexlean verify` output: no `external` declaration exists in the compiler. + +## 8. Could Rust translated to Lean by Aeneas discharge a contract? + +Aeneas translates a subset of safe Rust to pure Lean definitions; a contract would then be a theorem about the translated function, and the evidence would be `proved`. + +What was checked (2026-11-12, the project's repository at `main`): + +- Its Lean backend requires Mathlib and pins `leanprover/lean4:v4.36.0-rc2`. LexLean pins 4.32.1, and the draft that moves the pin (#433) moves it to 4.33.1. +- Generated files import the `Aeneas` Lean package, so its declarations and Mathlib would have to be imported, pinned and audited (#362, with the 7 GB library cost noted there). +- It supports a subset of safe Rust. Unsafe code and concurrency are stated as unsupported; some loop forms are unsupported. +- The translation is described in two papers; the tool that performs it is not itself verified. + +Assessment: + +- **Sound?** As far as Lean is concerned, yes: the theorem is kernel-checked and the axiom audit reports whatever axioms the library uses. But the theorem is about the Lean model, not about the Rust. That the model is faithful is the translator's claim. So an Aeneas bridge does not remove the trust entry; it replaces "this code was tested against the reference" with "this translator is faithful and the compiled Rust behaves as its source", which must be named the same way. +- **Small?** No. It needs Lean-library imports to land, a toolchain where LexLean's pin and Aeneas's meet, Mathlib in the verification of every project that uses it, and a new evidence kind. +- **Useful for this engine?** Only for a scalar, safe-Rust kernel. The fast paths that motivate an external function use SIMD intrinsics, which are outside the supported subset. + +Recommendation: do not build the bridge now. Keep `proved` in the design so it can be added without changing the declaration, and revisit under #356 when #362 has landed. + +## 9. What it costs + +Estimated from the arrays change, which touched the same layers: + +- IR, linker rules, schema (module and snapshot), Lean backend, canonical LaTeX, generated-source audit: one new declaration kind. +- Axiom handling: admit a generated name in exact policies; the attestation's `trust` records; the summary lines. +- Configuration and lock: `[[external_source]]`. +- One artifact role and report schema. +- Production registry row (formal-only), oracle overlap row. +- Register rows: one for the declaration and its refusals, one for the trust report. An example, negative fixtures for each refusal, and planted defects: a witness theorem about another function, a report bound to another statement ID, a theorem that omits the contract axiom from its policy, an external without its configuration row. +- It moves the language-1.2 identity, so it needs one regeneration, and lands one at a time with the other identity changes on the line (arrays, #474). + +## 10. Limits of the design itself + +- The contract is about a mathematical function. Foreign code that reads a clock, keeps state, or does not terminate is outside what the axiom says, and evidence by testing cannot establish totality. +- Attested evidence is as good as the test that produced it. LexLean binds the report to the contract and to the code digest; it does not judge coverage. +- A witness is required. A contract for which no LexLean function can be written (for example one that only bounds an error) needs the reference written first. For an inference kernel the witness is the integer reference engine, which has to exist anyway. +- Until D6 is decided the compiled Lean runs the witness, so the trust entry describes a binding a host makes, not one LexLean emits. + +## 11. Not implemented by this PR + +Everything. The file is the proposal. What would have to be true before work starts: the owners accept D1 to D3; arrays (`SM-39`) are on the line, because the example is over arrays; and the identity change is sequenced with #474. + +## 12. Decisions that belong to the owners + +### D1. An assumption about foreign code in a document + +§4.2 bans author axioms so that a verified status means what Lean checked. This proposal keeps that sentence true by putting the assumption in the theorem's own axiom set, where the status already shows it. The alternative is that systems with a hand-written kernel are never modelled. + +### D2. Mechanism + +Section 5. Option A if the trust must be reported by Lean; option B if the owners prefer that no axiom of any kind is ever generated, at the cost of threading parameters through every caller. + +### D3. Mandatory witness + +Without a witness an unsatisfiable contract proves anything. With it, the form adds no logical strength (section 6.3). + +### D4. Evidence kinds + +`attested` first. The report format and the artifact role are small. `proved` waits for #362. + +### D5. Project opt-in + +A configuration row makes every external visible in a diff of `lexlean.toml` and the lock, and keeps the default at "none". + +### D6. `@[extern]` + +Lean's `@[extern "symbol"]` on the opaque constant makes Lean-compiled C call the symbol. Prism builds applications that way, so this is how the fast engine would actually run. It fixes a calling convention for arrays and integers that PrismPM has to agree to, and the generated-source audit forbids the token today. + +### D7. Production + +Formal-only at first. A Rust realization would be an `extern` item or a trait parameter and is a separate design. + +### D8. Aeneas + +Section 8. From 513ea1534ff9dc0ee2a7fbd4c04c9ff567c15903 Mon Sep 17 00:00:00 2001 From: humuhumu33 Date: Thu, 12 Nov 2026 14:59:10 +0000 Subject: [PATCH 05/13] verify: every part names its toolchain by address A shard writes toolchain.json (lexlean/verify-toolchain/1) beside its output: the SHA-256 of the lean, lake and leanchecker its preflight hashed, of the running lexlean, and the address of the rustc that compiled it (its executable and rustc_driver library, hashed by the build script). A part that reads another refuses it (LLI9001, naming the part, the tool and both addresses) unless all five equal its own. A process record names only lean or leanchecker, so a part that ran another lake, lexlean or rustc was accepted before. VR-23 plants another lake address in a shard's output and, on unix, runs a join whose own lake differs from the pinned one by one byte; both are refused. Published directories, attestations and expected/verify do not change, and neither does the compiler-semantics ID. Co-Authored-By: Claude Opus 5.5 --- CHANGELOG.md | 12 ++ CONFORMANCE.md | 2 +- SPEC.md | 6 +- crates/conformance/src/cases/operational.rs | 74 +++++++++ crates/lexlean/Cargo.toml | 5 + crates/lexlean/build.rs | 77 +++++++++ crates/lexlean/src/lib.rs | 7 + crates/lexlean/src/verify/mod.rs | 25 ++- crates/lexlean/src/verify/partition.rs | 174 ++++++++++++++++---- crates/lexlean/src/verify/toolchain.rs | 111 +++++++++++++ features/suites/verification.feature | 3 +- model/ids.toml | 2 +- 12 files changed, 455 insertions(+), 43 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 08322fa32a..5af8bd4b4e 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -17,6 +17,18 @@ workspace carried at those versions without a tag. ## Unreleased +- Every part of a verification names its toolchain by address (SPEC.md + §22.11, §9.4). A shard writes `toolchain.json` (`lexlean/verify-toolchain/1`) + beside its output: the SHA-256 of the `lean`, `lake`, and `leanchecker` its + preflight hashed, of the running `lexlean`, and the address of the `rustc` + that compiled it (its executable and `rustc_driver` library, which the build + script hashes). A part that reads another refuses it (`LLI9001`, naming the + part, the tool, and both addresses) unless all five equal its own. A record + names only the executable it ran, so a part that ran another `lake`, + `lexlean`, or `rustc` was accepted before. `VR-23` plants another `lake` + address in a shard's output, and on unix a join whose own `lake` differs by + one byte. Published directories, attestations, and `expected/verify` are + unchanged. - A one-pass writer for the counts of the bootstrap count cases, #92. Under `LEXLEAN_COUNTS=fast` each of `BS-05` to `BS-08` and `BS-11` to `BS-15` records every count it checks in `target/count-report/` instead of diff --git a/CONFORMANCE.md b/CONFORMANCE.md index 5e0010e5e9..438caf2cef 100644 --- a/CONFORMANCE.md +++ b/CONFORMANCE.md @@ -675,7 +675,7 @@ the error registry does not sanction (R5, `ERRORS.md`). | `VR-20` | `build` | The verifier process width is an operational resource profile selected only by the environment, defaulting to 1 and refusing any malformed value with LLV7017, and it enters no lock, identity, or verified artifact. | | `VR-21` | `build` | A multi-module project whose imports form nontrivial frontiers verifies at width 1 and at a larger width to byte-identical verified directories and the same attestation identity, observed axiom sets, and policy rows, and no completion order orders a record or changes which failure is reported. | | `VR-22` | `build` | Performance telemetry is written only to the CI evidence directory the environment names, a verification with telemetry on publishes byte-identical artifacts to one without, and telemetry planted in a verified artifact fails the gate. | -| `VR-23` | `build` | A project verified as the parts of one run, each shard running the processes its plan names with the oleans of the shards it needs and the join reading every shard's records, publishes a verified directory byte-identical to the whole verification's with the same attestation identity, and a shard whose plan leaves a module without its imports, a join missing a record, or a join reading a record of an executable other than its own, is refused. | +| `VR-23` | `build` | A project verified as the parts of one run, each shard running the processes its plan names with the oleans of the shards it needs and the join reading every shard's records, publishes a verified directory byte-identical to the whole verification's with the same attestation identity, and a shard whose plan leaves a module without its imports, a join missing a record, a join reading a record of an executable other than its own, or a part that ran a toolchain other than its own, is refused. | ## Cited authorities diff --git a/SPEC.md b/SPEC.md index fb94dc902f..d2646e6557 100644 --- a/SPEC.md +++ b/SPEC.md @@ -695,7 +695,7 @@ Its image MUST install the pinned Rust and Lean toolchains at build, so that not In a run that is the whole gate, the jobs run the recipes as the rows of `.github/vv-rows.json`, each from its own clean checkout: `examples`, which verifies every example but UOR Atlas; `honesty`, which runs `fmt-check model spec-links bdd` before any expensive root; `rest`, the other recipes in the order of `vv`; and one `bdd-` row for each named part of the `bdd` plan below, which runs `bdd` alone. Each leg runs `just` with its recipes, which stops at the first that fails, as `vv` does. The part of `examples` a job runs is named by its matrix row through `LEXLEAN_EXAMPLES_PART` and by nothing else: `without:uor-atlas` on the leg, `shard:uor-atlas:` and `join:uor-atlas` on the Atlas jobs below; unset or empty, which is what `just vv` runs, the recipe verifies every example whole. After honesty succeeds, the remaining rows run as one matrix and the supported-host matrix, Intel construction and Atlas prefix may start; a failed or skipped honesty part starts none of these expensive roots. Together the legs and the Atlas jobs run every recipe of `vv`, every example, and every test of `bdd` exactly once, and the run passes only when every job passes, so it proves what one run of `just vv` proves; no recipe depends on another having run, and every recipe owns the files it builds. Its wall time is the longest path through the jobs rather than the sum. `just vv` remains the acceptance recipe of §9.2 for every other run, and release acceptance requires the complete same-tree run. -UOR Atlas is verified as the parts of one run. `.github/verify-shards.json` partitions its verification into shards, each naming the shards it needs, the modules it elaborates, and the modules it replays and audits, one of them named `join`; `cargo xtask ci-shards` checks, as the verifier would when a part ran, that every module is elaborated by exactly one shard and replayed by exactly one, that every import of a module a shard elaborates or replays is elaborated by that shard or by one it needs, directly or through another, and that `join` needs every other shard. Each shard is a job of its own clean checkout that runs the verifier's prelude whole (certificate generation, the preflights, staging, the generated-source audit, the probe), then elaborates, replays, and audits only the modules of its plan, reading the `.olean` files of the modules it imports from the output the jobs of the shards it needs uploaded in the same run, and uploads its own `.olean` files and process records as its output. The join runs the modules of its plan, reads every shard's records, requires each to name the executable the join itself hashed for the tool that produced it (`lean` for an elaboration or an audit member, `leanchecker` for a replay), judges each as the stage that produced it judges its own, and continues through policy, the attestation over every record in the canonical order of §22.11, publication, and the comparison of every normalized record with `expected/verify` (§29.5): what it publishes is what the whole verification publishes, record for record and attestation identity included (`VR-23`). A module without a record from any part, a record of a process no module owns, a record whose `executable_sha256` is not the join's digest of its tool (`LLI9001`, naming the record and both digests), or a shard whose plan leaves a module without the `.olean` it imports fails the run. Every process of the verification runs exactly once per run. The executable the Atlas jobs run is the one the `prefix` job built from its clean checkout, carried to the other jobs of the run as an artifact beside the shards' output; it, the output, and the records cross no run, and a job reads the artifacts of its own run only. The Atlas jobs run after the jobs of the shards they need, at the profile of the `examples` leg, and only in a run that is the whole gate. +UOR Atlas is verified as the parts of one run. `.github/verify-shards.json` partitions its verification into shards, each naming the shards it needs, the modules it elaborates, and the modules it replays and audits, one of them named `join`; `cargo xtask ci-shards` checks, as the verifier would when a part ran, that every module is elaborated by exactly one shard and replayed by exactly one, that every import of a module a shard elaborates or replays is elaborated by that shard or by one it needs, directly or through another, and that `join` needs every other shard. Each shard is a job of its own clean checkout that runs the verifier's prelude whole (certificate generation, the preflights, staging, the generated-source audit, the probe), then elaborates, replays, and audits only the modules of its plan, reading the `.olean` files of the modules it imports from the output the jobs of the shards it needs uploaded in the same run, and uploads its own `.olean` files and process records as its output. The join runs the modules of its plan, reads every shard's records, requires each to name the executable the join itself hashed for the tool that produced it (`lean` for an elaboration or an audit member, `leanchecker` for a replay), requires every shard's output to name the join's own toolchain addresses (§22.11), judges each as the stage that produced it judges its own, and continues through policy, the attestation over every record in the canonical order of §22.11, publication, and the comparison of every normalized record with `expected/verify` (§29.5): what it publishes is what the whole verification publishes, record for record and attestation identity included (`VR-23`). A module without a record from any part, a record of a process no module owns, a record whose `executable_sha256` is not the join's digest of its tool (`LLI9001`, naming the record and both digests), a shard whose output names no toolchain addresses or another address of any tool (`LLI9001`, naming the part, the tool, and both addresses), or a shard whose plan leaves a module without the `.olean` it imports fails the run. Every process of the verification runs exactly once per run. The executable the Atlas jobs run is the one the `prefix` job built from its clean checkout, carried to the other jobs of the run as an artifact beside the shards' output; it, the output, and the records cross no run, and a job reads the artifacts of its own run only. The Atlas jobs run after the jobs of the shards they need, at the profile of the `examples` leg, and only in a run that is the whole gate. The `bdd` recipe runs as the parts of one run as well. `.github/bdd-parts.json` names parts by conformance ID, complete integration-test targets in `targets`, and a remainder, `rest`. Cases that share a fixture built once per test process belong to one part. The `honesty` part owns the complete `bdd` meta-gate target, including any tests added to that target; no copied test-name list selects it. `cargo xtask bdd` runs `cargo test -p repo-conformance --all-features` with the Cargo target selectors and harness filters of `LEXLEAN_BDD_PART`. A target part selects its targets through `--test`; an ID part uses `--exact` and the test of each ID. The remainder discovers all integration-test targets from Cargo metadata, selects every target no target part owns, and keeps the library and binary tests and doctests; Cargo requires doctests in a separate invocation when target selectors are present. Its `--exact` and `--skip` filters omit every conformance test an ID part owns. A new test in a target belongs to that target's part; a new integration target and a new conformance ID belong to the remainder until assigned. No case decides whether it runs. `inventory` lists the tests using the same selectors and filters, proves disjointness and equality with the whole `bdd` suite, and requires a target part to own every test of its target (§9.2). Exactly one row runs every part, the remainder included. The initial honesty row names its part; each later `bdd-` row and the `rest` row name theirs. Unset or empty, as in local `just vv`, the recipe runs the whole suite unchanged. Each row builds from its own clean checkout; no build or evidence crosses runs. @@ -10224,7 +10224,7 @@ The profile changes how processes are scheduled and nothing else: For every project, the directory published at any profile equals, byte for byte, the directory published at width 1 without hints and without a budget, on the same host and toolchain; in particular the attestation ID, the observed axiom sets, the policy rows, the canonical compiler input, and every normalized verification record (§29.5) are identical. -A verification may also run as the parts of one run (§9.4): each part runs the processes of its plan at the profile of its own host, a part reads from another only the `.olean` files and process records that part's processes produced, and the join judges every record it reads as the stage that produced it judges its own, after requiring it to name the join's own digest of the executable that stage runs. The directory the join publishes equals, byte for byte, the one the whole verification publishes, attestation ID included (`VR-23`); a part is defined for a project without production roots and without PDF rendering. +A verification may also run as the parts of one run (§9.4): each part runs the processes of its plan at the profile of its own host, a part reads from another only the `.olean` files and process records that part's processes produced, and the join judges every record it reads as the stage that produced it judges its own, after requiring it to name the join's own digest of the executable that stage runs. Every part writes beside its output `toolchain.json` (`lexlean/verify-toolchain/1`): the SHA-256 of the `lean`, `lake`, and `leanchecker` its preflight hashed, of the running `lexlean`, and the address of the `rustc` that compiled that `lexlean`, which is the SHA-256 of one line ` ` per file of the compiler's `rustc` executable and `rustc_driver` library under `bin/` and `lib/`, in path order, as the build of `lexlean` found them. A part that reads another part requires its `toolchain.json` to name its own five addresses, and refuses the part otherwise, before it reads any record (`LLI9001`): a record names only the executable it ran, so a part that ran another `lake`, `lexlean`, or `rustc` is seen only there. The directory the join publishes equals, byte for byte, the one the whole verification publishes, attestation ID included (`VR-23`); a part is defined for a project without production roots and without PDF rendering. ### 22.12 Performance telemetry @@ -11805,7 +11805,7 @@ Every row below is normative, has honesty level `build`, and MUST be copied byte | `VR-20` | `verification` | The verifier process width is an operational resource profile selected only by the environment, defaulting to 1 and refusing any malformed value with LLV7017, and it enters no lock, identity, or verified artifact. | §22.11, §23.1 | | `VR-21` | `verification` | A multi-module project whose imports form nontrivial frontiers verifies at width 1 and at a larger width to byte-identical verified directories and the same attestation identity, observed axiom sets, and policy rows, and no completion order orders a record or changes which failure is reported. | §22.3, §22.4, §22.11 | | `VR-22` | `verification` | Performance telemetry is written only to the CI evidence directory the environment names, a verification with telemetry on publishes byte-identical artifacts to one without, and telemetry planted in a verified artifact fails the gate. | §22.12 | -| `VR-23` | `verification` | A project verified as the parts of one run, each shard running the processes its plan names with the oleans of the shards it needs and the join reading every shard's records, publishes a verified directory byte-identical to the whole verification's with the same attestation identity, and a shard whose plan leaves a module without its imports, a join missing a record, or a join reading a record of an executable other than its own, is refused. | §9.4, §22.11 | +| `VR-23` | `verification` | A project verified as the parts of one run, each shard running the processes its plan names with the oleans of the shards it needs and the join reading every shard's records, publishes a verified directory byte-identical to the whole verification's with the same attestation identity, and a shard whose plan leaves a module without its imports, a join missing a record, a join reading a record of an executable other than its own, or a part that ran a toolchain other than its own, is refused. | §9.4, §22.11 | | `CL-01` | `cli-api` | Global options and upward project discovery obey the exact CLI contract. | §23.1, §23.2 | | `CL-02` | `cli-api` | Init creates the complete canonical skeleton only in an absent or empty destination and never overwrites. | §23.4 | | `CL-03` | `cli-api` | Lock check, local update, and explicit network acquisition obey their exact mutually exclusive behavior. | §23.4 | diff --git a/crates/conformance/src/cases/operational.rs b/crates/conformance/src/cases/operational.rs index 5719b0f8ac..2cd3da1638 100644 --- a/crates/conformance/src/cases/operational.rs +++ b/crates/conformance/src/cases/operational.rs @@ -905,6 +905,80 @@ fn parts_equal_the_whole() { text.contains("from any part of the run") && text.contains(&rest[0]), "{text}" ); + // A join refuses a part that ran another toolchain: the first shard's + // output names the address of every executable it ran or was built by + // (§22.11), and a `lake` other than the join's is refused, naming the + // part, the tool, and both addresses, although no record names `lake`. + let addresses_path = dir("a").join("toolchain.json"); + let addresses = std::fs::read_to_string(addresses_path.as_std_path()) + .expect("a shard names its toolchain addresses"); + let lake = serde_json::from_str::(&addresses).expect("the addresses parse") + ["lake"] + .as_str() + .expect("the addresses name lake") + .to_owned(); + let planted_lake = "f".repeat(lake.len()); + assert_ne!(lake, planted_lake); + std::fs::write( + addresses_path.as_std_path(), + addresses.replacen(&lake, &planted_lake, 1), + ) + .expect("plant another lake"); + let error = run_part(VerifyPart::Join { + plan: plan(&rest, &rest), + parts: vec![dir("a"), dir("b")], + }) + .map(|_| ()) + .expect_err("a part of another lake"); + support::expect_code(&error, "LLI9001"); + let text = error.to_string(); + assert!( + text.contains("ran `lake`") && text.contains(&planted_lake) && text.contains(&lake), + "{text}" + ); + std::fs::write(addresses_path.as_std_path(), &addresses).expect("restore the addresses"); + // The same refusal from a real binary: a join whose own toolchain's + // `lake` differs by one appended byte from the pinned one the shards ran + // refuses them, naming both addresses. Its preflight hashes the changed + // file, so the join never trusts a part of the pinned toolchain. + #[cfg(unix)] + { + let pinned = support::real_elan_home() + .join("toolchains") + .join(support::mangled_toolchain_name()) + .join("bin") + .join("lake"); + let mut changed = std::fs::read(&pinned).expect("the pinned lake"); + changed.push(0); + let changed_address = lexlean::Sha256Digest::of(&changed).to_hex(); + let home = support::fake_elan_home(&[("lake".to_owned(), changed)]); + let home_text = home.path().to_string_lossy().into_owned(); + let project = P::copy_example(example); + let error = support::with_env(&[("ELAN_HOME", Some(&home_text))], || { + Operational::new(1, None).expect("width 1").scoped(|| { + lexlean::verify_part( + &project.engine(), + VerifyRequest { + selection: Selection::Entrypoints, + }, + VerifyPart::Join { + plan: plan(&rest, &rest), + parts: vec![dir("a"), dir("b")], + }, + ) + }) + }) + .map(|_| ()) + .expect_err("a join whose own lake changed"); + support::expect_code(&error, "LLI9001"); + let text = error.to_string(); + assert!( + text.contains("ran `lake`") && text.contains(&lake) && text.contains(&changed_address), + "{text}" + ); + } + #[cfg(not(unix))] + support::unix_only("VR-23", "symlinked toolchain to plant a changed `lake` in"); // A join refuses a record that another `leanchecker` ran: the second // shard's replay record of a module names an executable that is not the // join's, as a part on a different toolchain would have written it. diff --git a/crates/lexlean/Cargo.toml b/crates/lexlean/Cargo.toml index ab72c8f8be..9f9576ea37 100644 --- a/crates/lexlean/Cargo.toml +++ b/crates/lexlean/Cargo.toml @@ -39,6 +39,11 @@ walkdir = { workspace = true } rustix = { workspace = true } signal-hook = { workspace = true } +# The build script records the address of the `rustc` that compiles this crate +# (SPEC.md §22.11): the SHA-256 of its executable and driver library. +[build-dependencies] +sha2 = { workspace = true } + [dev-dependencies] proptest = { workspace = true } diff --git a/crates/lexlean/build.rs b/crates/lexlean/build.rs index ddac668a2e..b8241cf791 100644 --- a/crates/lexlean/build.rs +++ b/crates/lexlean/build.rs @@ -82,6 +82,83 @@ fn main() { errors.display() ); fs::write(out_dir.join("errors.toml"), bytes).expect("write errors.toml"); + + rustc_identity(&out_dir); +} + +/// The address of the compiler that builds this crate (SPEC.md §22.11): the +/// SHA-256 of one line ` ` per +/// file of the `rustc` executable and its driver library, in path order, and +/// what `rustc -vV` reports. The `rustc` executable is a thin launcher; the +/// compiler is the driver library it loads, so both are addressed. A compiler +/// whose sysroot cannot be read is a build failure, never an empty address. +fn rustc_identity(out_dir: &Path) { + use sha2::{Digest, Sha256}; + use std::process::Command; + + println!("cargo:rerun-if-env-changed=RUSTC"); + let rustc = env::var("RUSTC").unwrap_or_else(|_| "rustc".to_owned()); + let run = |argument: &str| { + let output = Command::new(&rustc) + .arg(argument) + .output() + .unwrap_or_else(|error| panic!("running `{rustc} {argument}`: {error}")); + assert!( + output.status.success(), + "`{rustc} {argument}` failed: {}", + String::from_utf8_lossy(&output.stderr) + ); + String::from_utf8(output.stdout).expect("rustc reports UTF-8") + }; + let version = run("-vV").replace("\r\n", "\n"); + let sysroot = PathBuf::from(run("--print=sysroot").trim()); + let mut files: Vec<(String, PathBuf)> = Vec::new(); + for directory in ["bin", "lib"] { + let Ok(entries) = fs::read_dir(sysroot.join(directory)) else { + continue; + }; + for entry in entries.filter_map(Result::ok) { + let name = entry.file_name().to_string_lossy().into_owned(); + let compiler = name == "rustc" + || name == "rustc.exe" + || name.starts_with("rustc_driver-") + || name.starts_with("librustc_driver-"); + if compiler && entry.path().is_file() { + files.push((format!("{directory}/{name}"), entry.path())); + } + } + } + files.sort(); + assert!( + files.iter().any(|(path, _)| path.starts_with("bin/rustc")), + "{}: no `rustc` executable in the compiler's sysroot", + sysroot.display() + ); + let mut listing = String::new(); + for (relative, path) in &files { + println!("cargo:rerun-if-changed={}", path.display()); + let bytes = + fs::read(path).unwrap_or_else(|error| panic!("reading {}: {error}", path.display())); + listing.push_str(&hex(&Sha256::digest(&bytes))); + listing.push_str(" "); + listing.push_str(relative); + listing.push('\n'); + } + let address = hex(&Sha256::digest(listing.as_bytes())); + fs::write( + out_dir.join("rustc_identity.rs"), + format!( + "/// What `rustc -vV` reported for the compiler that built this crate.\n\ + pub const RUSTC_VERSION: &str = {version:?};\n\ + /// The address of that compiler's executable and driver library.\n\ + pub const RUSTC_SHA256: &str = {address:?};\n" + ), + ) + .expect("write rustc_identity.rs"); +} + +fn hex(bytes: &[u8]) -> String { + bytes.iter().map(|byte| format!("{byte:02x}")).collect() } /// Resolve a crate-relative normative path: a directory or file as such; a diff --git a/crates/lexlean/src/lib.rs b/crates/lexlean/src/lib.rs index dd7664959b..0edc6c3780 100644 --- a/crates/lexlean/src/lib.rs +++ b/crates/lexlean/src/lib.rs @@ -106,6 +106,13 @@ pub mod embedded { include!(concat!(env!("OUT_DIR"), "/embedded.rs")); } +/// The compiler that built this crate, as the build script found it +/// (SPEC.md §22.11): what `rustc -vV` reported and the address of its +/// executable and driver library. It is no input of any compiler semantics. +pub mod build_identity { + include!(concat!(env!("OUT_DIR"), "/rustc_identity.rs")); +} + /// The original language identifier. Kept as the compatibility default for /// downstream code that compiled against LexLean 1.0. pub const LANGUAGE_VERSION: &str = "1.0"; diff --git a/crates/lexlean/src/verify/mod.rs b/crates/lexlean/src/verify/mod.rs index 498053eb77..7adcaa1de0 100644 --- a/crates/lexlean/src/verify/mod.rs +++ b/crates/lexlean/src/verify/mod.rs @@ -1333,16 +1333,23 @@ pub fn run_part( // What the parts before this one wrote (§9.4): their `.olean` files into // the staged tree, and, for the part that publishes, their records. stages.enter("part-import"); + // The addresses of everything this run executes or was built by + // (§22.11): a part writes them beside its output and a reader requires + // its own. The running executable must be readable to be named. + let own_addresses = toolchain::Addresses::of( + &toolchain, + running_executable_sha256().map_err(|io_error| { + fail(internal(format!( + "reading the running executable: {io_error}" + ))) + })?, + ); let mut imported = partition::import(part.inputs(), &olean_root, part.publishes()).map_err(fail)?; - // Every record another part wrote was run by the toolchain this run's - // preflight hashed: the attestation lists them under its digests. - partition::check_toolchain( - &imported, - toolchain.lean.sha256, - toolchain.leanchecker.sha256, - ) - .map_err(fail)?; + // Every part before this one ran the toolchain this run's preflight + // hashed, and every record it wrote names it: the attestation lists them + // under its digests. + partition::check_toolchain(&imported, &own_addresses).map_err(fail)?; // The leanchecker identity (module documentation), before any replay: // the preflight's toolchain-relative path and digest line, then the @@ -1932,7 +1939,7 @@ pub fn run_part( .plan() .map(|plan| plan.elaborate.clone()) .unwrap_or_default(); - partition::export(staging.path(), output, &own).map_err(fail)?; + partition::export(staging.path(), output, &own, &own_addresses).map_err(fail)?; telemetry_run.succeeded(); return Ok(PartOutcome::Shard { output: (*output).to_owned(), diff --git a/crates/lexlean/src/verify/partition.rs b/crates/lexlean/src/verify/partition.rs index b50a1c205a..e887693394 100644 --- a/crates/lexlean/src/verify/partition.rs +++ b/crates/lexlean/src/verify/partition.rs @@ -22,9 +22,13 @@ use std::collections::{BTreeMap, BTreeSet}; use camino::{Utf8Path, Utf8PathBuf}; use crate::artifact::canonical_json::Json; -use crate::artifact::content_id::Sha256Digest; use crate::diagnostic::Diagnostic; use crate::verify::child::ChildRecord; +use crate::verify::toolchain::Addresses; + +/// The file of a part's output that names the addresses of the executables +/// the part ran and was built by (§22.11). +pub const TOOLCHAIN_FILE: &str = "toolchain.json"; /// Which modules one part elaborates, and which it replays and audits. /// @@ -116,6 +120,8 @@ pub struct Imported { pub leanchecker: BTreeMap, /// Audit records by audit member name. pub audit: BTreeMap, + /// The toolchain addresses each part named, by its output directory. + pub toolchains: Vec<(Utf8PathBuf, Addresses)>, } fn io(what: &str, error: &std::io::Error) -> Diagnostic { @@ -137,12 +143,15 @@ fn malformed(what: &str, reason: impl std::fmt::Display) -> Diagnostic { /// /// A module's `.olean` may come from one part only, and a record of one /// process from one part only: two parts that both wrote one is a plan that -/// ran a process twice, which is refused rather than resolved. +/// ran a process twice, which is refused rather than resolved. Every part +/// names the addresses of its toolchain ([`TOOLCHAIN_FILE`]), which +/// [`check_toolchain`] compares with the reader's own. /// /// # Errors /// -/// A part that cannot be read, a duplicate `.olean` or record, or a record -/// that does not parse as the verifier wrote it. +/// A part that cannot be read, a duplicate `.olean` or record, a record +/// that does not parse as the verifier wrote it, or a part without its +/// toolchain addresses. pub fn import( parts: &[Utf8PathBuf], olean_root: &Utf8Path, @@ -156,6 +165,22 @@ pub fn import( "the output directory of a part is required and is not a directory", )); } + let addresses_path = part.join(TOOLCHAIN_FILE); + let addresses = std::fs::read(addresses_path.as_std_path()) + .map_err(|error| { + malformed( + addresses_path.as_str(), + format!("a part must name the addresses of its toolchain: {error}"), + ) + }) + .and_then(|bytes| { + Json::parse(&bytes).map_err(|reason| malformed(addresses_path.as_str(), reason)) + }) + .and_then(|json| { + Addresses::from_json(&json) + .map_err(|reason| malformed(addresses_path.as_str(), reason)) + })?; + imported.toolchains.push((part.clone(), addresses)); let oleans = part.join("oleans"); if oleans.as_std_path().is_dir() { for entry in walkdir::WalkDir::new(oleans.as_std_path()) @@ -222,31 +247,49 @@ pub fn import( Ok(imported) } -/// Require every imported record to name the executable the join itself -/// runs: `lean` for an elaboration or an audit member, `leanchecker` for a -/// replay (§9.4, §22.9). +/// Require every part to name the toolchain this run's preflight hashed, and +/// every imported record to name the executable the join itself runs: +/// `lean` for an elaboration or an audit member, `leanchecker` for a replay +/// (§9.4, §22.9, §22.11). /// /// In a whole verification every record carries the digest of the toolchain /// the run's preflight hashed, by construction. Across the parts of a run it /// holds only because every job installs the same pinned toolchain, which is -/// a practice and not a check: a part whose `lean` or `leanchecker` differed -/// from the join's would otherwise contribute records the attestation then -/// lists under the join's toolchain digests. +/// a practice and not a check: a part whose `lean`, `lake`, `leanchecker`, +/// `lexlean`, or the `rustc` that built it differed from the reader's would +/// otherwise contribute records the attestation then lists under the +/// reader's toolchain. A record names only the executable it ran, so the +/// part's own addresses ([`TOOLCHAIN_FILE`]) are compared first, whole. /// /// # Errors /// -/// The first record, in the order elaborations, replays, audit members, and -/// by name within each, whose `executable_sha256` is not the join's digest of -/// the tool that produced it, naming the record and both digests. -pub fn check_toolchain( - imported: &Imported, - lean: Sha256Digest, - leanchecker: Sha256Digest, -) -> Result<(), Diagnostic> { +/// The first part, in the order given, whose addresses differ from `own`, +/// naming the part, the tool, and both addresses; then the first record, in +/// the order elaborations, replays, audit members, and by name within each, +/// whose `executable_sha256` is not the reader's digest of the tool that +/// produced it, naming the record and both digests. +pub fn check_toolchain(imported: &Imported, own: &Addresses) -> Result<(), Diagnostic> { + for (part, addresses) in &imported.toolchains { + if let Some((tool, theirs, mine)) = addresses.first_difference(own) { + return Err(malformed( + &format!("the part `{part}`"), + format!( + "it ran `{tool}` {}, but this run's `{tool}` is {}; every part of a run must run one toolchain", + theirs.to_hex(), + mine.to_hex() + ), + )); + } + } for (what, tool, expected, records) in [ - ("elaboration", "lean", lean, &imported.lean), - ("replay", "leanchecker", leanchecker, &imported.leanchecker), - ("audit", "lean", lean, &imported.audit), + ("elaboration", "lean", own.lean, &imported.lean), + ( + "replay", + "leanchecker", + own.leanchecker, + &imported.leanchecker, + ), + ("audit", "lean", own.lean, &imported.audit), ] { for (name, record) in records { if record.executable_sha256 != expected { @@ -314,7 +357,9 @@ fn read_records( /// intermediates (a later part's elaboration reads them), the elaboration /// and replay records, and the audit records. The `.olean` files the shard /// imported stay behind: they are the part that produced them's to export, -/// once. Nothing else leaves the staging tree, which is removed with it. +/// once. Beside them the part names the addresses of its toolchain +/// ([`TOOLCHAIN_FILE`]). Nothing else leaves the staging tree, which is +/// removed with it. /// /// # Errors /// @@ -323,6 +368,7 @@ pub fn export( staging: &std::path::Path, output: &Utf8Path, own: &BTreeSet, + addresses: &Addresses, ) -> Result<(), Diagnostic> { if output.as_std_path().exists() { let mut entries = std::fs::read_dir(output.as_std_path()) @@ -336,6 +382,11 @@ pub fn export( } std::fs::create_dir_all(output.as_std_path()) .map_err(|error| io("creating the part's output directory", &error))?; + std::fs::write( + output.join(TOOLCHAIN_FILE).as_std_path(), + addresses.to_json().to_file_bytes(), + ) + .map_err(|error| io("writing the part's toolchain addresses", &error))?; let oleans = staging.join("oleans"); if oleans.is_dir() { for entry in walkdir::WalkDir::new(&oleans).sort_by_file_name() { @@ -545,7 +596,15 @@ mod tests { let out = tempfile::tempdir().expect("tempdir"); let output = Utf8PathBuf::from_path_buf(out.path().join("part")).expect("utf8"); let own: BTreeSet = ["X.M".to_owned()].into_iter().collect(); - export(staging.path(), &output, &own).expect("exports"); + let digest = crate::artifact::content_id::Sha256Digest::of; + let addresses = Addresses { + lean: digest(b"lean"), + lake: digest(b"lake"), + leanchecker: digest(b"leanchecker"), + lexlean: digest(b"lexlean"), + rustc: digest(b"rustc"), + }; + export(staging.path(), &output, &own, &addresses).expect("exports"); assert!( staging.path().join("oleans/X/N.olean").exists() && !staging.path().join("oleans/X/M.olean").exists(), @@ -566,11 +625,58 @@ mod tests { assert!(imported.audit.contains_key("LexLeanAudit.X.M")); // The records name the join's `lean`; a join whose `lean` is another // executable refuses them, naming the record and both digests. - let lean = crate::artifact::content_id::Sha256Digest::of(b"lean"); - let other = crate::artifact::content_id::Sha256Digest::of(b"another lean"); - check_toolchain(&imported, lean, other).expect("the records name the join's lean"); - let refused = check_toolchain(&imported, other, other) - .expect_err("a record of another lean is refused"); + let lean = addresses.lean; + let other = digest(b"another lean"); + assert_eq!(imported.toolchains, vec![(output.clone(), addresses)]); + check_toolchain(&imported, &addresses).expect("the part and its records name the join's"); + // A part that ran another executable of any of the five is refused, + // naming the part, the tool, and both addresses, before any record. + for (tool, plant) in [ + ( + "lake", + Addresses { + lake: other, + ..addresses + }, + ), + ( + "lexlean", + Addresses { + lexlean: other, + ..addresses + }, + ), + ( + "rustc", + Addresses { + rustc: other, + ..addresses + }, + ), + ] { + let refused = check_toolchain(&imported, &plant) + .expect_err("a part of another toolchain is refused"); + let message = format!("{refused:?}"); + assert!( + message.contains("LLI9001") + && message.contains(&format!("ran `{tool}`")) + && message.contains(&other.to_hex()), + "{message}" + ); + } + // Records are compared against the reader's own `lean` once the part + // agrees: here the part's addresses are taken as the reader's, and + // the reader's `lean` differs from the one the record names. + let mut reader = imported; + reader.toolchains.clear(); + let refused = check_toolchain( + &reader, + &Addresses { + lean: other, + ..addresses + }, + ) + .expect_err("a record of another lean is refused"); let message = format!("{refused:?}"); assert!( message.contains("LLI9001") @@ -586,9 +692,21 @@ mod tests { let wrong = out.path().join("wrong/process/lean/X.N.json"); std::fs::create_dir_all(wrong.parent().expect("parent")).expect("mkdir"); std::fs::write(&wrong, record.to_json().to_file_bytes()).expect("write"); + std::fs::write( + out.path().join("wrong").join(TOOLCHAIN_FILE), + addresses.to_json().to_file_bytes(), + ) + .expect("write"); let wrong_part = Utf8PathBuf::from_path_buf(out.path().join("wrong")).expect("utf8"); let fresh = tempfile::tempdir().expect("tempdir"); let fresh_root = Utf8PathBuf::from_path_buf(fresh.path().join("oleans")).expect("utf8"); assert!(import(std::slice::from_ref(&wrong_part), &fresh_root, true).is_err()); + // A part that names no toolchain addresses is refused. + std::fs::remove_file(output.join(TOOLCHAIN_FILE)).expect("remove"); + let bare = tempfile::tempdir().expect("tempdir"); + let bare_root = Utf8PathBuf::from_path_buf(bare.path().join("oleans")).expect("utf8"); + let refused = import(std::slice::from_ref(&output), &bare_root, true) + .expect_err("a part without toolchain addresses"); + assert!(format!("{refused:?}").contains("addresses of its toolchain")); } } diff --git a/crates/lexlean/src/verify/toolchain.rs b/crates/lexlean/src/verify/toolchain.rs index 0aae60e21b..ad2ba98784 100644 --- a/crates/lexlean/src/verify/toolchain.rs +++ b/crates/lexlean/src/verify/toolchain.rs @@ -34,6 +34,117 @@ pub struct Toolchain { pub leanchecker: Tool, } +/// The format of [`Addresses`] as a part of a verification writes it. +pub const ADDRESSES_SPEC: &str = "lexlean/verify-toolchain/1"; + +/// The addresses of every executable a verification ran or was built by +/// (SPEC.md §22.11): `lean`, `lake`, and `leanchecker` as the preflight +/// hashed them, the running `lexlean`, and the `rustc` that compiled it. +/// Two parts of one verification agree on all five or neither trusts the +/// other's records. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct Addresses { + /// `lean`. + pub lean: Sha256Digest, + /// `lake`. + pub lake: Sha256Digest, + /// `leanchecker`. + pub leanchecker: Sha256Digest, + /// The running `lexlean` executable. + pub lexlean: Sha256Digest, + /// The `rustc` that compiled this `lexlean` (its executable and driver + /// library, [`crate::build_identity::RUSTC_SHA256`]). + pub rustc: Sha256Digest, +} + +impl Addresses { + /// The addresses of this preflighted toolchain, the running executable + /// whose digest is `lexlean`, and the compiler that built it. + #[must_use] + pub fn of(toolchain: &Toolchain, lexlean: Sha256Digest) -> Self { + Self { + lean: toolchain.lean.sha256, + lake: toolchain.lake.sha256, + leanchecker: toolchain.leanchecker.sha256, + lexlean, + rustc: Sha256Digest::from_hex(crate::build_identity::RUSTC_SHA256) + .expect("the build script writes a SHA-256"), + } + } + + /// Every tool with its address, in name order. + #[must_use] + pub fn tools(&self) -> [(&'static str, Sha256Digest); 5] { + [ + ("lake", self.lake), + ("lean", self.lean), + ("leanchecker", self.leanchecker), + ("lexlean", self.lexlean), + ("rustc", self.rustc), + ] + } + + /// The canonical JSON form. + #[must_use] + pub fn to_json(&self) -> crate::artifact::canonical_json::Json { + use crate::artifact::canonical_json::Json; + let mut pairs = vec![("spec", Json::Str(ADDRESSES_SPEC.to_owned()))]; + for (tool, address) in self.tools() { + pairs.push((tool, Json::Str(address.to_hex()))); + } + Json::object(pairs) + } + + /// Read the canonical JSON form, refusing anything else: another + /// format, a missing or malformed address, or an unknown field. + /// + /// # Errors + /// + /// What is wrong with `json`. + pub fn from_json(json: &crate::artifact::canonical_json::Json) -> Result { + use crate::artifact::canonical_json::Json; + let Json::Obj(fields) = json else { + return Err("the toolchain addresses are an object".to_owned()); + }; + if fields.get("spec") != Some(&Json::Str(ADDRESSES_SPEC.to_owned())) { + return Err(format!("`spec` must be `{ADDRESSES_SPEC}`")); + } + let address = |tool: &str| match fields.get(tool) { + Some(Json::Str(hex)) => Sha256Digest::from_hex(hex) + .map_err(|reason| format!("the address of `{tool}`: {reason}")), + _ => Err(format!("the address of `{tool}` is required")), + }; + let addresses = Self { + lean: address("lean")?, + lake: address("lake")?, + leanchecker: address("leanchecker")?, + lexlean: address("lexlean")?, + rustc: address("rustc")?, + }; + if let Some(unknown) = fields + .keys() + .find(|key| *key != "spec" && !addresses.tools().iter().any(|(tool, _)| tool == key)) + { + return Err(format!("unknown field `{unknown}`")); + } + Ok(addresses) + } + + /// The first tool whose address differs between `self` and `other`, with + /// both addresses, in name order. + #[must_use] + pub fn first_difference( + &self, + other: &Self, + ) -> Option<(&'static str, Sha256Digest, Sha256Digest)> { + self.tools() + .into_iter() + .zip(other.tools()) + .find(|((_, mine), (_, theirs))| mine != theirs) + .map(|((tool, mine), (_, theirs))| (tool, mine, theirs)) + } +} + fn environment(message: impl Into) -> Diagnostic { Diagnostic::new(code!("LLV7001"), message) } diff --git a/features/suites/verification.feature b/features/suites/verification.feature index 98b176bec9..b222b31d9f 100644 --- a/features/suites/verification.feature +++ b/features/suites/verification.feature @@ -162,9 +162,10 @@ Feature: verification And a verified directory in which a telemetry key is planted is refused @VR-23 @build - Scenario: A project verified as the parts of one run, each shard running the processes its plan names with the oleans of the shards it needs and the join reading every shard's records, publishes a verified directory byte-identical to the whole verification's with the same attestation identity, and a shard whose plan leaves a module without its imports, a join missing a record, or a join reading a record of an executable other than its own, is refused. + Scenario: A project verified as the parts of one run, each shard running the processes its plan names with the oleans of the shards it needs and the join reading every shard's records, publishes a verified directory byte-identical to the whole verification's with the same attestation identity, and a shard whose plan leaves a module without its imports, a join missing a record, a join reading a record of an executable other than its own, or a part that ran a toolchain other than its own, is refused. Given a committed multi-module example project and a plan of two shards and a join over its import graph When it is verified whole and as the parts of one run Then the join publishes a verified directory byte-identical to the whole verification's, with the same attestation identity And a shard whose plan elaborates a module before its imports, and a join that is handed one shard too few, are refused + And a join reading a part whose toolchain addresses name another lake is refused And a join reading a replay record whose executable digest is not its own leanchecker's is refused diff --git a/model/ids.toml b/model/ids.toml index 7a3ca502f5..129e540642 100644 --- a/model/ids.toml +++ b/model/ids.toml @@ -1349,7 +1349,7 @@ statement = "Performance telemetry is written only to the CI evidence directory id = "VR-23" level = "build" suite = "verification" -statement = "A project verified as the parts of one run, each shard running the processes its plan names with the oleans of the shards it needs and the join reading every shard's records, publishes a verified directory byte-identical to the whole verification's with the same attestation identity, and a shard whose plan leaves a module without its imports, a join missing a record, or a join reading a record of an executable other than its own, is refused." +statement = "A project verified as the parts of one run, each shard running the processes its plan names with the oleans of the shards it needs and the join reading every shard's records, publishes a verified directory byte-identical to the whole verification's with the same attestation identity, and a shard whose plan leaves a module without its imports, a join missing a record, a join reading a record of an executable other than its own, or a part that ran a toolchain other than its own, is refused." [[id]] id = "CL-01" From 3f0096fdc317d5897719fbbeb6f03d4b66f3a51b Mon Sep 17 00:00:00 2001 From: humuhumu33 Date: Thu, 12 Nov 2026 18:48:30 +0000 Subject: [PATCH 06/13] ci: the bootstrap export's custody names executable addresses MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The custody record becomes lexlean/ci-bootstrap-export/2. Beside what `rustc -vV` and `lean --version` report, it names the SHA-256 of the pinned toolchain's lake, lean and leanchecker and the address of the rustc that compiled the exporting binary (SPEC.md §22.11). A leg whose own executables differ refuses the export. A version banner is the same for a rebuilt or patched binary; the bytes are not. RP-14 plants another leanchecker and another rustc. Co-Authored-By: Claude Opus 5.5 --- CHANGELOG.md | 8 +++- SPEC.md | 2 +- crates/conformance/src/cases/repository.rs | 30 +++++++++++++++ crates/conformance/src/export_custody.rs | 43 +++++++++++++++++++--- 4 files changed, 75 insertions(+), 8 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 07b3b22200..0f4c7ee698 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -27,8 +27,12 @@ workspace carried at those versions without a tag. names only the executable it ran, so a part that ran another `lake`, `lexlean`, or `rustc` was accepted before. `VR-23` plants another `lake` address in a shard's output, and on unix a join whose own `lake` differs by - one byte. Published directories, attestations, and `expected/verify` are - unchanged. + one byte. The bootstrap export's custody record becomes + `lexlean/ci-bootstrap-export/2`: it also names the SHA-256 of the pinned + `lake`, `lean`, and `leanchecker` and the address of the `rustc` that built + the exporting binary, and a leg whose own differ refuses the export (`RP-14` + plants another `leanchecker` and another `rustc`). Published directories, + attestations, and `expected/verify` are unchanged. - A one-pass writer for the counts of the bootstrap count cases, #92. Under `LEXLEAN_COUNTS=fast` each of `BS-05` to `BS-08` and `BS-11` to `BS-15` records every count it checks in `target/count-report/` instead of diff --git a/SPEC.md b/SPEC.md index 21cc5ca7b7..32d68ad314 100644 --- a/SPEC.md +++ b/SPEC.md @@ -703,7 +703,7 @@ The `bdd` recipe runs as the parts of one run as well. `.github/bdd-parts.json` Every normative gate job runs on the standard GitHub-hosted runner, `ubuntu-24.04`; no larger runner is part of the gate. The supported-host execution jobs run on their named hosts (§8.3); the Intel and Windows aggregates run on `ubuntu-24.04` and execute no host test. The verification resource profile (§22.11) of a job is named by its matrix row, or on an Atlas job by the job itself, and by nothing else, no repository or workflow variable and no input: the `examples` leg and every Atlas job verify at width 2, with the scheduling hints committed in `.github/verify-hints.json` (derived from a run's telemetry by `cargo xtask ci-hints`) and a memory budget of 12 GiB (12582912 KiB) for the summed expected peaks of the proof processes running at once; the other legs name no profile and run at the default. A profile is a schedule and never a verdict: every elaboration, replay, and audit member still runs on the pinned toolchain, the directory each project publishes is byte for byte the one of width 1 without hints or a budget (§22.11), and the leg and the join still require every example's normalized verification records to equal `expected/verify` (§29.5), so a profile that changed a byte would fail the gate rather than pass a different one. A stale hint reorders processes and never skips one. Local `just vv` verifies UOR Atlas whole at width 1 with no profile. The budget is below the runner's 16 GB, with the 4 GiB swap file of the job as overflow, so two processes run together only when their expected peaks fit, and a process whose expected peak alone passes the budget runs alone. The gate has no path filter, no cache of a build directory, object, verification tree, attestation, or proof result, and no condition that skips a recipe of `just vv` but the plan's, which decides only what a run is, as above; the artifacts the jobs of one run exchange are read by that run alone, and every job starts from a clean checkout with the exact pinned toolchains. Each proof or fan-out job writes its performance telemetry (§22.12) to `ci-evidence/` and uploads that directory as the artifact named after it, `acceptance-gate-evidence-` or `acceptance-gate-evidence-atlas-`: the gate log (`just --timestamp` stamps each recipe's first command on a leg, which is how a recipe is timed without changing it; an Atlas job's log is the recipe's own output), the host's memory and swap sampled every five seconds, the verifier's telemetry, and a summary of the wall time of each recipe and verification stage, the slowest modules and audit members, and the peak resident set and swap of the proof processes. The summary step also prints that summary to the job log and appends it to the step summary, and runs when the job failed, because an uploaded artifact cannot be read from the log; each table lists only its slowest rows and the part appended to the step summary is cut at 512 KiB, half of what GitHub accepts. The initial honesty job retains its recipe timing and summary in the same evidence format, without Lean processes or proof-resource samples. None of it is an input of any recipe, and a timing is never a claim about a semantic property. -The bootstrap production export (§24.7) is made once per run. Every bootstrap case compares the packages of the bootstrap project's export with the committed packages, and a test process that needs the export exports the project, which verifies it whole; each part that ran a bootstrap case ran that verification. In a run that is the whole gate, the job `bootstrap-export` runs `cargo xtask export-bootstrap` from its clean checkout after honesty, at the profile of the `examples` leg, requires every exported package to equal the committed package, and uploads the bundle as the artifact `bootstrap-export` with a custody record (`lexlean/ci-bootstrap-export/1`) that names the repository, the run and its attempt, the commit and its tree, the SHA-256 of `rust-toolchain.toml`, `lean-toolchain` and `Cargo.lock`, what `rustc -vV` and `lean --version` report, the bundle's project-relative path, and the digest of its files. The legs do not wait for that job to start: each leg of such a run starts `.github/scripts/take-bootstrap-export.sh`, which asks nothing until a case of the leg needs the export, then downloads that artifact of its own run, or records that the export job ended without it, and the case fails with that reason. The harness names the directory it waits in through `LEXLEAN_BOOTSTRAP_EXPORT`; before any case reads the bundle it requires the record to name the leg's own repository, run, commit, tree, pins and toolchains, an attempt at most the leg's (a rerun of failed jobs keeps the export that passed, on the same commit), the digest of the files it received, and a path below the project, and it replays the bundle (§24.7). A record that differs in any of these fails the case. Unset or empty, as in `just vv` and in a run that is not the whole gate, each process that needs the export runs it itself. The export crosses no run, as the Atlas parts do not; `RP-14` checks the job, the legs' fetcher, and the record against planted changes. +The bootstrap production export (§24.7) is made once per run. Every bootstrap case compares the packages of the bootstrap project's export with the committed packages, and a test process that needs the export exports the project, which verifies it whole; each part that ran a bootstrap case ran that verification. In a run that is the whole gate, the job `bootstrap-export` runs `cargo xtask export-bootstrap` from its clean checkout after honesty, at the profile of the `examples` leg, requires every exported package to equal the committed package, and uploads the bundle as the artifact `bootstrap-export` with a custody record (`lexlean/ci-bootstrap-export/2`) that names the repository, the run and its attempt, the commit and its tree, the SHA-256 of `rust-toolchain.toml`, `lean-toolchain` and `Cargo.lock`, what `rustc -vV` and `lean --version` report, the SHA-256 of the pinned toolchain's `lake`, `lean` and `leanchecker` executables and the address of the `rustc` that compiled the job's own binary (§22.11), the bundle's project-relative path, and the digest of its files. The legs do not wait for that job to start: each leg of such a run starts `.github/scripts/take-bootstrap-export.sh`, which asks nothing until a case of the leg needs the export, then downloads that artifact of its own run, or records that the export job ended without it, and the case fails with that reason. The harness names the directory it waits in through `LEXLEAN_BOOTSTRAP_EXPORT`; before any case reads the bundle it requires the record to name the leg's own repository, run, commit, tree, pins, toolchains and executable addresses, an attempt at most the leg's (a rerun of failed jobs keeps the export that passed, on the same commit), the digest of the files it received, and a path below the project, and it replays the bundle (§24.7). A record that differs in any of these fails the case. Unset or empty, as in `just vv` and in a run that is not the whole gate, each process that needs the export runs it itself. The export crosses no run, as the Atlas parts do not; `RP-14` checks the job, the legs' fetcher, and the record against planted changes. The Intel host factory is separate from the normative BDD and Atlas partitions above: it transfers only the same-run host test construction and dependency data of §8.3. Construction requires successful honesty; consumers require construction; the aggregate requires all of them and cannot skip an incomplete result. The factory's behavioral tests run in the initial honesty job, before the expensive roots, and exercise inventory completeness, custody and fail-closed result joins without needing an Intel runner. These tests do not substitute for execution of the complete workload on Intel macOS. diff --git a/crates/conformance/src/cases/repository.rs b/crates/conformance/src/cases/repository.rs index 9c227c41dd..e52b0edccf 100644 --- a/crates/conformance/src/cases/repository.rs +++ b/crates/conformance/src/cases/repository.rs @@ -3496,6 +3496,15 @@ fn bootstrap_custody_decisions() { .into_iter() .map(|(name, text)| (name.to_owned(), text.to_owned())) .collect(); + let executables: BTreeMap = [ + ("lake", "5"), + ("lean", "6"), + ("leanchecker", "7"), + ("rustc", "8"), + ] + .into_iter() + .map(|(name, digit)| (name.to_owned(), digit.repeat(64))) + .collect(); let here = Identity { repository: "UOR-Foundation/LexLean".to_owned(), run_id: "100".to_owned(), @@ -3504,6 +3513,7 @@ fn bootstrap_custody_decisions() { tree: "2".repeat(40), pins: pins.clone(), toolchains: toolchains.clone(), + executables: executables.clone(), }; let bundle = ("d".repeat(64), 162); let record = Custody { @@ -3515,6 +3525,7 @@ fn bootstrap_custody_decisions() { tree: here.tree.clone(), pins, toolchains, + executables, bundle_path: ".lexlean/production/bundle".to_owned(), bundle_sha256: bundle.0.clone(), bundle_files: bundle.1, @@ -3550,6 +3561,25 @@ fn bootstrap_custody_decisions() { .insert("rustc".to_owned(), "rustc 1.97.0".to_owned()); }), ), + // An export whose toolchain reports the pinned versions but whose + // executables are other bytes: a changed `leanchecker`, or a binary + // built by another `rustc` (§22.11). + ( + "executables", + Box::new(|record| { + record + .executables + .insert("leanchecker".to_owned(), "9".repeat(64)); + }), + ), + ( + "executables", + Box::new(|record| { + record + .executables + .insert("rustc".to_owned(), "0".repeat(64)); + }), + ), ( "bundle", Box::new(|record| record.bundle_sha256 = "f".repeat(64)), diff --git a/crates/conformance/src/export_custody.rs b/crates/conformance/src/export_custody.rs index 0f6c5fff54..a1bc4d5101 100644 --- a/crates/conformance/src/export_custody.rs +++ b/crates/conformance/src/export_custody.rs @@ -2,8 +2,9 @@ //! (SPEC.md §9.4). The `bootstrap-export` job exports the bootstrap project //! once, requires its packages to equal the committed packages, and uploads //! the bundle with a custody record that binds it to the repository, the -//! run and its attempt, the commit and its tree, the toolchain pins and the -//! toolchains that ran, and the bundle's bytes. A conformance case of the same +//! run and its attempt, the commit and its tree, the toolchain pins, the +//! toolchains that ran and the addresses of their executables, and the +//! bundle's bytes. A conformance case of the same //! run that needs the export takes it from there instead of exporting the //! project again: the harness names the directory it waits in through //! [`VARIABLE`], checks the record against its own run and checkout, replays @@ -26,7 +27,7 @@ use crate::support::{self, P}; pub const VARIABLE: &str = "LEXLEAN_BOOTSTRAP_EXPORT"; /// The custody record's format. -pub const SPEC: &str = "lexlean/ci-bootstrap-export/1"; +pub const SPEC: &str = "lexlean/ci-bootstrap-export/2"; /// The custody record, beside the bundle in the uploaded directory. pub const CUSTODY_FILE: &str = "custody.json"; @@ -49,6 +50,10 @@ pub const ARTIFACT_DIR: &str = "artifact"; /// The repository files whose bytes pin the toolchains and the dependencies. pub const PINS: [&str; 3] = ["rust-toolchain.toml", "lean-toolchain", "Cargo.lock"]; +/// The executables of the pinned Lean toolchain a custody record addresses, +/// beside `rustc` (SPEC.md §22.11). +pub const LEAN_EXECUTABLES: [&str; 3] = ["lake", "lean", "leanchecker"]; + /// The longest a case waits for the run's export: the export job's own /// limit, after which the job has failed and the fetcher says so. const WAIT: Duration = Duration::from_secs(6 * 60 * 60); @@ -73,6 +78,10 @@ pub struct Custody { pub pins: BTreeMap, /// What the toolchains report: `rustc -vV` and `lean --version`. pub toolchains: BTreeMap, + /// The address of each executable: the SHA-256 of `lake`, `lean`, and + /// `leanchecker` of the pinned toolchain, and the address of the `rustc` + /// that compiled the job's own binary (§22.11). + pub executables: BTreeMap, /// The project-relative bundle directory of the export. pub bundle_path: String, /// [`bundle_digest`] of the bundle. @@ -98,6 +107,8 @@ pub struct Identity { pub pins: BTreeMap, /// What the toolchains report. pub toolchains: BTreeMap, + /// The address of each executable. + pub executables: BTreeMap, } fn sha256_hex(bytes: &[u8]) -> String { @@ -130,7 +141,8 @@ fn run(root: &Utf8Path, program: &str, arguments: &[&str]) -> Result Result { let variable = |name: &str| -> Result { std::env::var(name) @@ -169,6 +181,19 @@ pub fn identity(root: &Utf8Path) -> Result { ("lean".to_owned(), run(root, "lean", &["--version"])?), ("rustc".to_owned(), run(root, "rustc", &["-vV"])?), ]); + let bin = lexlean::verify::toolchain::toolchain_root() + .map_err(|error| format!("the pinned toolchain: {}", error.message))? + .join("bin"); + let mut executables = BTreeMap::new(); + for name in LEAN_EXECUTABLES { + let bytes = std::fs::read(bin.join(name).as_std_path()) + .map_err(|error| format!("{bin}/{name}: {error}"))?; + executables.insert(name.to_owned(), sha256_hex(&bytes)); + } + executables.insert( + "rustc".to_owned(), + lexlean::build_identity::RUSTC_SHA256.to_owned(), + ); Ok(Identity { repository, run_id, @@ -177,6 +202,7 @@ pub fn identity(root: &Utf8Path) -> Result { tree: run(root, "git", &["rev-parse", "HEAD^{tree}"])?, pins, toolchains, + executables, }) } @@ -261,6 +287,12 @@ pub fn check(custody: &Custody, current: &Identity, bundle: &(String, u64)) -> R ¤t.toolchains, custody.toolchains == current.toolchains, ); + same( + "executables", + &custody.executables, + ¤t.executables, + custody.executables == current.executables, + ); same( "bundle", &(&custody.bundle_sha256, custody.bundle_files), @@ -330,6 +362,7 @@ pub fn publish(output: &Utf8Path) -> Result { tree: before.tree, pins: before.pins, toolchains: before.toolchains, + executables: before.executables, bundle_path: exported.output.bundle.to_string(), bundle_sha256, bundle_files, @@ -349,7 +382,7 @@ pub fn publish(output: &Utf8Path) -> Result { /// # Errors /// /// When the run has no export, the record names another run, commit, tree, -/// pin, toolchain, or bundle, or the bundle does not replay. +/// pin, toolchain, executable, or bundle, or the bundle does not replay. pub fn take(directory: &Utf8Path) -> Result { std::fs::create_dir_all(directory.as_std_path()) .and_then(|()| std::fs::write(directory.join(WANTED).as_std_path(), b"")) From 041b7ab83d43cad13908028c13e66b1aa9fb6360 Mon Sep 17 00:00:00 2001 From: humuhumu33 Date: Thu, 12 Nov 2026 22:58:37 +0000 Subject: [PATCH 07/13] lexlean: build_identity is an internal module (CL-13) Co-Authored-By: Claude Opus 5.5 --- crates/lexlean/src/lib.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/crates/lexlean/src/lib.rs b/crates/lexlean/src/lib.rs index 0edc6c3780..2996ef667b 100644 --- a/crates/lexlean/src/lib.rs +++ b/crates/lexlean/src/lib.rs @@ -109,6 +109,7 @@ pub mod embedded { /// The compiler that built this crate, as the build script found it /// (SPEC.md §22.11): what `rustc -vV` reported and the address of its /// executable and driver library. It is no input of any compiler semantics. +#[doc(hidden)] pub mod build_identity { include!(concat!(env!("OUT_DIR"), "/rustc_identity.rs")); } From 491cb33a18bacfc7980d666f5b25bd5f00b363a0 Mon Sep 17 00:00:00 2001 From: Maura Clark Date: Fri, 13 Nov 2026 19:58:47 +0000 Subject: [PATCH 08/13] fix(canonical-json): compare duplicate keys after escape decoding Json::parse refused {"a":1,"a":2} but accepted {"a":1,"a":2} and returned {"a":2}, because check_duplicate_keys compared raw escaped key bytes. Decode each key before inserting it into the per-object set, add AR-11 assertions, and a CHANGELOG entry. Fixes #475. Recreated from #473 (conflicted with release/v0.4; fork gets no CI). Co-Authored-By: Claude Sonnet 5.5 Claude-Session: https://claude.ai/code/session_013Asa3M8ULnzEQwLLngyBBX --- CHANGELOG.md | 5 +++++ crates/conformance/src/cases/artifacts.rs | 12 ++++++++++++ crates/lexlean/src/artifact/canonical_json.rs | 14 +++++++++----- 3 files changed, 26 insertions(+), 5 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index bcbd097509..0ce0369644 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -17,6 +17,11 @@ workspace carried at those versions without a tag. ## Unreleased +- Canonical JSON refuses duplicate keys that differ only in their escapes (SPEC.md §21.7, + `AR-11`, #475). The duplicate check compared each key as written, so `{"a":1,"\u0061":2}` + passed it and `Json::parse` returned `{"a":2}`, dropping the first member; keys are now + compared after escape decoding. Equal keys in distinct objects stay admitted, and no valid + canonical document is affected. - Releases and regeneration need no hand steps (SPEC.md §9.4). `regenerate.yml` gains the job `deliver`: when the regenerated commit heads one open pull request of this repository, the patch is committed on it, pushed to the pull diff --git a/crates/conformance/src/cases/artifacts.rs b/crates/conformance/src/cases/artifacts.rs index 01eba8d1aa..b6f5692949 100644 --- a/crates/conformance/src/cases/artifacts.rs +++ b/crates/conformance/src/cases/artifacts.rs @@ -533,6 +533,18 @@ pub(crate) fn run(id: &str) { Json::parse(b"{\"a\":{\"b\":1,\"b\":2}}").is_err(), "nested duplicate keys are rejected" ); + assert!( + Json::parse(b"{\"a\":1,\"\\u0061\":2}").is_err(), + "a key spelled with an escape duplicates its plain spelling" + ); + assert!( + Json::parse(b"{\"x\":{\"a\\\"b\":1,\"a\\u0022b\":2}}").is_err(), + "nested keys that decode equal are duplicates" + ); + assert!( + Json::parse(b"[{\"a\":1},{\"\\u0061\":2}]").is_ok(), + "keys that decode equal in distinct objects are not duplicates" + ); assert!( Json::parse(b"{\"a\":[{\"b\":1},{\"b\":2}]}").is_ok(), "equal keys in distinct objects are not duplicates" diff --git a/crates/lexlean/src/artifact/canonical_json.rs b/crates/lexlean/src/artifact/canonical_json.rs index 7d26a88905..c403073db4 100644 --- a/crates/lexlean/src/artifact/canonical_json.rs +++ b/crates/lexlean/src/artifact/canonical_json.rs @@ -159,9 +159,12 @@ fn write_escaped(text: &str, out: &mut String) { } /// A streaming duplicate-key check over raw JSON bytes: every object level -/// keeps the set of keys seen so far (as their raw escaped spelling, which -/// canonical JSON makes unique per key). Structural errors are left to the -/// full parser; only a duplicate is reported here. +/// keeps the set of keys seen so far, compared after JSON escape decoding. +/// The input need not be canonical yet, so `"a"` and `"\u0061"` are the same +/// key and must collide here; comparing the raw spelling would let the full +/// parser keep the last of them silently. Structural errors, including a key +/// that does not decode, are left to the full parser; only a duplicate is +/// reported here. fn check_duplicate_keys(bytes: &[u8]) -> Result<(), String> { #[derive(Clone, Copy, PartialEq, Eq)] enum Frame { @@ -189,8 +192,9 @@ fn check_duplicate_keys(bytes: &[u8]) -> Result<(), String> { } if expecting_key { if let Some((Frame::Object, keys)) = frames.last_mut() { - let key = bytes[start..end].to_vec(); - if !keys.insert(key) { + // The slice includes both quotes, so it is one JSON string. + let decoded = serde_json::from_slice::(&bytes[start - 1..=end]); + if decoded.is_ok_and(|key| !keys.insert(key.into_bytes())) { return Err(format!( "duplicate key {}", String::from_utf8_lossy(&bytes[start..end]) From a49071f9c7681fb4452251abf9a66ad8c7ed9caf Mon Sep 17 00:00:00 2001 From: Claude Date: Fri, 13 Nov 2026 19:59:41 +0000 Subject: [PATCH 09/13] docs(proposals): address review 5875193015 on external contracts Separate proof-axiom dependencies from executable external uses (call inventory), complete the report-to-implementation binding, narrow the opacity statement. Co-Authored-By: Claude Sonnet 5.5 Claude-Session: https://claude.ai/code/session_013Asa3M8ULnzEQwLLngyBBX --- docs/proposals/external-contracts.md | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/docs/proposals/external-contracts.md b/docs/proposals/external-contracts.md index 84af21cc11..f82c7a20f9 100644 --- a/docs/proposals/external-contracts.md +++ b/docs/proposals/external-contracts.md @@ -101,7 +101,7 @@ public axiom dotFast.contract (left : Array Int8) (right : Array Int8) : DotContract left right (dotFast left right) ``` -The hidden value of the constant is the witness. The kernel never unfolds an opaque constant, so nothing about `dotFast` is provable except through the axiom. A document refers to the axiom as the member `dotFast.contract`, in `apply` and `simplify`, exactly as it refers to a theorem. +The hidden value of the constant is the witness. The kernel never unfolds an opaque constant, so a theorem cannot unfold `dotFast` to its witness, and cannot derive the intended computational contract from that body; the contract is available only through the axiom. Reflexivity (`dotFast l r = dotFast l r`) and hypotheses about `dotFast` remain available and carry no axiom. A document refers to the axiom as the member `dotFast.contract`, in `apply` and `simplify`, exactly as it refers to a theorem. The canonical document states the declaration, the contract, the witness and the evidence. The generated-source audit admits `opaque` and `axiom` tokens only at the positions an `external` declaration of the IR accounts for. @@ -113,18 +113,19 @@ What remains assumed is not logical. It is the statement that the foreign code, ### 6.4 Evidence -- `attested{report: A}`: `A` is an `artifact` declaration of role `conformance`, content-addressed like every artifact. Its bytes are a canonical JSON report that states the statement ID of the external declaration (`SM-38`), the digest of the foreign code tested, the reference it was compared with, the number of cases and the result. Linking refuses a report that names another statement ID. So a change of the contract, the signature or the witness makes old evidence stale by construction. LexLean does not run the foreign code and does not vouch for the report: the attestation records who is trusted for what. +- `attested{report: A}`: `A` is an `artifact` declaration of role `conformance`, content-addressed like every artifact. Its bytes are a canonical JSON report that states the statement ID of the external declaration (`SM-38`), the digest of the foreign code tested, the reference it was compared with, the number of cases and the result. Linking refuses a report that names another statement ID, and the project row must pin the report's digest. The report's bytes and the contract's identity are thereby authenticated; that is all the hash and the statement ID do. Binding the report to what actually runs is a separate check, which `verify` makes and which refuses (`LLV7007`-class refusal, code to be registered with the implementation) unless all of these hold: the report's code digest equals the digest of the artifact the build selects for the declaration; the report's symbol, ABI and target equal the declaration's `symbol` and the build's target; the report's attester is one the `[[external_source]]` row names as trusted; and the report's result is `pass` with at least the case count the row requires. With D6 undecided there is no selected artifact, so until then `verify` reports the evidence as `unbound` and says so in the trust line. So a change of the contract, the signature or the witness makes old evidence stale by construction. LexLean does not run the foreign code and does not vouch for the report: the attestation records who is trusted for what. The witness (D3) establishes only that the logical contract is satisfiable; a finite conformance report does not establish universal native correctness, purity or termination, and no wording of this document claims it. - `proved{theorem: T}`: `T` is a theorem, checked by the pinned Lean, that a Lean model of the foreign code meets the contract. This needs the model to be importable (#362) and belongs to a later change. It does not remove trust; it moves it to whatever produced the model (section 8). ### 6.5 Policy and reporting - A project lists the externals it admits: `[[external_source]]` in `lexlean.toml` with the module, the name and the report digest, pinned in `lexlean.lock`. An `external` declaration without its row is refused. A project with no row accepts no external declaration, so the default is the ban as it is today. +- **Proof dependencies and executable uses are different facts.** The axiom audit (§5.4) reports what `#print axioms` returns: a theorem that uses `dotFast.contract` lists it. It is not a call graph. A definition can call the opaque `dotFast` without mentioning the axiom, and a reflexive or conditional theorem can mention the call without it. So the axiom set alone does not account for every runtime use of foreign code. The design therefore adds a second, fail-closed inventory, the **external-call inventory**: the linker computes, from the IR, every definition, directly or transitively, that calls an `external` function, and the attestation records it (`external_uses`) beside `trust`. A production or `verify` root that reaches an external call not covered by an admitted `[[external_source]]` row is refused. The inventory is computed by LexLean, not by Lean, and the trust lines say so; the axiom audit is not claimed to be it. - Each theorem and definition states its exact axioms as now. A theorem that uses `dotFast.contract` lists `Project.Module.dotFast.contract` beside `propext`; a missing or extra one is `LLV7005`, unchanged. -- The attestation gains `trust`: for each contract axiom, its evidence, and the declarations whose observed sets contain it. `verify` prints one line per contract axiom after its summary, for example: +- The attestation gains `trust`: for each contract axiom, its evidence, the declarations whose observed sets contain it (proof dependencies), and, from the external-call inventory, the declarations that call the function (executable uses). `verify` prints one line per contract axiom after its summary, for example: ```text verified 1 module; attestation -trust: Engine.Main.dotFast.contract, attested by sha256:, used by 1 theorem and 1 definition +trust: Engine.Main.dotFast.contract, attested by sha256:, proof-used by 1 theorem; called by 1 definition (call inventory: LexLean) ``` - A status line never says "verified" without the trust lines when any exist. @@ -219,6 +220,7 @@ Estimated from the arrays change, which touched the same layers: - The contract is about a mathematical function. Foreign code that reads a clock, keeps state, or does not terminate is outside what the axiom says, and evidence by testing cannot establish totality. - Attested evidence is as good as the test that produced it. LexLean binds the report to the contract and to the code digest; it does not judge coverage. - A witness is required. A contract for which no LexLean function can be written (for example one that only bounds an error) needs the reference written first. For an inference kernel the witness is the integer reference engine, which has to exist anyway. +- Evidence is witness-only until D6: the report is bound to the contract, not to a running artifact, and `verify` says `unbound`. - Until D6 is decided the compiled Lean runs the witness, so the trust entry describes a binding a host makes, not one LexLean emits. ## 11. Not implemented by this PR From 29be144a11b842ddddb564de324a752a9bfdd06b Mon Sep 17 00:00:00 2001 From: Claude Date: Fri, 13 Nov 2026 19:59:52 +0000 Subject: [PATCH 10/13] docs(proposals): fold verification-memo (#508) into this docs carrier, record D1 One reviewed documentation carrier, as requested on #492. D1 (SPEC.md 9.4 reuse of verification results) is decided: not adopted now. Co-Authored-By: Claude Sonnet 5.5 Claude-Session: https://claude.ai/code/session_013Asa3M8ULnzEQwLLngyBBX --- docs/proposals/external-contracts.md | 2 +- docs/proposals/verification-memo.md | 135 +++++++++++++++++++++++++++ 2 files changed, 136 insertions(+), 1 deletion(-) create mode 100644 docs/proposals/verification-memo.md diff --git a/docs/proposals/external-contracts.md b/docs/proposals/external-contracts.md index f82c7a20f9..cd8aae3872 100644 --- a/docs/proposals/external-contracts.md +++ b/docs/proposals/external-contracts.md @@ -113,7 +113,7 @@ What remains assumed is not logical. It is the statement that the foreign code, ### 6.4 Evidence -- `attested{report: A}`: `A` is an `artifact` declaration of role `conformance`, content-addressed like every artifact. Its bytes are a canonical JSON report that states the statement ID of the external declaration (`SM-38`), the digest of the foreign code tested, the reference it was compared with, the number of cases and the result. Linking refuses a report that names another statement ID, and the project row must pin the report's digest. The report's bytes and the contract's identity are thereby authenticated; that is all the hash and the statement ID do. Binding the report to what actually runs is a separate check, which `verify` makes and which refuses (`LLV7007`-class refusal, code to be registered with the implementation) unless all of these hold: the report's code digest equals the digest of the artifact the build selects for the declaration; the report's symbol, ABI and target equal the declaration's `symbol` and the build's target; the report's attester is one the `[[external_source]]` row names as trusted; and the report's result is `pass` with at least the case count the row requires. With D6 undecided there is no selected artifact, so until then `verify` reports the evidence as `unbound` and says so in the trust line. So a change of the contract, the signature or the witness makes old evidence stale by construction. LexLean does not run the foreign code and does not vouch for the report: the attestation records who is trusted for what. The witness (D3) establishes only that the logical contract is satisfiable; a finite conformance report does not establish universal native correctness, purity or termination, and no wording of this document claims it. +- `attested{report: A}`: `A` is an `artifact` declaration of role `conformance`, content-addressed like every artifact. Its bytes are a canonical JSON report that states the statement ID of the external declaration (`SM-38`), the digest of the foreign code tested, the reference it was compared with, the number of cases and the result. Linking refuses a report that names another statement ID, and the project row must pin the report's digest. The report's bytes and the contract's identity are thereby authenticated; that is all the hash and the statement ID do. Binding the report to what actually runs is a separate check, which `verify` makes and which refuses (a new diagnostic, registered with the implementation) unless all of these hold: the report's code digest equals the digest of the artifact the build selects for the declaration; the report's symbol, ABI and target equal the declaration's `symbol` and the build's target; the report's attester is one the `[[external_source]]` row names as trusted; and the report's result is `pass` with at least the case count the row requires. With D6 undecided there is no selected artifact, so until then `verify` reports the evidence as `unbound` and says so in the trust line. So a change of the contract, the signature or the witness makes old evidence stale by construction. LexLean does not run the foreign code and does not vouch for the report: the attestation records who is trusted for what. The witness (D3) establishes only that the logical contract is satisfiable; a finite conformance report does not establish universal native correctness, purity or termination, and no wording of this document claims it. - `proved{theorem: T}`: `T` is a theorem, checked by the pinned Lean, that a Lean model of the foreign code meets the contract. This needs the model to be importable (#362) and belongs to a later change. It does not remove trust; it moves it to whatever produced the model (section 8). ### 6.5 Policy and reporting diff --git a/docs/proposals/verification-memo.md b/docs/proposals/verification-memo.md new file mode 100644 index 0000000000..cf27e897c2 --- /dev/null +++ b/docs/proposals/verification-memo.md @@ -0,0 +1,135 @@ +# Verification results reused across runs: design + +Draft for owner acceptance, written 2026-11-13, against `release/v0.4` at `26e5e0ace`. Normative text is `SPEC.md`; this document explains and asks. It is a proposal only: this pull request adds this one file and changes no specification text, register row, workflow, compiler code, or generated document. It builds on two draft pull requests: #498 (every verification part names its toolchain by address) and #506 (one address scheme, `sha256:` over canonical bytes, `AR-15`). + +**Decision recorded on D1 (2026-11-13, maintainer, from SPEC.md §9.4 and the #106 plan): not adopted now.** §9.4's rule that the gate re-proves everything in every run is what makes a pull request's green mean what Lean checked in that run; this proposal's own text says it changes what the gate verifies, and its savings are estimates with no store to measure. §9.4 stands unchanged, no reuse on pull-request runs. The document stays as the design to revisit once the implementation can report measured numbers, and then only in a form that keeps pull-request runs proving their own inputs (for example reuse restricted to release-line runs). D2 to D8 are moot until D1 is reopened. + +## 1. Summary + +Today every CI run proves everything again. SPEC.md §9.4 says the gate has "no cache of a ... verification tree, attestation, or proof result" and that "every process of the verification runs exactly once per run". A slice pull request that changes one bootstrap module therefore re-elaborates, replays, and audits every module of every project, UOR Atlas included. + +The proposal is a content-addressed store of verifier process results: + +- A stored result is reused only when its key matches exactly. The key is the address of everything the process reads and runs: its source bytes, the keys of its imports, the executables and toolchain library, its arguments, its environment, its limits, and the compiler-semantics ID. +- The stored result's own address must also check out. +- Only pushes to `release/*` write the store. +- Every push to `main` or `release/*`, and every release, re-proves everything with the store off. + +**What it saves.** On a typical slice pull request, about 158 runner-minutes of Atlas and about 330 minutes of bdd and examples verification would reuse earlier results. + +**What it changes.** On a pull request, a reused process was proved by an earlier release-line run on byte-identical inputs, not by that pull request's run. That is a change to what the gate verifies, so it is the owner's decision. + +| # | Decision | Recommendation | +| --- | --- | --- | +| D1 | Adopt reuse by exact address on pull-request runs (the §9.4 wording in section 6) | Yes | +| D2 | The unit of reuse | One verifier process (an elaboration, a replay, an audit member), not one LexLean module | +| D3 | What a stored entry holds | The process record and its output files, never a verdict; every reused record is re-judged by this run's code | +| D4 | Who writes the store | Only pushes to `release/*`, which also re-prove everything; pull-request runs only read it | +| D5 | Whether the toolchain library tree is in the key | Yes: `lean` loads `Init`, `Std` and `Lean` from it, and the executable's digest does not fix them | +| D6 | The `lexlean` executable in the key | No: it only judges records, and judging is redone every run. The attestation still names it | +| D7 | Spot check | Each run re-runs one reused process, chosen from the run ID, and requires byte equality | +| D8 | RP-14 | It changes with D1: no cache is still forbidden, except the custody-checked store | + +## 2. The unit, and why + +A LexLean module becomes three processes of the verifier: + +- its elaboration (`lake env lean -o `); +- its replay (`lake env leanchecker`); +- its audit member. + +The partitioned Atlas verification already moves exactly these between the jobs of one run (`verify/partition.rs`). A shard exports its `.olean` files and process records, and the join re-judges every record as the stage that produced it would. `VR-23` requires the join to publish, byte for byte, what the whole verification publishes. The store is the same thing across runs: a part an earlier run produced, found by address instead of by job name. + +## 3. The key, exactly + +`key(p)` is the address (#506) of a framed recipe with its own domain, `lexlean-verify-step-v1`, whose frames are: + +| Frame | Content | +| --- | --- | +| `step` | `elaborate`, `replay`, or `audit` | +| `module` | the full Lean module name | +| `source` | the address of the exact generated `.lean` bytes the process reads; for a replay, the key of the module's elaboration | +| `imports` | the keys of the elaborations of the module's direct imports, sorted by module. Each fixes its `.olean` and, recursively, everything below it | +| `argv`, `env` | the normalized argument vector and allow-listed environment, as the process record writes them | +| `toolchain` | the addresses of `lean`, `lake`, `leanchecker` (#498), and of the toolchain's `lib/` tree | +| `lake-workspace` | the lock hashes the attestation lists | +| `compiler-semantics` | the project language's compiler-semantics ID | +| `limits` | `child_timeout_ms` and `max_child_output_bytes` | +| `host` | operating system and architecture | + +**Left out of the key, on purpose:** +- **Width, hints and the memory budget.** §22.11 already requires that they never change a byte. +- **The `lexlean` executable.** It decides how records are judged, and judging is redone on every run. +- **Timings and the run.** + +**A stored entry** is `{key, record, outputs}`: the normalized process record plus the address of every output file. The output files are the `.olean`, `.ilean` and the intermediates the next elaboration reads. The entry's own address is the address of its canonical bytes. The store is `index/`, which holds the entry's address, plus `objects/
`, which holds entries and output files. + +## 4. Why reuse is sound + +A process is a function of the executable and every file it loads, its arguments, its environment, the bytes it reads, and its limits. The key names all of them, directly or through import keys. + +LexLean already relies on that function being deterministic, in three places: +- `VR-23` requires the partitioned Atlas to publish what the whole verification publishes; +- §22.11 requires width 1 and width N to agree; +- every gate compares normalized records against `expected/verify` (§29.5). + +So equal keys give equal records and equal `.olean` bytes. The attestation built over reused records is byte-identical to a fresh one, and it does not mention reuse; telemetry and the job summary do. + +**The one input that is not a function of bytes is wall time.** A process that passed in 290 s may time out at 300 s on a slower host. A timeout is an environment failure, never a verdict, so reusing the pass changes no proof claim. + +## 5. What it refuses + +- **A stale store.** Any changed input changes the key, so the lookup misses and the process runs. No entry is ever matched by name or path. +- **A changed toolchain.** The toolchain addresses are in the key, so it misses. On a hit, the stored record must still name this run's executables (the join's existing `LLI9001` check, extended by #498 to `lake`, `lexlean` and `rustc`). +- **A corrupted entry.** On every hit the verifier recomputes the entry's address and every output file's address, and requires them to equal the index. It also requires the entry's key to equal the key it asked for. A mismatch fails the verification; it is evidence of tampering, not a miss. +- **A consistent forgery**, by someone who can write the store and recompute the hashes. Addresses give integrity, not authority. Authority comes from custody: + - Only a push to `release/*` writes the store. + - Pull-request runs read it from that push run's artifact, through a custody record checked the way the bootstrap export's record is (#476, #498). The record names the repository, workflow, run, commit, and executable addresses. + - The spot check (D7) re-runs one reused process in every run and requires byte equality. +- **Release evidence that rests on the store.** Every push to `main` or `release/*`, every release, and every `workflow_dispatch` marked `full` verifies with the store off. + +## 6. The SPEC.md §9.4 wording (D1) + +Replace "The gate has no path filter, no cache of a build directory, object, verification tree, attestation, or proof result, and no condition that skips a recipe of `just vv` but the plan's" with: + +> The gate has no path filter, no cache of a build directory or object, and no condition that skips a recipe of `just vv` but the plan's. A verification process (§22.11) may be reused from an earlier run only by exact address: its key is the address of every input it reads, the executables and toolchain library it runs, its argument vector, environment, and limits, and the compiler-semantics ID; the reused record and output files must reproduce their recorded addresses, and the record must name this run's executables. Only a push to `release/*` writes such results, carried to later runs as an artifact with a custody record (`lexlean/ci-verify-store/1`) that `RP-14` checks; a pull request run reads them and writes none. Every push to `main` or to a release line, every release, and every `workflow_dispatch` with `full` verifies with no reuse. The records and attestation a run publishes are byte for byte those of a run with no reuse. + +Two further sentences change: +- "Every process of the verification runs exactly once per run" becomes "Every process of the verification runs at most once per run and is reused only as above". +- "it, the output, and the records cross no run" (Atlas) becomes "they cross runs only through the store above". + +**This changes what the gate verifies.** On a pull request, a reused process was proved by an earlier release-line run on byte-identical inputs, not by that pull request's run. + +## 7. What it saves + +From full gate 43046966603, using the verification seconds each job reports (gate-speed notes of 2026-11-12): + +| Where | Seconds | Reusable on a slice PR | +| --- | ---: | --- | +| Atlas shards | ~9,500 | all | +| `examples` leg | 4,866 | all but the bootstrap module that changed and its importers | +| `rest` | 4,378 | models ×18 = 2,132 of it | +| `preservation` | 4,396 | production ×10 collapse to one | +| `production` | 3,385 | production ×17 collapse to one | + +**Wall clock.** +- `preservation` (66 min) and `examples` (53–85 min) would drop to roughly 10–35 min. +- The Atlas chain would leave pull-request runs. +- The critical path becomes the BS-15 evaluator differential (~70 min) and the macOS AArch64 job. Differentials are not verification and do not speed up. + +**Locally.** +- A second `lexlean verify` of an unchanged project would run no Lean process. +- With one module changed, it would run: + - that module's elaboration and replay; + - the elaborations of the modules that import it whose `.olean` changed; + - every audit member. + + Audit members rerun on any change because the audit module's name embeds the semantic ID (`LexLeanAudit.A`, `backend/lean.rs`), which moves with every source change. + +**These numbers are estimates: the store does not exist to measure.** The pull request that implements it reports measured before and after times for a second verify of an unchanged project, for one changed module, and for a CI run of an unchanged tree. + +## 8. Cost + +- **Hashing the toolchain `lib/` tree.** It is 2.8 GB and took 24 s warm and 36 s cold in a shared 16 GB WSL VM. It is computed once per process, and only when the store is on. +- **Storage.** About as large as the `.olean` files of every verified project, carried as one artifact per release-line push. +- **A compiler-semantics or Lean-pin change invalidates every key,** so such pull requests pay the full price, as today. From 65bfb484c093115fb969139269993d5592cb9ae1 Mon Sep 17 00:00:00 2001 From: humuhumu33 <68450279+humuhumu33@users.noreply.github.com> Date: Sat, 14 Nov 2026 01:06:33 +0000 Subject: [PATCH 11/13] model-write: regenerate CONFORMANCE.md for VR-23's new statement --- CONFORMANCE.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CONFORMANCE.md b/CONFORMANCE.md index a1d178c889..47cd55c2b7 100644 --- a/CONFORMANCE.md +++ b/CONFORMANCE.md @@ -678,7 +678,7 @@ the error registry does not sanction (R5, `ERRORS.md`). | `VR-20` | `build` | The verifier process width is an operational resource profile selected only by the environment, defaulting to 1 and refusing any malformed value with LLV7017, and it enters no lock, identity, or verified artifact. | | `VR-21` | `build` | A multi-module project whose imports form nontrivial frontiers verifies at width 1 and at a larger width to byte-identical verified directories and the same attestation identity, observed axiom sets, and policy rows, and no completion order orders a record or changes which failure is reported. | | `VR-22` | `build` | Performance telemetry is written only to the CI evidence directory the environment names, a verification with telemetry on publishes byte-identical artifacts to one without, and telemetry planted in a verified artifact fails the gate. | -| `VR-23` | `build` | A project verified as the parts of one run, each shard running the processes its plan names with the oleans of the shards it needs and the join reading every shard's records, publishes a verified directory byte-identical to the whole verification's with the same attestation identity, and a shard whose plan leaves a module without its imports, a join missing a record, or a join reading a record of an executable other than its own, is refused. | +| `VR-23` | `build` | A project verified as the parts of one run, each shard running the processes its plan names with the oleans of the shards it needs and the join reading every shard's records, publishes a verified directory byte-identical to the whole verification's with the same attestation identity, and a shard whose plan leaves a module without its imports, a join missing a record, a join reading a record of an executable other than its own, or a part that ran a toolchain other than its own, is refused. | ## Cited authorities From f6e9af79c74306a2be4fb8274e76fccd143ff081 Mon Sep 17 00:00:00 2001 From: Claude Date: Sat, 14 Nov 2026 07:57:34 +0000 Subject: [PATCH 12/13] ci: the Intel host tests accept the repository's renamed spelling The repository is now UOR-Foundation/lexlean. intel_host_tests.py compared GITHUB_REPOSITORY with "UOR-Foundation/LexLean" exactly, so every Intel test construction job refused its own run as a foreign repository. GitHub names repositories case-insensitively; the check now does too, and any other repository is still refused (a unit test covers both spellings and two foreign names). The workflow if: guards already compare without case. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_013Asa3M8ULnzEQwLLngyBBX --- .../intel_host_tests.cpython-313.pyc | Bin 0 -> 76370 bytes .../test_intel_host_tests.cpython-313.pyc | Bin 0 -> 59962 bytes .github/scripts/intel_host_tests.py | 4 +++- .github/scripts/test_intel_host_tests.py | 10 ++++++++++ 4 files changed, 13 insertions(+), 1 deletion(-) create mode 100644 .github/scripts/__pycache__/intel_host_tests.cpython-313.pyc create mode 100644 .github/scripts/__pycache__/test_intel_host_tests.cpython-313.pyc diff --git a/.github/scripts/__pycache__/intel_host_tests.cpython-313.pyc b/.github/scripts/__pycache__/intel_host_tests.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7424f6854b98d6217fd355f60ba77ce890bd8241 GIT binary patch literal 76370 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

=X3$IFllk{)Pf@0hb= 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 Date: Sat, 14 Nov 2026 08:00:06 +0000 Subject: [PATCH 13/13] ci: drop the committed Python bytecode and ignore it Running the helper scripts' unit tests left __pycache__/*.pyc beside them, and the previous commit carried them. They are removed, and .gitignore names Python bytecode so it cannot be committed again. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_013Asa3M8ULnzEQwLLngyBBX --- .../intel_host_tests.cpython-313.pyc | Bin 76370 -> 0 bytes .../test_intel_host_tests.cpython-313.pyc | Bin 59962 -> 0 bytes .gitignore | 4 ++++ 3 files changed, 4 insertions(+) delete mode 100644 .github/scripts/__pycache__/intel_host_tests.cpython-313.pyc delete mode 100644 .github/scripts/__pycache__/test_intel_host_tests.cpython-313.pyc diff --git a/.github/scripts/__pycache__/intel_host_tests.cpython-313.pyc b/.github/scripts/__pycache__/intel_host_tests.cpython-313.pyc deleted file mode 100644 index 7424f6854b98d6217fd355f60ba77ce890bd8241..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 76370 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

=X3$IFllk{)Pf@0hb= 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