Sync from meridian-mcp@bf1547266b87d49e4fef560bf851bd07c585f5ac

.github/workflows/finish-line.yml

@@ -0,0 +1,85 @@
+name: photon-route finish-line (B1 + B2 + A3-Real)
+
+on:
+  workflow_dispatch:
+    inputs:
+      seeds:
+        description: "Sweep seeds for A3-Real (default: 1 2 3 4 5)"
+        required: false
+        default: "1 2 3 4 5"
+      steps:
+        description: "Training steps for A3-Real (default: 200)"
+        required: false
+        default: "200"
+
+permissions:
+  contents: read
+
+jobs:
+  finish:
+    runs-on: ubuntu-latest
+    timeout-minutes: 90
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install numpy scipy thewalrus torch sentence-transformers
+
+      - name: B1 — g^(1) coherence-time sim
+        run: |
+          mkdir -p reports
+          PYTHONPATH=src:. python -m space.sim_b1_g1_coherence | tee reports/b1.txt
+
+      - name: B2 — g^(2) classifier sim
+        run: |
+          PYTHONPATH=src:. python -m space.sim_b2_g2_classifier | tee reports/b2.txt
+
+      - name: Expand relevance (title queries)
+        run: |
+          PYTHONPATH=src:. python -m eval.expand_titles
+
+      - name: A3-Real — Fock-basis non-Gaussian sweep
+        run: |
+          PYTHONPATH=src:. python -m space.run_sweep_fock \
+            --seeds ${{ github.event.inputs.seeds }} \
+            --steps ${{ github.event.inputs.steps }} \
+            --herald-ns 1 0 \
+            --out-csv sweep_fock_results.csv \
+            --log-dir sweep_fock_logs \
+            | tee reports/a3.txt
+
+      - name: Upload artifacts
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: photon-finish-line
+          path: |
+            reports/
+            sweep_fock_results.csv
+            sweep_fock_logs/
+            eval/relevance_expanded.json
+          if-no-files-found: warn
+          retention-days: 30
+
+      - name: Print summaries
+        if: always()
+        run: |
+          echo "=========================================="
+          echo "B1 — g^(1) coherence sim"
+          echo "=========================================="
+          tail -25 reports/b1.txt || true
+          echo
+          echo "=========================================="
+          echo "B2 — g^(2) classifier sim"
+          echo "=========================================="
+          tail -25 reports/b2.txt || true
+          echo
+          echo "=========================================="
+          echo "A3-Real — Fock sweep CSV"
+          echo "=========================================="
+          cat sweep_fock_results.csv || true

.github/workflows/pages.yml

@@ -0,0 +1,33 @@
+name: Deploy photon-route UI to GitHub Pages
+
+on:
+  push:
+    branches: [main]
+    paths:
+      - 'pages/**'
+      - '.github/workflows/pages.yml'
+  workflow_dispatch: {}
+
+permissions:
+  contents: read
+  pages: write
+  id-token: write
+
+concurrency:
+  group: pages
+  cancel-in-progress: false
+
+jobs:
+  deploy:
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/configure-pages@v5
+      - uses: actions/upload-pages-artifact@v3
+        with:
+          path: ./pages
+      - id: deployment
+        uses: actions/deploy-pages@v4

.github/workflows/photon-sweep.yml

@@ -0,0 +1,61 @@
+name: photon-route sweep (5 splits × squeeze ablation)
+
+on:
+  workflow_dispatch:
+    inputs:
+      seeds:
+        description: "Space-separated seeds (default: 1 2 3 4 5)"
+        required: false
+        default: "1 2 3 4 5"
+      steps:
+        description: "Training steps per run (default: 200)"
+        required: false
+        default: "200"
+
+permissions:
+  contents: read
+
+jobs:
+  sweep:
+    runs-on: ubuntu-latest
+    timeout-minutes: 60
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install numpy scipy thewalrus torch sentence-transformers
+
+      - name: Expand relevance (title queries)
+        run: |
+          PYTHONPATH=src:. python -m eval.expand_titles
+
+      - name: Run sweep
+        run: |
+          PYTHONPATH=src:. python -m space.run_sweep \
+            --seeds ${{ github.event.inputs.seeds }} \
+            --steps ${{ github.event.inputs.steps }} \
+            --out-csv sweep_results.csv \
+            --log-dir sweep_logs
+
+      - name: Upload sweep results
+        uses: actions/upload-artifact@v4
+        with:
+          name: photon-sweep-results
+          path: |
+            sweep_results.csv
+            sweep_logs/
+            eval/relevance_expanded.json
+          if-no-files-found: error
+          retention-days: 30
+
+      - name: Print CSV summary
+        if: always()
+        run: |
+          echo "=== sweep_results.csv ==="
+          cat sweep_results.csv || true

eval/expand_titles.py

@@ -0,0 +1,103 @@
+"""Expand the eval relevance set with title-as-query pairs.
+
+For each arXiv ID in corpus_ids.json, fetch og:title from the abstract
+page (same scrape pattern as eval.fetch but a different meta tag), and
+emit one query whose only relevant document is that paper.
+
+Output: eval/relevance_expanded.json — original 6 multi-positive queries
+plus 20 single-positive title queries = 26 total. Increases trainer
+signal 4× without any human labeling.
+
+This script does NOT touch the existing relevance.json. It writes a
+sibling file the trainer / eval harness opt into via --relevance.
+"""
+from __future__ import annotations
+
+import argparse
+import html
+import json
+import re
+import time
+import urllib.request
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent.parent
+ARXIV_ABS = "https://arxiv.org/abs/"
+_OG_TITLE = re.compile(
+    r'<meta\s+(?:property|name)="og:title"\s+content="([^"]*)"',
+    re.IGNORECASE,
+)
+_BROWSER_HEADERS = {
+    "User-Agent": (
+        "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 "
+        "(KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36"
+    ),
+    "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+    "Accept-Language": "en-US,en;q=0.9",
+}
+
+
+def _normalize(text: str) -> str:
+    return re.sub(r"\s+", " ", text).strip()
+
+
+def _strip_arxiv_prefix(title: str) -> str:
+    """og:title comes back as '[2304.12717] Quantum natural language ...';
+    strip the '[id]' prefix so the query is just the paper title."""
+    return re.sub(r"^\s*\[[^\]]+\]\s*", "", title).strip()
+
+
+def fetch_title(arxiv_id: str, timeout: float = 30.0) -> str:
+    url = ARXIV_ABS + arxiv_id
+    req = urllib.request.Request(url, headers=_BROWSER_HEADERS)
+    with urllib.request.urlopen(req, timeout=timeout) as resp:
+        body = resp.read().decode("utf-8", errors="replace")
+    m = _OG_TITLE.search(body)
+    if not m:
+        raise RuntimeError(f"og:title not found for {arxiv_id}")
+    return _strip_arxiv_prefix(_normalize(html.unescape(m.group(1))))
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--corpus",       type=Path, default=ROOT / "eval" / "corpus_ids.json")
+    ap.add_argument("--in-relevance", type=Path, default=ROOT / "eval" / "relevance.json")
+    ap.add_argument("--out",          type=Path, default=ROOT / "eval" / "relevance_expanded.json")
+    ap.add_argument("--cache",        type=Path, default=Path.home() / ".cache" / "photon-route" / "titles")
+    ap.add_argument("--sleep",        type=float, default=0.5)
+    args = ap.parse_args()
+
+    args.cache.mkdir(parents=True, exist_ok=True)
+    ids = json.loads(args.corpus.read_text("utf-8"))["ids"]
+    base = json.loads(args.in_relevance.read_text("utf-8"))
+
+    titles = {}
+    for j, i in enumerate(ids):
+        cache_path = args.cache / f"{i}.title"
+        if cache_path.exists():
+            titles[i] = cache_path.read_text("utf-8").strip()
+            continue
+        t = fetch_title(i)
+        cache_path.write_text(t, encoding="utf-8")
+        titles[i] = t
+        print(f"[{j+1:2d}/{len(ids)}] {i}: {t[:60]}")
+        if j + 1 < len(ids):
+            time.sleep(args.sleep)
+
+    title_queries = [
+        {"query": titles[i], "relevant_ids": [i], "kind": "title"}
+        for i in ids
+    ]
+    out_payload = {
+        **base,
+        "queries": [
+            *[{**q, "kind": "topical"} for q in base["queries"]],
+            *title_queries,
+        ],
+    }
+    args.out.write_text(json.dumps(out_payload, indent=2) + "\n", encoding="utf-8")
+    print(f"\nwrote {len(out_payload['queries'])} queries → {args.out}")
+
+
+if __name__ == "__main__":
+    main()

eval/run_bm25.py

@@ -0,0 +1,113 @@
+"""BM25 baseline against the same eval set photon-route uses.
+
+Drops in next to eval.run so apples-to-apples on Recall@k / nDCG@k.
+Pure-stdlib BM25 — no external IR library — to keep the dependency
+surface identical to the rest of eval/.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import math
+from collections import Counter
+from pathlib import Path
+
+import numpy as np
+
+from eval.fetch import fetch_all, verify_against_manifest
+
+
+class BM25:
+    def __init__(self, docs: list[str], k1: float = 1.5, b: float = 0.75):
+        self.k1, self.b = k1, b
+        self.toks = [d.lower().split() for d in docs]
+        self.N = len(docs)
+        self.avgdl = sum(len(t) for t in self.toks) / self.N
+        df: Counter = Counter()
+        for t in self.toks:
+            for w in set(t):
+                df[w] += 1
+        self.idf = {
+            w: math.log(1 + (self.N - n + 0.5) / (n + 0.5)) for w, n in df.items()
+        }
+
+    def score(self, query: str, doc_index: int) -> float:
+        d = self.toks[doc_index]
+        tf = Counter(d)
+        s = 0.0
+        for w in query.lower().split():
+            if w not in self.idf:
+                continue
+            f = tf[w]
+            denom = f + self.k1 * (1 - self.b + self.b * len(d) / self.avgdl)
+            s += self.idf[w] * f * (self.k1 + 1) / max(denom, 1e-9)
+        return s
+
+
+def recall_at_k(ranked_ids: list[str], relevant: set[str], k: int) -> float:
+    if not relevant:
+        return float("nan")
+    return len(set(ranked_ids[:k]) & relevant) / len(relevant)
+
+
+def ndcg_at_k(ranked_ids: list[str], relevant: set[str], k: int) -> float:
+    if not relevant:
+        return float("nan")
+    dcg = sum(
+        1.0 / math.log2(i + 1)
+        for i, a in enumerate(ranked_ids[:k], start=1)
+        if a in relevant
+    )
+    ideal = sum(1.0 / math.log2(i + 1) for i in range(1, min(k, len(relevant)) + 1))
+    return dcg / ideal if ideal > 0 else float("nan")
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--corpus", type=Path, default=Path(__file__).parent / "corpus_ids.json")
+    ap.add_argument("--relevance", type=Path, default=Path(__file__).parent / "relevance.json")
+    ap.add_argument("--manifest", type=Path, default=Path(__file__).parent / "manifest.json")
+    ap.add_argument("--ks", type=int, nargs="+", default=[1, 3, 5, 10])
+    args = ap.parse_args()
+
+    ids = json.loads(args.corpus.read_text("utf-8"))["ids"]
+    queries = json.loads(args.relevance.read_text("utf-8"))["queries"]
+    abstracts = fetch_all(ids)
+    bad = verify_against_manifest(abstracts, args.manifest)
+    if bad:
+        raise SystemExit(f"manifest mismatch: {list(bad)[:3]}")
+
+    docs_in_order = [abstracts[i] for i in ids]
+    bm25 = BM25(docs_in_order)
+
+    per_query = []
+    for q in queries:
+        scored = sorted(
+            ((bm25.score(q["query"], i), ids[i]) for i in range(len(ids))),
+            key=lambda x: -x[0],
+        )
+        ranked_ids = [doc_id for _, doc_id in scored]
+        rel = set(q["relevant_ids"])
+        row = {"query": q["query"], "ranked": ranked_ids[: max(args.ks)]}
+        for k in args.ks:
+            row[f"recall@{k}"] = recall_at_k(ranked_ids, rel, k)
+            row[f"ndcg@{k}"] = ndcg_at_k(ranked_ids, rel, k)
+        per_query.append(row)
+
+    aggregate = {
+        f"recall@{k}": float(np.mean([q[f"recall@{k}"] for q in per_query])) for k in args.ks
+    }
+    aggregate.update(
+        {f"ndcg@{k}": float(np.mean([q[f"ndcg@{k}"] for q in per_query])) for k in args.ks}
+    )
+    print(f"backend=bm25 corpus={len(ids)} queries={len(queries)}")
+    for q in per_query:
+        cells = " ".join(
+            f"{m}={q[m]:.3f}" for m in q if m.startswith(("recall", "ndcg"))
+        )
+        print(f"  {q['query'][:48]:<48s}  {cells}")
+    print("aggregate: " + " ".join(f"{m}={aggregate[m]:.3f}" for m in aggregate))
+
+
+if __name__ == "__main__":
+    main()

eval/run_sbert.py

@@ -0,0 +1,87 @@
+"""SBERT (all-MiniLM-L6-v2) baseline against the same eval set.
+
+Mean-pooled 384-d sentence embedding, cosine similarity. Establishes the
+modern dense-retrieval ceiling for the photon-route eval. Runs entirely
+on CPU in a few seconds for this corpus size.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import math
+from pathlib import Path
+
+import numpy as np
+
+from eval.fetch import fetch_all, verify_against_manifest
+
+
+def recall_at_k(ranked_ids: list[str], relevant: set[str], k: int) -> float:
+    if not relevant:
+        return float("nan")
+    return len(set(ranked_ids[:k]) & relevant) / len(relevant)
+
+
+def ndcg_at_k(ranked_ids: list[str], relevant: set[str], k: int) -> float:
+    if not relevant:
+        return float("nan")
+    dcg = sum(
+        1.0 / math.log2(i + 1)
+        for i, a in enumerate(ranked_ids[:k], start=1)
+        if a in relevant
+    )
+    ideal = sum(1.0 / math.log2(i + 1) for i in range(1, min(k, len(relevant)) + 1))
+    return dcg / ideal if ideal > 0 else float("nan")
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--model", default="sentence-transformers/all-MiniLM-L6-v2")
+    ap.add_argument("--corpus",    type=Path, default=Path(__file__).parent / "corpus_ids.json")
+    ap.add_argument("--relevance", type=Path, default=Path(__file__).parent / "relevance.json")
+    ap.add_argument("--manifest",  type=Path, default=Path(__file__).parent / "manifest.json")
+    ap.add_argument("--ks", type=int, nargs="+", default=[1, 3, 5, 10])
+    args = ap.parse_args()
+
+    from sentence_transformers import SentenceTransformer
+
+    ids = json.loads(args.corpus.read_text("utf-8"))["ids"]
+    queries = json.loads(args.relevance.read_text("utf-8"))["queries"]
+    abstracts = fetch_all(ids)
+    bad = verify_against_manifest(abstracts, args.manifest)
+    if bad:
+        raise SystemExit(f"manifest mismatch: {list(bad)[:3]}")
+
+    print(f"loading {args.model}...")
+    model = SentenceTransformer(args.model)
+
+    docs_in_order = [abstracts[i] for i in ids]
+    doc_emb = model.encode(docs_in_order, normalize_embeddings=True, show_progress_bar=False)
+    q_emb   = model.encode([q["query"] for q in queries], normalize_embeddings=True, show_progress_bar=False)
+
+    per_query = []
+    for qi, q in enumerate(queries):
+        sims = doc_emb @ q_emb[qi]  # cosine since both are normalized
+        order = np.argsort(-sims)
+        ranked_ids = [ids[i] for i in order]
+        rel = set(q["relevant_ids"])
+        row = {"query": q["query"], "ranked": ranked_ids[: max(args.ks)]}
+        for k in args.ks:
+            row[f"recall@{k}"] = recall_at_k(ranked_ids, rel, k)
+            row[f"ndcg@{k}"]   = ndcg_at_k(ranked_ids, rel, k)
+        per_query.append(row)
+
+    aggregate = {f"recall@{k}": float(np.mean([q[f"recall@{k}"] for q in per_query])) for k in args.ks}
+    aggregate.update(
+        {f"ndcg@{k}": float(np.mean([q[f"ndcg@{k}"] for q in per_query])) for k in args.ks}
+    )
+
+    print(f"backend=sbert/{args.model.split('/')[-1]}  corpus={len(ids)} queries={len(queries)}")
+    for q in per_query:
+        cells = " ".join(f"{m}={q[m]:.3f}" for m in q if m.startswith(("recall", "ndcg")))
+        print(f"  {q['query'][:48]:<48s}  {cells}")
+    print("aggregate: " + " ".join(f"{m}={aggregate[m]:.3f}" for m in aggregate))
+
+
+if __name__ == "__main__":
+    main()

