quantum-cortex 1.0.0__py3-none-any.whl

cortex_eval/ablation_mqar.py

@@ -0,0 +1,187 @@
+"""cortex_eval.ablation_mqar — Slice C: the C2 ablation on MQAR.
+
+Runs the MQAR difficulty curriculum on the three variants (control / hopfield /
+delta) at the *same* regime, produces the three accuracy curves, compares them,
+and emits the verdict — the second point on the Pareto frontier, the first that
+*decides* between architectures.
+
+Per the founder (2026-09-06): full curriculum first for a solid base, then a
+fast pass driven by insights. Results are a SEPARATE artefact (metrics/mqar/),
+not a run-v1 ledger record — MQAR is an architecture bench, distinct from the
+language-training runs whose `comparison` slot fills at the real FineWeb-Edu
+ablations (W1 proper). NOW-6: benchmarks as open, versioned deliverables.
+
+The reading rule (D16 + the founder's curve principle): an architecture is
+characterised by *where its curve drops off*; the gap between drop-off points is
+the clean signal. The circuit breaker (ADR-006 D7) applies per tier per variant.
+
+Usage:
+    python -m cortex_eval.ablation_mqar --steps 1500 --out metrics/mqar
+    python -m cortex_eval.ablation_mqar --quick        # tiny, for a smoke check
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import time
+from datetime import datetime, timezone
+from pathlib import Path
+
+from cortex_eval.mqar import MQARTier, standard_curriculum
+from cortex_eval.run_mqar import run_curriculum
+
+VARIANTS = ("none", "hopfield", "delta")
+REPO = Path(__file__).resolve().parents[1]
+
+
+def _dropoff(per_tier: list[dict], threshold: float, axis: str = "kv_pairs") -> dict:
+    """Where each curve first drops below threshold, per the smallest other-axis."""
+    other = "seq_len" if axis == "kv_pairs" else "kv_pairs"
+    base = min((t[other] for t in per_tier), default=None)
+    if base is None:
+        return {}
+    row = sorted((t for t in per_tier if t[other] == base), key=lambda t: t[axis])
+    for t in row:
+        if t["accuracy"] < threshold:
+            return {"axis": axis, other: base, "dropoff": t[axis], "below": threshold}
+    return {"axis": axis, other: base, "dropoff": None, "below": threshold}  # never dropped
+
+
+def _auc(per_tier: list[dict]) -> float:
+    """Mean accuracy across all tiers — area under the curve. A threshold-free
+    reading: even when no curve crosses a fixed threshold (the v1 "held" artefact),
+    AUC separates architectures by their whole-curve strength (the founder's
+    "read the curve, not a point" principle applied to the verdict itself)."""
+    accs = [t["accuracy"] for t in per_tier if t["accuracy"] == t["accuracy"]]  # drop NaN
+    return float(sum(accs) / len(accs)) if accs else float("nan")
+
+
+def run_ablation(steps: int = 1500, tiers: list[MQARTier] | None = None,
+                 threshold: float = 0.5, seed: int = 1337, **kw) -> dict:
+    tiers = tiers or standard_curriculum()
+    curves: dict[str, list[dict]] = {}
+    t0 = time.time()
+    for v in VARIANTS:
+        res = run_curriculum(c2_variant=v, steps=steps, tiers=tiers, seed=seed, **kw)
+        curves[v] = res.per_tier
+
+    # comparison: drop-off per variant, and the gap vs control
+    dropoffs = {v: _dropoff(curves[v], threshold) for v in VARIANTS}
+    ctrl_do = dropoffs["none"].get("dropoff")
+    deltas = {}
+    for v in ("hopfield", "delta"):
+        vdo = dropoffs[v].get("dropoff")
+        if ctrl_do is None and vdo is None:
+            deltas[v] = "both never dropped (raise difficulty)"
+        elif vdo is None:
+            deltas[v] = "later than control (never dropped)"
+        elif ctrl_do is None:
+            deltas[v] = "earlier than control (control never dropped)"
+        else:
+            g = vdo - ctrl_do
+            deltas[v] = f"{'+' if g >= 0 else ''}{g} kv vs control ({vdo} vs {ctrl_do})"
+
+    # AUC per variant — the threshold-free reading (fixes the v1 "held" artefact,
+    # where Hopfield beat the control on the whole curve but not at the 0.5 cutoff)
+    auc = {v: _auc(curves[v]) for v in VARIANTS}
+    ctrl_auc = auc["none"]
+    auc_delta = {v: (auc[v] - ctrl_auc if auc[v] == auc[v] and ctrl_auc == ctrl_auc else None)
+                 for v in ("hopfield", "delta")}
+    auc_winners = [v for v in ("hopfield", "delta")
+                   if auc[v] == auc[v] and ctrl_auc == ctrl_auc and auc[v] > ctrl_auc]
+
+    # honest verdict: which variant extends the frontier on this axis
+    winners = [v for v in ("hopfield", "delta")
+               if isinstance(dropoffs[v].get("dropoff"), int)
+               and (ctrl_do is None or dropoffs[v]["dropoff"] > ctrl_do)]
+    if auc_winners:
+        deltas_str = ", ".join(f"{v} (+{auc[v]-ctrl_auc:.3f} AUC)" for v in auc_winners)
+        verdict = f"advances (AUC): {deltas_str} beat the control's whole-curve MQAR strength"
+    elif winners:
+        verdict = f"advances (drop-off): {', '.join(winners)} recall further than control"
+    else:
+        verdict = "held — no associative variant beat the control on AUC or drop-off"
+
+    return {
+        "benchmark": "mqar",
+        "timestamp_utc": datetime.now(timezone.utc).isoformat(),
+        "regime": {"steps": steps, "tiers": len(tiers), "threshold": threshold, "seed": seed},
+        "curves": curves,
+        "dropoffs": dropoffs,
+        "auc": auc,
+        "auc_vs_control": auc_delta,
+        "control_delta": deltas,
+        "verdict": verdict,
+        "wall_s": round(time.time() - t0, 1),
+        "note": "architecture bench (separate artefact, not a run-v1 record); "
+                "circuit breaker per tier; the gap between drop-offs is the signal.",
+    }
+
+
+def write_artefact(result: dict, out_dir: str | Path) -> Path:
+    out = Path(out_dir)
+    out.mkdir(parents=True, exist_ok=True)
+    stamp = result["timestamp_utc"][:19].replace(":", "").replace("-", "")
+    path = out / f"mqar-ablation-{stamp}.json"
+    path.write_text(json.dumps(result, indent=2) + "\n")
+    # also refresh a LATEST pointer
+    (out / "LATEST.json").write_text(json.dumps(result, indent=2) + "\n")
+    return path
+
+
+def _cli():
+    ap = argparse.ArgumentParser(description="MQAR C2 ablation (Slice C, ADR-006)")
+    ap.add_argument("--steps", type=int, default=1500)
+    ap.add_argument("--threshold", type=float, default=0.5)
+    ap.add_argument("--seed", type=int, default=1337)
+    ap.add_argument("--out", default="metrics/mqar")
+    ap.add_argument("--quick", action="store_true", help="tiny curriculum + few steps")
+    args = ap.parse_args()
+    tiers = None
+    steps = args.steps
+    if args.quick:
+        tiers = [MQARTier(kv_pairs=4, seq_len=64), MQARTier(kv_pairs=16, seq_len=64)]
+        steps = 300
+    result = run_ablation(steps=steps, tiers=tiers, threshold=args.threshold, seed=args.seed)
+    path = write_artefact(result, args.out)
+    print("\n=== MQAR ablation verdict ===")
+    print(result["verdict"])
+    print(f"drop-offs: {json.dumps(result['dropoffs'])}")
+    print(f"vs control: {json.dumps(result['control_delta'])}")
+    print(f"artefact: {path}")
+
+
+if __name__ == "__main__":
+    _cli()
+
+
+def run_hopfield_capacity_sweep(steps: int = 1500, seed: int = 1337,
+                                slots: tuple[int, ...] = (32, 64, 128, 256),
+                                tier: MQARTier | None = None, **kw) -> dict:
+    """The founder's question: is Hopfield limited by its memory SIZE or by its
+    structure? Sweep c2_mem_slots at a fixed hard tier. If accuracy RISES with
+    slots → the limit is dimensioning (fixable). If it PLATEAUS → the structure
+    is the ceiling (delta's expressivity may be the better bet). Reads the curve.
+    """
+    from datetime import datetime, timezone
+    tier = tier or MQARTier(kv_pairs=16, seq_len=256)  # a hard-enough tier to separate
+    points = []
+    for s in slots:
+        res = run_curriculum(c2_variant="hopfield", steps=steps, tiers=[tier],
+                             seed=seed, c2_mem_slots=s, **kw)
+        acc = res.per_tier[0]["accuracy"]
+        points.append({"mem_slots": s, "accuracy": acc})
+        print(f"[hopfield-sweep] slots={s} kv={tier.kv_pairs} seq={tier.seq_len} -> acc={acc:.3f}")
+    # verdict: monotone increase → dimensioning-limited; flat → structure-limited
+    accs = [p["accuracy"] for p in points]
+    rising = accs[-1] > accs[0] + 0.02
+    reading = ("dimensioning-limited (accuracy rises with capacity — add slots)"
+               if rising else
+               "structure-limited (accuracy plateaus — capacity is not the ceiling)")
+    return {
+        "benchmark": "hopfield_capacity_sweep",
+        "timestamp_utc": datetime.now(timezone.utc).isoformat(),
+        "tier": {"kv_pairs": tier.kv_pairs, "seq_len": tier.seq_len},
+        "points": points,
+        "reading": reading,
+    }

cortex_eval/confirmation_run.py

@@ -0,0 +1,133 @@
+"""cortex_eval.confirmation_run — the run that unlocks whitepaper v0.
+
+One GPU job that turns today's single-seed signals into gate-passing claims
+(WHITEPAPER.md admission gate: ≥3 seeds, significant, anchored, real, reproducible).
+
+Three parts, all at the same regime (steps, seeds), on the DISCRIMINATING tiers —
+those where the variants actually separated in the 12-tier run (kv 8/16 at
+seq 128/256) — so the job fits one Kaggle session:
+  1. C2 ablation × 5 seeds  → paired t-tests, CIs  (hopfield/delta vs control)
+  2. Recurrent ladder × 5 seeds → is "delta-rule pays only when hybridised" real?
+  3. External anchor × 5 seeds  → the three families, statistically
+
+Everything is written to metrics/mqar/confirmation-*.json. Nothing is claimed
+here; the artefact feeds the whitepaper's §4 only where the gate passes.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+from datetime import datetime, timezone
+from pathlib import Path
+
+import numpy as np
+
+from cortex_eval.mqar import MQARTier
+from cortex_eval.multiseed import run_multiseed, _mean_ci, _paired_test
+from cortex_eval.recurrent_ladder import run_ladder, LADDER
+from cortex_eval.external_baseline import _run_mlp_baseline
+
+# the discriminating tiers (from the 12-tier ablation: where the paths separated)
+DISCRIMINATING = [MQARTier(kv_pairs=8, seq_len=128), MQARTier(kv_pairs=16, seq_len=128),
+                  MQARTier(kv_pairs=8, seq_len=256), MQARTier(kv_pairs=16, seq_len=256)]
+
+
+def _ladder_multiseed(seeds, tiers, steps, **kw) -> dict:
+    per_rung: dict[str, list[float]] = {r.name: [] for r in LADDER}
+    for s in seeds:
+        res = run_ladder(tiers=tiers, steps=steps, seed=s, **kw)
+        for pt in res["curve"]:
+            per_rung[pt["rung"]].append(pt["auc"])
+    stats = {r: _mean_ci([v for v in vals if v == v]) for r, vals in per_rung.items()}
+    # the candidate finding: L4 (pure delta) vs L3 (best pure) — does delta regress when pure?
+    l3, l4 = per_rung["L3-+local-conv"], per_rung["L4-+delta-rule"]
+    return {"per_seed": per_rung, "stats": stats,
+            "L4_vs_L3": _paired_test(l4, l3)}
+
+
+def _floor_multiseed(seeds, tiers, steps, **kw) -> dict:
+    vals = []
+    for s in seeds:
+        accs = [_run_mlp_baseline(t, steps, s, d_model=kw.get("d_model", 64)) for t in tiers]
+        vals.append(float(np.mean(accs)))
+    return {"per_seed": vals, "stats": _mean_ci(vals)}
+
+
+def run_confirmation(seeds=(1337, 2024, 7, 42, 99), steps: int = 1500,
+                     tiers=None, **kw) -> dict:
+    tiers = tiers or DISCRIMINATING
+    print("=== 1/3 C2 ablation × seeds ===")
+    abl = run_multiseed(list(seeds), steps=steps, tiers=tiers, **kw)
+    print("=== 2/3 recurrent ladder × seeds ===")
+    lad = _ladder_multiseed(seeds, tiers, steps, **kw)
+    print("=== 3/3 no-attention floor × seeds ===")
+    flo = _floor_multiseed(seeds, tiers, steps, **kw)
+
+    # hybrid vs best pure recurrent (the hybrid thesis, statistically)
+    best_pure = max(lad["per_seed"], key=lambda r: np.nanmean(lad["per_seed"][r]))
+    hyb_vs_pure = {
+        "best_pure_rung": best_pure,
+        "hopfield_vs_best_pure": _paired_test(abl["per_seed_auc"]["hopfield"], lad["per_seed"][best_pure]),
+        "delta_hybrid_vs_best_pure": _paired_test(abl["per_seed_auc"]["delta"], lad["per_seed"][best_pure]),
+    }
+    return {
+        "benchmark": "confirmation_run",
+        "timestamp_utc": datetime.now(timezone.utc).isoformat(),
+        "regime": {"seeds": list(seeds), "steps": steps,
+                   "tiers": [(t.kv_pairs, t.seq_len) for t in tiers], "note": "discriminating tiers"},
+        "c2_ablation": {"stats": abl["stats"], "paired_tests": abl["paired_tests"], "claims": abl["claims"],
+                        "per_seed_auc": abl["per_seed_auc"]},
+        "recurrent_ladder": lad,
+        "floor_mlp": flo,
+        "hybrid_vs_pure": hyb_vs_pure,
+        "gate_readout": {
+            "hopfield_beats_control_significant": abl["paired_tests"]["hopfield_vs_control"].get("significant_95"),
+            "delta_beats_control_significant": abl["paired_tests"]["delta_vs_control"].get("significant_95"),
+            "delta_regresses_when_pure_significant": lad["L4_vs_L3"].get("significant_95") and lad["L4_vs_L3"]["mean_diff"] < 0,
+            "hybrid_beats_best_pure_significant": hyb_vs_pure["hopfield_vs_best_pure"].get("significant_95"),
+        },
+        "note": "Feeds WHITEPAPER.md §4 only where the gate passes; otherwise §5 open questions.",
+    }
+
+
+def write_artefact(result: dict, out_dir="metrics/mqar") -> Path:
+    out = Path(out_dir); out.mkdir(parents=True, exist_ok=True)
+    stamp = result["timestamp_utc"][:19].replace(":", "").replace("-", "")
+    p = out / f"confirmation-{stamp}.json"
+    p.write_text(json.dumps(result, indent=2) + "\n")
+    (out / "LATEST-confirmation.json").write_text(json.dumps(result, indent=2) + "\n")
+    return p
+
+
+def _cli():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--steps", type=int, default=1500)
+    ap.add_argument("--seeds", type=int, nargs="+", default=[1337, 2024, 7, 42, 99])
+    ap.add_argument("--tiers", type=int, default=4,
+                    help="how many discriminating tiers to use (1-4, sharpest first) — "
+                         "use 2 to fit a ~3h GPU budget with 3 seeds at 1000 steps")
+    ap.add_argument("--quick", action="store_true")
+    args = ap.parse_args()
+    if args.quick:
+        r = run_confirmation(seeds=(1, 2, 3), steps=150,
+                             tiers=[MQARTier(kv_pairs=4, seq_len=48)], d_model=48)
+    else:
+        # sharpest-first ordering: the tiers where paths separated most in the 12-tier run
+        sharpest = [MQARTier(kv_pairs=16, seq_len=128), MQARTier(kv_pairs=8, seq_len=128),
+                    MQARTier(kv_pairs=16, seq_len=256), MQARTier(kv_pairs=8, seq_len=256)]
+        tiers = sharpest[:max(1, min(4, args.tiers))]
+        print(f"[confirmation] seeds={args.seeds} steps={args.steps} tiers={[(t.kv_pairs,t.seq_len) for t in tiers]}")
+        r = run_confirmation(seeds=tuple(args.seeds), steps=args.steps, tiers=tiers)
+    p = write_artefact(r)
+    print("\n=== GATE READOUT ===")
+    print(json.dumps(r["gate_readout"], indent=2))
+    print("=== C2 claims ===")
+    for c in r["c2_ablation"]["claims"]:
+        print("  ", c)
+    print("=== hybrid vs best pure recurrent ===")
+    print(json.dumps(r["hybrid_vs_pure"], indent=2))
+    print("artefact:", p)
+
+
+if __name__ == "__main__":
+    _cli()

cortex_eval/domain_map.py

@@ -0,0 +1,127 @@
+"""cortex_eval.domain_map — the per-domain reading of the C2 ablation.
+
+The confirmation run showed that the "winner" flips between regimes: on the
+12-tier average Hopfield leads; on the hard/short discriminating tiers delta
+leads (and Hopfield sinks to the control). That is not a contradiction — it is
+RES-20 in action: the ranking depends on Σ = which tiers are held. The honest
+object is therefore not a ranking but a DOMAIN MAP: for each tier, which path
+wins and by what margin, with the evidence basis (single-seed / multi-seed).
+
+This map is (a) what §4 of the whitepaper displays, and (b) exactly what the
+RES-18 router must learn — the map is the router's training target (ADR-007
+Slice C). "No single memory dominates" is the result; the router is the answer.
+
+Inputs: the 12-tier ablation artefact (single seed) and, when present, the
+confirmation artefact (multi-seed on the discriminating tiers). Output: a JSON
+map + a markdown table for the paper.
+"""
+from __future__ import annotations
+
+import json
+from datetime import datetime, timezone
+from pathlib import Path
+
+import numpy as np
+
+PATHS = ("none", "hopfield", "delta")
+LABEL = {"none": "control", "hopfield": "hopfield", "delta": "delta"}
+
+
+def _load(path):
+    p = Path(path)
+    return json.loads(p.read_text()) if p.exists() else None
+
+
+def build_domain_map(ablation12_path="metrics/mqar/mqar-ablation-final-2026-09-07.json",
+                     confirmation_path="metrics/mqar/LATEST-confirmation.json") -> dict:
+    a12 = _load(ablation12_path)
+    conf = _load(confirmation_path)
+    rows = []
+
+    # --- basis 1: the 12-tier single-seed curves ---
+    if a12:
+        curves = a12["curves"]
+        n = len(curves["none"])
+        for i in range(n):
+            kv, sq = curves["none"][i]["kv_pairs"], curves["none"][i]["seq_len"]
+            sc = {p: curves[p][i]["accuracy"] for p in PATHS}
+            best = max(sc, key=sc.get)
+            ranked = sorted(sc.values(), reverse=True)
+            margin = ranked[0] - ranked[1]
+            rows.append({"kv_pairs": kv, "seq_len": sq, "scores": sc, "winner": LABEL[best],
+                         "margin": round(margin, 4), "basis": "12-tier, 1 seed",
+                         "separable": margin >= 0.01})
+
+    # --- basis 2: confirmation (multi-seed) on discriminating tiers — overrides where present ---
+    domain_multiseed = {}
+    if conf and "c2_ablation" in conf:
+        st = conf["c2_ablation"]["stats"]          # per-variant mean over the held tiers
+        tests = conf["c2_ablation"]["paired_tests"]
+        tiers = conf["regime"]["tiers"]
+        means = {p: st[p]["mean"] for p in PATHS}
+        best = max(means, key=means.get)
+        sig = {
+            "hopfield_vs_control": tests["hopfield_vs_control"].get("significant_95"),
+            "delta_vs_control": tests["delta_vs_control"].get("significant_95"),
+            "hopfield_vs_delta": tests["hopfield_vs_delta"].get("significant_95"),
+        }
+        domain_multiseed = {
+            "tiers": tiers, "means": means, "winner": LABEL[best],
+            "n_seeds": conf["regime"]["n_seeds"] if "n_seeds" in conf["regime"] else len(conf["regime"].get("seeds", [])),
+            "significant": sig,
+            "basis": f"confirmation, {len(conf['regime'].get('seeds', []))} seeds, {conf['regime'].get('steps')} steps",
+        }
+
+    # --- the reading ---
+    winners = [r["winner"] for r in rows if r["separable"]]
+    counts = {LABEL[p]: winners.count(LABEL[p]) for p in PATHS}
+    dominated = max(counts, key=counts.get) if winners else None
+    no_single = len([c for c in counts.values() if c > 0]) >= 2
+    reading = ("no single memory dominates — each path has a domain; the per-tier map is the result "
+               "and the multi-path router (RES-18) is the answer" if no_single else
+               f"{dominated} dominates the separable tiers")
+
+    return {
+        "benchmark": "domain_map",
+        "timestamp_utc": datetime.now(timezone.utc).isoformat(),
+        "law": "RES-20: a ranking that flips between regimes is not a contradiction — it is Σ (which tiers are held). Read the map, not a ranking.",
+        "per_tier": rows,
+        "separable_winner_counts": counts,
+        "discriminating_multiseed": domain_multiseed,
+        "reading": reading,
+    }
+
+
+def to_markdown(dm: dict) -> str:
+    lines = ["| kv | seq | control | hopfield | delta | winner | margin | basis |",
+             "|---:|---:|---:|---:|---:|:---|---:|:---|"]
+    for r in dm["per_tier"]:
+        s = r["scores"]
+        mark = "" if r["separable"] else " (noise-level)"
+        lines.append(f"| {r['kv_pairs']} | {r['seq_len']} | {s['none']:.3f} | {s['hopfield']:.3f} | {s['delta']:.3f} | "
+                     f"**{r['winner']}**{mark} | {r['margin']:.3f} | {r['basis']} |")
+    ms = dm.get("discriminating_multiseed")
+    if ms:
+        m = ms["means"]
+        lines.append("")
+        lines.append(f"**Discriminating tiers {ms['tiers']} — {ms['basis']}:** control {m['none']:.4f} · "
+                     f"hopfield {m['hopfield']:.4f} · delta {m['delta']:.4f} → winner **{ms['winner']}**; "
+                     f"significance@95%: {ms['significant']}")
+    lines.append("")
+    lines.append(f"**Reading:** {dm['reading']}")
+    return "\n".join(lines)
+
+
+def write_artefact(dm: dict, out_dir="metrics/mqar") -> Path:
+    out = Path(out_dir); out.mkdir(parents=True, exist_ok=True)
+    p = out / "domain-map.json"
+    p.write_text(json.dumps(dm, indent=2) + "\n")
+    (out / "domain-map.md").write_text(to_markdown(dm) + "\n")
+    return p
+
+
+if __name__ == "__main__":
+    dm = build_domain_map()
+    p = write_artefact(dm)
+    print(to_markdown(dm))
+    print(f"\nartefact: {p}")

cortex_eval/external_baseline.py

@@ -0,0 +1,148 @@
+"""cortex_eval.external_baseline — D19 Level 1c: an external anchor.
+
+A number nobody can situate is not a result. This module runs, on OUR MQAR
+protocol at EQUAL size, two reference points anyone can reproduce:
+  - a standard GPT-2-style transformer (the nanoGPT / VanillaGPT lineage —
+    which is exactly our control, so this makes the "control = a known public
+    architecture" statement explicit and checkable);
+  - an absolute floor: a position-wise MLP with NO attention (cannot do
+    associative recall by construction) — the chance-level anchor.
+So our variants sit between a public reference (the transformer) and a hard
+floor (no-attention MLP). Same tiers, same steps, same seeds — equal at
+everything (hub-019). Nothing borrowed: the MLP baseline is written here.
+"""
+from __future__ import annotations
+
+from datetime import datetime, timezone
+
+import numpy as np
+
+from cortex_eval.mqar import MQARTier, make_batch
+
+
+def _run_mlp_baseline(tier: MQARTier, steps: int, seed: int, d_model: int = 64,
+                      batch: int = 32, lr: float = 3e-3, eval_batch: int = 64) -> float:
+    """A position-wise MLP over token embeddings — no attention, no recurrence.
+    It sees each position independently, so it CANNOT look back at the key/value
+    pairs: an honest floor for associative recall."""
+    import torch, torch.nn as nn
+    torch.manual_seed(seed)
+    vocab = 256 + 8
+    emb = nn.Embedding(vocab, d_model)
+    mlp = nn.Sequential(nn.Linear(d_model, 4 * d_model), nn.GELU(), nn.Linear(4 * d_model, vocab))
+    params = list(emb.parameters()) + list(mlp.parameters())
+    opt = torch.optim.AdamW(params, lr=lr)
+    for step in range(steps):
+        X, Y = make_batch(tier, batch, seed=seed + step)
+        logits = mlp(emb(torch.from_numpy(X)))
+        loss = nn.functional.cross_entropy(logits.view(-1, vocab),
+                                           torch.from_numpy(Y).view(-1), ignore_index=-100)
+        opt.zero_grad(); loss.backward(); opt.step()
+    Xe, Ye = make_batch(tier, eval_batch, seed=seed + 10_000)
+    with torch.no_grad():
+        preds = mlp(emb(torch.from_numpy(Xe))).argmax(-1).numpy()
+    mask = Ye != -100
+    return float((preds[mask] == Ye[mask]).mean())
+
+
+def _run_gla_baseline(tier: MQARTier, steps: int, seed: int, d_model: int = 64,
+                      n_head: int = 2, batch: int = 32, lr: float = 3e-3,
+                      eval_batch: int = 64) -> float:
+    """A PURE gated linear-attention recurrent model (the Mamba/RWKV/GLA lineage),
+    written from scratch in its canonical minimal form:
+        S_t = g_t ⊙ S_{t-1} + k_t v_tᵀ      (gated fixed-size state)
+        o_t = q_t S_t                          (linear read)
+    No softmax attention anywhere. This is the *incumbent* of the fixed-state
+    memory family our C2 layers belong to, and the reference the MQAR literature
+    (Zoology, Kimi Linear) expects. Equal size to the control."""
+    import torch, torch.nn as nn
+    torch.manual_seed(seed)
+    vocab = 256 + 8
+    dk = d_model // n_head
+
+    class GLA(nn.Module):
+        def __init__(self):
+            super().__init__()
+            self.emb = nn.Embedding(vocab, d_model)
+            self.ln = nn.LayerNorm(d_model)
+            self.qkv = nn.Linear(d_model, 3 * d_model, bias=False)
+            self.gate = nn.Linear(d_model, n_head * dk, bias=True)
+            self.out = nn.Linear(d_model, d_model, bias=False)
+            self.ln2 = nn.LayerNorm(d_model)
+            self.mlp = nn.Sequential(nn.Linear(d_model, 4 * d_model), nn.GELU(),
+                                     nn.Linear(4 * d_model, d_model))
+            self.head = nn.Linear(d_model, vocab, bias=False)
+
+        def forward(self, idx):
+            x = self.emb(idx)
+            b, T, c = x.shape
+            z = self.ln(x)
+            q, k, v = self.qkv(z).split(c, dim=2)
+            q = torch.nn.functional.normalize(q.view(b, T, n_head, dk), dim=-1)
+            k = torch.nn.functional.normalize(k.view(b, T, n_head, dk), dim=-1)
+            v = v.view(b, T, n_head, dk)
+            g = torch.sigmoid(self.gate(z)).view(b, T, n_head, dk)
+            S = torch.zeros(b, n_head, dk, dk, device=x.device)
+            outs = []
+            for i in range(T):
+                S = S * g[:, i].unsqueeze(2) + torch.einsum('bhi,bhj->bhij', k[:, i], v[:, i])
+                outs.append(torch.einsum('bhi,bhij->bhj', q[:, i], S).reshape(b, c))
+            o = torch.stack(outs, 1)
+            x = x + self.out(o)
+            x = x + self.mlp(self.ln2(x))
+            return self.head(x)
+
+    model = GLA()
+    opt = torch.optim.AdamW(model.parameters(), lr=lr)
+    for step in range(steps):
+        X, Y = make_batch(tier, batch, seed=seed + step)
+        logits = model(torch.from_numpy(X))
+        loss = nn.functional.cross_entropy(logits.view(-1, vocab),
+                                           torch.from_numpy(Y).view(-1), ignore_index=-100)
+        if not torch.isfinite(loss):
+            return float("nan")   # circuit-breaker spirit: report, do not hide
+        opt.zero_grad(); loss.backward()
+        nn.utils.clip_grad_norm_(model.parameters(), 1.0); opt.step()
+    Xe, Ye = make_batch(tier, eval_batch, seed=seed + 10_000)
+    with torch.no_grad():
+        preds = model(torch.from_numpy(Xe)).argmax(-1).numpy()
+    mask = Ye != -100
+    return float((preds[mask] == Ye[mask]).mean())
+
+
+def run_external_anchor(tiers: list[MQARTier] | None = None, steps: int = 1500,
+                        seed: int = 1337, **kw) -> dict:
+    from cortex_eval.run_mqar import run_curriculum
+    tiers = tiers or [MQARTier(kv_pairs=4, seq_len=128), MQARTier(kv_pairs=8, seq_len=128),
+                      MQARTier(kv_pairs=16, seq_len=128)]
+    out = {"mlp_no_attention": [], "gla_pure_recurrent": [], "transformer_control": [],
+           "hopfield": [], "delta": []}
+    for tier in tiers:
+        out["mlp_no_attention"].append(
+            {"kv_pairs": tier.kv_pairs, "seq_len": tier.seq_len,
+             "accuracy": _run_mlp_baseline(tier, steps, seed)})
+        out["gla_pure_recurrent"].append(
+            {"kv_pairs": tier.kv_pairs, "seq_len": tier.seq_len,
+             "accuracy": _run_gla_baseline(tier, steps, seed)})
+    for name, v in (("transformer_control", "none"), ("hopfield", "hopfield"), ("delta", "delta")):
+        res = run_curriculum(c2_variant=v, steps=steps, tiers=tiers, seed=seed, **kw)
+        out[name] = res.per_tier
+    auc = {k: round(float(np.mean([t["accuracy"] for t in v])), 4) for k, v in out.items()}
+    return {
+        "benchmark": "mqar_external_anchor",
+        "timestamp_utc": datetime.now(timezone.utc).isoformat(),
+        "regime": {"tiers": [(t.kv_pairs, t.seq_len) for t in tiers], "steps": steps, "seed": seed},
+        "curves": out,
+        "auc": auc,
+        "reading": {
+            "floor": "mlp_no_attention — cannot recall by construction (chance-level anchor)",
+            "recurrent_reference": "gla_pure_recurrent — a PURE gated linear-attention model (Mamba/RWKV/GLA "
+                                   "lineage, from scratch): the incumbent of the fixed-state memory family our C2 "
+                                   "layers belong to, and the reference the MQAR literature expects",
+            "attention_reference": "transformer_control — a standard GPT-2-style model (nanoGPT lineage), "
+                                   "identical to our control: our 'control' IS a known public architecture",
+            "our_variants": "hopfield / delta — the C2 HYBRIDS (attention + memory), measured against all three "
+                            "families: no-memory floor, pure-recurrent, pure-attention",
+        },
+        "note": "D19 Level 1c — equal size, tiers, steps, seed. The MLP floor is written from scratch here.",
+    }