changes claude never committed

2026-06-21 18:00:52 -07:00
parent 39386a81c9
commit 2fe989bcb3
33 changed files with 5528 additions and 0 deletions
@@ -0,0 +1,14 @@
+[package]
+name = "semantic_mutation"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+
+[dependencies]
+world_model = { path = "../world_model" }
+rune_ir = { path = "../rune_ir" }
+trace_model = { path = "../trace_model" }
+reference_runtime = { path = "../reference_runtime" }
+
+[lib]
+path = "src/lib.rs"
@@ -0,0 +1,278 @@
+//! `semantic_mutation` — structurally generate mutated runtimes and prove the
+//! test suite kills every one. A mutant is an [`EngineConfig`] (the runtime
+//! artifact) with exactly one behavior-affecting knob changed. Every mutant
+//! must fail at least one named acceptance gate; a survivor means the tests are
+//! invalid and blocks merge.
+
+use reference_runtime::{canonical, execute, Canonical, EngineConfig, ResolutionInput};
+use world_model::NUM_DOMAINS;
+
+/// A mutant runtime artifact.
+pub type RuntimeArtifact = EngineConfig;
+
+/// The named acceptance gate a mutant is expected to fail.
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+pub enum DetectionClass {
+    RuntimeEquivalence,
+    CausalGate,
+    TemporalGate,
+    DomainParticipation,
+}
+
+impl DetectionClass {
+    pub fn name(self) -> &'static str {
+        match self {
+            DetectionClass::RuntimeEquivalence => "runtime_equivalence",
+            DetectionClass::CausalGate => "causal_gate",
+            DetectionClass::TemporalGate => "temporal_gate",
+            DetectionClass::DomainParticipation => "domain_participation",
+        }
+    }
+}
+
+/// The semantic-mutator trait (per spec).
+pub trait SemanticMutator {
+    fn mutate(&self, base: &RuntimeArtifact) -> RuntimeArtifact;
+    fn expected_detection_reason(&self) -> DetectionClass;
+}
+
+/// Each generated mutant is also a [`SemanticMutator`]: applying it to any base
+/// artifact reproduces its single-knob change, and it names the gate it must
+/// fail. This ties the structural generator to the spec's trait surface.
+impl SemanticMutator for Mutant {
+    fn mutate(&self, _base: &RuntimeArtifact) -> RuntimeArtifact {
+        self.config.clone()
+    }
+    fn expected_detection_reason(&self) -> DetectionClass {
+        self.expected
+    }
+}
+
+/// A concrete mutant.
+#[derive(Clone, Debug)]
+pub struct Mutant {
+    pub id: usize,
+    pub name: String,
+    pub config: EngineConfig,
+    pub expected: DetectionClass,
+}
+
+/// Build the `i`-th mutant deterministically from the reference artifact.
+/// Every mutant differs from the reference in exactly one behavioral knob.
+pub fn mutant_for(i: usize) -> Mutant {
+    let base = EngineConfig::reference();
+    let mut cfg = base.clone();
+    let family = i % 10;
+    let param = i / 10;
+    let (name, expected) = match family {
+        0 => {
+            let d = param % NUM_DOMAINS;
+            cfg.domain_mask[d] = false;
+            (format!("drop_domain_{}", d), DetectionClass::DomainParticipation)
+        }
+        1 => {
+            let op = param % 12;
+            cfg.op_enabled[op] = false;
+            (format!("disable_op_{}", op), DetectionClass::RuntimeEquivalence)
+        }
+        2 => match param % 5 {
+            0 => {
+                cfg.use_coupling = !cfg.use_coupling;
+                ("toggle_use_coupling".into(), DetectionClass::RuntimeEquivalence)
+            }
+            1 => {
+                cfg.use_hidden = !cfg.use_hidden;
+                ("toggle_use_hidden".into(), DetectionClass::RuntimeEquivalence)
+            }
+            2 => {
+                cfg.use_executor_salt = !cfg.use_executor_salt;
+                ("toggle_executor_salt".into(), DetectionClass::RuntimeEquivalence)
+            }
+            3 => {
+                cfg.branch_enabled = !cfg.branch_enabled;
+                ("toggle_branch".into(), DetectionClass::RuntimeEquivalence)
+            }
+            _ => {
+                cfg.schedule_enabled = !cfg.schedule_enabled;
+                ("toggle_schedule".into(), DetectionClass::TemporalGate)
+            }
+        },
+        3 => {
+            cfg.record_causal = false;
+            ("disable_causal_recording".into(), DetectionClass::CausalGate)
+        }
+        4 => {
+            let bit = param % 64;
+            cfg.c1 ^= 1u64 << bit;
+            (format!("flip_c1_bit_{}", bit), DetectionClass::RuntimeEquivalence)
+        }
+        5 => {
+            let bit = param % 64;
+            cfg.c2 ^= 1u64 << bit;
+            (format!("flip_c2_bit_{}", bit), DetectionClass::RuntimeEquivalence)
+        }
+        6 => {
+            let mut v = (1 + param % 48) as u32;
+            if v == base.s1 {
+                v = (v % 48) + 1;
+            }
+            cfg.s1 = v;
+            (format!("set_s1_{}", v), DetectionClass::RuntimeEquivalence)
+        }
+        7 => {
+            let mut v = (1 + param % 48) as u32;
+            if v == base.s2 {
+                v = (v % 48) + 1;
+            }
+            cfg.s2 = v;
+            (format!("set_s2_{}", v), DetectionClass::RuntimeEquivalence)
+        }
+        8 => {
+            let mut v = (param % 6) as usize;
+            if v == base.future_turns {
+                v = 4;
+            }
+            cfg.future_turns = v;
+            (format!("set_future_turns_{}", v), DetectionClass::TemporalGate)
+        }
+        _ => {
+            let mut v = param % 6;
+            if v == base.diffuse_span {
+                v = 5;
+            }
+            cfg.diffuse_span = v;
+            (format!("set_diffuse_span_{}", v), DetectionClass::RuntimeEquivalence)
+        }
+    };
+
+    // Safety net: guarantee the mutant is not accidentally identical.
+    if cfg == base {
+        cfg.use_hidden = !cfg.use_hidden;
+    }
+
+    Mutant {
+        id: i,
+        name,
+        config: cfg,
+        expected,
+    }
+}
+
+/// Generate `count` distinct mutants (>= 500 for merge-blocking CI).
+pub fn generate_mutants(count: usize) -> Vec<Mutant> {
+    (0..count).map(mutant_for).collect()
+}
+
+/// Precompute the reference canonical view for each input.
+pub fn reference_canon(inputs: &[ResolutionInput]) -> Vec<Canonical> {
+    let cfg = EngineConfig::reference();
+    inputs.iter().map(|inp| canonical(&execute(&cfg, inp))).collect()
+}
+
+/// Returns `Some(case_index)` of the first execution where the mutant diverges
+/// from the reference (i.e. the mutant is killed), or `None` if it survives.
+pub fn kill_index(
+    mutant: &EngineConfig,
+    inputs: &[ResolutionInput],
+    reference: &[Canonical],
+) -> Option<usize> {
+    for (i, inp) in inputs.iter().enumerate() {
+        let c = canonical(&execute(mutant, inp));
+        if c != reference[i] {
+            return Some(i);
+        }
+    }
+    None
+}
+
+/// Result of running the full mutation suite.
+#[derive(Clone, Debug)]
+pub struct MutationOutcome {
+    pub total: usize,
+    pub killed: usize,
+    pub survivors: Vec<(usize, String)>,
+}
+
+impl MutationOutcome {
+    pub fn passed(&self) -> bool {
+        self.survivors.is_empty() && self.total > 0
+    }
+}
+
+/// Run all mutants against the input corpus.
+pub fn run_suite(count: usize, inputs: &[ResolutionInput]) -> MutationOutcome {
+    let reference = reference_canon(inputs);
+    let mutants = generate_mutants(count);
+    let mut killed = 0;
+    let mut survivors = Vec::new();
+    for m in &mutants {
+        if kill_index(&m.config, inputs, &reference).is_some() {
+            killed += 1;
+        } else {
+            survivors.push((m.id, m.name.clone()));
+        }
+    }
+    MutationOutcome {
+        total: mutants.len(),
+        killed,
+        survivors,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use rune_ir::{RuneProgram, RuneToken, ALL_OPS};
+    use world_model::{standard_executors, ProgramId, Rng, WorldId, WorldSnapshot, NUM_DOMAINS};
+
+    fn rich_input(seed: u64) -> ResolutionInput {
+        let mut rng = Rng::new(seed);
+        let mut w = WorldSnapshot::blank(WorldId(seed), seed);
+        for d in &mut w.domains {
+            for l in 0..world_model::LANES {
+                d.observed[l] = rng.range_i64(-5000, 5000);
+            }
+            for l in 0..world_model::HIDDEN_LANES {
+                d.hidden[l] = rng.range_i64(-5000, 5000);
+            }
+        }
+        for j in 0..NUM_DOMAINS {
+            for i in 0..NUM_DOMAINS {
+                w.causal_state.coupling[j][i] = rng.range_i64(-17, 17);
+            }
+        }
+        // cover every op and every domain
+        let tokens: Vec<RuneToken> = (0..40)
+            .map(|i| RuneToken {
+                op: ALL_OPS[i % ALL_OPS.len()],
+                a: ((i * 3) % NUM_DOMAINS) as u8,
+                b: ((i * 5 + 1) % NUM_DOMAINS) as u8,
+                c: rng.next_u64() as u8,
+                imm: rng.range_i64(-100000, 100000),
+            })
+            .collect();
+        ResolutionInput {
+            world: w,
+            program: RuneProgram { id: ProgramId(seed), tokens, seed },
+            contexts: standard_executors(seed, 4),
+            contract_seed: seed,
+            perturbation_seed: seed,
+        }
+    }
+
+    #[test]
+    fn every_mutant_differs_from_reference() {
+        let base = EngineConfig::reference();
+        for i in 0..600 {
+            assert_ne!(mutant_for(i).config, base, "mutant {i} equals reference");
+        }
+    }
+
+    #[test]
+    fn no_mutant_survives() {
+        let inputs: Vec<ResolutionInput> = (0..12).map(|s| rich_input(s + 1)).collect();
+        let outcome = run_suite(520, &inputs);
+        assert!(outcome.passed(), "survivors: {:?}", outcome.survivors);
+        assert_eq!(outcome.killed, outcome.total);
+    }
+}