pages/CNAME

@@ -0,0 +1 @@
+photon.ask-meridian.uk

worker/proxy.js → pages/index.html

@@ -1,57 +1,4 @@
-// photon-route Cloudflare Worker
-// Routes photon.ask-meridian.uk → HF Space (luuow-photon-route),
-// edge-caches /rank, and serves an inline interactive UI at /.
-//
-// Endpoints (worker-local):
-//   /         interactive HTML page
-//   /health   liveness JSON
-//   /api      service banner JSON
-// Endpoints (proxied to HF Space):
-//   /rank?q=&top_k=   edge-cached 24 h
-//   /version /docs /openapi.json
-//
-// Cache key includes CACHE_VERSION; bump to invalidate after UI changes
-// or fixture updates upstream.
-
-const HF = 'https://luuow-photon-route.hf.space';
-const PROXY = new Set(['/rank', '/version', '/docs', '/openapi.json']);
-// CACHE_VERSION bump: /rank responses now include `backend` and the
-// payload differs per backend; the cache key already includes the
-// query string so backends are cached separately, but old (v3) entries
-// don't have the backend field — invalidate.
-const CACHE_VERSION = 'v4';
-
-const BANNER = {
-  service: 'photon-route',
-  proxy: 'cloudflare-worker',
-  backend: 'huggingface-space',
-  upstream: HF,
-  repo: 'https://github.com/LuuOW/photon-route',
-  sister: 'https://qrouter.ask-meridian.uk (DV / qubit-gate sister project)',
-  endpoints: {
-    ui:      '/         (interactive HTML)',
-    api:     '/api      (this banner)',
-    health:  '/health   (worker-local)',
-    rank:    '/rank?q=<query>&top_k=N&backend=v1|sha_init|trained   (proxied, edge-cached 24 h)',
-    version: '/version  (proxied)',
-    docs:    '/docs     (proxied — FastAPI swagger)',
-  },
-  backends: ['v1 (SF)', 'sha_init (numpy)', 'trained (numpy + learned)'],
-  note: 'CV photonic retrieval. Strawberry Fields Gaussian programs, thewalrus closed-form fidelity.',
-};
-
-const CSP = [
-  "default-src 'self'",
-  "style-src 'self' 'unsafe-inline'",
-  "script-src 'self' 'unsafe-inline'",
-  "connect-src 'self'",
-  "img-src 'self' data:",
-  "base-uri 'none'",
-  "form-action 'none'",
-  "frame-ancestors 'none'",
-].join('; ');
-
-const HTML = `<!doctype html>
+<!doctype html>
 <html lang="en">
 <head>
 <meta charset="utf-8">
@@ -161,7 +108,6 @@ const HTML = `<!doctype html>
     border-bottom:1px dotted var(--line)}
   footer a:hover{color:var(--fg);border-bottom-color:var(--cyan)}
   .empty{color:var(--muted);text-align:center;padding:32px 12px;font-size:12px}
-  /* phase-space visualization */
   .viz{margin:14px 0 18px;display:grid;grid-template-columns:1fr 1fr;gap:10px}
   .modepanel{position:relative;background:var(--panel);border:1px solid var(--line);
     border-radius:var(--radius);overflow:hidden;aspect-ratio:5/4;min-height:200px}
@@ -198,6 +144,193 @@ const HTML = `<!doctype html>
 </style>
 </head>
 <body>
+<style>
+  .nav { position: fixed; inset: 0 0 auto 0;
+    display: flex; align-items: center; justify-content: space-between;
+    padding: 14px clamp(12px, 3vw, 24px);
+    z-index: 100; pointer-events: none;
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", system-ui, sans-serif; }
+  .nav > * { pointer-events: auto; }
+  /* Nav-scoped: the page body has its own <div class="brand"> gradient
+     for the page title — don't let nav .brand rules override it. */
+  .nav .brand { color: #e9eef7; font-weight: 600; letter-spacing: 0.04em;
+    text-decoration: none; font-size: 15px;
+    background: none; -webkit-text-fill-color: currentColor; }
+  .nav .brand .brand-glyph { color: #ffa276; margin-right: 6px; }
+  .burger { width: 40px; height: 40px; padding: 0;
+    background: rgba(167,139,250,0.05);
+    border: 1px solid rgba(167,139,250,0.18);
+    border-radius: 10px; cursor: pointer; position: relative;
+    transition: background 0.15s, border-color 0.15s, box-shadow 0.15s; }
+  .burger:hover { background: rgba(167,139,250,0.12); border-color: #a78bfa; box-shadow: 0 0 14px rgba(167,139,250,0.25); }
+  .burger span { position: absolute; left: 11px; right: 11px; height: 2px;
+    background: #c9d4ec; border-radius: 1px;
+    transition: top 0.18s, transform 0.18s, opacity 0.18s; }
+  .burger span:nth-child(1) { top: 13px; }
+  .burger span:nth-child(2) { top: 19px; }
+  .burger span:nth-child(3) { top: 25px; }
+  .burger.open { background: rgba(167,139,250,0.18); border-color: #a78bfa; }
+  .burger.open span:nth-child(1) { top: 19px; transform: rotate(45deg); }
+  .burger.open span:nth-child(2) { opacity: 0; }
+  .burger.open span:nth-child(3) { top: 19px; transform: rotate(-45deg); }
+  .nav-menu { position: fixed; top: 64px; right: clamp(12px, 3vw, 24px);
+    width: min(330px, calc(100vw - 24px));
+    display: flex; flex-direction: column; gap: 2px; padding: 14px;
+    background: rgba(10, 13, 20, 0.96); backdrop-filter: blur(16px);
+    border: 1px solid rgba(167, 139, 250, 0.3); border-radius: 14px;
+    box-shadow: 0 20px 50px rgba(0,0,0,0.5); transform-origin: top right;
+    transform: translateY(-12px) scale(0.97); opacity: 0; pointer-events: none;
+    transition: transform 0.22s cubic-bezier(0.16,1,0.3,1), opacity 0.2s ease;
+    z-index: 110; max-height: calc(100vh - 80px); overflow-y: auto; }
+  .nav-menu.open { transform: translateY(0) scale(1); opacity: 1; pointer-events: auto; }
+  .nav-menu a { display: block; padding: 10px 14px; border-radius: 8px;
+    font-size: 14px; color: #9bb6ea; text-decoration: none;
+    transition: background 0.15s, color 0.15s; }
+  .nav-menu a:hover, .nav-menu .current { background: rgba(167,139,250,0.10); color: #fff; }
+  .nav-group { border-top: 1px solid rgba(167, 139, 250, 0.10); margin-top: 6px; padding-top: 4px; }
+  .nav-group:first-of-type { border-top: 0; margin-top: 4px; padding-top: 0; }
+  .nav-group > summary { cursor: pointer; list-style: none; user-select: none; }
+  .nav-group > summary::-webkit-details-marker { display: none; }
+  .nav-section { font-size: 11px; letter-spacing: 0.12em; text-transform: uppercase;
+    color: rgba(167, 139, 250, 0.75); padding: 10px 14px 6px; font-weight: 600;
+    display: flex; align-items: center; justify-content: space-between; }
+  .nav-section::after { content: '+'; font-size: 14px;
+    color: rgba(167, 139, 250, 0.55);
+    transition: transform 0.18s, color 0.18s; }
+  .nav-group[open] > summary .nav-section::after { transform: rotate(45deg); color: #a78bfa; }
+  .nav-group > summary:hover .nav-section { color: #fff; }
+  .nav-app { background: rgba(167,139,250,0.04);
+    border: 1px solid rgba(167,139,250,0.10);
+    margin: 4px 0; line-height: 1.3;
+    padding: 10px 14px !important; border-radius: 10px !important; }
+  .nav-app:hover { background: rgba(167,139,250,0.12); border-color: rgba(167,139,250,0.32); }
+  .nav-app .nav-app-name { display: block; font-size: 14px; color: #e9eef7; font-weight: 500; }
+  .nav-app .nav-app-tag  { display: block; font-size: 12px; color: #9bb6ea; margin-top: 2px; }
+  .nav-app .nav-app-emoji { margin-right: 6px; }
+</style>
+
+<nav class="nav" aria-label="Primary">
+  <a href="https://ask-meridian.uk/" class="brand" style="view-transition-name: brand">◎ Meridian</a>
+
+  <button id="burgerBtn" class="burger" type="button" aria-label="Toggle navigation menu" aria-expanded="false" aria-controls="navMenu">
+    <span aria-hidden="true"></span><span aria-hidden="true"></span><span aria-hidden="true"></span>
+  </button>
+
+  <div id="navMenu" class="nav-menu" role="menu">
+    <a href="https://ask-meridian.uk/">Home</a>
+
+    <details class="nav-group" open>
+      <summary class="nav-section">Showcase</summary>
+      <a href="https://meridian.ask-meridian.uk/helix/" class="nav-app" data-status="live">
+        <span class="nav-app-name"><span class="nav-app-emoji">🧬</span>helix · proteins</span>
+        <span class="nav-app-tag">Injury → top therapeutic protein candidates, each rendered as its own star system</span>
+      </a>
+      <a href="https://ask-meridian.uk/miniapp/" class="nav-app" data-status="live">
+        <span class="nav-app-name"><span class="nav-app-emoji">🛰️</span>Try it · Task orbit</span>
+        <span class="nav-app-tag">Browser miniapp · routes any task to candidates</span>
+      </a>
+      <a href="https://ask-meridian.uk/miniapp/vision-lab/" class="nav-app" data-status="live">
+        <span class="nav-app-name"><span class="nav-app-emoji">🔭</span>Vision Lab</span>
+        <span class="nav-app-tag">SmolVLM / Moondream in browser via WebGPU</span>
+      </a>
+      <a href="https://photon.ask-meridian.uk" class="nav-app" data-status="live">
+        <span class="nav-app-name"><span class="nav-app-emoji">⚛︎</span>Photon Router</span>
+        <span class="nav-app-tag">CV photonic retrieval · trained on HF Space</span>
+      </a>
+      <a href="https://lens.ask-meridian.uk" class="nav-app" data-status="live">
+        <span class="nav-app-name"><span class="nav-app-emoji">◎</span>Lens · WebXR</span>
+        <span class="nav-app-tag">Vision Lab in VR · controllers, raycaster, orbit</span>
+      </a>
+    </details>
+
+    <details class="nav-group">
+      <summary class="nav-section">Resources</summary>
+      <a href="https://ask-meridian.uk/blog/">Blog</a>
+      <a href="https://ask-meridian.uk/docs/">Docs</a>
+      <a href="https://ask-meridian.uk/#pricing">Pricing</a>
+    </details>
+
+    <details class="nav-group">
+      <summary class="nav-section">Source</summary>
+      <a href="https://github.com/LuuOW/meridian-mcp">GitHub · meridian-mcp</a>
+      <a href="https://github.com/LuuOW/photon-route">GitHub · photon-route</a>
+    </details>
+  </div>
+
+  <!-- Self-contained burger + current-link behaviour. Lives inside <nav>
+       so sync-nav.py treats it as part of the synced block — every page
+       gets the same wiring without needing a separate <script> import.
+       Re-runs on DOMContentLoaded too so it survives module-script
+       races and weird parse orders. -->
+  <script>
+  (function () {
+    function setup() {
+      var btn  = document.getElementById('burgerBtn')
+      var menu = document.getElementById('navMenu')
+      if (!btn || !menu) return
+      if (btn.dataset.wired) return
+      btn.dataset.wired = '1'
+
+      function toggle(open) {
+        var isOpen = open === undefined ? !menu.classList.contains('open') : open
+        menu.classList.toggle('open', isOpen)
+        btn.classList.toggle('open', isOpen)
+        btn.setAttribute('aria-expanded', String(isOpen))
+      }
+      btn.addEventListener('click', function () { toggle() })
+      menu.querySelectorAll('a').forEach(function (a) {
+        a.addEventListener('click', function () { toggle(false) })
+      })
+      document.addEventListener('click', function (e) {
+        if (!menu.classList.contains('open')) return
+        if (!menu.contains(e.target) && !btn.contains(e.target)) toggle(false)
+      })
+      document.addEventListener('keydown', function (e) {
+        if (e.key === 'Escape') toggle(false)
+      })
+
+      // Cross-host aware: same protocol+host+path → current. Lets the
+      // highlight follow you whether you're on ask-meridian.uk,
+      // meridian.ask-meridian.uk, or photon.ask-meridian.uk.
+      var here = location.host + location.pathname.replace(/\/index\.html$/, '/')
+      menu.querySelectorAll('a').forEach(function (a) {
+        var href = a.getAttribute('href')
+        if (!href) return
+        try {
+          var u = new URL(href, location.href)
+          var target = u.host + u.pathname.replace(/\/index\.html$/, '/')
+          if (target === here) a.classList.add('current')
+        } catch (_) {}
+      })
+    }
+    if (document.readyState === 'loading') {
+      document.addEventListener('DOMContentLoaded', setup, { once: true })
+    } else {
+      setup()
+    }
+  })()
+  </script>
+</nav>
+
+<script>
+  (function () {
+    const btn  = document.querySelector('.burger');
+    const menu = document.getElementById('navMenu');
+    if (!btn || !menu) return;
+    const set = (open) => {
+      menu.classList.toggle('open', open);
+      btn.classList.toggle('open', open);
+      btn.setAttribute('aria-expanded', String(open));
+    };
+    btn.addEventListener('click', e => { e.stopPropagation(); set(!menu.classList.contains('open')); });
+    document.addEventListener('click', e => {
+      if (!menu.classList.contains('open')) return;
+      if (!menu.contains(e.target) && !btn.contains(e.target)) set(false);
+    });
+    document.addEventListener('keydown', e => { if (e.key === 'Escape') set(false); });
+    menu.querySelectorAll('a').forEach(a => a.addEventListener('click', () => set(false)));
+  })();
+</script>
 <main>
 <header>
   <div>
@@ -249,28 +382,29 @@ const HTML = `<!doctype html>
   <div class="body">
     <p><strong>photon-route</strong> is a research artifact exploring whether semantic retrieval can run in the continuous-variable (CV) photonic regime — the regime that real photonic hardware (Xanadu Borealis, fiber-loop reservoirs, coherent Ising machines) actually operates in.</p>
     <p>Each document is encoded as a <em>Gaussian state</em> over N bosonic modes via a <a href="https://strawberryfields.ai/" target="_blank" rel="noopener">Strawberry Fields</a> program: words contribute squeezing and displacement operations, then a beam-splitter network mixes the modes. Query and document fidelity is computed in closed form using the <a href="https://the-walrus.readthedocs.io/" target="_blank" rel="noopener">thewalrus</a> implementation of the Banchi-Braunstein-Pirandola formula.</p>
