ci: fix RUF002 ambiguous-unicode lint errors (× → x, – → -)

CI rejected 494c7fa and 73e613a on RUF002 (ambiguous unicode characters in
docstrings and strings). Local runs had passed earlier due to stale ruff
cache; the actual lint is strict about:

  ×  (U+00D7 MULTIPLICATION SIGN)  → replaced with  x
  –  (U+2013 EN DASH)              → replaced with  -

Also applied ruff auto-fix on scripts/*.py (removed extraneous f-prefixes)
and ruff format across src, tests, scripts. Functional behavior unchanged.

Now local `ruff check src tests scripts && ruff format --check src tests scripts
&& mypy && pytest -m "not slow"` all pass, matching CI expectations.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: cahlen

scripts/horizon_probe.py

@@ -3,7 +3,7 @@
 
 Tests three promising Δs (the top-3 from the depth-56 search) at six depths:
 60, 64, 68, 72, 76, 80. Each run is a tiny-budget training (100 k samples
-× 2 epochs). Total: 18 runs, ~10–15 min on a 5090.
+x 2 epochs). Total: 18 runs, ~10-15 min on a 5090.
 
 Outputs: docs/phase3b-results/horizon_probe.md with a per-depth-per-Δ table
 plus a "deepest viable depth" recommendation.
@@ -20,7 +20,6 @@
 
 from keeloq.neural.distinguisher import TrainingConfig, train
 
-
 # The three Δs that reached val-acc ≥ 0.65 at depth 56 (from delta_search.md).
 PROBE_DELTAS = [0x00000002, 0x00010000, 0x00800000]
 PROBE_DEPTHS = [60, 64, 68, 72, 76, 80]
@@ -33,8 +32,11 @@
 
 def probe() -> dict:
     print("=" * 70, flush=True)
-    print(f"Horizon probe: depths {PROBE_DEPTHS} × Δs {[f'0x{d:08x}' for d in PROBE_DELTAS]}", flush=True)
-    print(f"Budget: 100 000 samples × 2 epochs per cell (depth=2, width=16)", flush=True)
+    print(
+        f"Horizon probe: depths {PROBE_DEPTHS} x Δs {[f'0x{d:08x}' for d in PROBE_DELTAS]}",
+        flush=True,
+    )
+    print("Budget: 100 000 samples x 2 epochs per cell (depth=2, width=16)", flush=True)
     print("=" * 70, flush=True)
 
     results: dict[int, dict[int, float]] = {}
@@ -61,7 +63,10 @@ def probe() -> dict:
             acc = res.final_val_accuracy
             elapsed = time.perf_counter() - t0
             results[depth][delta] = acc
-            print(f"  depth={depth:3d}  Δ=0x{delta:08x}  val_acc={acc:.4f}  loss={res.final_loss:.4f}  ({elapsed:.1f}s)", flush=True)
+            print(
+                f"  depth={depth:3d}  Δ=0x{delta:08x}  val_acc={acc:.4f}  loss={res.final_loss:.4f}  ({elapsed:.1f}s)",
+                flush=True,
+            )
 
     print("=" * 70, flush=True)
     print(f"Probe complete in {time.perf_counter() - t_all:.1f}s", flush=True)
@@ -70,9 +75,7 @@ def probe() -> dict:
 
 def analyze(results: dict) -> dict:
     # Max accuracy achieved at each depth across all tested Δs:
-    per_depth_best = {
-        depth: max(cells.values()) for depth, cells in results.items()
-    }
+    per_depth_best = {depth: max(cells.values()) for depth, cells in results.items()}
     # Deepest depth that crossed the viability threshold at any Δ:
     viable_depths = [d for d, acc in per_depth_best.items() if acc >= VIABILITY_THRESHOLD]
     deepest_viable = max(viable_depths) if viable_depths else None
@@ -93,7 +96,7 @@ def write_markdown(results: dict, summary: dict, out: Path) -> None:
     lines.append(
         "Tests the signal cliff between depth 56 (known signal, d64.pt "
         f"trained here) and depth 88 (known collapse). Budget per cell: "
-        f"100 k samples × 2 epochs, depth-2/width-16 tiny model. Viability "
+        f"100 k samples x 2 epochs, depth-2/width-16 tiny model. Viability "
         f"threshold: val_acc ≥ {VIABILITY_THRESHOLD}.\n"
     )
     lines.append("## Results (val-accuracy at tiny-budget training)\n")
@@ -135,15 +138,21 @@ def main() -> None:
     results = probe()
     summary = analyze(results)
     print("\nSummary:", flush=True)
-    print(json.dumps({
-        "per_depth_best": {str(k): v for k, v in summary["per_depth_best"].items()},
-        "deepest_viable_depth": summary["deepest_viable_depth"],
-        "best_delta_at_deepest": (
-            f"0x{summary['best_delta_at_deepest']:08x}"
-            if summary["best_delta_at_deepest"] is not None
-            else None
+    print(
+        json.dumps(
+            {
+                "per_depth_best": {str(k): v for k, v in summary["per_depth_best"].items()},
+                "deepest_viable_depth": summary["deepest_viable_depth"],
+                "best_delta_at_deepest": (
+                    f"0x{summary['best_delta_at_deepest']:08x}"
+                    if summary["best_delta_at_deepest"] is not None
+                    else None
+                ),
+            },
+            indent=2,
         ),
-    }, indent=2), flush=True)
+        flush=True,
+    )
 
     out = Path("docs/phase3b-results/horizon_probe.md")
     write_markdown(results, summary, out)

scripts/horizon_probe_fine.py

@@ -1,7 +1,7 @@
 """Fine-grained horizon probe at depths 57, 58, 59 (between known-signal 56
 and probe-collapsed 60).
 
-If any cell at depths 57–59 crosses the viability threshold (0.55), full-scale
+If any cell at depths 57-59 crosses the viability threshold (0.55), full-scale
 training at that (depth, Δ) would give us a distinguisher for attacks at
 ~(depth + 8) rounds, pushing the coverage table past d64.pt.
 
@@ -16,7 +16,6 @@
 
 from keeloq.neural.distinguisher import TrainingConfig, train
 
-
 # Top-8 Δs from the depth-56 search (val-acc ≥ 0.62).
 FINE_DELTAS = [
     0x00000002,  # 0.688
@@ -34,7 +33,7 @@
 
 def probe() -> dict:
     print("=" * 70, flush=True)
-    print(f"Fine horizon probe: depths {FINE_DEPTHS} × top-8 Δs from depth-56 search", flush=True)
+    print(f"Fine horizon probe: depths {FINE_DEPTHS} x top-8 Δs from depth-56 search", flush=True)
     print("=" * 70, flush=True)
     results: dict[int, dict[int, float]] = {}
     t_all = time.perf_counter()
@@ -43,9 +42,17 @@ def probe() -> dict:
         results[depth] = {}
         for delta in FINE_DELTAS:
             cfg = TrainingConfig(
-                rounds=depth, delta=delta, n_samples=100_000,
-                batch_size=1024, epochs=2, lr=2e-3, weight_decay=1e-5,
-                seed=0, depth=2, width=16, val_samples=5000,
+                rounds=depth,
+                delta=delta,
+                n_samples=100_000,
+                batch_size=1024,
+                epochs=2,
+                lr=2e-3,
+                weight_decay=1e-5,
+                seed=0,
+                depth=2,
+                width=16,
+                val_samples=5000,
             )
             _, res = train(cfg)
             acc = res.final_val_accuracy
@@ -72,7 +79,7 @@ def main() -> None:
     out = Path("docs/phase3b-results/horizon_probe_fine.md")
     lines = ["# Phase 3b Horizon Probe — Fine-Grained (57, 58, 59)\n"]
     lines.append(
-        f"Top-8 Δs from depth-56 search, 100 k samples × 2 epochs. "
+        f"Top-8 Δs from depth-56 search, 100 k samples x 2 epochs. "
         f"Viability threshold: val_acc ≥ {VIABILITY_THRESHOLD}.\n"
     )
     lines.append("## Results\n")

scripts/v2_experiment.py

@@ -2,7 +2,7 @@
 
 Runs three sub-experiments to test whether the kernel-size-3 spatial-conv
 DistinguisherSpatial architecture surfaces signal at depths that collapsed
-with the v1 1×1-conv Distinguisher:
+with the v1 1x1-conv Distinguisher:
 
   1. Δ search at depth 56 (control — should reproduce v1's signal,
      confirming v2 isn't broken).
@@ -27,7 +27,6 @@
 from keeloq.neural.differences import _default_candidate_set
 from keeloq.neural.distinguisher_v2 import DistinguisherSpatial
 
-
 # ---------- Standalone training loop (uses v2 architecture) ----------
 
 
@@ -42,14 +41,23 @@ def _set_seeds(seed: int) -> None:
     random.seed(seed)
 
 
-def _val_accuracy(model: nn.Module, rounds: int, delta: int, seed: int,
-                  n_samples: int = 5000, batch_size: int = 1024) -> float:
+def _val_accuracy(
+    model: nn.Module,
+    rounds: int,
+    delta: int,
+    seed: int,
+    n_samples: int = 5000,
+    batch_size: int = 1024,
+) -> float:
     model.train(False)
     correct, total = 0, 0
     with torch.no_grad():
         for batch in generate_pairs(
-            rounds=rounds, delta=delta, n_samples=n_samples,
-            seed=seed, batch_size=min(batch_size, n_samples),
+            rounds=rounds,
+            delta=delta,
+            n_samples=n_samples,
+            seed=seed,
+            batch_size=min(batch_size, n_samples),
         ):
             preds = (model(batch.pairs) >= 0.5).float()
             correct += (preds == batch.labels).sum().item()
@@ -84,8 +92,11 @@ def train_v2(
     for epoch in range(epochs):
         loss_sum, n_batches = 0.0, 0
         for batch in generate_pairs(
-            rounds=rounds, delta=delta, n_samples=n_samples,
-            seed=seed + epoch * 991, batch_size=batch_size,
+            rounds=rounds,
+            delta=delta,
+            n_samples=n_samples,
+            seed=seed + epoch * 991,
+            batch_size=batch_size,
         ):
             opt.zero_grad()
             preds = model(batch.pairs)
@@ -96,11 +107,13 @@ def train_v2(
             loss_sum += float(loss.item())
             n_batches += 1
         val_acc = _val_accuracy(model, rounds, delta, seed=seed + 1_000_000)
-        history.append({
-            "epoch": epoch,
-            "train_loss": loss_sum / max(1, n_batches),
-            "val_accuracy": val_acc,
-        })
+        history.append(
+            {
+                "epoch": epoch,
+                "train_loss": loss_sum / max(1, n_batches),
+                "val_accuracy": val_acc,
+            }
+        )
     return model, {
         "final_loss": history[-1]["train_loss"],
         "final_val_accuracy": history[-1]["val_accuracy"],
@@ -134,17 +147,25 @@ def search_delta_v2(
     results = []
     for i, delta in enumerate(uniq):
         _, res = train_v2(
-            rounds=rounds, delta=delta,
-            n_samples=tiny_budget_samples, batch_size=1024,
-            epochs=tiny_budget_epochs, lr=2e-3, weight_decay=1e-5,
-            seed=seed + i * 7919, depth=depth, width=width,
+            rounds=rounds,
+            delta=delta,
+            n_samples=tiny_budget_samples,
+            batch_size=1024,
+            epochs=tiny_budget_epochs,
+            lr=2e-3,
+            weight_decay=1e-5,
+            seed=seed + i * 7919,
+            depth=depth,
+            width=width,
             kernel_size=kernel_size,
         )
-        results.append({
-            "delta": delta,
-            "val_accuracy": res["final_val_accuracy"],
-            "training_loss_final": res["final_loss"],
-        })
+        results.append(
+            {
+                "delta": delta,
+                "val_accuracy": res["final_val_accuracy"],
+                "training_loss_final": res["final_loss"],
+            }
+        )
     results.sort(key=lambda c: c["val_accuracy"], reverse=True)
     return results
 
@@ -166,57 +187,82 @@ def main() -> None:
     cands_56 = search_delta_v2(rounds=56, tiny_budget_samples=100_000, tiny_budget_epochs=2, seed=0)
     elapsed_56 = time.perf_counter() - t0
     best_56 = cands_56[0]
-    lines.append(f"## Control: Δ search at depth 56 (v1 got best 0.688)\n")
+    lines.append("## Control: Δ search at depth 56 (v1 got best 0.688)\n")
     lines.append(f"Wall clock: {elapsed_56:.1f}s — top 5:\n")
     lines.append("| Δ | val_acc | loss |\n|---|---:|---:|")
     for c in cands_56[:5]:
-        lines.append(f"| 0x{c['delta']:08x} | {c['val_accuracy']:.4f} | {c['training_loss_final']:.4f} |")
-    print(json.dumps({"experiment": "control_56", "best": best_56, "wall_s": elapsed_56}), flush=True)
+        lines.append(
+            f"| 0x{c['delta']:08x} | {c['val_accuracy']:.4f} | {c['training_loss_final']:.4f} |"
+        )
+    print(
+        json.dumps({"experiment": "control_56", "best": best_56, "wall_s": elapsed_56}), flush=True
+    )
 
     # Experiment 2: Δ search at depth 88 (primary hypothesis).
     print("\n[v2-exp] Δ search at depth 88 (primary hypothesis)...", flush=True)
     t0 = time.perf_counter()
     cands_88 = search_delta_v2(rounds=88, tiny_budget_samples=100_000, tiny_budget_epochs=2, seed=0)
     elapsed_88 = time.perf_counter() - t0
     best_88 = cands_88[0]
-    lines.append(f"\n## Primary: Δ search at depth 88 (v1 all < 0.517)\n")
+    lines.append("\n## Primary: Δ search at depth 88 (v1 all < 0.517)\n")
     lines.append(f"Wall clock: {elapsed_88:.1f}s — top 10:\n")
     lines.append("| Δ | val_acc | loss |\n|---|---:|---:|")
     for c in cands_88[:10]:
-        lines.append(f"| 0x{c['delta']:08x} | {c['val_accuracy']:.4f} | {c['training_loss_final']:.4f} |")
-    print(json.dumps({"experiment": "primary_88", "best": best_88, "wall_s": elapsed_88}), flush=True)
+        lines.append(
+            f"| 0x{c['delta']:08x} | {c['val_accuracy']:.4f} | {c['training_loss_final']:.4f} |"
+        )
+    print(
+        json.dumps({"experiment": "primary_88", "best": best_88, "wall_s": elapsed_88}), flush=True
+    )
 
     # Experiment 3 (conditional): Δ search at depth 120.
     print("\n[v2-exp] Δ search at depth 120 (stretch)...", flush=True)
     t0 = time.perf_counter()
-    cands_120 = search_delta_v2(rounds=120, tiny_budget_samples=100_000, tiny_budget_epochs=2, seed=0)
+    cands_120 = search_delta_v2(
+        rounds=120, tiny_budget_samples=100_000, tiny_budget_epochs=2, seed=0
+    )
     elapsed_120 = time.perf_counter() - t0
     best_120 = cands_120[0]
-    lines.append(f"\n## Stretch: Δ search at depth 120 (v1 all < 0.515)\n")
+    lines.append("\n## Stretch: Δ search at depth 120 (v1 all < 0.515)\n")
     lines.append(f"Wall clock: {elapsed_120:.1f}s — top 10:\n")
     lines.append("| Δ | val_acc | loss |\n|---|---:|---:|")
     for c in cands_120[:10]:
-        lines.append(f"| 0x{c['delta']:08x} | {c['val_accuracy']:.4f} | {c['training_loss_final']:.4f} |")
-    print(json.dumps({"experiment": "stretch_120", "best": best_120, "wall_s": elapsed_120}), flush=True)
+        lines.append(
+            f"| 0x{c['delta']:08x} | {c['val_accuracy']:.4f} | {c['training_loss_final']:.4f} |"
+        )
+    print(
+        json.dumps({"experiment": "stretch_120", "best": best_120, "wall_s": elapsed_120}),
+        flush=True,
+    )
 
     # Experiment 4 (conditional): if depth 88 has signal, full train.
     verdict_lines: list[str] = []
-    verdict_lines.append(f"\n## Verdict\n")
+    verdict_lines.append("\n## Verdict\n")
     if best_88["val_accuracy"] >= SIGNAL_THRESHOLD:
         verdict_lines.append(
             f"- Depth 88 best Δ=0x{best_88['delta']:08x} reached val-acc "
             f"{best_88['val_accuracy']:.4f} — **above the {SIGNAL_THRESHOLD} threshold**. "
-            "Spatial conv architecture surfaces signal where v1's 1×1 version failed. "
+            "Spatial conv architecture surfaces signal where v1's 1x1 version failed. "
             "Proceeding with a full-scale train at this Δ.\n"
         )
-        print(f"\n[v2-exp] Depth 88 signal confirmed ({best_88['val_accuracy']:.4f}). "
-              "Kicking off full train (10M samples × 20 epochs)...", flush=True)
+        print(
+            f"\n[v2-exp] Depth 88 signal confirmed ({best_88['val_accuracy']:.4f}). "
+            "Kicking off full train (10M samples x 20 epochs)...",
+            flush=True,
+        )
         t0 = time.perf_counter()
         _, full_res = train_v2(
-            rounds=88, delta=best_88["delta"],
-            n_samples=10_000_000, batch_size=4096,
-            epochs=20, lr=2e-3, weight_decay=1e-5,
-            seed=1729, depth=5, width=256, kernel_size=3,
+            rounds=88,
+            delta=best_88["delta"],
+            n_samples=10_000_000,
+            batch_size=4096,
+            epochs=20,
+            lr=2e-3,
+            weight_decay=1e-5,
+            seed=1729,
+            depth=5,
+            width=256,
+            kernel_size=3,
         )
         verdict_lines.append(
             f"- Full train: val_acc={full_res['final_val_accuracy']:.4f}, "
@@ -230,7 +276,7 @@ def main() -> None:
             f"{best_88['val_accuracy']:.4f} — **below the {SIGNAL_THRESHOLD} threshold**. "
             "Spatial conv architecture *also* fails to surface signal at depth 88. "
             "This tightens the negative result from 'v1 architecture fails' to "
-            "'both 1×1 and spatial 3-tap architectures fail' — suggesting the "
+            "'both 1x1 and spatial 3-tap architectures fail' — suggesting the "
             "signal horizon is a genuine property of KeeLoq's diffusion at these "
             "depths, not an artifact of any one architecture.\n"
         )

src/keeloq/neural/distinguisher_v2.py

@@ -1,7 +1,7 @@
 """Spatial-convolution variant of the Gohr-style distinguisher for KeeLoq.
 
 Hypothesis under test (see docs/phase3b-results/ambition_outcome.md §"What
-would push the frontier"): the v1 architecture's 1×1 convolutions blind the
+would push the frontier"): the v1 architecture's 1x1 convolutions blind the
 model to bit-neighbor correlations, explaining its signal-horizon collapse
 between depths 56 and 88. This variant reshapes the 64-bit input to
 ``(N, 2, 32)`` — two channels (c₀, c₁) over 32 spatial bit positions — and
@@ -75,9 +75,7 @@ def __init__(
         super().__init__()
         self.unpack = _BitUnpackSpatial()
         padding = kernel_size // 2
-        self.embed = nn.Conv1d(
-            2, width, kernel_size=kernel_size, padding=padding
-        )
+        self.embed = nn.Conv1d(2, width, kernel_size=kernel_size, padding=padding)
         self.blocks = nn.ModuleList(
             [_ResidualBlockSpatial(width, kernel_size) for _ in range(depth)]
         )