Upload ablation/routing_ablation_experiment.py with huggingface_hub

ablation/routing_ablation_experiment.py

@@ -0,0 +1,716 @@
+"""
+Routing Ablation Experiment: Readout Neutralization + Structured Interference
+
+PURPOSE: Determine if routing genuinely improves global identity retention,
+or if the prior result was due to readout alignment and noise-only interference.
+
+PART A - READOUT NEUTRALIZATION:
+  Test with three readout modes to decouple write/read channels:
+  - uniform: mean(h_i) across all oscillators
+  - slow_only: mean(h_i) for tau_i >= threshold
+  - tau_weighted: sum(tau_i * h_i) / sum(tau_i) [original]
+
+PART B - STRUCTURED INTERFERENCE:
+  Replace Gaussian noise with low-rank correlated interference.
+
+DECISION RULE:
+  - If C/D dominate B under uniform readout → routing is real
+  - If C/D only dominate under tau_weighted → readout alignment artifact
+
+Authors: Routing Ablation
+Date: 2026-01-22
+"""
+
+import numpy as np
+import json
+import hashlib
+from typing import Dict, List, Tuple, Optional, Any
+from dataclasses import dataclass
+from pathlib import Path
+from datetime import datetime
+import sys
+
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from training.fdra_oscillators import FDRAOscillatorBank, OscillatorConfig
+
+
+def compute_checkpoint_hash(lambdas: np.ndarray) -> str:
+    return hashlib.sha256(lambdas.tobytes()).hexdigest()[:16]
+
+
+@dataclass
+class ParameterSnapshot:
+    lambdas: np.ndarray
+    checkpoint_hash: str
+    half_life_stats: Dict[str, Any]
+    per_oscillator_taus: List[float]
+    condition_name: str
+    
+    @classmethod
+    def from_lambdas(cls, lambdas: np.ndarray, condition_name: str) -> 'ParameterSnapshot':
+        safe_lambdas = np.clip(lambdas, 1e-10, 1 - 1e-10)
+        taus = np.log(0.5) / np.log(safe_lambdas)
+        
+        stats = {
+            "tau_min": float(np.min(taus)),
+            "tau_max": float(np.max(taus)),
+            "tau_mean": float(np.mean(taus)),
+            "frac_tau_ge_2048": float(np.mean(taus >= 2048)),
+            "n_long_range": int(np.sum(taus >= 2048)),
+        }
+        
+        return cls(
+            lambdas=lambdas.copy(),
+            checkpoint_hash=compute_checkpoint_hash(lambdas),
+            half_life_stats=stats,
+            per_oscillator_taus=taus.tolist(),
+            condition_name=condition_name
+        )
+    
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "condition_name": self.condition_name,
+            "checkpoint_hash": self.checkpoint_hash,
+            "half_life_stats": self.half_life_stats,
+        }
+
+
+def sample_tau_collapsed(n: int, seed: int = 42) -> np.ndarray:
+    rng = np.random.default_rng(seed)
+    taus = rng.uniform(2, 10, n)
+    return np.power(0.5, 1.0 / taus)
+
+
+def sample_tau_anchored_tail(n: int, L: int = 4096, p_tail: float = 0.25, seed: int = 42) -> np.ndarray:
+    rng = np.random.default_rng(seed)
+    
+    n_tail = int(n * p_tail)
+    n_non_tail = n - n_tail
+    
+    tail_min, tail_max = 0.75 * L, 1.25 * L
+    log_taus_tail = rng.uniform(np.log(tail_min), np.log(tail_max), n_tail)
+    taus_tail = np.exp(log_taus_tail)
+    
+    log_taus_non_tail = rng.uniform(np.log(1), np.log(512), n_non_tail)
+    taus_non_tail = np.exp(log_taus_non_tail)
+    
+    taus = np.concatenate([taus_tail, taus_non_tail])
+    return np.power(0.5, 1.0 / taus)
+
+
+class IdentityEncoderWithReadoutModes:
+    """
+    Identity encoder with configurable routing AND readout strategies.
+    
+    Routing modes (write):
+      - "uniform": Equal weight to all oscillators
+      - "tau_weighted": Weight ∝ τ
+      - "tau_gated": Only write to τ > threshold
+    
+    Readout modes (read):
+      - "uniform": mean(h_i) - equal weight
+      - "slow_only": mean(h_i for τ_i >= threshold)
+      - "tau_weighted": sum(τ_i * h_i) / sum(τ_i)
+    """
+    
+    def __init__(self, dim: int = 16, routing_mode: str = "uniform", readout_mode: str = "tau_weighted"):
+        self.dim = dim
+        self.routing_mode = routing_mode
+        self.readout_mode = readout_mode
+        self.tau_threshold = 2048  # For slow_only and tau_gated
+        
+        self.patterns = {
+            "decision_rule": self._make_pattern(0),
+            "normative_constraint": self._make_pattern(1),
+            "self_continuity": self._make_pattern(2),
+        }
+    
+    def _make_pattern(self, idx: int) -> np.ndarray:
+        pattern = np.zeros(self.dim)
+        start = (idx * self.dim // 3) % self.dim
+        for i in range(self.dim // 3):
+            pattern[(start + i) % self.dim] = 1.0 / np.sqrt(self.dim // 3)
+        return pattern
+    
+    def _compute_routing_weights(self, taus: np.ndarray, L: int = 4096) -> np.ndarray:
+        if self.routing_mode == "uniform":
+            return np.ones(len(taus)) / len(taus)
+        elif self.routing_mode == "tau_weighted":
+            return taus / np.sum(taus)
+        elif self.routing_mode == "tau_gated":
+            threshold = L / 4
+            mask = (taus > threshold).astype(float)
+            if np.sum(mask) == 0:
+                return np.ones(len(taus)) / len(taus)
+            return mask / np.sum(mask)
+        else:
+            raise ValueError(f"Unknown routing mode: {self.routing_mode}")
+    
+    def encode(self, bank: FDRAOscillatorBank, strength: float = 1.0):
+        taus = bank.get_half_lives()
+        weights = self._compute_routing_weights(taus, bank.L)
+        
+        for name, pattern in self.patterns.items():
+            u = np.outer(weights, pattern) * strength * len(taus)
+            for _ in range(10):
+                bank.forward(u)
+    
+    def measure_identity(self, bank: FDRAOscillatorBank) -> Dict[str, float]:
+        """Measure identity with CONFIGURABLE readout mode."""
+        taus = bank.get_half_lives()
+        
+        # Compute readout based on mode
+        if self.readout_mode == "uniform":
+            # Equal weight to all oscillators
+            slow = np.mean(bank.h, axis=0)
+        
+        elif self.readout_mode == "slow_only":
+            # Only oscillators with τ >= threshold
+            mask = taus >= self.tau_threshold
+            if np.sum(mask) == 0:
+                return {name: 0.0 for name in self.patterns}
+            slow = np.mean(bank.h[mask], axis=0)
+        
+        elif self.readout_mode == "tau_weighted":
+            # Original τ-weighted readout
+            weights = taus / np.sum(taus)
+            weighted_h = bank.h * weights[:, np.newaxis]
+            slow = np.sum(weighted_h, axis=0)
+        
+        else:
+            raise ValueError(f"Unknown readout mode: {self.readout_mode}")
+        
+        slow_norm = np.linalg.norm(slow)
+        if slow_norm < 1e-10:
+            return {name: 0.0 for name in self.patterns}
+        
+        alignments = {}
+        for name, pattern in self.patterns.items():
+            alignment = np.dot(slow, pattern) / slow_norm
+            alignments[name] = max(0, float(alignment))
+        
+        return alignments
+
+
+class StructuredInterference:
+    """
+    Generate structured (non-Gaussian) interference.
+    
+    Options:
+    - "gaussian": Original i.i.d. Gaussian noise
+    - "low_rank": Low-rank correlated interference (A @ v(t))
+    - "repeating": Repeating pattern interference
+    """
+    
+    def __init__(self, n: int, d: int, mode: str = "gaussian", seed: int = 42):
+        self.n = n
+        self.d = d
+        self.mode = mode
+        self.rng = np.random.default_rng(seed)
+        
+        if mode == "low_rank":
+            # Create low-rank projection matrix (rank 4)
+            self.rank = 4
+            self.A = self.rng.standard_normal((n * d, self.rank)) / np.sqrt(self.rank)
+            self.v_state = self.rng.standard_normal(self.rank)  # AR(1) state
+            self.ar_coef = 0.9  # Autocorrelation
+        
+        elif mode == "repeating":
+            # Create repeating pattern
+            self.period = 32
+            self.patterns = [self.rng.standard_normal((n, d)) * 0.5 for _ in range(self.period)]
+            self.t = 0
+    
+    def generate(self) -> np.ndarray:
+        if self.mode == "gaussian":
+            return self.rng.standard_normal((self.n, self.d)) * 0.5
+        
+        elif self.mode == "low_rank":
+            # AR(1) process for v(t)
+            self.v_state = self.ar_coef * self.v_state + np.sqrt(1 - self.ar_coef**2) * self.rng.standard_normal(self.rank)
+            # Project to full space
+            flat = (self.A @ self.v_state).reshape(self.n, self.d)
+            return flat * 0.5
+        
+        elif self.mode == "repeating":
+            pattern = self.patterns[self.t % self.period]
+            self.t += 1
+            return pattern
+        
+        else:
+            raise ValueError(f"Unknown interference mode: {self.mode}")
+
+
+class RoutingAblationExperiment:
+    """
+    Ablation experiment for routing with:
+    - Multiple readout modes
+    - Multiple interference types
+    """
+    
+    def __init__(
+        self,
+        num_oscillators: int = 32,
+        state_dim: int = 16,
+        sequence_length: int = 4096
+    ):
+        self.n = num_oscillators
+        self.d = state_dim
+        self.L = sequence_length
+        
+        self.osc_config = OscillatorConfig(
+            num_oscillators=num_oscillators,
+            state_dim=state_dim,
+            sequence_length=sequence_length
+        )
+        
+        self.k_values = [0, 64, 128, 256, 512, 1024, 2048, 4096]
+        self.output_dir = Path("outputs/routing_ablation")
+        self.output_dir.mkdir(parents=True, exist_ok=True)
+    
+    def run_identity_trial(
+        self,
+        snapshot: ParameterSnapshot,
+        encoder: IdentityEncoderWithReadoutModes,
+        interference: StructuredInterference,
+        k: int,
+        seed: int
+    ) -> Dict[str, Any]:
+        
+        bank = FDRAOscillatorBank(self.osc_config)
+        bank.lambdas = snapshot.lambdas.copy()
+        bank.reset()
+        
+        # Encode
+        encoder.encode(bank, strength=1.0)
+        
+        # Measure pre
+        pre_identity = encoder.measure_identity(bank)
+        pre_score = np.mean(list(pre_identity.values()))
+        
+        if pre_score < 0.2:
+            return {
+                "k": k, "seed": seed,
+                "pre_score": float(pre_score),
+                "post_score": 0.0,
+                "retention": 0.0,
+                "identity_preserved": False,
+                "encoding_failed": True
+            }
+        
+        # Interference
+        interference.rng = np.random.default_rng(seed)  # Reset for reproducibility
+        for _ in range(k):
+            noise = interference.generate()
+            bank.forward(noise)
+        
+        # Measure post
+        post_identity = encoder.measure_identity(bank)
+        post_score = np.mean(list(post_identity.values()))
+        retention = post_score / pre_score if pre_score > 0 else 0.0
+        
+        return {
+            "k": k, "seed": seed,
+            "pre_score": float(pre_score),
+            "post_score": float(post_score),
+            "retention": float(retention),
+            "identity_preserved": retention >= 0.5,
+            "encoding_failed": False
+        }
+    
+    def run_sweep(
+        self,
+        snapshot: ParameterSnapshot,
+        encoder: IdentityEncoderWithReadoutModes,
+        interference_mode: str,
+        condition_name: str,
+        seeds: List[int],
+        n_trials: int = 8
+    ) -> Dict[str, Any]:
+        
+        print(f"\n  {condition_name}")
+        print(f"    Routing: {encoder.routing_mode}, Readout: {encoder.readout_mode}, Interference: {interference_mode}")
+        
+        all_trials = []
+        preservation_curve = []
+        
+        for k in self.k_values:
+            k_trials = []
+            for seed in seeds:
+                for t in range(n_trials):
+                    interference = StructuredInterference(self.n, self.d, interference_mode, seed * 1000 + t)
+                    trial = self.run_identity_trial(snapshot, encoder, interference, k, seed * 1000 + t)
+                    k_trials.append(trial)
+                    all_trials.append(trial)
+            
+            preserved_rate = np.mean([1 if t["identity_preserved"] else 0 for t in k_trials])
+            mean_retention = np.mean([t["retention"] for t in k_trials])
+            
+            preservation_curve.append({
+                "k": k,
+                "preserved_rate": float(preserved_rate),
+                "mean_retention": float(mean_retention)
+            })
+        
+        # Basin widths
+        bw80 = max([p["k"] for p in preservation_curve if p["preserved_rate"] >= 0.8], default=0)
+        bw50 = max([p["k"] for p in preservation_curve if p["preserved_rate"] >= 0.5], default=0)
+        
+        # Print summary
+        print(f"    Basin width (80%): {bw80}, (50%): {bw50}")
+        
+        return {
+            "condition_name": condition_name,
+            "routing_mode": encoder.routing_mode,
+            "readout_mode": encoder.readout_mode,
+            "interference_mode": interference_mode,
+            "analysis": {
+                "preservation_curve": preservation_curve,
+                "basin_width_80": bw80,
+                "basin_width_50": bw50
+            }
+        }
+    
+    def run_part_a(self, seeds: List[int] = [42, 137, 256], n_trials: int = 8) -> Dict[str, Any]:
+        """Part A: Readout Neutralization - 4 conditions × 3 readout modes"""
+        
+        print("=" * 70)
+        print("PART A: READOUT NEUTRALIZATION")
+        print("=" * 70)
+        print("\nQuestion: Does routing advantage hold under different readout modes?")
+        print()
+        
+        # Create snapshots
+        collapsed = ParameterSnapshot.from_lambdas(sample_tau_collapsed(self.n), "collapsed")
+        anchored = ParameterSnapshot.from_lambdas(sample_tau_anchored_tail(self.n, self.L), "anchored_tail")
+        
+        # Define conditions
+        routing_conditions = [
+            ("A", collapsed, "uniform"),
+            ("B", anchored, "uniform"),
+            ("C", anchored, "tau_weighted"),
+            ("D", anchored, "tau_gated"),
+        ]
+        
+        readout_modes = ["uniform", "slow_only", "tau_weighted"]
+        
+        results = {}
+        
+        for readout_mode in readout_modes:
+            print(f"\n--- Readout mode: {readout_mode} ---")
+            results[readout_mode] = {}
+            
+            for cond_name, snapshot, routing_mode in routing_conditions:
+                encoder = IdentityEncoderWithReadoutModes(self.d, routing_mode, readout_mode)
+                result = self.run_sweep(
+                    snapshot, encoder, "gaussian",
+                    f"{cond_name}) {snapshot.condition_name} + {routing_mode}",
+                    seeds, n_trials
+                )
+                results[readout_mode][cond_name] = result
+        
+        # Generate 3×4 table
+        print("\n" + "=" * 70)
+        print("BASIN WIDTH TABLE (80% threshold)")
+        print("=" * 70)
+        print(f"\n{'Readout':<15} | {'A':>6} | {'B':>6} | {'C':>6} | {'D':>6}")
+        print("-" * 50)
+        
+        for readout_mode in readout_modes:
+            row = f"{readout_mode:<15} |"
+            for cond in ["A", "B", "C", "D"]:
+                bw = results[readout_mode][cond]["analysis"]["basin_width_80"]
+                row += f" {bw:>5} |"
+            print(row)
+        
+        print("\n" + "=" * 70)
+        print("BASIN WIDTH TABLE (50% threshold)")
+        print("=" * 70)
+        print(f"\n{'Readout':<15} | {'A':>6} | {'B':>6} | {'C':>6} | {'D':>6}")
+        print("-" * 50)
+        
+        for readout_mode in readout_modes:
+            row = f"{readout_mode:<15} |"
+            for cond in ["A", "B", "C", "D"]:
+                bw = results[readout_mode][cond]["analysis"]["basin_width_50"]
+                row += f" {bw:>5} |"
+            print(row)
+        
+        # Decision
+        print("\n" + "=" * 70)
+        print("DECISION (Part A)")
+        print("=" * 70)
+        
+        # Check if C/D dominate B under uniform readout
+        bw_B_uniform = results["uniform"]["B"]["analysis"]["basin_width_50"]
+        bw_C_uniform = results["uniform"]["C"]["analysis"]["basin_width_50"]
+        bw_D_uniform = results["uniform"]["D"]["analysis"]["basin_width_50"]
+        
+        if bw_C_uniform > bw_B_uniform * 1.5 or bw_D_uniform > bw_B_uniform * 1.5:
+            verdict = "ROUTING_GENUINE"
+            explanation = (
+                f"C/D dominate B even under UNIFORM readout:\n"
+                f"  B (uniform readout): {bw_B_uniform}\n"
+                f"  C (uniform readout): {bw_C_uniform}\n"
+                f"  D (uniform readout): {bw_D_uniform}\n"
+                f"→ Routing genuinely improves global retention, not just aligned readout."
+            )
+        else:
+            verdict = "READOUT_ARTIFACT"
+            explanation = (
+                f"C/D advantage disappears under UNIFORM readout:\n"
+                f"  B (uniform readout): {bw_B_uniform}\n"
+                f"  C (uniform readout): {bw_C_uniform}\n"
+                f"  D (uniform readout): {bw_D_uniform}\n"
+                f"→ Prior result was partially readout alignment artifact.\n"
+                f"→ Identity concentrates in slow modes but leaks elsewhere."
+            )
+        
+        print(f"\n  Verdict: {verdict}")
+        print(f"\n  {explanation}")
+        
+        return {
+            "results": results,
+            "verdict": verdict,
+            "explanation": explanation
+        }
+    
+    def run_part_b(self, seeds: List[int] = [42, 137, 256], n_trials: int = 8) -> Dict[str, Any]:
+        """Part B: Structured Interference - B vs C with different interference types"""
+        
+        print("\n" + "=" * 70)
+        print("PART B: STRUCTURED INTERFERENCE")
+        print("=" * 70)
+        print("\nQuestion: Does routing hold against structured (non-Gaussian) interference?")
+        print()
+        
+        anchored = ParameterSnapshot.from_lambdas(sample_tau_anchored_tail(self.n, self.L), "anchored_tail")
+        
+        interference_modes = ["gaussian", "low_rank", "repeating"]
+        
+        results = {}
+        
+        for interference_mode in interference_modes:
+            print(f"\n--- Interference mode: {interference_mode} ---")
+            results[interference_mode] = {}
+            
+            # Only B and C, uniform readout
+            for cond_name, routing_mode in [("B", "uniform"), ("C", "tau_weighted")]:
+                encoder = IdentityEncoderWithReadoutModes(self.d, routing_mode, "uniform")
+                result = self.run_sweep(
+                    anchored, encoder, interference_mode,
+                    f"{cond_name}) anchored + {routing_mode}",
+                    seeds, n_trials
+                )
+                results[interference_mode][cond_name] = result
+        
+        # Table
+        print("\n" + "=" * 70)
+        print("STRUCTURED INTERFERENCE TABLE (uniform readout, 50% threshold)")
+        print("=" * 70)
+        print(f"\n{'Interference':<15} | {'B':>6} | {'C':>6} | {'Delta':>8}")
+        print("-" * 45)
+        
+        for interference_mode in interference_modes:
+            bw_B = results[interference_mode]["B"]["analysis"]["basin_width_50"]
+            bw_C = results[interference_mode]["C"]["analysis"]["basin_width_50"]
+            delta = bw_C - bw_B
+            print(f"{interference_mode:<15} | {bw_B:>5} | {bw_C:>5} | {delta:>+7}")
+        
+        # Decision
+        print("\n" + "=" * 70)
+        print("DECISION (Part B)")
+        print("=" * 70)
+        
+        # Check if routing holds across interference types
+        holds_count = 0
+        for interference_mode in interference_modes:
+            bw_B = results[interference_mode]["B"]["analysis"]["basin_width_50"]
+            bw_C = results[interference_mode]["C"]["analysis"]["basin_width_50"]
+            if bw_C > bw_B:
+                holds_count += 1
+        
+        if holds_count == len(interference_modes):
+            verdict = "ROUTING_ROBUST"
+            explanation = "Routing advantage holds across ALL interference types."
+        elif holds_count > 0:
+            verdict = "ROUTING_PARTIAL"
+            explanation = f"Routing advantage holds for {holds_count}/{len(interference_modes)} interference types."
+        else:
+            verdict = "ROUTING_FRAGILE"
+            explanation = "Routing advantage disappears under structured interference."
+        
+        print(f"\n  Verdict: {verdict}")
+        print(f"\n  {explanation}")
+        
+        return {
+            "results": results,
+            "verdict": verdict,
+            "explanation": explanation
+        }
+    
+    def run_full_ablation(self) -> Dict[str, Any]:
+        """Run complete ablation experiment."""
+        
+        print("=" * 70)
+        print("ROUTING ABLATION EXPERIMENT")
+        print("=" * 70)
+        print("\nThis experiment tests if the routing breakthrough is genuine or artifact.")
+        print("=" * 70)
+        
+        seeds = [42, 137, 256]
+        n_trials = 8
+        
+        part_a = self.run_part_a(seeds, n_trials)
+        part_b = self.run_part_b(seeds, n_trials)
+        
+        # Overall verdict
+        print("\n" + "=" * 70)
+        print("OVERALL VERDICT")
+        print("=" * 70)
+        
+        if part_a["verdict"] == "ROUTING_GENUINE" and part_b["verdict"] == "ROUTING_ROBUST":
+            overall = "ROUTING_CONFIRMED"
+            overall_explanation = (
+                "Routing is GENUINE and ROBUST:\n"
+                "  - Holds under uniform readout (not alignment artifact)\n"
+                "  - Holds under structured interference (not noise-specific)\n"
+                "→ Ready to integrate into FDRA training."
+            )
+        elif part_a["verdict"] == "ROUTING_GENUINE":
+            overall = "ROUTING_CONFIRMED_PARTIAL"
+            overall_explanation = (
+                "Routing is GENUINE but may be noise-specific:\n"
+                "  - Holds under uniform readout ✓\n"
+                "  - May degrade under structured interference\n"
+                "→ Worth integrating but monitor under real conditions."
+            )
+        elif part_b["verdict"] in ["ROUTING_ROBUST", "ROUTING_PARTIAL"]:
+            overall = "ROUTING_LIMITED"
+            overall_explanation = (
+                "Routing helps but has readout alignment component:\n"
+                "  - Advantage reduced under uniform readout\n"
+                "  - Still helps under some interference types\n"
+                "→ Need auxiliary loss or architectural enforcement."
+            )
+        else:
+            overall = "ROUTING_ARTIFACT"
+            overall_explanation = (
+                "Prior routing result was largely artifact:\n"
+                "  - Disappears under uniform readout\n"
+                "  - Fragile to structured interference\n"
+                "→ Need fundamentally different approach."
+            )
+        
+        print(f"\n  {overall}")
+        print(f"\n  {overall_explanation}")
+        print("=" * 70)
+        
+        # Save results
+        full_results = {
+            "timestamp": datetime.now().isoformat(),
+            "experiment": "routing_ablation",
+            "part_a": part_a,
+            "part_b": part_b,
+            "overall": {
+                "verdict": overall,
+                "explanation": overall_explanation
+            }
+        }
+        
+        ts = datetime.now().strftime("%Y%m%d_%H%M%S")
+        with open(self.output_dir / f"routing_ablation_{ts}.json", "w") as f:
+            json.dump(full_results, f, indent=2, default=str)
+        
+        # Generate report
+        report = self._generate_report(full_results)
+        with open(self.output_dir / f"ABLATION_REPORT_{ts}.md", "w") as f:
+            f.write(report)
+        
+        print(f"\nResults saved to: {self.output_dir}/")
+        
+        return full_results
+    
+    def _generate_report(self, results: Dict[str, Any]) -> str:
+        report = f"""# Routing Ablation Experiment
+
+**Date:** {results['timestamp']}
+
+## Purpose
+
+Test if the routing breakthrough is genuine or an artifact of:
+1. Readout alignment (τ-weighted write + τ-weighted read)
+2. Noise-only interference (Gaussian vs structured)
+
+## Part A: Readout Neutralization
+
+### Question
+Does C/D dominate B under UNIFORM readout (not just τ-weighted)?
+
+### Results
+
+**Basin Width Table (50% threshold)**
+
+| Readout | A | B | C | D |
+|---------|---|---|---|---|
+"""
+        for readout_mode in ["uniform", "slow_only", "tau_weighted"]:
+            row = f"| {readout_mode} |"
+            for cond in ["A", "B", "C", "D"]:
+                bw = results["part_a"]["results"][readout_mode][cond]["analysis"]["basin_width_50"]
+                row += f" {bw} |"
+            report += row + "\n"
+        
+        report += f"""
+### Verdict: {results['part_a']['verdict']}
+
+{results['part_a']['explanation']}
+
+## Part B: Structured Interference
+
+### Question
+Does routing hold against low-rank correlated and repeating interference?
+
+### Results
+
+**Basin Width Table (uniform readout, 50% threshold)**
+
+| Interference | B | C | Delta |
+|--------------|---|---|-------|
+"""
+        for interference_mode in ["gaussian", "low_rank", "repeating"]:
+            bw_B = results["part_b"]["results"][interference_mode]["B"]["analysis"]["basin_width_50"]
+            bw_C = results["part_b"]["results"][interference_mode]["C"]["analysis"]["basin_width_50"]
+            delta = bw_C - bw_B
+            report += f"| {interference_mode} | {bw_B} | {bw_C} | {delta:+d} |\n"
+        
+        report += f"""
+### Verdict: {results['part_b']['verdict']}
+
+{results['part_b']['explanation']}
+
+## Overall Verdict
+
+**{results['overall']['verdict']}**
+
+{results['overall']['explanation']}
+
+---
+
+*Report generated by routing_ablation_experiment.py*
+"""
+        return report
+
+
+def run_ablation():
+    experiment = RoutingAblationExperiment(
+        num_oscillators=32,
+        state_dim=16,
+        sequence_length=4096
+    )
+    return experiment.run_full_ablation()
+
+
+if __name__ == "__main__":
+    run_ablation()