-    <p>Three swappable encoders share the same fidelity scoring. <strong>v1</strong> uses Strawberry Fields to run an N-mode Gaussian program with SHA-256-derived parameters. <strong>sha_init</strong> is a pure-numpy port of the same gates (no SF at deploy time). <strong>trained</strong> swaps the SHA-256 lookup for a learned table fit by InfoNCE + Bhattacharyya-coefficient surrogate fidelity on a small arXiv quant-ph eval set. Toggle <em>compare</em> to see the three side by side; the DV-qubit sister project is <a href="https://qrouter.ask-meridian.uk" target="_blank" rel="noopener">qrouter</a>.</p>
+    <p>Three swappable encoders share the same fidelity scoring. <strong>v1</strong> uses Strawberry Fields to run an N-mode Gaussian program with SHA-256-derived parameters. <strong>sha_init</strong> is a pure-numpy port of the same gates (no SF at deploy time). <strong>trained</strong> swaps the SHA-256 lookup for a learned table fit by InfoNCE + Bhattacharyya-coefficient surrogate fidelity on a small arXiv quant-ph eval set. Toggle <em>compare</em> to see the three side by side.</p>
     <p>Source · <a href="https://github.com/LuuOW/photon-route" target="_blank" rel="noopener">github.com/LuuOW/photon-route</a></p>
   </div>
 </details>
 
 <footer>
-  <span>CV photonic · gaussian backend · edge-cached at the Cloudflare boundary</span>
-  <span><a href="https://qrouter.ask-meridian.uk" rel="noopener">qrouter (DV)</a> · <a href="/docs">/docs</a> · <a href="/api">json</a></span>
+  <span>CV photonic · gaussian backend · UI on GitHub Pages, retrieval on HF Space</span>
+  <span><a href="https://luuow-photon-route.hf.space/docs" rel="noopener">/docs</a> · <a href="https://luuow-photon-route.hf.space/health" rel="noopener">/health</a></span>
 </footer>
 </main>
 
 <script>
 (function(){
+  // Backend lives on Hugging Face Spaces. CORS is wide-open on the FastAPI app
+  // so the browser hits this directly. Override with a ?api=https://… query
+  // string for local Space testing.
+  var SPACE = (new URL(location.href)).searchParams.get('api') || 'https://luuow-photon-route.hf.space';
+
   function $(id){return document.getElementById(id)}
   var q=$('q'), k=$('k'), results=$('results'), status=$('status');
   var healthPill=$('health'), healthText=$('health-text');
   var abort=null, debounceT=0;
 
-  // ============================================================
-  // Gaussian-state encoding (mirrors src/photon_route/encode.py)
-  // xpxp ordering: mu = [q0, p0, q1, p1]; sigma is 4x4
-  // ============================================================
   var N_MODES = 2, MAX_SQUEEZE = 0.5, MAX_DISPLACE = 1.0;
   var _wcache = new Map();
 
@@ -282,7 +416,6 @@ const HTML = `<!doctype html>
       var hash = await crypto.subtle.digest('SHA-256', buf);
       bytes = new Uint8Array(hash);
     } catch(e){
-      // fallback: not cryptographic but stable enough for viz when subtle unavailable
       bytes = new Uint8Array(32);
       var h = 2166136261;
       for(var i=0;i<word.length;i++){ h ^= word.charCodeAt(i); h = (h*16777619)>>>0; }
@@ -290,7 +423,6 @@ const HTML = `<!doctype html>
     }
     var parts = [];
     for(var i2=0;i2<4;i2++){
-      // 8 bytes -> BigInt -> mod 1e9 / 1e9
       var big = 0n;
       for(var j2=0;j2<8;j2++) big = (big << 8n) + BigInt(bytes[i2*8 + j2]);
       parts.push(Number(big % 1000000000n) / 1e9);
@@ -322,7 +454,6 @@ const HTML = `<!doctype html>
   function tr4(A){var T=mat4(); for(var i=0;i<4;i++) for(var j=0;j<4;j++) T[i][j]=A[j][i]; return T;}
 
   function sgateMat(k, r, phi){
-    // S22 = R(phi/2) @ diag(e^{-r}, e^r) @ R(-phi/2)
     var c=Math.cos(phi/2), s=Math.sin(phi/2), em=Math.exp(-r), ep=Math.exp(r);
     var a = c*c*em + s*s*ep;
     var b = c*s*(em - ep);
@@ -377,11 +508,7 @@ const HTML = `<!doctype html>
     };
   }
 
-  // ============================================================
-  // 2.5D Wigner-function rendering on a 2D canvas (no WebGL).
-  // For Gaussian states: W(x) = (1 / (2π√det Σ)) exp(-½ (x-μ)ᵀΣ⁻¹(x-μ))
-  // ============================================================
-  var GRID = 26;            // quads per side; 26² × 2 modes ~= 1352 quads/frame
+  var GRID = 26;
   var DPR  = Math.min(window.devicePixelRatio || 1, 2);
 
   function WignerView(canvas, coordEl){
@@ -390,8 +517,8 @@ const HTML = `<!doctype html>
     this.ctx    = canvas.getContext('2d');
     this.mu     = [0,0];
     this.sigma  = [[1,0],[0,1]];
-    this.yaw    = 0.55;       // initial ~31°
-    this.pitch  = 0.85;       // tilt down
+    this.yaw    = 0.55;
+    this.pitch  = 0.85;
     this.userYaw = false;
     this.dragging = false;
     this.lastX = 0; this.lastY = 0;
@@ -440,29 +567,24 @@ const HTML = `<!doctype html>
   WignerView.prototype.draw = function(){
     var ctx = this.ctx, W = this.canvas.width, H = this.canvas.height;
     ctx.clearRect(0,0,W,H);
-
     var mu = this.mu, sg = this.sigma;
     var det = sg[0][0]*sg[1][1] - sg[0][1]*sg[1][0];
     if(det < 1e-12){ return; }
     var iv00 = sg[1][1]/det, iv01 = -sg[0][1]/det, iv10 = -sg[1][0]/det, iv11 = sg[0][0]/det;
     var norm = 1/(2*Math.PI*Math.sqrt(det));
-
-    // auto-scale to fit ±3σ ellipse around μ
     var sQ = Math.sqrt(Math.abs(sg[0][0])), sP = Math.sqrt(Math.abs(sg[1][1]));
     var extent = Math.max(2.6, Math.abs(mu[0]) + 3*sQ, Math.abs(mu[1]) + 3*sP);
     var scaleXY = (Math.min(W, H) * 0.32) / extent;
-    var scaleZ  = (Math.min(W, H) * 0.55) * Math.sqrt(det);  // visual height ~ peak amplitude
+    var scaleZ  = (Math.min(W, H) * 0.55) * Math.sqrt(det);
     var ox = W*0.5, oy = H*0.62;
-
     var cy = Math.cos(this.yaw),   sy = Math.sin(this.yaw);
     var cp = Math.cos(this.pitch), sp = Math.sin(this.pitch);
-
     function project(q, p, w){
       var xr = q*cy - p*sy;
       var yr = q*sy + p*cy;
       var sx = ox + xr * scaleXY;
       var sy_ = oy - yr * scaleXY * cp - w * scaleZ * sp;
-      var depth = yr * sp - w * cp;  // larger = farther back
+      var depth = yr * sp - w * cp;
       return [sx, sy_, depth];
     }
     function projectFlat(q, p){
@@ -470,8 +592,6 @@ const HTML = `<!doctype html>
       var yr = q*sy + p*cy;
       return [ox + xr*scaleXY, oy - yr*scaleXY*cp];
     }
-
-    // floor grid on (q, p) plane
     ctx.strokeStyle = 'rgba(28,39,66,0.7)';
     ctx.lineWidth = 1;
     var gN = 6;
@@ -484,7 +604,6 @@ const HTML = `<!doctype html>
       var dFlat = projectFlat( extent, t);
       ctx.beginPath(); ctx.moveTo(cFlat[0], cFlat[1]); ctx.lineTo(dFlat[0], dFlat[1]); ctx.stroke();
     }
-    // axes: q (cyan), p (indigo) at origin
     var oFlat = projectFlat(0,0);
     var qAxis = projectFlat(extent, 0);
     var pAxis = projectFlat(0, extent);
@@ -492,8 +611,6 @@ const HTML = `<!doctype html>
     ctx.beginPath(); ctx.moveTo(oFlat[0], oFlat[1]); ctx.lineTo(qAxis[0], qAxis[1]); ctx.stroke();
     ctx.strokeStyle = 'rgba(129,140,248,0.45)';
     ctx.beginPath(); ctx.moveTo(oFlat[0], oFlat[1]); ctx.lineTo(pAxis[0], pAxis[1]); ctx.stroke();
-
-    // sample Wigner on grid + project
     var N = GRID;
     var step = (2*extent)/N;
     var pts = new Array(N+1);
@@ -512,8 +629,6 @@ const HTML = `<!doctype html>
         pts[i][j] = {w:w, sx:pr[0], sy:pr[1], depth:pr[2]};
       }
     }
-
-    // build quads + sort back-to-front
     var quads = [];
     for(var i2=0;i2<N;i2++){
       for(var j2=0;j2<N;j2++){
@@ -523,13 +638,10 @@ const HTML = `<!doctype html>
         quads.push({a:a, b:b, c:c, d:d, depth:depth, w:wAvg});
       }
     }
-    quads.sort(function(x, y){ return y.depth - x.depth; }); // larger depth first (farther)
-
-    // draw
+    quads.sort(function(x, y){ return y.depth - x.depth; });
     for(var qi2=0; qi2<quads.length; qi2++){
       var qd = quads[qi2];
       var t2 = wmax > 1e-12 ? Math.max(0, Math.min(1, qd.w / wmax)) : 0;
-      // indigo (low) -> cyan (high)
       var rC = Math.round(0x81*(1-t2) + 0x22*t2);
       var gC = Math.round(0x8c*(1-t2) + 0xd3*t2);
       var bC = Math.round(0xf8*(1-t2) + 0xee*t2);
@@ -556,7 +668,6 @@ const HTML = `<!doctype html>
     v1 = new WignerView(c1, document.getElementById('c1'));
     var resize = function(){ v0.resize(); v1.resize(); };
     window.addEventListener('resize', resize);
-    // vacuum initial
     v0.setState([0,0],[[1,0],[0,1]]);
     v1.setState([0,0],[[1,0],[0,1]]);
     var lastT = performance.now();
@@ -577,23 +688,21 @@ const HTML = `<!doctype html>
     if(text === lastQuery) return;
     lastQuery = text;
     var st = await encodeState(text);
-    if(text !== lastQuery) return;  // newer query came in
+    if(text !== lastQuery) return;
     currentState = st;
     var m0 = modeMarginal(st, 0), m1 = modeMarginal(st, 1);
     v0.setState(m0.mu, m0.sigma);
     v1.setState(m1.mu, m1.sigma);
   }
-  // init after DOM ready (we're at end of body so DOM exists)
   initViz();
 
   var backendSel = document.getElementById('backend');
   var compareBox = document.getElementById('compare');
-  fetch('/health',{cache:'no-store'}).then(function(r){return r.json()}).then(function(j){
-    var ok = j && j.ok && j.upstream_ok;
+  fetch(SPACE+'/health',{cache:'no-store'}).then(function(r){return r.json()}).then(function(j){
+    var ok = j && j.ok;
     healthPill.classList.add(ok?'ok':'err');
     var backends = (j && j.backends_available) || [];
     healthText.textContent = ok ? (j.default_backend || 'ok') : 'offline';
-    // hide options for backends that aren't actually live upstream
     Array.prototype.forEach.call(backendSel.options, function(opt){
       opt.disabled = backends.length>0 && backends.indexOf(opt.value) < 0;
       if (opt.disabled) opt.text = opt.value + ' (n/a)';
@@ -674,12 +783,11 @@ const HTML = `<!doctype html>
   }
 
   async function fetchRank(text, topk, backend, sig){
-    var url='/rank?q='+encodeURIComponent(text)+'&top_k='+topk+'&backend='+encodeURIComponent(backend);
+    var url=SPACE+'/rank?q='+encodeURIComponent(text)+'&top_k='+topk+'&backend='+encodeURIComponent(backend);
     var r=await fetch(url,{signal:sig});
     if(!r.ok) throw new Error('http '+r.status);
     var j=await r.json();
-    return {backend:j.backend||backend, items:j.results||[],
-            cache:r.headers.get('x-photon-route-cache')||''};
+    return {backend:j.backend||backend, items:j.results||[], cache:''};
   }
 
   async function run(){
@@ -704,7 +812,7 @@ const HTML = `<!doctype html>
         var j = await fetchRank(text, topk, backendSel.value, abort.signal);
         var ms=(performance.now()-t0).toFixed(0);
         status.textContent = j.items.length+' result'+(j.items.length===1?'':'s')+
-          ' · '+ms+' ms'+(j.cache?' · cache '+j.cache:'')+' · backend '+j.backend;
+          ' · '+ms+' ms · backend '+j.backend;
         render(j.items);
         return;
       }
@@ -745,114 +853,4 @@ const HTML = `<!doctype html>
 })();
 </script>
 </body>
-</html>`;
-
-addEventListener('fetch', (e) => e.respondWith(handle(e.request)));
-
-async function handle(req) {
-  const url = new URL(req.url);
-  const path = url.pathname;
-
-  if (req.method === 'OPTIONS') {
-    return cors(new Response(null, { status: 204 }));
-  }
-
-  if (path === '/' && (req.method === 'GET' || req.method === 'HEAD')) {
-    return new Response(req.method === 'HEAD' ? null : HTML, {
-      headers: {
-        'content-type': 'text/html; charset=utf-8',
-        'content-security-policy': CSP,
-        'referrer-policy': 'strict-origin-when-cross-origin',
-        'x-content-type-options': 'nosniff',
-        'cache-control': 'public, max-age=300',
-      },
-    });
-  }
-
-  if (path === '/api' || path === '/info') {
-    return jsonResp(BANNER);
-  }
-
-  if (path === '/health') {
-    // Merge upstream /health so the UI knows which backends are live.
-    let upstream = null;
-    try {
-      const r = await fetch(HF + '/health', { cf: { cacheTtl: 30 } });
-      if (r.ok) upstream = await r.json();
-    } catch (_) {}
-    return jsonResp({
-      ok: true,
-      proxy: 'cloudflare-worker',
-      upstream_ok: upstream ? !!upstream.ok : false,
-      backends_available: upstream && upstream.backends_available
-        ? upstream.backends_available : ['stub'],
-      default_backend: upstream && upstream.default_backend
-        ? upstream.default_backend : 'stub',
-      weights_loaded: upstream ? !!upstream.weights_loaded : false,
-    });
-  }
-
-  if (PROXY.has(path) && (req.method === 'GET' || req.method === 'HEAD')) {
-    return await proxied(req, url, path);
-  }
-
-  return jsonResp({ error: 'not found' }, 404);
-}
-
-function jsonResp(obj, status = 200) {
-  return new Response(JSON.stringify(obj, null, 2), {
-    status,
-    headers: {
-      'content-type': 'application/json; charset=utf-8',
-      'access-control-allow-origin': '*',
-      'cache-control': 'no-store',
-    },
-  });
-}
-
-function cors(resp) {
-  resp.headers.set('access-control-allow-origin', '*');
-  resp.headers.set('access-control-allow-methods', 'GET, HEAD, OPTIONS');
-  resp.headers.set('access-control-allow-headers', 'content-type');
-  return resp;
-}
-
-async function proxied(req, url, path) {
-  const upstream = new URL(HF);
-  upstream.pathname = path;
-  upstream.search = url.search;
-
-  const isRank = path === '/rank';
-  const cacheKey = new Request(upstream.toString() + '#' + CACHE_VERSION, req);
-  const cache = caches.default;
-
-  if (isRank) {
-    const hit = await cache.match(cacheKey);
-    if (hit) {
-      const r = new Response(hit.body, hit);
-      r.headers.set('x-photon-route-cache', 'hit');
-      return cors(r);
-    }
-  }
-
-  const fetched = await fetch(upstream.toString(), {
-    method: req.method,
-    headers: { accept: req.headers.get('accept') || '*/*' },
-    cf: { cacheTtl: 0 },
-  });
-
-  if (!fetched.ok || fetched.status >= 500) {
-    const r = new Response(fetched.body, fetched);
-    r.headers.set('x-photon-route-cache', 'bypass');
-    return cors(r);
-  }
-
-  const body = await fetched.arrayBuffer();
-  const headers = new Headers(fetched.headers);
-  headers.delete('set-cookie');
-  if (isRank) headers.set('cache-control', 'public, s-maxage=86400, max-age=300');
-  const ok = new Response(body, { status: fetched.status, headers });
-  ok.headers.set('x-photon-route-cache', 'miss');
-  if (isRank) await cache.put(cacheKey, ok.clone());
-  return cors(ok);
-}
+</html>

space/analyze_sweep.py

@@ -0,0 +1,112 @@
+"""Read sweep_results.csv, decide whether SBERT-photon's gain is real
+and whether photon-number-distribution metric (A3-Simple) outperforms
+Gaussian-state-overlap (BBP fidelity) on the same trained encoder.
+
+Q1. Does SBERT-photon (full, gaussian metric) robustly beat raw SBERT?
+Q2. Does the squeezing layer specifically pay (full vs no-squeeze)?
+Q3. A3-Simple: does photon-prob metric > gaussian metric on same encoder?
+Q4. Generalization tax (train − test nDCG@10).
+"""
+from __future__ import annotations
+
+import argparse
+import csv
+import statistics
+from pathlib import Path
+
+
+SBERT_ALONE_NDCG10 = 0.385
+
+
+def stat(rs, key):
+    vals = [r[key] for r in rs if r[key] == r[key]]
+    if len(vals) < 2:
+        return (vals[0] if vals else float("nan"), 0.0, len(vals))
+    return statistics.mean(vals), statistics.stdev(vals), len(vals)
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--csv", type=Path, default=Path(__file__).resolve().parent.parent / "sweep_results.csv")
+    args = ap.parse_args()
+
+    rows = list(csv.DictReader(args.csv.open()))
+    for r in rows:
+        for k, v in list(r.items()):
+            try:
+                r[k] = float(v)
+            except (ValueError, TypeError):
+                pass
+
+    full = sorted([r for r in rows if int(r["no_squeeze"]) == 0], key=lambda r: r["seed"])
+    nosq = sorted([r for r in rows if int(r["no_squeeze"]) == 1], key=lambda r: r["seed"])
+
+    print(f"loaded {len(rows)} runs from {args.csv}")
+    print(f"  full (squeezing on):  n={len(full)}")
+    print(f"  no-squeeze:           n={len(nosq)}")
+
+    print("\n=== Q1. SBERT-photon (full, gaussian metric) vs raw SBERT (0.385) ===")
+    m, s, n = stat(full, "test_gaussian_n10")
+    delta = m - SBERT_ALONE_NDCG10
+    z = delta / s if s > 0 else float("inf")
+    verdict = "✓ YES" if delta > s and m > SBERT_ALONE_NDCG10 else "✗ noisy or no gain"
+    print(f"  full mean test nDCG@10 (gaussian) = {m:.3f} ± {s:.3f}  (n={n})")
+    print(f"  Δ vs raw SBERT = {delta:+.3f}  (Δ/σ ≈ {z:+.2f})  → {verdict}")
+
+    print("\n=== Q2. Squeezing pays? (paired full − no_squeeze, gaussian metric) ===")
+    paired = []
+    for r in full:
+        n_row = next((x for x in nosq if x["seed"] == r["seed"]), None)
+        if n_row:
+            paired.append((int(r["seed"]), r["test_gaussian_n10"], n_row["test_gaussian_n10"]))
+    diffs = [a - b for _, a, b in paired]
+    m_d = statistics.mean(diffs) if diffs else float("nan")
+    s_d = statistics.stdev(diffs) if len(diffs) > 1 else 0.0
+    for sid, a, b in paired:
+        print(f"    seed {sid}:  full={a:.3f}  no_sq={b:.3f}  Δ={a-b:+.3f}")
+    verdict = ("✓ YES" if m_d > s_d and m_d > 0.01 else
+               "✗ NO" if m_d <= 0 else "≈ within noise")
+    print(f"  mean Δ = {m_d:+.3f} ± {s_d:.3f}  → {verdict}")
+
+    print("\n=== Q3. A3-Simple: photon-prob > gaussian metric on same encoder? ===")
+    for label, rs in [("full", full), ("no-squeeze", nosq)]:
+        if not rs:
+            continue
+        # Paired per-seed: same encoder, two metrics on test set
+        diffs = [r["test_photon_prob_n10"] - r["test_gaussian_n10"] for r in rs]
+        m_d = statistics.mean(diffs)
+        s_d = statistics.stdev(diffs) if len(diffs) > 1 else 0.0
+        m_g, _, _ = stat(rs, "test_gaussian_n10")
+        m_p, _, _ = stat(rs, "test_photon_prob_n10")
+        verdict = ("✓ photon-prob wins" if m_d > s_d and m_d > 0.01 else
+                   "✗ photon-prob loses" if m_d < -0.01 else
+                   "≈ tie within noise")
+        print(f"  {label:>10}: gaussian={m_g:.3f}  photon_prob={m_p:.3f}  Δ={m_d:+.3f} ± {s_d:.3f}  → {verdict}")
+
+    print("\n=== Q4. Generalization tax (train − test, gaussian metric) ===")
+    for label, rs in [("full", full), ("no-squeeze", nosq)]:
+        if not rs:
+            continue
+        gaps = [r["train_gaussian_n10"] - r["test_gaussian_n10"] for r in rs]
+        m_g = statistics.mean(gaps)
+        s_g = statistics.stdev(gaps) if len(gaps) > 1 else 0.0
+        print(f"  {label:>10}: gap = {m_g:.3f} ± {s_g:.3f}")
+
+    print("\nFull table:")
+    headers = ("seed", "mode", "train_g_n10", "test_g_n10", "train_p_n10", "test_p_n10")
+    print("  " + "  ".join(f"{h:>11}" for h in headers))
+    for r in full + nosq:
+        mode = "no_squeeze" if int(r["no_squeeze"]) else "full"
+        cells = (
+            int(r["seed"]), mode,
+            r["train_gaussian_n10"], r["test_gaussian_n10"],
+            r["train_photon_prob_n10"], r["test_photon_prob_n10"],
+        )
+        print("  " + "  ".join(
+            f"{c:>11}" if isinstance(c, str) else f"{c:>11.3f}" if isinstance(c, float) else f"{c:>11}"
+            for c in cells
+        ))
+
+
+if __name__ == "__main__":
+    main()

space/run_sweep.py

@@ -0,0 +1,155 @@
+"""5-split × 2-mode sweep over the SBERT-backed photon-route trainer.
+
+Designed to run on cloud CI (e.g. GitHub Actions ubuntu-latest, free tier),
+NOT locally. Output is a CSV of (split_seed, no_squeeze, train_ndcg10, test_ndcg10, ...)
+that gets uploaded as a workflow artifact for the user to read.
+
+For each random split seed:
+  1. Pick 2 of the eval queries as held-out test, rest as train.
+  2. Train SBERTPhoton (full vs --no-squeeze).
+  3. Evaluate on train and test.
+  4. Append result row.
+
+The point: we want error bars, not a point estimate. If the +30% nDCG@10
+the SBERT-backed run got on one specific 4/2 split is real, it should hold
+across multiple random splits. If it varies wildly, the headline was a
+2-query coincidence.
+"""
+from __future__ import annotations
+
+import argparse
+import csv
+import json
+import os
+import random
+import sys
+import tempfile
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent.parent
+SRC = ROOT / "src"
+if str(SRC) not in sys.path:
+    sys.path.insert(0, str(SRC))
+
+
+def make_split(rel_payload: dict, n_test: int, seed: int) -> tuple[dict, dict]:
+    """Returns (train_relevance, test_relevance) as separate JSON-able dicts."""
+    rng = random.Random(seed)
+    queries = list(rel_payload["queries"])
+    rng.shuffle(queries)
+    test = queries[:n_test]
+    train = queries[n_test:]
+    return (
+        {**rel_payload, "queries": train},
+        {**rel_payload, "queries": test},
+    )
+
+
+def run_one(seed: int, no_squeeze: bool, steps: int, relevance_path: Path,
+            n_test: int, log_dir: Path) -> dict:
+    """Train + eval one configuration; return summary dict for the CSV row."""
+    import space.train_sbert as ts
+
+    rel_payload = json.loads(relevance_path.read_text("utf-8"))
+    train_rel, test_rel = make_split(rel_payload, n_test=n_test, seed=seed)
+
+    with tempfile.TemporaryDirectory() as tmp:
+        train_p = Path(tmp) / "rel_train.json"
+        test_p  = Path(tmp) / "rel_test.json"
+        train_p.write_text(json.dumps(train_rel, indent=2))
+        test_p.write_text(json.dumps(test_rel, indent=2))
+
+        # Build a Namespace mimicking train_sbert's CLI args so we can call
+        # train(args) directly without subprocess. Faster + captures Python
+        # exceptions cleanly.
+        import argparse as _ap
+        args = _ap.Namespace(
+            steps=steps, lr=1e-2, weight_decay=1e-3, temperature=2.0,
+            negatives=8, clip=1.0, seed=seed, log_every=50,
+            relevance=str(train_p),
+            eval_train_rel=str(train_p), eval_test_rel=str(test_p),
+            no_squeeze=no_squeeze,
+        )
+
+        # Capture stdout to recover SUMMARY_JSON line.
+        import io, contextlib
+        buf = io.StringIO()
+        with contextlib.redirect_stdout(buf):
+            ts.train(args)
+        out = buf.getvalue()
+
+    # Persist log
+    log_path = log_dir / f"seed{seed}_nosqz{int(no_squeeze)}.log"
+    log_path.write_text(out, encoding="utf-8")
+
+    summary_line = next(
+        (l for l in out.splitlines() if l.startswith("SUMMARY_JSON=")), ""
+    )
+    summary = json.loads(summary_line.split("=", 1)[1]) if summary_line else {}
+
+    def g(key, metric_key):
+        return summary.get(f"{key}/{metric_key}", {})
+
+    row = {"seed": seed, "no_squeeze": int(no_squeeze)}
+    for split in ("train", "test"):
+        for metric in ("gaussian", "photon_prob"):
+            agg = g(split, metric)
+            for m in ("ndcg@10", "recall@10", "recall@1"):
+                short = m.replace("@", "").replace("recall", "r").replace("ndcg", "n")
+                row[f"{split}_{metric}_{short}"] = agg.get(m, float("nan"))
+    return row
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--relevance", type=Path, default=ROOT / "eval" / "relevance_expanded.json",
+                    help="Default to the title-expanded set so each split has more train signal.")
+    ap.add_argument("--seeds",   type=int, nargs="+", default=[1, 2, 3, 4, 5])
+    ap.add_argument("--n-test",  type=int, default=4,
+                    help="Held-out test queries per split. With expanded relevance (26 q), 4 test is ~15%.")
+    ap.add_argument("--steps",   type=int, default=200)
+    ap.add_argument("--out-csv", type=Path, default=ROOT / "sweep_results.csv")
+    ap.add_argument("--log-dir", type=Path, default=ROOT / "sweep_logs")
+    args = ap.parse_args()
+
+    args.log_dir.mkdir(parents=True, exist_ok=True)
+
+    results = []
+    for seed in args.seeds:
+        for no_squeeze in [False, True]:
+            print(f"\n{'='*72}\nseed={seed} no_squeeze={no_squeeze}\n{'='*72}")
+            row = run_one(
+                seed=seed, no_squeeze=no_squeeze, steps=args.steps,
+                relevance_path=args.relevance, n_test=args.n_test, log_dir=args.log_dir,
+            )
+            print(f"  → gaussian:    train n10={row['train_gaussian_n10']:.3f}  test n10={row['test_gaussian_n10']:.3f}")
+            print(f"     photon_prob: train n10={row['train_photon_prob_n10']:.3f}  test n10={row['test_photon_prob_n10']:.3f}")
+            results.append(row)
+
+    # Write CSV
+    fieldnames = list(results[0].keys())
+    with args.out_csv.open("w", newline="") as f:
+        w = csv.DictWriter(f, fieldnames=fieldnames)
+        w.writeheader()
+        w.writerows(results)
+    print(f"\nwrote {len(results)} rows → {args.out_csv}")
+
+    # Aggregate stats
+    import statistics
+    def stat(rows, key):
+        vals = [r[key] for r in rows]
+        return statistics.mean(vals), statistics.stdev(vals) if len(vals) > 1 else 0.0
+
+    print("\nAggregates over seeds:")
+    for ns in [False, True]:
+        rows = [r for r in results if r["no_squeeze"] == int(ns)]
+        if not rows:
+            continue
+        label = "no-squeeze" if ns else "full"
+        for metric in ("gaussian", "photon_prob"):
+            m, s = stat(rows, f"test_{metric}_n10")
+            print(f"  {label:>10}/{metric:>11}: test nDCG@10 = {m:.3f} ± {s:.3f}   (n={len(rows)})")
+
+
+if __name__ == "__main__":
+    main()

space/run_sweep_fock.py

@@ -0,0 +1,125 @@
+"""5-split sweep for the A3-Real Fock-basis trainer.
+
+Mirrors space/run_sweep.py but for train_sbert_fock.py (non-Gaussian
+heralded encoder). Outputs one CSV row per (seed) — no squeeze ablation
+since the Fock encoder structure already includes a learnable TMS gate
+and learnable squeezing; the equivalent ablation is herald_n=0 (heralding
+on vacuum keeps the state Gaussian).
+"""
+from __future__ import annotations
+
+import argparse
+import csv
+import io
+import contextlib
+import json
+import random
+import sys
+import tempfile
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent.parent
+SRC = ROOT / "src"
+if str(SRC) not in sys.path:
+    sys.path.insert(0, str(SRC))
+
+
+def make_split(rel_payload, n_test, seed):
+    rng = random.Random(seed)
+    queries = list(rel_payload["queries"])
+    rng.shuffle(queries)
+    return (
+        {**rel_payload, "queries": queries[n_test:]},
+        {**rel_payload, "queries": queries[:n_test]},
+    )
+
+
+def run_one(seed, herald_n, steps, cutoff, relevance_path, n_test, log_dir):
+    import space.train_sbert_fock as ts
+
+    rel_payload = json.loads(relevance_path.read_text("utf-8"))
+    train_rel, test_rel = make_split(rel_payload, n_test=n_test, seed=seed)
+    with tempfile.TemporaryDirectory() as tmp:
+        train_p = Path(tmp) / "rel_train.json"
+        test_p  = Path(tmp) / "rel_test.json"
+        train_p.write_text(json.dumps(train_rel, indent=2))
+        test_p.write_text(json.dumps(test_rel, indent=2))
+        import argparse as _ap
+        args = _ap.Namespace(
+            cutoff=cutoff, herald_n=herald_n,
+            steps=steps, lr=1e-2, weight_decay=1e-3, temperature=0.5,
+            negatives=8, clip=1.0, seed=seed, log_every=50,
+            relevance=str(train_p),
+            eval_train_rel=str(train_p), eval_test_rel=str(test_p),
+        )
+        buf = io.StringIO()
+        with contextlib.redirect_stdout(buf):
+            ts.train(args)
+        out = buf.getvalue()
+    log_path = log_dir / f"fock_seed{seed}_n{herald_n}.log"
+    log_path.write_text(out, encoding="utf-8")
+    summary_line = next(
+        (l for l in out.splitlines() if l.startswith("SUMMARY_JSON=")), ""
+    )
+    summary = json.loads(summary_line.split("=", 1)[1]) if summary_line else {}
+    train_agg = summary.get("train/fock", {})
+    test_agg  = summary.get("test/fock", {})
+    return {
+        "seed": seed,
+        "herald_n": herald_n,
+        "cutoff": cutoff,
+        "train_ndcg10":  train_agg.get("ndcg@10",   float("nan")),
+        "test_ndcg10":   test_agg.get("ndcg@10",    float("nan")),
+        "train_recall10":train_agg.get("recall@10", float("nan")),
+        "test_recall10": test_agg.get("recall@10",  float("nan")),
+        "train_recall1": train_agg.get("recall@1",  float("nan")),
+        "test_recall1":  test_agg.get("recall@1",   float("nan")),
+    }
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--relevance", type=Path, default=ROOT / "eval" / "relevance_expanded.json")
+    ap.add_argument("--seeds", type=int, nargs="+", default=[1, 2, 3, 4, 5])
+    ap.add_argument("--n-test", type=int, default=4)
+    ap.add_argument("--steps",  type=int, default=200)
+    ap.add_argument("--cutoff", type=int, default=6)
+    ap.add_argument("--herald-ns", type=int, nargs="+", default=[1, 0],
+                    help="Ancilla outcomes to test. herald_n=0 keeps state Gaussian; herald_n=1 makes it non-Gaussian.")
+    ap.add_argument("--out-csv", type=Path, default=ROOT / "sweep_fock_results.csv")
+    ap.add_argument("--log-dir", type=Path, default=ROOT / "sweep_fock_logs")
+    args = ap.parse_args()
+    args.log_dir.mkdir(parents=True, exist_ok=True)
+
+    results = []
+    for seed in args.seeds:
+        for hn in args.herald_ns:
+            print(f"\n{'='*72}\nseed={seed}  herald_n={hn}\n{'='*72}")
+            row = run_one(seed=seed, herald_n=hn, steps=args.steps,
+                          cutoff=args.cutoff, relevance_path=args.relevance,
+                          n_test=args.n_test, log_dir=args.log_dir)
+            print(f"  → train n10={row['train_ndcg10']:.3f}  test n10={row['test_ndcg10']:.3f}")
+            results.append(row)
+
+    fieldnames = list(results[0].keys())
+    with args.out_csv.open("w", newline="") as f:
+        w = csv.DictWriter(f, fieldnames=fieldnames)
+        w.writeheader()
+        w.writerows(results)
+    print(f"\nwrote {len(results)} rows → {args.out_csv}")
+
+    import statistics
+    def stat(rs, key):
+        vals = [r[key] for r in rs if r[key] == r[key]]
+        return (statistics.mean(vals), statistics.stdev(vals) if len(vals) > 1 else 0.0, len(vals))
+
+    print("\nAggregates:")
+    for hn in args.herald_ns:
+        rs = [r for r in results if r["herald_n"] == hn]
+        m, s, n = stat(rs, "test_ndcg10")
+        label = "non-Gaussian (herald=1)" if hn == 1 else "Gaussian (herald=0)" if hn == 0 else f"herald={hn}"
+        print(f"  {label:>26}: test nDCG@10 = {m:.3f} ± {s:.3f}   (n={n})")
+
+
+if __name__ == "__main__":
+    main()

space/sim_b1_g1_coherence.py

@@ -0,0 +1,126 @@
+"""B1 sim — does g^(1)-style coherence time τ_c discriminate candidates
+better than meridian's current 3-bin Shannon entropy `cross_domain`?
+
+Loudon eq 3.1.3: g^(1)(τ) = ⟨E*(t) E(t+τ)⟩ / ⟨|E|²⟩.
+For a chaotic source, |g^(1)(τ)| decays exponentially with characteristic
+τ_c = (∫|g^(1)(τ)|² dτ).
+
+Treat each candidate's keyword stream as a chaotic light source where
+each token at position t is a "wavetrain at frequency ω_token". The
+autocorrelation of one-hot token vectors gives an effective τ_c that
+scales with vocabulary diversity.
+
+This is a self-contained synthetic-data sim. No external corpus / no
+cloud compute required. Runs in <1 s.
+"""
+from __future__ import annotations
+
+import math
+import numpy as np
+from collections import Counter
+
+
+def cross_domain_proxy(tokens: list[str], systems: dict[str, set[str]]) -> float:
+    """Mirror meridian's existing computation: Shannon entropy / log(3)
+    over hits in {forge, signal, mind} term lists, normalized to [0, 1]."""
+    affinity = {sys: 0 for sys in systems}
+    for t in tokens:
+        for sys, terms in systems.items():
+            if t in terms:
+                affinity[sys] += 1
+    total = sum(affinity.values()) or 1
+    probs = [n / total for n in affinity.values() if n > 0]
+    H = -sum(p * math.log(p) for p in probs)
+    return H / math.log(3) if H else 0.0
+
+
+def coherence_time(tokens: list[str], window: int = 8) -> float:
+    """Empirical g^(1)-style coherence time of a token stream.
+
+    Treat the sequence as a discrete-time signal where each token is a
+    distinct mode. g^(1)(τ) = (# matched-token pairs at offset τ) /
+    (# matched at τ=0). τ_c = sum_{τ≥1} |g^(1)(τ)|² up to a window.
+
+    Pure-stdlib, normalised so τ_c ∈ [0, window].
+    """
+    n = len(tokens)
+    if n < 2:
+        return 0.0
+    g0 = sum(1 for t in tokens) or 1  # τ=0 normalisation = total length
+    tau_c = 0.0
+    for tau in range(1, min(window, n)):
+        matches = sum(1 for i in range(n - tau) if tokens[i] == tokens[i + tau])
+        gtau = matches / g0
+        tau_c += gtau * gtau
+    return tau_c
+
+
+# ─── Synthetic candidates with realistic body lengths ──────────────────────
+SYSTEMS = {
+    "forge":  {"build", "compile", "deploy", "ci", "container", "image", "binary",
+               "docker", "kubernetes", "package", "release", "monorepo"},
+    "signal": {"data", "stream", "ingest", "pipeline", "etl", "kafka", "queue",
+               "throughput", "latency", "broker", "subscriber", "publish"},
+    "mind":   {"llm", "embed", "embedding", "model", "transformer", "agent",
+               "reasoning", "prompt", "context", "rag", "fine", "tune"},
+}
+
+
+def make_candidate(label: str, vocab_pool: list[str], length: int = 250,
+                   alpha: float = 1.0, seed: int = 0) -> list[str]:
+    """Generate length tokens drawn Zipfian from vocab_pool. alpha controls
+    head heaviness; alpha=1.0 ≈ thermal; alpha→∞ ≈ heavy concentrated."""
+    rng = np.random.default_rng(seed)
+    weights = 1.0 / (np.arange(1, len(vocab_pool) + 1) ** alpha)
+    weights /= weights.sum()
+    return list(rng.choice(vocab_pool, size=length, p=weights))
+
+
+def main():
+    # 9 archetypes spanning body lengths and topical vs scattered patterns.
+    forge_terms  = sorted(SYSTEMS["forge"])
+    signal_terms = sorted(SYSTEMS["signal"])
+    mind_terms   = sorted(SYSTEMS["mind"])
+    cross_terms  = forge_terms + signal_terms + mind_terms
+    cases = [
+        ("focused-forge",       forge_terms,  300, 1.0, 1),
+        ("focused-signal",      signal_terms, 300, 1.0, 2),
+        ("focused-mind",        mind_terms,   300, 1.0, 3),
+        ("cross-forge-signal",  forge_terms + signal_terms, 300, 1.0, 4),
+        ("cross-mind-signal",   mind_terms + signal_terms,  300, 1.0, 5),
+        ("cross-three-systems", cross_terms,  300, 1.0, 6),
+        ("scattered-cross",     cross_terms,  300, 0.5, 7),  # less Zipfian, more uniform
+        ("very-narrow",         forge_terms[:3], 300, 2.0, 8),  # 3 dominant words
+        ("very-broad",          cross_terms,  300, 0.3, 9),  # near-uniform
+    ]
+
+    print(f"{'archetype':>22}  {'len':>5}  {'cross_domain':>13}  {'τ_c (g^(1))':>12}")
+    print("-" * 64)
+    rows = []
+    for label, pool, length, alpha, seed in cases:
+        toks = make_candidate(label, pool, length=length, alpha=alpha, seed=seed)
+        cd = cross_domain_proxy(toks, SYSTEMS)
+        tc = coherence_time(toks)
+        print(f"{label:>22}  {length:>5}  {cd:>13.3f}  {tc:>12.3f}")
+        rows.append((label, cd, tc))
+
+    print("\nDiscrimination check (variance across archetypes, higher = better signal):")
+    cd_vals = [r[1] for r in rows]
+    tc_vals = [r[2] for r in rows]
+    print(f"  cross_domain:  std = {np.std(cd_vals):.3f}, range = [{min(cd_vals):.3f}, {max(cd_vals):.3f}]")
+    print(f"  τ_c (g^(1)):   std = {np.std(tc_vals):.3f}, range = [{min(tc_vals):.3f}, {max(tc_vals):.3f}]")
+
+    # CV (coefficient of variation) — higher = more discriminative on its own scale
+    cd_cv = np.std(cd_vals) / max(np.mean(cd_vals), 1e-9)
+    tc_cv = np.std(tc_vals) / max(np.mean(tc_vals), 1e-9)
+    print(f"\n  CV (std/mean): cross_domain={cd_cv:.3f}  τ_c={tc_cv:.3f}")
+    if tc_cv > cd_cv * 1.2:
+        print("  → τ_c is more discriminative than cross_domain — B1 stands.")
+    elif tc_cv < cd_cv * 0.8:
+        print("  → τ_c is LESS discriminative than cross_domain — B1 fails.")
+    else:
+        print("  → τ_c and cross_domain have similar discrimination — B1 is a wash.")
+
+
+if __name__ == "__main__":
+    main()

space/sim_b2_g2_classifier.py

@@ -0,0 +1,132 @@
+"""B2 sim — does g^(2)(0) cleanly classify candidates into planet / comet
+/ asteroid on REAL meridian-shaped data (Llama-emitted bodies of typical
+length 100–500 tokens), and where does it disagree with the existing
+mass × scope × independence rule?
+
+Sim 4b earlier (synthetic Zipfian) showed g^(2) > 1 only emerges at
+N_distinct × token_total scales typical of real bodies, not the 8–12
+token toy archetypes from Sim 4. This sim re-runs that check on
+realistic body shapes and compares per-candidate the g^(2) class label
+to the mass × scope × independence label that orbital.mjs assigns today.
+"""
+from __future__ import annotations
+
+import math
+import numpy as np
+from collections import Counter
+
+
+def g2_zero(tokens: list[str]) -> float:
+    """g^(2)(0) = ⟨n(n-1)⟩ / ⟨n⟩² over per-word counts {n_i}.
+    Loudon Ch 6.4: coherent → 1, chaotic → 2, antibunched → <1."""
+    if not tokens:
+        return float("nan")
+    counts = np.asarray(list(Counter(tokens).values()), dtype=np.float64)
+    n_mean = counts.mean()
+    n_n_minus_1 = (counts * (counts - 1)).mean()
+    return n_n_minus_1 / (n_mean ** 2) if n_mean > 0 else float("nan")
+
+
+def class_from_g2(g2: float) -> str:
+    """Threshold rule from Loudon Ch 6.4."""
+    if g2 < 0.7:
+        return "asteroid"   # antibunched / sparse / niche
+    elif g2 < 1.4:
+        return "planet"     # ≈ 1 = coherent / focused
+    else:
+        return "comet"      # > 1 = thermal / scattered
+
+
+def class_from_meridian(mass: float, scope: float, indep: float,
+                        cross_domain: float, drag: float, fragmentation: float,
+                        dep_ratio: float, has_parent: bool) -> str:
+    """Mirror orbital.mjs:139-167 — compute the same scores and pick max."""
+    planet  = min(mass, scope, indep) ** 1.5
+    moon    = (max(0, 0.5 - indep) * 2 *
+               (1.0 if has_parent else 0.4) * (1 - 0.5 * mass))
+    trojan  = dep_ratio * (1.0 if has_parent else 0.5) * (1 - fragmentation)
+    asteroid = max(0, 0.55 - mass) * 2.5 * scope * indep
+    comet    = drag * cross_domain * (1 - dep_ratio)
+    irregular = cross_domain * fragmentation * 0.85
+    scores = {"planet": planet, "moon": moon, "trojan": trojan,
+              "asteroid": asteroid, "comet": comet, "irregular": irregular}
+    return max(scores, key=scores.get)
+
+
+def physics_from_tokens(tokens: list[str]) -> dict:
+    """Approximate the physics scalars meridian computes from text."""
+    body_len = sum(len(t) for t in tokens)
+    n_words = len(tokens)
+    mass = max(0, min(1, 0.6 * np.log10(max(50, body_len) / 200) /
+                       np.log10(3000 / 200) + 0.4 * (n_words - 3) / 9))
+    distinct = len(set(tokens))
+    scope = min(0.7, distinct / 12) + 0.2  # rough proxy
+    scope = max(0, min(1, scope))
+    indep  = 0.7  # synthetic candidates have no siblings; assume mid-high
+    drag   = 0.3
+    fragmentation = 0.4
+    cross_domain  = 0.5  # placeholder
+    dep_ratio    = 0.2
+    return dict(mass=mass, scope=scope, indep=indep,
+                drag=drag, fragmentation=fragmentation,
+                cross_domain=cross_domain, dep_ratio=dep_ratio,
+                has_parent=False)
+
+
+# ─── Realistic synthetic candidates ─────────────────────────────────────────
+def zipfian_words(prefix: str, n_distinct: int, length: int, alpha: float, seed: int):
+    rng = np.random.default_rng(seed)
+    vocab = [f"{prefix}-{i:02d}" for i in range(n_distinct)]
+    weights = 1.0 / (np.arange(1, n_distinct + 1) ** alpha)
+    weights /= weights.sum()
+    return list(rng.choice(vocab, size=length, p=weights))
+
+
+def main():
+    # 9 archetypes covering the planet/comet/asteroid spectrum at realistic
+    # body length (200–400 tokens) — the regime Sim 4b proved relevant.
+    cases = [
+        # label,                      n_distinct, length, alpha (Zipf head),  expected
+        ("planet-tight-vocab",        20,  300, 1.0, "planet"),    # coherent-shaped
+        ("planet-medium",             15,  250, 0.8, "planet"),
+        ("planet-broad-vocab",        50,  400, 1.2, "planet"),
+        ("comet-thermal",             30,  300, 1.5, "comet"),     # heavier head
+        ("comet-very-heavy",          25,  300, 2.0, "comet"),
+        ("comet-multimodal",          40,  350, 1.8, "comet"),
+        ("asteroid-narrow",           5,   300, 1.0, "asteroid"),  # too few distinct
+        ("asteroid-fragments",        10,  100, 0.5, "asteroid"),  # short body
+        ("asteroid-uniform",          50,  300, 0.3, "asteroid"),  # near-uniform
+    ]
+
+    print(f"{'archetype':>22}  {'len':>5}  {'g^(2)':>7}  {'g2_class':>10}  "
+          f"{'mass×s×i_class':>16}  {'expected':>10}")
+    print("-" * 90)
+    correct_g2 = 0
+    correct_meridian = 0
+    for label, n_distinct, length, alpha, expected in cases:
+        toks = zipfian_words(label, n_distinct, length, alpha, seed=hash(label) & 0xFFFF)
+        g2 = g2_zero(toks)
+        cls_g2 = class_from_g2(g2)
+        phys = physics_from_tokens(toks)
+        cls_m = class_from_meridian(**phys)
+        ok_g2 = cls_g2 == expected
+        ok_m  = cls_m == expected
+        correct_g2 += int(ok_g2)
+        correct_meridian += int(ok_m)
+        marker_g2 = "✓" if ok_g2 else "✗"
+        marker_m  = "✓" if ok_m  else "✗"
+        print(f"{label:>22}  {length:>5}  {g2:>7.3f}  "
+              f"{cls_g2:>9}{marker_g2}  {cls_m:>15}{marker_m}  {expected:>10}")
+
+    print(f"\n  g^(2)-only classifier:        {correct_g2}/{len(cases)} archetypes correct")
+    print(f"  meridian's mass×scope×indep:  {correct_meridian}/{len(cases)} archetypes correct")
+    if correct_g2 > correct_meridian:
+        print("  → B2 stands: g^(2) classifies more reliably on real-shape data")
+    elif correct_g2 < correct_meridian:
+        print("  → B2 fails: meridian's existing rule is better")
+    else:
+        print("  → B2 is a wash: both classifiers tied on archetype recovery")
+
+
+if __name__ == "__main__":
+    main()

space/train.py

@@ -245,7 +245,7 @@ def train(args: argparse.Namespace) -> None:
     torch.manual_seed(args.seed)
     np.random.seed(args.seed)
 
-    rel_path  = ROOT / "eval" / "relevance.json"
+    rel_path  = Path(args.relevance) if args.relevance else ROOT / "eval" / "relevance.json"
     cids_path = ROOT / "eval" / "corpus_ids.json"
     man_path  = ROOT / "eval" / "manifest.json"
 
@@ -380,6 +380,8 @@ def train(args: argparse.Namespace) -> None:
 def main() -> None:
     ap = argparse.ArgumentParser()
     ap.add_argument("--out", type=Path, default=ROOT / "weights.npz")
+    ap.add_argument("--relevance", type=str, default=None,
+                    help="path to alternate relevance.json (e.g. for held-out splits)")
     ap.add_argument("--steps", type=int, default=100)
     ap.add_argument("--lr", type=float, default=5e-3)
     # D-scale logits: with D in [0, 50], temp=0.1 made -D/temp logits up to

space/train_sbert.py

@@ -0,0 +1,392 @@
+"""SBERT-backed photon-route encoder. The language model does language;
+the photonic gates do the structured projection.
+
+Architecture:
+    text → frozen SentenceTransformer (all-MiniLM-L6-v2, 384-d, no grad)
+         → Linear(384 → 4N + 2N)  [trainable]
+         → 4N displacement outputs (αq, αp per mode) + 2N squeezing outputs (r, φ per mode)
+         → photonic gates (Sgate + Dgate per mode)
+         → 2N-d Gaussian state (μ, σ) at hbar=2
+
+Trainable surface:
+    Linear(384 → 6N) ≈ 384·6N + 6N params  (6 numbers per mode: αq, αp, r, φ_s, plus 2 future)
+    For N=2: 384·8 + 8 = 3,080 params total
+    vs word-level photon-route: |V|·4 = 5,772 (and grows with vocab)
+
+Loss is the same InfoNCE-on-Bhattacharyya as space/train.py so the comparison
+is apples-to-apples on the encoder, not the loss.
+
+Holdout discipline: load --relevance from a file. The eval driver
+(eval/run.py) does NOT support sbert weights yet; this module ships its
+own evaluator alongside the trainer for now.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import math
+import sys
+import time
+from pathlib import Path
+
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torch import Tensor
+
+ROOT = Path(__file__).resolve().parent.parent
+SRC = ROOT / "src"
+if str(SRC) not in sys.path:
+    sys.path.insert(0, str(SRC))
+
+from eval.fetch import fetch_all, verify_against_manifest  # noqa: E402
+
+N_MODES = 2
+HBAR = 2.0
+SBERT_MODEL_NAME = "sentence-transformers/all-MiniLM-L6-v2"
+SBERT_DIM = 384
+
+
+# ─── differentiable single-mode squeezing in qqpp ─────────────────────────────
+def _eye2N(n: int, ref: Tensor) -> Tensor:
+    return torch.eye(2 * n, dtype=ref.dtype, device=ref.device)
+
+
+def squeezing_qqpp(n: int, k: int, r: Tensor, phi: Tensor) -> Tensor:
+    S = _eye2N(n, r).clone()
+    cr, sr = torch.cosh(r), torch.sinh(r)
+    cp, sp = torch.cos(phi), torch.sin(phi)
+    S[k,     k    ] = cr - sr * cp
+    S[k,     k + n] = -sr * sp
+    S[k + n, k    ] = -sr * sp
+    S[k + n, k + n] = cr + sr * cp
+    return S
+
+
+class SBERTPhoton(nn.Module):
+    """Frozen SBERT → Linear → photonic state.
+
+    The Linear emits 6 numbers per mode (αq, αp, r, φ_s, plus 2 reserved).
+    Currently 4 are used; spare dims are zero'd by their learnable weight
+    converging to small values, so unused capacity self-prunes.
+    """
+
+    def __init__(self, n_modes: int = N_MODES, max_squeeze: float = 0.5,
+                 max_displace: float = 1.0, no_squeeze: bool = False):
+        super().__init__()
+        from sentence_transformers import SentenceTransformer
+        self.n = n_modes
+        self.max_sq = max_squeeze
+        self.max_disp = max_displace
+        self.no_squeeze = no_squeeze
+        self.dgate_prefactor = math.sqrt(2.0 * HBAR)
+        self.sbert = SentenceTransformer(SBERT_MODEL_NAME)
+        for p in self.sbert.parameters():
+            p.requires_grad = False
+        # float32 throughout — MPS (Apple-Silicon GPU) doesn't support float64;
+        # cast to float64 at the eval-fidelity boundary (numpy + thewalrus).
+        # Squeezing magnitudes are bounded ≤ 0.5 so the covariance stays
+        # well-conditioned and float32 slogdet is numerically safe.
+        self.proj = nn.Linear(SBERT_DIM, 4 * n_modes, dtype=torch.float32)
+        # Small-random init (NOT zeros). Zero init puts every text at the
+        # same vacuum state, so all pairwise distances equal zero, gradients
+        # vanish, and loss stays at log(N+1) = saddle point forever.
+        nn.init.normal_(self.proj.weight, std=0.02)
+        nn.init.zeros_(self.proj.bias)
+
+    def encode_features(self, texts: list[str]) -> Tensor:
+        """Run frozen SBERT, return (B, 384) float32 on CPU."""
+        with torch.no_grad():
+            emb = self.sbert.encode(
+                texts, normalize_embeddings=True, convert_to_numpy=False,
+                show_progress_bar=False,
+            )
+            emb = torch.stack([e for e in emb]) if isinstance(emb, list) else emb
+            return emb.to(torch.float32).cpu()
+
+    def state_from_features(self, feat: Tensor) -> tuple[Tensor, Tensor]:
+        """Forward from a *precomputed* SBERT feature vector — used during
+        training when frozen-SBERT features are cached at start to avoid
+        re-running the transformer every step."""
+        out = self.proj(feat)
+        return self._gates_from_logits(out)
+
+    def state_from_text(self, text: str) -> tuple[Tensor, Tensor]:
+        feat = self.encode_features([text])[0]        # (384,)
+        out  = self.proj(feat)                        # (4N,)
+        return self._gates_from_logits(out)
+
+    def _gates_from_logits(self, out: Tensor) -> tuple[Tensor, Tensor]:
+        # Decompose: per-mode (αq, αp, raw_r, raw_phi).
+        # tanh-bound squeezing magnitude to [0, max_sq]; phi free.
+        per_mode = out.view(self.n, 4)
+        alpha_q = self.dgate_prefactor * torch.tanh(per_mode[:, 0])
+        alpha_p = self.dgate_prefactor * torch.tanh(per_mode[:, 1])
+        if self.no_squeeze:
+            r     = torch.zeros(self.n, dtype=out.dtype)
+            phi_s = torch.zeros(self.n, dtype=out.dtype)
+        else:
+            r     = self.max_sq * torch.sigmoid(per_mode[:, 2])
+            phi_s = (2 * math.pi) * torch.sigmoid(per_mode[:, 3])
+
+        mu = torch.zeros(2 * self.n, dtype=out.dtype)
+        sigma = _eye2N(self.n, out)
+        for k in range(self.n):
+            if not self.no_squeeze:
+                S = squeezing_qqpp(self.n, k, r[k], phi_s[k])
+                mu = S @ mu
+                sigma = S @ sigma @ S.T
+            shift = torch.zeros_like(mu)
+            shift[k]            = alpha_q[k]
+            shift[k + self.n]   = alpha_p[k]
+            mu = mu + shift
+        return mu, sigma
+
+
+def bhattacharyya_distance(mu_a, sg_a, mu_b, sg_b, ridge: float = 1e-3) -> Tensor:
+    d = sg_a.shape[0]
+    eye = torch.eye(d, dtype=sg_a.dtype, device=sg_a.device)
+    A = sg_a + ridge * eye
+    B = sg_b + ridge * eye
+    V = 0.5 * (A + B)
+    delta = mu_a - mu_b
+    quad = (delta * torch.linalg.solve(V, delta)).sum()
+    log_det_V = torch.linalg.slogdet(V)[1]
+    log_det_A = torch.linalg.slogdet(A)[1]
+    log_det_B = torch.linalg.slogdet(B)[1]
+    D = 0.125 * quad + 0.5 * (log_det_V - 0.5 * (log_det_A + log_det_B))
+    return torch.clamp(D, min=0.0, max=50.0)
+
+
+def gaussian_fidelity_eval(mu_a: np.ndarray, sg_a: np.ndarray,
+                            mu_b: np.ndarray, sg_b: np.ndarray) -> float:
+    """thewalrus closed-form for eval-time scoring (not used in loss)."""
+    from thewalrus.quantum import fidelity as tw_fidelity
+    f = tw_fidelity(mu_a, sg_a, mu_b, sg_b, hbar=HBAR)
+    val = float(f.real if hasattr(f, "real") else f)
+    return max(0.0, min(1.0, val))
+
+
+# ── photon-number-distribution Bhattacharyya coefficient (A3-Simple) ──────
+# Loudon Ch 6.10 — direct detection projects a state onto Fock basis and
+# measures the photon-number distribution P(n_0, n_1, ...). A retrieval
+# metric grounded in what the detector actually sees, rather than the
+# Gaussian-state inner product. Closed-form computable from (μ, σ) for
+# Gaussian states via thewalrus.quantum.probabilities; non-differentiable
+# (numpy under the hood), eval-only — A3-Real would do this differentiably.
+_PHOTON_PROB_CACHE: dict[int, np.ndarray] = {}
+
+
+def photon_prob_eval(mu_a: np.ndarray, sg_a: np.ndarray,
+                      mu_b: np.ndarray, sg_b: np.ndarray, cutoff: int = 4) -> float:
+    """Bhattacharyya coefficient between two photon-number distributions:
+    BC(P, Q) = Σ √(p_i q_i).  ∈ [0, 1]; 1 = identical distributions.
+
+    Reuses the cutoff-sized P arrays via caching keyed by (id(mu), id(sg))
+    isn't viable across calls (μ, σ get re-allocated). Caller's responsibility
+    to dedup per-state; here we just compute fresh.
+    """
+    from thewalrus.quantum import probabilities
+    P_a = np.asarray(probabilities(mu_a, sg_a, cutoff=cutoff, hbar=HBAR), dtype=np.float64).real
+    P_b = np.asarray(probabilities(mu_b, sg_b, cutoff=cutoff, hbar=HBAR), dtype=np.float64).real
+    # Truncation can leave a tail — renormalize so distributions sum to 1.
+    P_a = np.clip(P_a, 0.0, None) / max(P_a.sum(), 1e-12)
+    P_b = np.clip(P_b, 0.0, None) / max(P_b.sum(), 1e-12)
+    bc = float(np.sum(np.sqrt(P_a) * np.sqrt(P_b)))
+    return max(0.0, min(1.0, bc))
+
+
+def recall_at_k(ranked_ids, relevant, k):
+    if not relevant:
+        return float("nan")
+    return len(set(ranked_ids[:k]) & relevant) / len(relevant)
+
+
+def ndcg_at_k(ranked_ids, relevant, k):
+    if not relevant:
+        return float("nan")
+    dcg = sum(1.0 / math.log2(i + 1) for i, a in enumerate(ranked_ids[:k], start=1) if a in relevant)
+    ideal = sum(1.0 / math.log2(i + 1) for i in range(1, min(k, len(relevant)) + 1))
+    return dcg / ideal if ideal > 0 else float("nan")
+
+
+def evaluate(model: SBERTPhoton, abstracts, ids, queries, ks=(1, 3, 5, 10),
+             metrics=("gaussian", "photon_prob"), photon_cutoff: int = 4) -> dict:
+    """Evaluate retrieval under multiple metrics on the same trained encoder.
+
+    Returns a dict with one report per metric:
+      {"gaussian": {"per_query":[...], "aggregate":{...}}, "photon_prob": {...}}
+
+    A3-Simple test: do "gaussian" (BBP fidelity) and "photon_prob" (Loudon
+    Ch 6.10 direct-detection-grounded Bhattacharyya coefficient on the
+    photon-number distribution) give different rankings on the same encoder?
+    """
+    model.eval()
+    # Encode all docs + queries once; convert to numpy float64 for thewalrus.
+    doc_np: dict[str, tuple[np.ndarray, np.ndarray]] = {}
+    q_np: list[tuple[dict, np.ndarray, np.ndarray]] = []
+    with torch.no_grad():
+        for arxiv_id, doc_text in abstracts.items():
+            mu_d, sg_d = model.state_from_text(doc_text)
+            doc_np[arxiv_id] = (
+                mu_d.cpu().numpy().astype(np.float64),
+                sg_d.cpu().numpy().astype(np.float64),
+            )
+        for q in queries:
+            mu_q, sg_q = model.state_from_text(q["query"])
+            q_np.append((
+                q,
+                mu_q.cpu().numpy().astype(np.float64),
+                sg_q.cpu().numpy().astype(np.float64),
+            ))
+
+    score_fn = {
+        "gaussian":    lambda mq, sq, md, sd: gaussian_fidelity_eval(mq, sq, md, sd),
+        "photon_prob": lambda mq, sq, md, sd: photon_prob_eval(mq, sq, md, sd, cutoff=photon_cutoff),
+    }
+
+    metric_rows: dict[str, list] = {m: [] for m in metrics}
+    for q, mu_q, sg_q in q_np:
+        for metric in metrics:
+            scored = []
+            for a in ids:
+                mu_d, sg_d = doc_np[a]
+                f = score_fn[metric](mu_q, sg_q, mu_d, sg_d)
+                scored.append((f, a))
+            scored.sort(key=lambda x: -x[0])
+            ranked_ids = [a for _, a in scored]
+            rel = set(q["relevant_ids"])
+            row = {"query": q["query"], "ranked": ranked_ids[: max(ks)]}
+            for k in ks:
+                row[f"recall@{k}"] = recall_at_k(ranked_ids, rel, k)
+                row[f"ndcg@{k}"]   = ndcg_at_k(ranked_ids, rel, k)
+            metric_rows[metric].append(row)
+
+    out = {}
+    for metric in metrics:
+        rows = metric_rows[metric]
+        agg = {f"recall@{k}": float(np.mean([r[f"recall@{k}"] for r in rows])) for k in ks}
+        agg.update({f"ndcg@{k}": float(np.mean([r[f"ndcg@{k}"] for r in rows])) for k in ks})
+        out[metric] = {"per_query": rows, "aggregate": agg}
+    return out
+
+
+def train(args):
+    torch.manual_seed(args.seed)
+    np.random.seed(args.seed)
+
+    rel_path  = Path(args.relevance) if args.relevance else ROOT / "eval" / "relevance.json"
+    cids_path = ROOT / "eval" / "corpus_ids.json"
+    man_path  = ROOT / "eval" / "manifest.json"
+
+    train_relevance = json.loads(rel_path.read_text("utf-8"))["queries"]
+    ids = json.loads(cids_path.read_text("utf-8"))["ids"]
+    print(f"[sbert] fetching {len(ids)} abstracts...", flush=True)
+    abstracts = fetch_all(ids)
+    bad = verify_against_manifest(abstracts, man_path)
+    if bad:
+        sys.exit(f"manifest mismatch: {list(bad)[:3]}")
+
+    model = SBERTPhoton(n_modes=N_MODES, no_squeeze=args.no_squeeze)
+    n_trainable = sum(p.numel() for p in model.parameters() if p.requires_grad)
+    print(f"[sbert] trainable params = {n_trainable}  no_squeeze={args.no_squeeze}", flush=True)
+
+    # ── Cache frozen-SBERT features for every doc and every query ONCE.
+    # Without this we re-run the transformer for every (doc, step) pair —
+    # 20 docs × 200 steps = 4000 forward passes per training run, ~5 min
+    # of pure-inference waste on cloud CPU. Frozen features don't change.
+    print(f"[sbert] caching SBERT features for {len(abstracts)} docs + "
+          f"{len(train_relevance)} queries...", flush=True)
+    doc_feats = {a: model.encode_features([t])[0] for a, t in abstracts.items()}
+    query_feats = {q["query"]: model.encode_features([q["query"]])[0]
+                    for q in train_relevance}
+
+    optim = torch.optim.AdamW(
+        [p for p in model.parameters() if p.requires_grad],
+        lr=args.lr, weight_decay=args.weight_decay,
+    )
+    rng = np.random.default_rng(args.seed)
+    queries = [(q["query"], set(q["relevant_ids"])) for q in train_relevance]
+
+    t0 = time.time()
+    for step in range(1, args.steps + 1):
+        optim.zero_grad()
+        # Re-run the trainable projection each step over CACHED features
+        # (instead of re-running SBERT). projection ∈ R^{384×4N}, cheap.
+        doc_states = {a: model.state_from_features(doc_feats[a]) for a in abstracts}
+
+        loss_sum = torch.zeros((), dtype=torch.float32)
+        for query_text, rel_set in queries:
+            mu_q, sg_q = model.state_from_features(query_feats[query_text])
+            pos_id = rng.choice(sorted(rel_set))
+            mu_p, sg_p = doc_states[pos_id]
+            negs = rng.choice(
+                [i for i in ids if i not in rel_set],
+                size=min(args.negatives, len(ids) - len(rel_set)), replace=False,
+            )
+            d_pos = bhattacharyya_distance(mu_q, sg_q, mu_p, sg_p)
+            d_negs = torch.stack([bhattacharyya_distance(mu_q, sg_q, *doc_states[n]) for n in negs])
+            logits = -torch.cat([d_pos.unsqueeze(0), d_negs]) / args.temperature
+            ce = F.cross_entropy(logits.unsqueeze(0), torch.zeros((), dtype=torch.long).unsqueeze(0))
+            loss_sum = loss_sum + ce
+        loss_sum = loss_sum / len(queries)
+        loss_sum.backward()
+        torch.nn.utils.clip_grad_norm_(
+            [p for p in model.parameters() if p.requires_grad], max_norm=args.clip,
+        )
+        optim.step()
+        if step == 1 or step % args.log_every == 0 or step == args.steps:
+            print(f"[sbert] step {step}/{args.steps}  loss={loss_sum.item():.4f}  "
+                  f"elapsed={time.time()-t0:.1f}s", flush=True)
+
+    # final eval against whichever relevance file the user asks for
+    eval_paths = []
+    if args.eval_train_rel:
+        eval_paths.append(("train", Path(args.eval_train_rel)))
+    if args.eval_test_rel:
+        eval_paths.append(("test",  Path(args.eval_test_rel)))
+    if not eval_paths:
+        eval_paths.append(("all", rel_path))
+    summary = {}
+    for label, p in eval_paths:
+        rels = json.loads(p.read_text("utf-8"))["queries"]
+        multi = evaluate(model, abstracts, ids, rels,
+                          metrics=("gaussian", "photon_prob"))
+        for metric, report in multi.items():
+            print(f"\n=== {label.upper()} EVAL — metric={metric} ({len(rels)} queries) ===")
+            for r in report["per_query"]:
+                cells = " ".join(f"{m}={r[m]:.3f}" for m in r if m.startswith(("recall", "ndcg")))
+                print(f"  {r['query'][:48]:<48s}  {cells}")
+            print("aggregate: " + " ".join(
+                f"{m}={report['aggregate'][m]:.3f}" for m in report["aggregate"]
+            ))
+            summary[f"{label}/{metric}"] = report["aggregate"]
+    # Sentinel line for downstream parsers (run_sweep.py).
+    print(f"\nSUMMARY_JSON={json.dumps(summary)}")
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--steps", type=int, default=200)
+    ap.add_argument("--lr", type=float, default=1e-2)
+    ap.add_argument("--weight-decay", type=float, default=1e-3)
+    ap.add_argument("--temperature", type=float, default=2.0)
+    ap.add_argument("--negatives", type=int, default=8)
+    ap.add_argument("--clip", type=float, default=1.0)
+    ap.add_argument("--seed", type=int, default=42)
+    ap.add_argument("--log-every", type=int, default=20)
+    ap.add_argument("--relevance",      type=str, default=None,
+                    help="training relevance.json (e.g. /tmp/rel_train.json)")
+    ap.add_argument("--eval-train-rel", type=str, default=None,
+                    help="optional separate train-eval set for in-sample numbers")
+    ap.add_argument("--eval-test-rel",  type=str, default=None,
+                    help="optional held-out eval set for generalization numbers")
+    ap.add_argument("--no-squeeze", action="store_true",
+                    help="ablation: force r=0 (displacement-only). Tests whether the squeezing layer specifically pays.")
+    args = ap.parse_args()
+    train(args)
+
+
+if __name__ == "__main__":
+    main()

space/train_sbert_fock.py

@@ -0,0 +1,325 @@
+"""A3-Real — non-Gaussian SBERT-photon trainer.
+
+Architecture:
+    text → frozen SBERT 384d → Linear(384, 6) → photonic params
+        → 2-mode (signal + ancilla) cutoff-D Fock-basis encoder
+        → unitary U = D_signal(α) S_signal(r,φ) S_2(τ,θ)  applied to |0,0⟩
+        → project ancilla onto |1⟩ (single-photon herald)
+        → normalised pure state |ψ_sig⟩ ∈ ℂ^D, NON-GAUSSIAN
+    score(q, d) = |⟨ψ_q,sig | ψ_d,sig⟩|²
+
+Why this is genuinely new vs space/train_sbert.py: with α small and r mild,
+the heralded-on-|1⟩ signal mode contains a single-photon contribution. A
+single-photon Fock state has Wigner-negative regions — non-Gaussian. The
+similarity |⟨ψ_q|ψ_d⟩|² is *not* representable as a Gaussian-RBF kernel
+on any finite-d projection of the inputs (Sim 1's negative result for the
+Gaussian path).
+
+Loss: InfoNCE on -log(score) (i.e. score is the affinity logit). Cached
+SBERT features. Same eval/relevance as the Gaussian trainer for direct
+head-to-head numbers.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import math
+import sys
+import time
+from pathlib import Path
+
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torch import Tensor
+
+ROOT = Path(__file__).resolve().parent.parent
+SRC = ROOT / "src"
+if str(SRC) not in sys.path:
+    sys.path.insert(0, str(SRC))
+
+from eval.fetch import fetch_all, verify_against_manifest  # noqa: E402
+
+SBERT_MODEL_NAME = "sentence-transformers/all-MiniLM-L6-v2"
+SBERT_DIM = 384
+HERALD_N = 1               # ancilla outcome we herald on; single-photon → genuinely non-Gaussian
+
+
+# ─── Truncated bosonic operators in Fock basis ────────────────────────────
+def annihilation_op(D: int) -> Tensor:
+    """a |n⟩ = √n |n-1⟩  (D-dim truncation; lossy at the top)."""
+    a = torch.zeros(D, D, dtype=torch.complex128)
+    for n in range(1, D):
+        a[n - 1, n] = math.sqrt(n)
+    return a
+
+
+def kron(A: Tensor, B: Tensor) -> Tensor:
+    return torch.kron(A, B)
+
+
+# ─── Generators of the unitaries ────────────────────────────────────────────
+def displace_generator(a: Tensor, alpha: Tensor) -> Tensor:
+    """G_D = α a† − α* a; applied as exp(G_D) gives D(α). α is complex scalar."""
+    return alpha * a.conj().T - torch.conj(alpha) * a
+
+
+def squeeze_generator(a: Tensor, zeta: Tensor) -> Tensor:
+    """G_S = (1/2)(ζ* a² − ζ a†²); applied as exp(G_S) gives S(ζ). ζ = r e^{iφ}."""
+    a2 = a @ a
+    return 0.5 * (torch.conj(zeta) * a2 - zeta * a2.conj().T)
+
+
+def two_mode_squeeze_generator(a: Tensor, b: Tensor, xi: Tensor) -> Tensor:
+    """G_{TMS} = ξ* a b − ξ a† b†. Acts on joint signal⊗ancilla space.
+    Inputs are full-dim joint operators a, b (e.g. a = a_signal ⊗ I_anc)."""
+    return torch.conj(xi) * (a @ b) - xi * (a.conj().T @ b.conj().T)
+
+
+# ─── Encoder ────────────────────────────────────────────────────────────────
+class SBERTPhotonFock(nn.Module):
+    """SBERT → Linear(384, 6) → 2-mode Fock encoder → herald → 1-mode pure state.
+
+    The 6 outputs decompose to (αq, αp, r, φ_s, τ, θ):
+      α = αq + i·αp                      (signal displacement)
+      ζ = r e^{iφ_s},  r ∈ [0, 0.5]      (signal squeezing)
+      ξ = τ e^{iθ},    τ ∈ [0, 0.5]      (two-mode squeezing toward ancilla)
+    """
+
+    def __init__(self, cutoff: int = 6, max_squeeze: float = 0.5,
+                 max_displace: float = 1.5, herald_n: int = HERALD_N):
+        super().__init__()
+        from sentence_transformers import SentenceTransformer
+        self.D = cutoff
+        self.max_sq = max_squeeze
+        self.max_disp = max_displace
+        self.herald_n = herald_n
+        if herald_n >= cutoff:
+            raise ValueError(f"herald_n={herald_n} must be < cutoff={cutoff}")
+        self.sbert = SentenceTransformer(SBERT_MODEL_NAME)
+        for p in self.sbert.parameters():
+            p.requires_grad = False
+        # Trainable surface
+        self.proj = nn.Linear(SBERT_DIM, 6, dtype=torch.float32)
+        nn.init.normal_(self.proj.weight, std=0.02)
+        nn.init.zeros_(self.proj.bias)
+        # Pre-compute truncated bosonic operators (constants — no grad needed)
+        a = annihilation_op(cutoff)
+        I = torch.eye(cutoff, dtype=torch.complex128)
+        # Joint-space (signal ⊗ ancilla): a_s = a ⊗ I, b_a = I ⊗ a
+        self.register_buffer("a_signal_full", kron(a, I))
+        self.register_buffer("b_anc_full",     kron(I, a))
+        self.register_buffer("a_signal_local", a)  # for solo signal-side gates if ever needed
+        # Initial vacuum |0,0⟩ in joint Fock basis (D² vector)
+        psi0 = torch.zeros(cutoff * cutoff, dtype=torch.complex128)
+        psi0[0] = 1.0  # index (0, 0) → flat 0
+        self.register_buffer("vacuum", psi0)
+
+    def encode_features(self, texts: list[str]) -> Tensor:
+        with torch.no_grad():
+            emb = self.sbert.encode(
+                texts, normalize_embeddings=True, convert_to_numpy=False,
+                show_progress_bar=False,
+            )
+            emb = torch.stack([e for e in emb]) if isinstance(emb, list) else emb
+            return emb.to(torch.float32).cpu()
+
+    def state_from_features(self, feat: Tensor) -> Tensor:
+        """Returns the heralded signal-mode state |ψ_sig⟩ ∈ ℂ^D, normalized.
+        Shape: (D,) complex128.
+        """
+        out = self.proj(feat)  # (6,) float32
+        out = out.to(torch.float64)
+        # decompose with bounded reparametrizations
+        alpha_q = self.max_disp * torch.tanh(out[0])
+        alpha_p = self.max_disp * torch.tanh(out[1])
+        r       = self.max_sq  * torch.sigmoid(out[2])
+        phi_s   = (2 * math.pi) * torch.sigmoid(out[3])
+        tau     = self.max_sq  * torch.sigmoid(out[4])
+        theta   = (2 * math.pi) * torch.sigmoid(out[5])
+        # Build complex parameters
+        alpha = torch.complex(alpha_q, alpha_p)
+        zeta  = torch.complex(r * torch.cos(phi_s), r * torch.sin(phi_s))
+        xi    = torch.complex(tau * torch.cos(theta), tau * torch.sin(theta))
+        # Generators in joint space
+        G_TMS = two_mode_squeeze_generator(
+            self.a_signal_full, self.b_anc_full, xi,
+        )
+        G_S   = squeeze_generator(self.a_signal_full, zeta)
+        G_D   = displace_generator(self.a_signal_full, alpha)
+        # Apply unitaries: |ψ⟩ = D · S · S_2 · |0,0⟩
+        U_TMS = torch.linalg.matrix_exp(G_TMS)
+        U_S   = torch.linalg.matrix_exp(G_S)
+        U_D   = torch.linalg.matrix_exp(G_D)
+        psi = U_TMS @ self.vacuum
+        psi = U_S   @ psi
+        psi = U_D   @ psi
+        # Project ancilla onto |herald_n⟩.  Joint flat index = signal*D + ancilla.
+        # Pick rows where ancilla == herald_n: rows = [signal*D + herald_n for signal in 0..D-1]
+        D = self.D
+        idx = torch.arange(D, device=psi.device, dtype=torch.long) * D + self.herald_n
+        psi_sig = psi[idx]
+        # Normalize (heralding probability is the squared norm; we drop it)
+        norm = torch.linalg.vector_norm(psi_sig)
+        psi_sig = psi_sig / torch.clamp(norm, min=1e-12)
+        return psi_sig
+
+    def state_from_text(self, text: str) -> Tensor:
+        feat = self.encode_features([text])[0]
+        return self.state_from_features(feat)
+
+
+def overlap_squared(psi_a: Tensor, psi_b: Tensor) -> Tensor:
+    """|⟨ψ_a|ψ_b⟩|². Pure-state fidelity since both are heralded pure."""
+    inner = torch.vdot(psi_a, psi_b)
+    return (inner.real ** 2 + inner.imag ** 2)
+
+
+def recall_at_k(ranked, relevant, k):
+    if not relevant:
+        return float("nan")
+    return len(set(ranked[:k]) & relevant) / len(relevant)
+
+
+def ndcg_at_k(ranked, relevant, k):
+    if not relevant:
+        return float("nan")
+    dcg = sum(1.0 / math.log2(i + 1) for i, a in enumerate(ranked[:k], start=1) if a in relevant)
+    ideal = sum(1.0 / math.log2(i + 1) for i in range(1, min(k, len(relevant)) + 1))
+    return dcg / ideal if ideal > 0 else float("nan")
+
+
+def evaluate(model, abstracts, ids, queries, ks=(1, 3, 5, 10)) -> dict:
+    model.eval()
+    with torch.no_grad():
+        doc_states = {a: model.state_from_text(t) for a, t in abstracts.items()}
+    rows = []
+    for q in queries:
+        with torch.no_grad():
+            psi_q = model.state_from_text(q["query"])
+        scored = []
+        for a in ids:
+            psi_d = doc_states[a]
+            scored.append((float(overlap_squared(psi_q, psi_d).item()), a))
+        scored.sort(key=lambda x: -x[0])
+        ranked = [a for _, a in scored]
+        rel = set(q["relevant_ids"])
+        row = {"query": q["query"], "ranked": ranked[: max(ks)]}
+        for k in ks:
+            row[f"recall@{k}"] = recall_at_k(ranked, rel, k)
+            row[f"ndcg@{k}"]   = ndcg_at_k(ranked, rel, k)
+        rows.append(row)
+    agg = {f"recall@{k}": float(np.mean([r[f"recall@{k}"] for r in rows])) for k in ks}
+    agg.update({f"ndcg@{k}": float(np.mean([r[f"ndcg@{k}"] for r in rows])) for k in ks})
+    return {"per_query": rows, "aggregate": agg}
+
+
+def train(args):
+    torch.manual_seed(args.seed)
+    np.random.seed(args.seed)
+
+    rel_path  = Path(args.relevance) if args.relevance else ROOT / "eval" / "relevance.json"
+    cids_path = ROOT / "eval" / "corpus_ids.json"
+    man_path  = ROOT / "eval" / "manifest.json"
+    train_relevance = json.loads(rel_path.read_text("utf-8"))["queries"]
+    ids = json.loads(cids_path.read_text("utf-8"))["ids"]
+    print(f"[fock] fetching {len(ids)} abstracts...", flush=True)
+    abstracts = fetch_all(ids)
+    bad = verify_against_manifest(abstracts, man_path)
+    if bad:
+        sys.exit(f"manifest mismatch: {list(bad)[:3]}")
+
+    model = SBERTPhotonFock(cutoff=args.cutoff, herald_n=args.herald_n)
+    n_trainable = sum(p.numel() for p in model.parameters() if p.requires_grad)
+    print(f"[fock] cutoff={args.cutoff}  herald_n={args.herald_n}  trainable={n_trainable}", flush=True)
+
+    # Cache features
+    print(f"[fock] caching SBERT features ({len(abstracts)} docs + "
+          f"{len(train_relevance)} queries)...", flush=True)
+    doc_feats = {a: model.encode_features([t])[0] for a, t in abstracts.items()}
+    query_feats = {q["query"]: model.encode_features([q["query"]])[0]
+                    for q in train_relevance}
+
+    optim = torch.optim.AdamW(
+        [p for p in model.parameters() if p.requires_grad],
+        lr=args.lr, weight_decay=args.weight_decay,
+    )
+    rng = np.random.default_rng(args.seed)
+    queries = [(q["query"], set(q["relevant_ids"])) for q in train_relevance]
+
+    t0 = time.time()
+    for step in range(1, args.steps + 1):
+        optim.zero_grad()
+        # Recompute every state (proj weights change every step). Cached
+        # SBERT features feed straight into state_from_features.
+        doc_psi = {a: model.state_from_features(doc_feats[a]) for a in abstracts}
+
+        loss_sum = torch.zeros((), dtype=torch.float64)
+        for query_text, rel_set in queries:
+            psi_q = model.state_from_features(query_feats[query_text])
+            pos_id = rng.choice(sorted(rel_set))
+            psi_pos = doc_psi[pos_id]
+            negs = rng.choice(
+                [i for i in ids if i not in rel_set],
+                size=min(args.negatives, len(ids) - len(rel_set)), replace=False,
+            )
+            f_pos = overlap_squared(psi_q, psi_pos)
+            f_negs = torch.stack([overlap_squared(psi_q, doc_psi[n]) for n in negs])
+            # InfoNCE: log P(pos) = log(f_pos / Σ f). Fidelities are in [0,1] so use as logits directly.
+            logits = torch.cat([f_pos.unsqueeze(0), f_negs]) / args.temperature
+            ce = F.cross_entropy(logits.unsqueeze(0), torch.zeros((), dtype=torch.long).unsqueeze(0))
+            loss_sum = loss_sum + ce
+        loss_sum = loss_sum / len(queries)
+        loss_sum.backward()
+        torch.nn.utils.clip_grad_norm_(
+            [p for p in model.parameters() if p.requires_grad], max_norm=args.clip,
+        )
+        optim.step()
+        if step == 1 or step % args.log_every == 0 or step == args.steps:
+            print(f"[fock] step {step}/{args.steps}  loss={loss_sum.item():.4f}  "
+                  f"elapsed={time.time()-t0:.1f}s", flush=True)
+
+    eval_paths = []
+    if args.eval_train_rel:
+        eval_paths.append(("train", Path(args.eval_train_rel)))
+    if args.eval_test_rel:
+        eval_paths.append(("test",  Path(args.eval_test_rel)))
+    if not eval_paths:
+        eval_paths.append(("all", rel_path))
+    summary = {}
+    for label, p in eval_paths:
+        rels = json.loads(p.read_text("utf-8"))["queries"]
+        report = evaluate(model, abstracts, ids, rels)
+        print(f"\n=== {label.upper()} EVAL ({len(rels)} queries) ===")
+        for r in report["per_query"]:
+            cells = " ".join(f"{m}={r[m]:.3f}" for m in r if m.startswith(("recall", "ndcg")))
+            print(f"  {r['query'][:48]:<48s}  {cells}")
+        print("aggregate: " + " ".join(f"{m}={report['aggregate'][m]:.3f}" for m in report["aggregate"]))
+        summary[f"{label}/fock"] = report["aggregate"]
+    print(f"\nSUMMARY_JSON={json.dumps(summary)}")
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--cutoff",       type=int, default=6,
+                    help="Fock-basis truncation per mode. Joint dim = cutoff².")
+    ap.add_argument("--herald-n",     type=int, default=HERALD_N,
+                    help="Ancilla photon-number outcome to project onto.")
+    ap.add_argument("--steps",        type=int, default=200)
+    ap.add_argument("--lr",           type=float, default=1e-2)
+    ap.add_argument("--weight-decay", type=float, default=1e-3)
+    ap.add_argument("--temperature",  type=float, default=0.5)
+    ap.add_argument("--negatives",    type=int, default=8)
+    ap.add_argument("--clip",         type=float, default=1.0)
+    ap.add_argument("--seed",         type=int, default=42)
+    ap.add_argument("--log-every",    type=int, default=20)
+    ap.add_argument("--relevance",      type=str, default=None)
+    ap.add_argument("--eval-train-rel", type=str, default=None)
+    ap.add_argument("--eval-test-rel",  type=str, default=None)
+    args = ap.parse_args()
+    train(args)
+
+
+if __name__ == "__main__":
+    main()