exp018_r12 + exp019_cr + exp020_gen packages (protocol ship: sub-article READMEs, standalone scrubbed code, self-asserting builders, ledgers, all specimens). exp018: keystone init avenues priced (neutral) / tied readout scoped (reconstruction-regime). exp019: capacity cliff, zero-to-negative distillation tax, anchors carry no bytes, universal forgetting. exp020: rule-induction plateau structure-independent; aleph bottleneck best generalizer; inverse law (memorization ease substitutes for induction)

README.md

@@ -198,6 +198,45 @@ trainable bank. Value case: the structured 768 address (conditioning/routing/
 lookup), not raw bpb. 8-row ledger + 6 checkpoints;
 write-up in [exp017_ac/README.md](./exp017_ac/README.md).
 
+## exp018 — experiment 18: exp012 rerun with keystone parameters (July 11, 2026)
+
+[`exp018_r12/`](./exp018_r12): a labeled rerun (exp012's record untouched)
+pricing the two keystone avenues the original bed never exercised. Verdicts:
+the init avenue is task-neutral (geovocab2 regular-pentachoron vertices and a
+farmed recon-real codebook both land in the certified band; farmed anchors
+drift less, accelerate nothing); the tied M̂ readout fails in autoregression
+(+1.0 bpb, codebook starved) — a reconstruction-regime device. Net: exp012's
+original parameters stand. Write-up: [exp018_r12/README.md](./exp018_r12/README.md).
+
+## exp019 — the capacity for distilled content retention (July 11, 2026)
+
+[`exp019_cr/`](./exp019_cr): fact corpora in the byte stream; exact-match
+recall as the retention gauge; distillation channels vs direct learning across
+N ∈ {64, 256, 1024}, plus a rule-content generalization block. Verdicts: a
+capacity cliff between 256 and 1024 facts; **the distillation tax is
+zero-to-negative** (teacher logits alone transfer rote content at parity+ and
+rule content better than ground truth, 2/2 seeds — with a steep clean-bpb
+cost); no logit leakage without exposure; **anchors carry no bytes** (a
+trained codebook from a 256-fact teacher transfers none of them); **universal
+catastrophic forgetting** (every channel → 0.000 exact after 1k clean steps) —
+persistence, not transfer, is the unsolved axis. Rules are learned only
+fragmentarily and content is format-locked (KD students less so). Write-up:
+[exp019_cr/README.md](./exp019_cr/README.md).
+
+## exp020 — generalization: structure vs capacity on a hidden rule (July 11, 2026)
+
+[`exp020_gen/`](./exp020_gen): the exp019 rule task raced across six
+structural arms with an exact param-matched control. Verdicts: no structure
+lifts rule induction off the ~0.26 plateau (exact 0.000 in all 12 cells); the
+**aleph bottleneck is the best generalizer** (+25% over its matched free head,
+both seeds); **the inverse law** — generalization ordering reverses modeling
+strength (the constellation head models best and generalizes worst;
+memorization ease substitutes for rule induction); format diversity covers
+seen formats at full rule level but not novel ones. The measured
+memorization↔generalization axis doubles as a component registry for
+slider/registry-style composites. Write-up:
+[exp020_gen/README.md](./exp020_gen/README.md).
+
 ## Reproducibility
 
 Every experiment package (`exp012_ar/`, `exp013_aug/`, `exp014_gd/`,

exp018_r12/README.md

@@ -0,0 +1,64 @@
+# exp018_r12 — experiment 18: exp012 rerun with the keystone parameters
+
+A labeled rerun, not a replacement: [exp012](../exp012_ar/)'s certified record
+stands untouched. A process review of the exp012 bed against the aleph
+keystone ([aleph-void article](https://huggingface.co/blog/AbstractPhil/geometric-vocabulary-patchwork-aleph-void))
+found the `AlephAddress` primitive faithful (K=64, D=4, τ=0.1, M̂ reads,
+pure Adam) but two keystone avenues never exercised. exp018 prices both.
+
+## Arms (2 seeds, 2000 steps, otherwise the certified bed unchanged)
+
+| arm | s0 | s1 | drift s0/s1 |
+|---|---|---|---|
+| penta_init — geovocab2 regular pentachoron vertices as codebook init | 2.4957 | 2.4389 | .242 / .211 |
+| farmed_init — an exp012 specimen's trained (recon-real) codebook as init | 2.4934 | 2.4614 | .179 / .199 |
+| tied — zero-parameter M̂ readout (decode tied through the projection + byte embedding) | 3.5131 | 3.4997 | .019 / .020 |
+| keystone — penta_init + tied | 3.5169 | 3.5006 | .020 / .021 |
+
+exp012 certified reference: addr_msl64 3-seed mean 2.469; s0 bed 2.4990.
+`build_results.py` re-asserts every claim from `results/ledger.jsonl`.
+
+## Verdicts
+
+1. **The init avenue is task-neutral.** Both the exact regular-pentachoron
+   init (the factory's 5-dim construction, centered and SVD-projected to R⁴ —
+   pairwise cos = −¼ asserted in the smoke) and the farmed recon-real
+   codebook land inside the certified band. Consistent with the
+   basin-set-at-init and interchangeable-scaffold results: codebook identity
+   does not price into bits-per-byte on this bed at this budget.
+2. **Farmed codebooks drift less** (0.18–0.20 vs 0.21–0.24) — mature anchors
+   are more stationary — **and accelerate nothing**, echoing the exp014
+   implant studies.
+3. **The tied M̂ readout fails in autoregression** (+1.0 bpb, both seeds, with
+   or without the pentachoron init) **and starves the codebook** (drift ~0.02,
+   binding fraction 0): it is a reconstruction-regime device; as a
+   zero-parameter AR head it cannot shape a 256-way distribution and passes
+   almost no cultivating gradient into the address.
+4. **Net: exp012's original parameters stand.** Random init + free linear
+   head was not a wrong configuration — the two unexercised keystone avenues
+   are now priced (one neutral, one negative in this regime).
+
+## Files
+- `exp018_reran12.py` — pentachoron/farmed inits, the tied readout, runner,
+  smoke (asserts exact simplex regularity).
+- `geolip_vitals.py` / `ar_differentiation_bed.py` /
+  `exp014_genetic_distillation.py` / `read_codebook.py` — this package's own
+  copies of the shared harness. Standalone.
+- `repro.py` — loads the code files from this folder and runs them.
+- `build_results.py` → `results/results.json` — re-asserts every claim above.
+- `results/ledger.jsonl` — 8 rows. `specimens/` — all 8 checkpoints.
+
+## Reproduce (from inside this folder)
+```bash
+pip install torch --index-url https://download.pytorch.org/whl/cu128
+pip install pyarrow huggingface_hub
+pip install "git+https://github.com/AbstractEyes/geolip-svae"   # geovocab2 (penta init)
+python repro.py            # CPU smoke
+python repro.py --run      # 4 arms x 2 seeds (GPU, ~40 min)
+python build_results.py    # re-assert every claim from the ledger
+```
+Data lands in `./data` (override `GEOLIP_DATA`); the farmed donor is
+`../exp012_ar/specimens/addr_msl64_s0_t2000.pt` (in this repo) or set
+`GEOLIP_FARMED_SPECIMEN`.
+
+License: MIT · AbstractPhil + Claude Fable 5 · July 11, 2026

exp018_r12/ar_differentiation_bed.py

@@ -0,0 +1,487 @@
+"""ar_differentiation_bed.py — exp012: autoregressive differentiation of the aleph.
+
+Differentiation is cultivated by PREDICTIVE pressure along the sequence — the
+address parameterizing the next-byte distribution (Law 2: chain-rule advantage pays
+ONLY where the composed address directly parameterizes the predictive distribution).
+This bed puts the aleph in the autoregressive gradient path and measures what
+differentiates. The head arms enforce the employment law at its maximum: the
+ENTIRE next-byte distribution is parameterized by the address.
+
+Byte-level causal LM on wikitext-2-raw (HF parquet, CDN-fast), block 256. ARMS:
+  sdpa       — standard causal transformer control (matched trunk).
+  hub        — attention replaced by CAUSAL HUB: linear attention whose feature map
+               is the 2K-oriented aleph address, prefix-sum memories (no selection
+               event; O(n*K*d)). Differentiation cultivated INSIDE attention.
+  addr_head  — sdpa trunk, but the OUTPUT HEAD reads ONLY the signed aleph
+               coefficient vector w_k = sinh(u_k)/sum_j cosh(u_j) of the final
+               hidden state (K -> 256 logits). The address MUST carry every bit of
+               next-byte information — the hardest Law-2 bottleneck.
+
+JUDGED BY: val bits-per-byte per arm (task) + CULTIVATION VITALS on every aleph
+codebook (readouts, never losses): axis aliveness/hppl, drift-from-init +
+binding fraction @0.29154, winner-|cos| saturation (sign-code emergence), shadow
+path diversity (fixed high-bits hash). Never by recon.
+
+Riders: pure Adam wd=0; no BN/Dropout/GAP on geometric paths; orthogonal init;
+Colab-cell-safe (paste-ahead imports, no bare argparse, no __file__ reliance);
+GPU-only for verdict runs.
+
+Terminal:  python ar_differentiation_bed.py            # shapes/parse smoke
+           python ar_differentiation_bed.py --train    # verdict run
+Colab:     paste geolip_vitals.py cell, then this file (smoke auto-runs),
+           then  train(steps=2000, data_root="/content/data")  in the next cell.
+"""
+from __future__ import annotations
+import math
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+if "anchor_drift" not in globals():
+    try:
+        from geolip_vitals import anchor_drift, axis_aliveness, path_diversity
+    except ImportError:
+        _here = globals().get("__file__")
+        if _here is not None:
+            import sys, pathlib
+            sys.path.insert(0, str(pathlib.Path(_here).parent))
+            from geolip_vitals import anchor_drift, axis_aliveness, path_diversity
+        else:
+            raise ImportError(
+                "geolip_vitals not found — paste/run its cell first, or "
+                "hf_hub_download exp012_ar/geolip_vitals.py from "
+                "AbstractPhil/geolip-aleph-differentiation.")
+
+VOCAB = 256  # bytes
+
+
+# ------------------------------------------------------------------ aleph address
+def _super_fibonacci_s3(n: int) -> torch.Tensor:
+    """Near-uniform unit quaternions (Alexa CVPR'22) —
+    starts the codebook INSIDE the RP^3 attractor basin. D=4 only."""
+    PHI, PSI = math.sqrt(2.0), 1.533751168755204288118041
+    i = torch.arange(n, dtype=torch.float64)
+    s = (i + 0.5) / n
+    r, R = torch.sqrt(s), torch.sqrt(1.0 - s)
+    a, b = 2 * math.pi * i / PHI, 2 * math.pi * i / PSI
+    q = torch.stack([r * torch.sin(a), r * torch.cos(a),
+                     R * torch.sin(b), R * torch.cos(b)], dim=-1)
+    return F.normalize(q, dim=-1).float()
+
+
+class AlephAddress(nn.Module):
+    """Closed-form aleph over 2K oriented half-axes (aleph-void article).
+    signed(x): (..., K) w_k = sinh(u_k)/sum_j cosh(u_j)   — the Law-2 head feature.
+    oriented(x): ((..., K), (..., K)) positive halves of the 2K softmax — HUB map."""
+
+    def __init__(self, K: int, D: int, tau: float = 0.1, init: str = "random"):
+        super().__init__()
+        self.K, self.D, self.tau = K, D, tau
+        if init == "fibonacci":
+            assert D == 4, "fibonacci init lives on S^3 (D=4)"
+            A = _super_fibonacci_s3(K)
+        else:
+            A = F.normalize(torch.randn(K, D), dim=-1)
+        self.codebook = nn.Parameter(A)
+        self.register_buffer("home", self.codebook.detach().clone())
+
+    def _u(self, x):
+        A = F.normalize(self.codebook, dim=-1)
+        return (F.normalize(x, dim=-1) @ A.transpose(-1, -2)) / self.tau
+
+    def oriented(self, x):
+        u = self._u(x)
+        m = u.abs().amax(dim=-1, keepdim=True)
+        ep, en = torch.exp(u - m), torch.exp(-u - m)
+        Z = (ep + en).sum(dim=-1, keepdim=True)
+        return ep / Z, en / Z
+
+    def signed(self, x):
+        u = self._u(x)
+        m = u.abs().amax(dim=-1, keepdim=True)
+        ep, en = torch.exp(u - m), torch.exp(-u - m)
+        return (ep - en) / (ep + en).sum(dim=-1, keepdim=True)
+
+    def signed_at(self, x, taus):
+        """Multi-tau stroboscope (rule of 3): signed coefficients at several
+        temperatures, concatenated — softer taus keep the vector dense while a
+        hard tau supplies the sign-code sharpness. v2 refinement (b)."""
+        A = F.normalize(self.codebook, dim=-1)
+        cos = F.normalize(x, dim=-1) @ A.transpose(-1, -2)
+        outs = []
+        for t in taus:
+            u = cos / t
+            m = u.abs().amax(dim=-1, keepdim=True)
+            ep, en = torch.exp(u - m), torch.exp(-u - m)
+            outs.append((ep - en) / (ep + en).sum(dim=-1, keepdim=True))
+        return torch.cat(outs, dim=-1)
+
+    def m_hat(self, x):
+        """Closed-form soft read (decoders read M_hat, never M). v2 control (c)."""
+        u = self._u(x)
+        m = u.abs().amax(dim=-1, keepdim=True)
+        ep, en = torch.exp(u - m), torch.exp(-u - m)
+        A = F.normalize(self.codebook, dim=-1)
+        return ((ep - en) @ A) / (ep + en).sum(dim=-1, keepdim=True)
+
+    def m_hard_ste(self, x):
+        """Hard mode (aleph-void article): M_hard = sign(cos_win) * A[win], straight-through to
+        the soft read — forward fully discrete SIGN CODE, backward soft gradient.
+        Legal per theme A (reconstructive sign code, not a one-hot roster pick)."""
+        u = self._u(x)
+        soft = self.m_hat(x)
+        win = u.abs().argmax(dim=-1)
+        A = F.normalize(self.codebook, dim=-1)
+        sign = torch.sign(torch.gather(u, -1, win.unsqueeze(-1))).squeeze(-1)
+        hard = sign.unsqueeze(-1) * A[win]
+        return hard + soft - soft.detach()
+
+    @torch.no_grad()
+    def vitals(self, x_sample) -> dict:
+        u = self._u(x_sample.reshape(-1, x_sample.shape[-1]))
+        p, n = self.oriented(x_sample.reshape(-1, x_sample.shape[-1]))
+        two_k = torch.cat([p, n], dim=-1)
+        win = two_k.argmax(dim=-1)
+        cos_win = (u.abs().amax(dim=-1) * self.tau)  # winner |cos| — sign-code sat.
+        d = anchor_drift(self.codebook, self.home)
+        return {"drift": round(d["mean"], 4),
+                "binding_frac": round(d["binding_fraction"], 4),
+                "aliveness": axis_aliveness(two_k),
+                "win_cos_mean": round(cos_win.mean().item(), 4),
+                "paths": path_diversity(win)}
+
+
+# ------------------------------------------------------------------------- blocks
+class CausalSDPA(nn.Module):
+    def __init__(self, d: int, heads: int = 4):
+        super().__init__()
+        self.h = heads
+        self.qkv = nn.Linear(d, 3 * d, bias=False)
+        self.o = nn.Linear(d, d, bias=False)
+        nn.init.orthogonal_(self.qkv.weight); nn.init.orthogonal_(self.o.weight)
+
+    def forward(self, x):
+        B, n, d = x.shape
+        q, k, v = self.qkv(x).chunk(3, dim=-1)
+        q, k, v = (t.view(B, n, self.h, d // self.h).transpose(1, 2) for t in (q, k, v))
+        y = F.scaled_dot_product_attention(q, k, v, is_causal=True)
+        return self.o(y.transpose(1, 2).reshape(B, n, d))
+
+
+class CausalHUB(nn.Module):
+    """Causal aleph linear attention: prefix-sum memories over the two K-wide
+    halves of the oriented address; 2K never materialized; no selection event."""
+
+    def __init__(self, d: int, K: int = 32, D: int = 4, tau: float = 0.1):
+        super().__init__()
+        self.addr = AlephAddress(K, D, tau)
+        self.q = nn.Linear(d, D, bias=False)
+        self.k = nn.Linear(d, D, bias=False)
+        self.v = nn.Linear(d, d, bias=False)
+        self.o = nn.Linear(d, d, bias=False)
+        for m in (self.q, self.k, self.v, self.o):
+            nn.init.orthogonal_(m.weight)
+
+    def forward(self, x):
+        qp, qn = self.addr.oriented(self.q(x))          # (B, n, K)
+        kp, kn = self.addr.oriented(self.k(x))
+        v = self.v(x)                                    # (B, n, d)
+        Sp = torch.cumsum(torch.einsum("bnk,bnd->bnkd", kp, v), dim=1)
+        Sn = torch.cumsum(torch.einsum("bnk,bnd->bnkd", kn, v), dim=1)
+        zp = torch.cumsum(kp, dim=1)
+        zn = torch.cumsum(kn, dim=1)
+        num = torch.einsum("bnk,bnkd->bnd", qp, Sp) + torch.einsum("bnk,bnkd->bnd", qn, Sn)
+        den = (qp * zp).sum(-1, keepdim=True) + (qn * zn).sum(-1, keepdim=True)
+        return self.o(num / den.clamp_min(1e-12))
+
+
+class MslRelay(nn.Module):
+    """Depth-composition unit (chain-rule probe): multi-slot M_hat read entering
+    the trunk as a NEAR-ZERO gated residual (gate init -3.0, sigma~0.047 — theme D:
+    geometry enters as a nudge and grows only if it earns gradient)."""
+
+    def __init__(self, d: int, n_slots: int = 16, K: int = 64):
+        super().__init__()
+        self.n_slots = n_slots
+        self.proj = nn.Linear(d, n_slots * 4, bias=False)
+        self.out = nn.Linear(n_slots * 4, d, bias=False)
+        nn.init.orthogonal_(self.proj.weight)
+        nn.init.orthogonal_(self.out.weight)
+        self.addr = AlephAddress(K, 4)
+        self.gate = nn.Parameter(torch.tensor(-3.0))
+
+    def forward(self, x):
+        B, n, _ = x.shape
+        slots = self.proj(x).view(B, n, self.n_slots, 4)
+        m = self.addr.m_hat(slots).reshape(B, n, -1)
+        return x + self.gate.sigmoid() * self.out(m)
+
+
+class Block(nn.Module):
+    def __init__(self, d: int, attn: nn.Module):
+        super().__init__()
+        self.n1, self.n2 = nn.LayerNorm(d), nn.LayerNorm(d)
+        self.attn = attn
+        self.mlp = nn.Sequential(nn.Linear(d, 4 * d), nn.GELU(), nn.Linear(4 * d, d))
+
+    def forward(self, x):
+        x = x + self.attn(self.n1(x))
+        return x + self.mlp(self.n2(x))
+
+
+class ByteLM(nn.Module):
+    def __init__(self, arm: str, d: int = 192, layers: int = 4, block: int = 256,
+                 K: int = 32, D: int = 4):
+        super().__init__()
+        # "<arm>_tri" suffix = trigram byte embedding (AlephLM byte_emb x3 lineage):
+        # token embedding is the sum of embeddings of bytes t, t-1, t-2.
+        self.trigram = arm.endswith("_tri")
+        if self.trigram:
+            arm = arm[:-4]
+        # "_fib" = super-Fibonacci S^3 codebook init (basin test: starts INSIDE
+        # the RP^3 attractor; primary observable is init->final geodesic drift).
+        self.fib = arm.endswith("_fib")
+        if self.fib:
+            arm = arm[:-4]
+        # "relay*" = stacked addresses in depth: MslRelay after every block.
+        # relay -> sdpa trunk + standard head; relay_msl64 -> + addressed head.
+        self.use_relay = arm.startswith("relay")
+        if arm == "relay":
+            arm = "sdpa"
+        elif arm == "relay_msl64":
+            arm = "addr_msl64"
+        self.arm, self.block = arm, block
+        self.emb = nn.Embedding(VOCAB, d)
+        if self.trigram:
+            self.emb1 = nn.Embedding(VOCAB, d)
+            self.emb2 = nn.Embedding(VOCAB, d)
+        self.pos = nn.Parameter(torch.zeros(1, block, d) + 0.01 * torch.randn(1, block, d))
+        mk_attn = (lambda: CausalHUB(d, K, D)) if arm == "hub" else (lambda: CausalSDPA(d))
+        self.blocks = nn.ModuleList([Block(d, mk_attn()) for _ in range(layers)])
+        if self.use_relay:
+            self.relays = nn.ModuleList([MslRelay(d) for _ in range(layers)])
+        self.nf = nn.LayerNorm(d)
+        if arm == "addr_head":
+            self.head_addr = AlephAddress(K, d)  # v1: codebook in model dim — COLLAPSED
+            self.head = nn.Linear(K, VOCAB, bias=True)
+        elif arm in ("addr_d4", "addr_3tau", "addr_mhat"):
+            # v2 refinements: LOW-D HOME — learned projection to the native D=4 home
+            # before addressing (mirrors the healthy HUB arms), K=64.
+            self.head_proj = nn.Linear(d, 4, bias=False)
+            nn.init.orthogonal_(self.head_proj.weight)
+            self.head_addr = AlephAddress(64, 4)
+            if arm == "addr_d4":
+                self.head = nn.Linear(64, VOCAB, bias=True)      # w alone, D=4 home
+            elif arm == "addr_3tau":
+                self.taus = (0.05, 0.1, 0.3)                     # rule-of-3 strobe
+                self.head = nn.Linear(64 * 3, VOCAB, bias=True)
+            else:                                                 # addr_mhat
+                self.head = nn.Linear(4, VOCAB, bias=True)       # tightest: M_hat
+        elif arm.startswith("addr_msl"):
+            # v3: MULTI-SLOT heads — the 16s funnel widening: P parallel D=4 slots
+            # over a SHARED codebook. addr_msl consumes the reconstructive M_hat per
+            # slot (Px4 dims); addr_msl_w consumes signed w per slot (Px64) — tests
+            # whether slot-parallel consumption alone rescues the coefficient path.
+            # addr_msl<P> = slot-count dose-response. addr_mslh<P> = HARD sign-code
+            # consumption (straight-through M_hard per slot).
+            self.hard = arm.startswith("addr_mslh")
+            if arm in ("addr_msl", "addr_msl_w"):
+                self.n_slots = 16
+            else:
+                self.n_slots = int(arm[len("addr_mslh" if self.hard else "addr_msl"):])
+            self.head_proj = nn.Linear(d, self.n_slots * 4, bias=False)
+            nn.init.orthogonal_(self.head_proj.weight)
+            self.head_addr = AlephAddress(
+                64, 4, init="fibonacci" if self.fib else "random")
+            width = self.n_slots * (64 if arm == "addr_msl_w" else 4)
+            self.head = nn.Linear(width, VOCAB, bias=True)
+        elif arm == "addr_3tau_mhat":
+            # v3: combine the two v2 winners — 3-tau stroboscope + reconstructive read.
+            self.head_proj = nn.Linear(d, 4, bias=False)
+            nn.init.orthogonal_(self.head_proj.weight)
+            self.head_addr = AlephAddress(64, 4)
+            self.taus = (0.05, 0.1, 0.3)
+            self.head = nn.Linear(64 * 3 + 4, VOCAB, bias=True)
+        else:
+            self.head = nn.Linear(d, VOCAB, bias=True)
+        self._last_h = None
+
+    def forward(self, idx):
+        x = self.emb(idx)
+        if self.trigram:  # past-only shifts — causality preserved
+            x = x + self.emb1(F.pad(idx, (1, 0), value=0)[:, :-1]) \
+                  + self.emb2(F.pad(idx, (2, 0), value=0)[:, :-2])
+        x = x + self.pos[:, : idx.shape[1]]
+        if self.use_relay:
+            for b, r in zip(self.blocks, self.relays):
+                x = r(b(x))
+        else:
+            for b in self.blocks:
+                x = b(x)
+        h = self.nf(x)
+        self._last_h = h.detach()
+        if self.arm == "addr_head":
+            return self.head(self.head_addr.signed(h))
+        if self.arm == "addr_d4":
+            return self.head(self.head_addr.signed(self.head_proj(h)))
+        if self.arm == "addr_3tau":
+            return self.head(self.head_addr.signed_at(self.head_proj(h), self.taus))
+        if self.arm == "addr_mhat":
+            return self.head(self.head_addr.m_hat(self.head_proj(h)))
+        if self.arm.startswith("addr_msl"):
+            B, n, _ = h.shape
+            slots = self.head_proj(h).view(B, n, self.n_slots, 4)
+            if self.arm == "addr_msl_w":
+                feats = self.head_addr.signed(slots).reshape(B, n, -1)
+            elif getattr(self, "hard", False):
+                feats = self.head_addr.m_hard_ste(slots).reshape(B, n, -1)
+            else:
+                feats = self.head_addr.m_hat(slots).reshape(B, n, -1)
+            return self.head(feats)
+        if self.arm == "addr_3tau_mhat":
+            p = self.head_proj(h)
+            feats = torch.cat([self.head_addr.signed_at(p, self.taus),
+                               self.head_addr.m_hat(p)], dim=-1)
+            return self.head(feats)
+        return self.head(h)
+
+    @torch.no_grad()
+    def vitals(self) -> dict:
+        out = {}
+        if self.arm == "hub":
+            for i, b in enumerate(self.blocks):
+                if self._last_h is not None:
+                    out[f"L{i}"] = b.attn.addr.vitals(b.attn.q(self._last_h[:2]))
+        elif self.arm == "addr_head" and self._last_h is not None:
+            out["head"] = self.head_addr.vitals(self._last_h[:2])
+        elif self.arm in ("addr_d4", "addr_3tau", "addr_mhat",
+                          "addr_3tau_mhat") and self._last_h is not None:
+            out["head"] = self.head_addr.vitals(self.head_proj(self._last_h[:2]))
+        elif self.arm.startswith("addr_msl") and self._last_h is not None:
+            slots = self.head_proj(self._last_h[:2])
+            out["head"] = self.head_addr.vitals(
+                slots.reshape(*slots.shape[:-1], self.n_slots, 4))
+        if self.use_relay and self._last_h is not None:
+            for i, r in enumerate(self.relays):
+                s = r.proj(self._last_h[:2])
+                v = r.addr.vitals(s.reshape(*s.shape[:-1], r.n_slots, 4))
+                out[f"relay{i}"] = {"gate": round(r.gate.sigmoid().item(), 4),
+                                    "drift": v["drift"],
+                                    "binding_frac": v["binding_frac"],
+                                    "ppl": round(v["aliveness"]["usage_ppl"], 1)}
+        return out
+
+
+# --------------------------------------------------------------------------- data
+def _wikitext_bytes(data_root: str):
+    """wikitext-2-raw as flat uint8 tensors via the HF parquet CDN."""
+    from huggingface_hub import hf_hub_download
+    import pyarrow.parquet as pq
+
+    def load(split):
+        p = hf_hub_download("Salesforce/wikitext",
+                            f"wikitext-2-raw-v1/{split}-00000-of-00001.parquet",
+                            repo_type="dataset", local_dir=data_root)
+        text = "".join(pq.read_table(p).column("text").to_pylist())
+        return torch.frombuffer(bytearray(text.encode("utf-8")), dtype=torch.uint8).clone()
+
+    return load("train"), load("validation")
+
+
+def _batch(data: torch.Tensor, batch: int, block: int, device, g: torch.Generator):
+    ix = torch.randint(0, data.numel() - block - 1, (batch,), generator=g)
+    x = torch.stack([data[i:i + block] for i in ix]).long().to(device)
+    y = torch.stack([data[i + 1:i + block + 1] for i in ix]).long().to(device)
+    return x, y
+
+
+# -------------------------------------------------------------------- train/smoke
+def train(arms=("sdpa", "hub", "addr_head"), steps: int = 2000, batch: int = 32,
+          block: int = 256, device: str = "cuda", data_root: str = "./data",
+          seed: int = 0, eval_every: int = 500, save: bool = True):
+    """Verdict run — GPU only. Pure Adam wd=0. Reports val bits-per-byte + vitals.
+    save=True writes {data_root}/ar_ckpts/{arm}_s{seed}_t{steps}.pt per arm —
+    the cultivated codebooks are SPECIMENS for the projective reading instruments."""
+    import os
+    if device == "cuda" and not torch.cuda.is_available():
+        raise RuntimeError("Verdict runs are GPU-only (never CPU-train for accuracy).")
+    ckpt_dir = os.path.join(data_root, "ar_ckpts")
+    os.makedirs(ckpt_dir, exist_ok=True)
+    tr, va = _wikitext_bytes(data_root)
+    print(f"data ready: train {tr.numel():,} bytes, val {va.numel():,} bytes", flush=True)
+    results = {}
+    for arm in arms:
+        torch.manual_seed(seed)
+        g = torch.Generator().manual_seed(seed)
+        model = ByteLM(arm, block=block).to(device)
+        n_params = sum(p.numel() for p in model.parameters())
+        opt = torch.optim.Adam(model.parameters(), lr=3e-4, weight_decay=0.0)
+        for step in range(1, steps + 1):
+            x, y = _batch(tr, batch, block, device, g)
+            logits = model(x)
+            loss = F.cross_entropy(logits.reshape(-1, VOCAB), y.reshape(-1))
+            opt.zero_grad(set_to_none=True)
+            loss.backward()
+            opt.step()
+            if step % eval_every == 0 or step == steps:
+                model.eval()
+                with torch.no_grad():
+                    losses = []
+                    for _ in range(20):
+                        xv, yv = _batch(va, batch, block, device, g)
+                        lv = F.cross_entropy(model(xv).reshape(-1, VOCAB),
+                                             yv.reshape(-1))
+                        losses.append(lv.item())
+                bpb = sum(losses) / len(losses) / math.log(2)
+                print(f"[{arm}] step {step} val_bpb={bpb:.4f} vitals={model.vitals()}",
+                      flush=True)
+                model.train()
+        results[arm] = {"val_bpb": bpb, "params": n_params, "vitals": model.vitals()}
+        if save:
+            path = os.path.join(ckpt_dir, f"{arm}_s{seed}_t{steps}.pt")
+            torch.save({"arm": arm, "seed": seed, "steps": steps, "val_bpb": bpb,
+                        "state_dict": {k: v.cpu() for k, v in
+                                       model.state_dict().items()}}, path)
+            print(f"saved specimen: {path}", flush=True)
+    print(results, flush=True)
+    return results
+
+
+def smoke():
+    """Shapes/parse only — no accuracy claims."""
+    x = torch.randint(0, VOCAB, (2, 64))
+    for arm in ("sdpa", "hub", "addr_head"):
+        m = ByteLM(arm, d=96, layers=2, block=64, K=16)
+        logits = m(x)
+        assert logits.shape == (2, 64, VOCAB)
+        logits.sum().backward()
+        # causality check: future byte must not affect past logits
+        with torch.no_grad():
+            a = m(x)[0, 10]
+            x2 = x.clone(); x2[0, 40] = (x2[0, 40] + 7) % 256
+            b = m(x2)[0, 10]
+        assert torch.allclose(a, b, atol=1e-4), f"{arm} leaks future context"
+        print(f"{arm}: OK params={sum(p.numel() for p in m.parameters()):,} "
+              f"vitals={m.vitals()}", flush=True)
+    print("OK — AR bed smoke passed (verdict run: train() on GPU)", flush=True)
+
+
+def _in_notebook() -> bool:
+    try:
+        get_ipython()  # type: ignore[name-defined]  # noqa: F821
+        return True
+    except NameError:
+        return False
+
+
+if __name__ == "__main__":
+    if _in_notebook():
+        smoke()
+        print("Notebook mode: call  train(steps=2000)  in the next cell (GPU).")
+    else:
+        import argparse
+        ap = argparse.ArgumentParser()
+        ap.add_argument("--train", action="store_true")
+        ap.add_argument("--steps", type=int, default=2000)
+        a, _ = ap.parse_known_args()
+        train(steps=a.steps) if a.train else smoke()

exp018_r12/build_results.py

@@ -0,0 +1,36 @@
+"""build_results.py — exp018_r12: read results/ledger.jsonl and RE-ASSERT every
+claim in the README. Run from inside this folder: python build_results.py
+"""
+import json
+import os
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+rows = [json.loads(l) for l in
+        open(os.path.join(HERE, "results", "ledger.jsonl"), encoding="utf-8")]
+assert all(r["exp"] == "18" for r in rows) and len(rows) == 8
+cell = {(r["arm"], r["seed"]): r for r in rows}
+CERT_BAND = (2.43, 2.50)     # exp012 certified: 3-seed mean 2.469, s0 bed 2.4990
+
+# claim 1: both init avenues land inside the certified band, both seeds
+for arm in ("penta_init", "farmed_init"):
+    for s in (0, 1):
+        assert CERT_BAND[0] < cell[(arm, s)]["bpb"] < CERT_BAND[1], (arm, s)
+
+# claim 2: the farmed codebook drifts LESS than the pentachoron init (maturity
+# = stationarity), both seeds — and neither accelerates
+for s in (0, 1):
+    assert cell[("farmed_init", s)]["drift"] < cell[("penta_init", s)]["drift"]
+
+# claim 3: the tied M_hat readout fails in AR (+1.0 bpb) and starves the
+# codebook (drift ~0.02, binding 0), both seeds, with or without penta init
+for arm in ("tied", "keystone"):
+    for s in (0, 1):
+        r = cell[(arm, s)]
+        assert r["bpb"] > 3.4 and r["drift"] < 0.03 and r["binding_frac"] == 0.0
+
+out = {f"{a}_s{s}": {"bpb": cell[(a, s)]["bpb"], "drift": cell[(a, s)]["drift"]}
+       for (a, s) in sorted(cell)}
+json.dump(out, open(os.path.join(HERE, "results", "results.json"), "w",
+                    encoding="utf-8"), indent=1)
+print(f"{len(rows)} rows -> results/results.json")
+print("all README claims asserted OK")

exp018_r12/exp014_genetic_distillation.py

@@ -0,0 +1,515 @@
+"""exp014_genetic_distillation.py — genetic distillation + memory substrate.
+14_a: multi-generational tournament (GM3 paradigm) where the aleph codebook is the
+      explicit heritable genome. Lineages: ALEPH-FLAT (consensus book + KD) |
+      ALEPH-TREE (structured genome: root book + branch books) | MLP-KD
+      (traditional: best-parent weights + KD) | NO-INHERIT (evolution floor).
+      Both sides intentionally inherit logits (KD); only ours inherits geometry.
+      Consensus = Procrustes/GPA alignment of parents' books to mean shape
+      (placement by construction — replaces GM3's k-means-on-consensus init).
+14_b: memory substrate — the D=4 home makes books size-agnostic. Implant books
+      cultivated in a small organism into a larger one (frozen / trainable), and
+      into GPT-2 relay adapters (cross-architecture frozen distillation).
+
+Riders: pure Adam wd=0; KD = KL to detached teacher probs (predictive pressure, no
+contrastive); tree routing is DENSE SOFT (oriented weights; collapse monitor on the
+root); drift-check precedes every freeze claim; GPU-only verdict runs; Colab-safe.
+Founders share a COMMON-ANCESTOR book so GPA row correspondence is inherited.
+
+Colab paste order: geolip_vitals.py -> ar_differentiation_bed.py ->
+exp013_augmentation_bed.py (only for run_b2) -> this file.
+"""
+from __future__ import annotations
+import copy
+import json
+import math
+import os
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+if "anchor_drift" not in globals():
+    try:
+        from geolip_vitals import anchor_drift, axis_aliveness, path_diversity
+    except ImportError:
+        _here = globals().get("__file__")
+        if _here is None:
+            raise ImportError("paste/run geolip_vitals.py first")
+        import sys, pathlib
+        sys.path.insert(0, str(pathlib.Path(_here).parent))
+        from geolip_vitals import anchor_drift, axis_aliveness, path_diversity
+if "ByteLM" not in globals():
+    try:
+        from ar_differentiation_bed import (ByteLM, AlephAddress, _wikitext_bytes,
+                                            _batch, VOCAB)
+    except ImportError:
+        raise ImportError("paste/run ar_differentiation_bed.py first")
+
+DATA_ROOT = os.environ.get("GEOLIP_DATA", "./data")
+EXP_DIR = os.path.join(DATA_ROOT, "exp014")
+
+
+class SquaredReLU(nn.Module):
+    def forward(self, x):
+        return F.relu(x) ** 2
+
+
+# ===================================================== consensus (the germline) ===
+@torch.no_grad()
+def procrustes_rotation(A: torch.Tensor, M: torch.Tensor) -> torch.Tensor:
+    """Orthogonal R minimizing ||A R - M||_F (rows correspond)."""
+    U, _, Vt = torch.linalg.svd(A.T.double() @ M.double())
+    return (U @ Vt).float()
+
+
+@torch.no_grad()
+def align_to(A: torch.Tensor, ref: torch.Tensor, iters: int = 20) -> torch.Tensor:
+    """Projective Procrustes (rows correspond, signs free): alternate the
+    orthogonal rotation and per-row sign flips (books live on RP^(D-1))."""
+    s = torch.ones(A.shape[0], 1)
+    for _ in range(iters):
+        R = procrustes_rotation(s * A, ref)
+        AR = (s * A) @ R
+        s_upd = torch.where((AR * ref).sum(-1, keepdim=True) < 0, -s, s)
+        if torch.equal(s_upd, s):
+            return AR
+        s = s_upd
+    return (s * A) @ procrustes_rotation(s * A, ref)
+
+
+@torch.no_grad()
+def consensus_codebook(books: list, iters: int = 50, tol: float = 1e-8):
+    """GPA to mean shape (GM3 machinery, applied to aleph books), anchored to the
+    FIRST parent's frame. Rows must correspond (common-ancestor convention); signs
+    are projective. Returns (consensus, n_iters, delta)."""
+    # device-pin to CPU: parent models may live on CUDA after KD teacher moves
+    Bs = [F.normalize(b.detach().float().cpu(), dim=-1).clone() for b in books]
+    # pairwise projective alignment to parent-0's frame, THEN GPA refinement
+    aligned = [Bs[0]] + [align_to(b, Bs[0]) for b in Bs[1:]]
+    M = F.normalize(torch.stack(aligned).mean(0), dim=-1)
+    delta, it = 0.0, 0
+    for it in range(1, iters + 1):
+        aligned = [align_to(b, M) for b in Bs]
+        M_new = F.normalize(torch.stack(aligned).mean(0), dim=-1)
+        delta = (M_new - M).norm().item()
+        M = M_new
+        if delta < tol:
+            break
+    # re-anchor to parent-0 (GPA drift of the global frame stays measurable)
+    M = align_to(M, Bs[0])
+    return M, it, delta
+
+
+@torch.no_grad()
+def implant_book(addr: "AlephAddress", book: torch.Tensor, trainable: bool = True):
+    """Load a book into an AlephAddress: codebook + home (drift measured from the
+    implant). Freeze only via trainable=False AFTER a drift-check justifies it."""
+    b = F.normalize(book.float(), dim=-1).to(addr.codebook.device)
+    assert b.shape == addr.codebook.shape, (b.shape, addr.codebook.shape)
+    addr.codebook.data.copy_(b)
+    addr.home.copy_(b)
+    addr.codebook.requires_grad_(trainable)
+
+
+# ============================================================= tree head ==========
+class TreeHead(nn.Module):
+    """Autoregressive tree (the constellation-anchor analogue, exp011 TREE operator
+    in the healthy consumption regime): a ROOT aleph (K=2, D=4) yields the 4
+    oriented weights (2K half-axes = the 4 branches, dense soft, sums to 1);
+    each BRANCH is a 64-slot... shared slot projection read by a branch-specific
+    book (K=64, D=4); output = branch-weighted mixture of branch reads -> vocab.
+    Heritable genome: root book (2,4) + 4 branch books (64,4)."""
+
+    ROOT_SLOTS = 4          # slot-parallel root consumption (the collapse cure)
+    ROOT_TAU = 0.3          # softer root temperature (wave-1 fix: single hard-tau
+                            # root partially collapsed, usage [.85,.12,.01,.02])
+
+    def __init__(self, d: int, vocab: int = 256, n_slots: int = 16):
+        super().__init__()
+        self.n_slots = n_slots
+        self.root_proj = nn.Linear(d, self.ROOT_SLOTS * 4, bias=False)
+        self.slot_proj = nn.Linear(d, n_slots * 4, bias=False)
+        nn.init.orthogonal_(self.root_proj.weight)
+        nn.init.orthogonal_(self.slot_proj.weight)
+        self.root = AlephAddress(2, 4, tau=self.ROOT_TAU)
+        self.branches = nn.ModuleList([AlephAddress(64, 4) for _ in range(4)])
+        self.out = nn.Linear(n_slots * 4, vocab, bias=True)
+        self._last_root = None
+
+    def forward(self, h):
+        B, n, _ = h.shape
+        rs = self.root_proj(h).view(B, n, self.ROOT_SLOTS, 4)
+        p, m = self.root.oriented(rs)                      # (B,n,S,2) x2
+        w = torch.cat([p, m], dim=-1).mean(dim=-2)          # slot-avg -> (B,n,4)
+        self._last_root = w.detach()
+        slots = self.slot_proj(h).view(B, n, self.n_slots, 4)
+        mix = 0
+        for b, br in enumerate(self.branches):
+            mix = mix + w[..., b:b + 1] * br.m_hat(slots).reshape(B, n, -1)
+        return self.out(mix)
+
+    def genome(self):
+        return {"root": self.root.codebook.detach().clone(),
+                **{f"branch{i}": br.codebook.detach().clone()
+                   for i, br in enumerate(self.branches)}}
+
+    @torch.no_grad()
+    def inherit(self, genomes: list):
+        c, it, dl = consensus_codebook([g["root"] for g in genomes])
+        implant_book(self.root, c)
+        for i, br in enumerate(self.branches):
+            c, _, _ = consensus_codebook([g[f"branch{i}"] for g in genomes])
+            implant_book(br, c)
+
+    @torch.no_grad()
+    def vitals(self):
+        out = {"root_drift": round(anchor_drift(self.root.codebook,
+                                                self.root.home)["mean"], 4)}
+        if self._last_root is not None:
+            w = self._last_root.reshape(-1, 4)
+            usage = w.mean(0)
+            usage = usage / usage.sum()
+            out["root_usage"] = [round(float(u), 3) for u in usage]
+            ent = -(usage.clamp_min(1e-9) * usage.clamp_min(1e-9).log()).sum()
+            out["root_ppl4"] = round(float(ent.exp()), 3)
+        d = [anchor_drift(br.codebook, br.home)["mean"] for br in self.branches]
+        out["branch_drift"] = [round(x, 3) for x in d]
+        return out
+
+
+# ============================================================ organisms ===========
+def make_organism(lineage: str, d: int = 192, layers: int = 4, block: int = 256,
+                  seed: int = 0):
+    """lineage in {aleph_flat, aleph_tree, mlp_kd, no_inherit}. no_inherit uses the
+    aleph_flat architecture (the control isolates INHERITANCE, not architecture)."""
+    torch.manual_seed(seed)
+    if lineage in ("aleph_flat", "no_inherit", "aleph_full", "aleph_weights"):
+        return ByteLM("addr_msl64", d=d, layers=layers, block=block)
+    if lineage == "aleph_tree":
+        m = ByteLM("sdpa", d=d, layers=layers, block=block)
+        m.head = TreeHead(d)
+        return m
+    if lineage == "mlp_kd":
+        m = ByteLM("sdpa", d=d, layers=layers, block=block)
+        m.head = nn.Sequential(nn.Linear(d, 224), SquaredReLU(),
+                               nn.LayerNorm(224), nn.Linear(224, VOCAB))
+        return m
+    raise ValueError(lineage)
+
+
+def genome_of(model):
+    """The heritable organ = co-adapted (projection, book) pair(s). Books inherit
+    by CONSENSUS (the geometric germline); projections inherit from the BEST
+    parent (weight copy) — implanting a book against a random projection puts the
+    child below random init (campaign-v2 lesson)."""
+    if isinstance(model.head, TreeHead):
+        g = model.head.genome()
+        g["root_proj"] = model.head.root_proj.weight.detach().cpu().clone()
+        g["slot_proj"] = model.head.slot_proj.weight.detach().cpu().clone()
+        return g
+    if hasattr(model, "head_addr"):
+        return {"flat": model.head_addr.codebook.detach().cpu().clone(),
+                "proj": model.head_proj.weight.detach().cpu().clone()}
+    return None
+
+
+@torch.no_grad()
+def inherit_genome(model, genomes: list):
+    """genomes[0] = the BEST parent (selection order matters)."""
+    if isinstance(model.head, TreeHead):
+        model.head.inherit(genomes)
+        model.head.root_proj.weight.copy_(genomes[0]["root_proj"].to(
+            model.head.root_proj.weight.device))
+        model.head.slot_proj.weight.copy_(genomes[0]["slot_proj"].to(
+            model.head.slot_proj.weight.device))
+    elif hasattr(model, "head_addr"):
+        c, it, dl = consensus_codebook([g["flat"] for g in genomes])
+        implant_book(model.head_addr, c)
+        model.head_proj.weight.copy_(genomes[0]["proj"].to(
+            model.head_proj.weight.device))
+
+
+def organism_vitals(model):
+    if isinstance(model.head, TreeHead):
+        return model.head.vitals()
+    return model.vitals() if hasattr(model, "vitals") else {}
+
+
+# ========================================================= train one member ======
+def train_member(model, tr, va, steps=2000, batch=32, block=256, device="cuda",
+                 seed=0, teachers=None, kd_alpha=1.0):
+    """CE (+ KL to detached mean teacher probs when teachers given). Pure Adam."""
+    g = torch.Generator().manual_seed(seed)
+    model = model.to(device)
+    opt = torch.optim.Adam(model.parameters(), lr=3e-4, weight_decay=0.0)
+    if teachers:
+        teachers = [t.to(device).eval() for t in teachers]
+    for step in range(1, steps + 1):
+        x, y = _batch(tr, batch, block, device, g)
+        logits = model(x)
+        loss = F.cross_entropy(logits.reshape(-1, VOCAB), y.reshape(-1))
+        if teachers:
+            with torch.no_grad():
+                tp = torch.stack([F.softmax(t(x), -1) for t in teachers]).mean(0)
+            loss = loss + kd_alpha * F.kl_div(
+                F.log_softmax(logits, -1), tp, reduction="batchmean")
+        opt.zero_grad(set_to_none=True); loss.backward(); opt.step()
+    model.eval()
+    with torch.no_grad():
+        ls = []
+        for _ in range(20):
+            xv, yv = _batch(va, batch, block, device, g)
+            ls.append(F.cross_entropy(model(xv).reshape(-1, VOCAB),
+                                      yv.reshape(-1)).item())
+    return sum(ls) / len(ls) / math.log(2)          # bpb
+
+
+# ============================================================ the tournament ======
+def run_tournament(lineage: str, gens: int = 4, pop: int = 4, steps: int = 2000,
+                   seed: int = 0, device: str = "cuda",
+                   catastrophic_at: int | None = None):
+    """One lineage, one tournament seed. Logs per-gen to the ledger; saves the
+    champion genome per generation. catastrophic_at=G injects a 0-step random
+    parent into the consensus at generation G (the GM3 robustness probe)."""
+    if not torch.cuda.is_available():
+        raise RuntimeError("verdict runs are GPU-only")
+    os.makedirs(EXP_DIR, exist_ok=True)
+    tr, va = _wikitext_bytes(DATA_ROOT)
+    ledger = open(os.path.join(EXP_DIR, "ledger.jsonl"), "a", encoding="utf-8")
+    # common ancestor: every founder book starts identical within a tournament
+    torch.manual_seed(9000 + seed)
+    ancestor = make_organism(lineage, seed=9000 + seed)
+    anc_genome = genome_of(ancestor)
+    parents, parent_models, champion_genomes = [], [], []
+    for gen in range(gens):
+        members = []
+        for i in range(pop):
+            mseed = seed * 1000 + gen * 100 + i
+            m = make_organism(lineage, seed=mseed)
+            if anc_genome and gen == 0:
+                inherit_genome(m, [anc_genome])            # common ancestor
+            if gen > 0:
+                is_fresh = (i == pop - 1)                   # gene flow founder
+                if not is_fresh:
+                    if lineage in ("aleph_flat", "aleph_tree"):
+                        gs = [genome_of(pm) for pm in parent_models]
+                        if catastrophic_at == gen:
+                            bad = make_organism(lineage, seed=666 + i)
+                            gs = gs + [genome_of(bad)]
+                        inherit_genome(m, gs)
+                    elif lineage == "aleph_full":
+                        # v4 arm (v3 lesson: continuity is what pays) — inherit the
+                        # WHOLE best parent, then overwrite the book with the
+                        # two-parent consensus: germline ON TOP of continuity.
+                        m.load_state_dict(copy.deepcopy(
+                            parent_models[0].state_dict()))
+                        gs = [genome_of(pm) for pm in parent_models]
+                        if catastrophic_at == gen:
+                            bad = make_organism(lineage, seed=666 + i)
+                            gs = gs + [genome_of(bad)]
+                        c, _, _ = consensus_codebook([g["flat"] for g in gs])
+                        implant_book(m.head_addr, c)
+                    elif lineage in ("mlp_kd", "aleph_weights"):
+                        # pure continuity (no germline op) — aleph_weights is the
+                        # within-architecture control for aleph_full
+                        m.load_state_dict(copy.deepcopy(
+                            parent_models[0].state_dict()))
+                    # no_inherit: nothing
+            # KD: alpha 0.25 (campaign-v2 lesson: alpha=1.0 from near-parity
+            # teachers COMPOUNDS DOWNWARD — inverse evolution; fresh-founder
+            # control isolated it). Fresh founders get NO KD (clean gene flow).
+            is_fresh_now = (gen > 0 and i == pop - 1)
+            teachers = parent_models if (gen > 0 and not is_fresh_now
+                                          and lineage != "no_inherit") else None
+            bpb = train_member(m, tr, va, steps=steps, device=device,
+                               seed=mseed, teachers=teachers, kd_alpha=0.25)
+            vit = organism_vitals(m)
+            members.append((bpb, m))
+            rec = {"exp": "14a", "lineage": lineage, "tseed": seed, "gen": gen,
+                   "member": i, "fresh": gen > 0 and i == pop - 1,
+                   "catastrophic": catastrophic_at == gen, "bpb": round(bpb, 4),
+                   "vitals": vit}
+            ledger.write(json.dumps(rec) + "\n"); ledger.flush()
+            print(f"[14a {lineage} t{seed} g{gen} m{i}] bpb={bpb:.4f} {vit}",
+                  flush=True)
+        members.sort(key=lambda t: t[0])
+        parent_models = [members[0][1].cpu(), members[1][1].cpu()]
+        best = members[0][0]
+        gene = genome_of(members[0][1])
+        if gene:
+            torch.save(gene, os.path.join(
+                EXP_DIR, f"champion_{lineage}_t{seed}_g{gen}.pt"))
+            champion_genomes.append(gene)
+        print(f"[14a {lineage} t{seed} g{gen}] BEST={best:.4f} "
+              f"mean={sum(b for b, _ in members)/pop:.4f}", flush=True)
+        for _, mm in members[2:]:
+            del mm
+        torch.cuda.empty_cache()
+    ledger.close()
+    return best
+
+
+# ============================================================ 14_b implants ======
+def run_b1(steps: int = 2000, seed: int = 0, device: str = "cuda",
+           donor_book: torch.Tensor | None = None, tag: str = "small_cultivated"):
+    """Cross-size: donor book (default: cultivate in a small organism) implanted
+    into a LARGE organism. Arms: fresh | implant-trainable | implant-frozen | mlp."""
+    if not torch.cuda.is_available():
+        raise RuntimeError("verdict runs are GPU-only")
+    os.makedirs(EXP_DIR, exist_ok=True)
+    tr, va = _wikitext_bytes(DATA_ROOT)
+    ledger = open(os.path.join(EXP_DIR, "ledger.jsonl"), "a", encoding="utf-8")
+    if donor_book is None:
+        small = make_organism("aleph_flat", d=128, layers=2, seed=seed)
+        bpb_small = train_member(small, tr, va, steps=steps, device=device, seed=seed)
+        donor_book = genome_of(small)["flat"]
+        print(f"[14b donor small] bpb={bpb_small:.4f}", flush=True)
+    results = {}
+    for arm in ("fresh", "implant_train", "implant_frozen", "mlp"):
+        lineage = "mlp_kd" if arm == "mlp" else "aleph_flat"
+        m = make_organism(lineage, d=384, layers=6, seed=seed + 10)
+        if arm.startswith("implant"):
+            implant_book(m.head_addr, donor_book, trainable=(arm == "implant_train"))
+        bpb = train_member(m, tr, va, steps=steps, device=device, seed=seed + 10)
+        vit = organism_vitals(m)
+        results[arm] = {"bpb": round(bpb, 4), "vitals": vit}
+        rec = {"exp": "14b1", "arm": arm, "donor": tag, "seed": seed,
+               "bpb": round(bpb, 4), "vitals": vit}
+        ledger.write(json.dumps(rec) + "\n"); ledger.flush()
+        print(f"[14b1 {arm} donor={tag}] bpb={bpb:.4f} {vit}", flush=True)
+        del m; torch.cuda.empty_cache()
+    ledger.close()
+    return results, donor_book
+
+
+def run_b2(donor_book: torch.Tensor, steps: int = 1500, seed: int = 0,
+           device: str = "cuda", tag: str = "small_cultivated"):
+    """Cross-architecture: implant the donor book into every GPT-2 relay adapter
+    (exp013 Track C bed) vs random-init relays. Books are (64,4) — size-agnostic."""
+    from exp013_augmentation_bed import _wikitext_lines
+    from transformers import GPT2LMHeadModel, GPT2TokenizerFast
+    if "MslRelay" not in globals():
+        from ar_differentiation_bed import MslRelay
+    from exp013_augmentation_bed import _BlockWithAdapter
+    tok = GPT2TokenizerFast.from_pretrained("gpt2")
+    tr_lines, va_lines = _wikitext_lines(DATA_ROOT)
+    stream_tr = tok("\n\n".join(tr_lines[:8000]), return_tensors="pt").input_ids[0]
+    stream_va = tok("\n\n".join(va_lines[:1000]), return_tensors="pt").input_ids[0]
+    ledger = open(os.path.join(EXP_DIR, "ledger.jsonl"), "a", encoding="utf-8")
+    out = {}
+    for arm in ("random_relays", "implanted_relays"):
+        torch.manual_seed(seed)
+        g = torch.Generator().manual_seed(seed)
+        model = GPT2LMHeadModel.from_pretrained("gpt2").to(device)
+        for p in model.parameters():
+            p.requires_grad_(False)
+        adapters = []
+        for i, blk in enumerate(model.transformer.h):
+            ad = MslRelay(model.config.n_embd).to(device)
+            if arm == "implanted_relays":
+                implant_book(ad.addr, donor_book, trainable=True)
+            model.transformer.h[i] = _BlockWithAdapter(blk, ad)
+            adapters.append(ad)
+        params = [p for ad in adapters for p in ad.parameters()
+                  if p.requires_grad]
+        opt = torch.optim.Adam(params, lr=1e-3, weight_decay=0.0)
+        block = 256
+        for step in range(1, steps + 1):
+            ix = torch.randint(0, stream_tr.numel() - block - 1, (8,), generator=g)
+            x = torch.stack([stream_tr[i:i + block] for i in ix]).to(device)
+            loss = model(x, labels=x).loss
+            opt.zero_grad(set_to_none=True); loss.backward(); opt.step()
+        model.eval()
+        with torch.no_grad():
+            ls = []
+            for j in range(0, stream_va.numel() - block - 1, block * 4):
+                x = stream_va[j:j + block].unsqueeze(0).to(device)
+                ls.append(model(x, labels=x).loss.item())
+        ppl = math.exp(sum(ls) / len(ls))
+        gates = [round(ad.gate.sigmoid().item(), 4) for ad in adapters]
+        drifts = [round(anchor_drift(ad.addr.codebook, ad.addr.home)["mean"], 3)
+                  for ad in adapters]
+        out[arm] = {"ppl": round(ppl, 3), "gates": gates, "drift": drifts}
+        rec = {"exp": "14b2", "arm": arm, "donor": tag, "seed": seed,
+               "ppl": round(ppl, 3), "gates": gates, "drift": drifts}
+        ledger.write(json.dumps(rec) + "\n"); ledger.flush()
+        print(f"[14b2 {arm} donor={tag}] ppl={ppl:.3f} gates={gates[:3]}.. "
+              f"drift={drifts[:3]}..", flush=True)
+        del model; torch.cuda.empty_cache()
+    ledger.close()
+    return out
+
+
+# ================================================================ smoke ===========
+def smoke():
+    """CPU shapes/parse only: GPA ground truth, tree causality, implant, KD path."""
+    g = torch.Generator().manual_seed(0)
+    # GPA: two rotated (+row-sign-flipped) copies of one book must align back to it
+    A = F.normalize(torch.randn(64, 4, generator=g), dim=-1)
+    q, _ = torch.linalg.qr(torch.randn(4, 4, generator=g))
+    B = A @ q
+    B[::3] = -B[::3]
+    C, it, dl = consensus_codebook([A, B])
+    cos = (F.normalize(C, dim=-1) * A).sum(-1).abs().mean()
+    assert cos > 0.999, cos
+    print(f"GPA OK (iters={it}, delta={dl:.2e}, |cos to truth|={cos:.5f})")
+    x = torch.randint(0, 256, (2, 64))
+    for lineage in ("aleph_flat", "aleph_tree", "mlp_kd", "no_inherit"):
+        m = make_organism(lineage, d=96, layers=2, block=64, seed=0)
+        lg = m(x); assert lg.shape == (2, 64, 256); lg.sum().backward()
+        with torch.no_grad():
+            a = m(x)[0, 10]; x2 = x.clone(); x2[0, 40] = (x2[0, 40] + 7) % 256
+            b = m(x2)[0, 10]
+        assert torch.allclose(a, b, atol=1e-4), lineage + " leaks"
+        gnm = genome_of(m)
+        if gnm:
+            inherit_genome(m, [gnm, gnm])       # self-consensus = identity-ish
+        print(lineage, "OK params",
+              f"{sum(p.numel() for p in m.parameters()):,}",
+              organism_vitals(m) if lineage != "mlp_kd" else {})
+    # KD path: teacher forward + KL backward
+    t = make_organism("mlp_kd", d=96, layers=2, block=64, seed=1)
+    s = make_organism("aleph_flat", d=96, layers=2, block=64, seed=2)
+    tp = F.softmax(t(x), -1).detach()
+    loss = F.kl_div(F.log_softmax(s(x), -1), tp, reduction="batchmean")
+    loss.backward()
+    print("KD OK — exp014 smoke passed (tournament on GPU: run_tournament(...))")
+
+
+def _in_notebook():
+    try:
+        get_ipython()  # type: ignore[name-defined]  # noqa: F821
+        return True
+    except NameError:
+        return False
+
+
+if __name__ == "__main__":
+    if _in_notebook():
+        smoke()
+        print("Notebook: run_tournament('aleph_flat'), run_b1(), run_b2(book).")
+    else:
+        import argparse
+        ap = argparse.ArgumentParser()
+        ap.add_argument("--mode", default="smoke",
+                        choices=["smoke", "tournament", "b1", "b2"])
+        ap.add_argument("--lineage", default="aleph_full",
+                        help="tournament lineage: aleph_flat|aleph_full|"
+                             "aleph_weights|aleph_tree|mlp_kd|no_inherit")
+        ap.add_argument("--seed", type=int, default=0)
+        ap.add_argument("--steps", type=int, default=2000)
+        ap.add_argument("--genome", default="genomes/champion_aleph_full_t0_g3.pt",
+                        help="donor genome .pt for --mode b1/b2 (uses its 'flat' book)")
+        a, _ = ap.parse_known_args()
+        if a.mode == "smoke":
+            smoke()
+        elif a.mode == "tournament":
+            run_tournament(a.lineage, steps=a.steps, seed=a.seed)
+        elif a.mode == "b1":
+            donor = (torch.load(a.genome, map_location="cpu")["flat"]
+                     if os.path.exists(a.genome) else None)
+            run_b1(steps=a.steps, seed=a.seed, donor_book=donor,
+                   tag=os.path.basename(a.genome) if donor is not None
+                   else "small_cultivated")
+        elif a.mode == "b2":
+            donor = torch.load(a.genome, map_location="cpu")["flat"]
+            run_b2(donor, seed=a.seed, tag=os.path.basename(a.genome))

exp018_r12/exp018_reran12.py

@@ -0,0 +1,176 @@
+"""exp018_reran12.py — EXPERIMENT 18: exp012 RERUN with the keystone aleph model
+parameters (exp012 and its certified record stay untouched — this is a labeled
+rerun, not a replacement). A process review found the exp012 bed's AlephAddress
+primitive faithful to the keystone (per the aleph-void article) but two keystone avenues
+never exercised: the caller-supplied FARMED/PENTACHORON codebook init and the
+TIED M_hat readout (U=M_hat, S=Omega-token, Vt=I). This rerun exercises them on the
+certified bed, unchanged otherwise (d=192, 4 layers, wikitext-2 bytes, 2000
+steps, pure Adam wd=0, addr_msl64 multi-slot base).
+
+Arms (x2 seeds):
+  penta_init  — codebook initialized from geovocab2 REGULAR PENTACHORON
+                vertices (13 randomly-rotated regular 4-simplices -> 64 rows on
+                S^3, row-normalized; SimplexFactory is the source per keystone
+                "geovocab pentachoron vertices"). Free linear head (isolates
+                the init).
+  farmed_init — codebook initialized from a FARMED recon-real book: the exp012
+                certified specimen addr_msl64_s0_t2000's trained codebook —
+                anchors the M_hat gradient itself produced. Free linear head.
+                (The direct "farm FROM the aleph logit structure" arm.)
+  tied        — random init + TIED readout: zero-parameter head; logits =
+                M_hat_slots @ head_proj.weight @ emb.weight^T (decode tied back
+                through the encoder projection and the byte embedding — the
+                AR form of the keystone's tied linear off M_hat).
+  keystone    — penta_init + tied (the keystone-faithful configuration).
+Baselines (exp012 certified, cited not rerun): addr_msl64 2.469 / sdpa 2.518
+(3-seed means @2k); certified bed reproduction 2.4990 (s0).
+Riders: pure Adam wd=0; GPU-only verdicts; >=2 seeds; drift-check before any
+freeze claim; Colab-safe. Paste order: geolip_vitals ->
+ar_differentiation_bed -> exp014_genetic_distillation -> this file.
+"""
+from __future__ import annotations
+import json
+import os
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+if "ByteLM" not in globals():
+    try:
+        from ar_differentiation_bed import ByteLM, _wikitext_bytes
+        from exp014_genetic_distillation import train_member, implant_book
+        from geolip_vitals import anchor_drift
+    except ImportError:
+        _here = globals().get("__file__")
+        if _here is None:
+            raise ImportError("paste geolip_vitals + ar_differentiation_bed + "
+                              "exp014_genetic_distillation first")
+        import sys, pathlib
+        sys.path.insert(0, str(pathlib.Path(_here).parent))
+        from ar_differentiation_bed import ByteLM, _wikitext_bytes
+        from exp014_genetic_distillation import train_member, implant_book
+        from geolip_vitals import anchor_drift
+
+DATA_ROOT = os.environ.get("GEOLIP_DATA", "./data")
+RERUN_DIR = os.path.join(DATA_ROOT, "exp018")
+FARMED_SPECIMEN = os.environ.get(
+    "GEOLIP_FARMED_SPECIMEN",
+    os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "exp012_ar",
+                 "specimens", "addr_msl64_s0_t2000.pt"))
+
+
+def pentachoron_book(K: int = 64, seed: int = 0) -> torch.Tensor:
+    """K rows on S^3 from geovocab2 regular pentachoron vertices: ceil(K/5)
+    regular 4-simplices, each rotated by a seeded random SO(4), stacked and
+    row-normalized. The keystone's 'geovocab pentachoron vertices' init."""
+    from geovocab2.shapes.factory.simplex_factory import SimplexFactory
+    g = torch.Generator().manual_seed(seed)
+    # the factory's regular construction lives in k+1 = 5 dims; center it and
+    # project isometrically onto its rank-4 subspace (SVD) -> exact regular
+    # pentachoron in R^4 (pairwise cos = -1/4 on the sphere)
+    fac = SimplexFactory(k=4, embed_dim=5, method="regular")
+    base5 = fac.build_torch().double()                         # (5, 5)
+    base5 = base5 - base5.mean(dim=0, keepdim=True)
+    _, _, Vt = torch.linalg.svd(base5, full_matrices=False)
+    base = (base5 @ Vt[:4].T).float()                          # (5, 4) regular
+    rows = []
+    for _ in range((K + 4) // 5):
+        q, _ = torch.linalg.qr(torch.randn(4, 4, generator=g, dtype=torch.float64))
+        rows.append((base.double() @ q).float())
+    book = torch.cat(rows)[:K]
+    return F.normalize(book, dim=-1)
+
+
+def farmed_book() -> torch.Tensor:
+    """The exp012 certified specimen's trained codebook — anchors farmed by the
+    M_hat recon/CE gradient itself (recon-real by construction)."""
+    ck = torch.load(FARMED_SPECIMEN, map_location="cpu", weights_only=True)
+    return F.normalize(ck["state_dict"]["head_addr.codebook"].float(), dim=-1)
+
+
+class TiedReadout(nn.Module):
+    """Zero-parameter tied decode: M_hat slots -> back through the encoder
+    projection -> byte-embedding transpose. Gradients flow into head_proj and
+    emb through both encode and decode paths (the tie)."""
+
+    def __init__(self, head_proj: nn.Linear, emb: nn.Embedding):
+        super().__init__()
+        self._proj = [head_proj]           # references, not submodules
+        self._emb = [emb]
+
+    def forward(self, feats):              # feats (..., P*4) = M_hat per slot
+        h = feats @ self._proj[0].weight   # (P*4, d) -> (..., d)
+        return h @ self._emb[0].weight.T   # (..., VOCAB)
+
+
+def make_rerun_model(arm: str, seed: int = 0, d: int = 192, layers: int = 4,
+                        block: int = 256):
+    torch.manual_seed(seed)
+    m = ByteLM("addr_msl64", d=d, layers=layers, block=block)
+    if arm in ("penta_init", "keystone"):
+        implant_book(m.head_addr, pentachoron_book(64, seed=seed))
+    elif arm == "farmed_init":
+        implant_book(m.head_addr, farmed_book())
+    if arm in ("tied", "keystone"):
+        m.head = TiedReadout(m.head_proj, m.emb)
+    return m
+
+
+def run_rerun(arms=("penta_init", "farmed_init", "tied", "keystone"),
+              seeds=(0, 1), steps=2000, device="cuda"):
+    if not torch.cuda.is_available():
+        raise RuntimeError("verdict runs are GPU-only")
+    os.makedirs(RERUN_DIR, exist_ok=True)
+    tr, va = _wikitext_bytes(DATA_ROOT)
+    ledger = open(os.path.join(RERUN_DIR, "ledger.jsonl"), "a", encoding="utf-8")
+    for seed in seeds:
+        for arm in arms:
+            m = make_rerun_model(arm, seed=seed)
+            bpb = train_member(m, tr, va, steps=steps, device=device, seed=seed)
+            d = anchor_drift(m.head_addr.codebook, m.head_addr.home)
+            rec = {"exp": "18", "arm": arm, "seed": seed, "steps": steps,
+                   "bpb": round(bpb, 4), "drift": round(d["mean"], 4),
+                   "binding_frac": round(d["binding_fraction"], 4)}
+            ledger.write(json.dumps(rec) + "\n"); ledger.flush()
+            print(f"[18r {arm} s{seed}] FINAL bpb={bpb:.4f} "
+                  f"drift={rec['drift']} bind={rec['binding_frac']}", flush=True)
+            torch.save({"arm": arm, "seed": seed, "steps": steps,
+                        "state_dict": {k: v.cpu() for k, v in
+                                       m.state_dict().items()}},
+                       os.path.join(RERUN_DIR, f"r12_{arm}_s{seed}.pt"))
+            del m
+            torch.cuda.empty_cache()
+    ledger.close()
+
+
+def smoke():
+    b = pentachoron_book(64, seed=0)
+    assert b.shape == (64, 4)
+    assert torch.allclose(b.norm(dim=-1), torch.ones(64), atol=1e-5)
+    # regular-simplex signature: within one pentachoron, pairwise cos ~ -1/4
+    c = (b[:5] @ b[:5].T)
+    off = c[~torch.eye(5, dtype=torch.bool)]
+    assert (off - (-0.25)).abs().max() < 1e-4, off
+    x = torch.randint(0, 256, (2, 64))
+    for arm in ("penta_init", "tied", "keystone"):
+        m = make_rerun_model(arm, seed=0, d=96, layers=2, block=64)
+        lg = m(x); assert lg.shape == (2, 64, 256); lg.sum().backward()
+        assert m.head_addr.codebook.grad is not None
+        if arm in ("tied", "keystone"):
+            assert sum(p.numel() for p in m.head.parameters()) == 0
+            assert m.emb.weight.grad is not None
+        m.zero_grad()
+    print("exp018 (reran 12) smoke passed (farmed_init needs the specimen on disk)")
+
+
+def _in_notebook():
+    try:
+        get_ipython()  # type: ignore[name-defined]  # noqa: F821
+        return True
+    except NameError:
+        return False
+
+
+if __name__ == "__main__":
+    smoke() if not _in_notebook() else (smoke(),
+        print("Notebook: run_rerun() on GPU."))

exp018_r12/geolip_vitals.py

@@ -0,0 +1,219 @@
+"""geolip_vitals.py — shared diagnostic harness for the GeoLIP aleph experiments.
+ALL functions are READOUTS: no gradients, no losses. CV is a readout, never a
+force. Addressing is judged by drift->0.29154 and CV->0.20, never by recon cosine
+(judgment criteria per the aleph-void article: https://huggingface.co/blog/AbstractPhil/geometric-vocabulary-patchwork-aleph-void).
+
+Vitals provided:
+  anchor_drift        — geodesic drift of anchors from init; binding fraction @0.29154
+  pentachoron_cv      — CM 4-volume CV over random 5-row subsets (geovocab2 import)
+  axis_aliveness      — oriented-address usage: axes alive, hppl, collapse flag
+  gate_stats          — gate means vs the 0.012-0.03 band
+  path_diversity      — unique-path counting, FIXED high-bits hash (low-16 bug is the
+                        retracted artifact — never use the low bits)
+  grad_norm_spread    — gradient democracy monitor (orders-of-magnitude spread)
+  CVScreen            — CV@1000-batch early band screen (<0.30 LOW / .35-.50 MID / >.80 HIGH)
+
+Smoke on a torch-capable env:  python geolip_vitals.py
+"""
+from __future__ import annotations
+import math
+import torch
+
+BINDING = 0.29154            # radians; the binding/separation constant
+CV_BAND = (0.13, 0.30)       # CM CV band (discovery_catalog #4)
+GATE_BAND = (0.012, 0.03)    # live invariant candidate (acd_campaign)
+KNUTH32 = 2654435761
+
+
+# ----------------------------------------------------------------------------- drift
+@torch.no_grad()
+def anchor_drift(current: torch.Tensor, init: torch.Tensor, tol: float = 0.05) -> dict:
+    """Geodesic drift (radians) of each row of `current` from its row in `init`,
+    both row-normalized. Returns mean/std/per-row drift and the fraction of rows
+    within +/-tol of BINDING (the GLFM '46%' readout)."""
+    a = torch.nn.functional.normalize(current.float(), dim=-1)
+    b = torch.nn.functional.normalize(init.float(), dim=-1)
+    cos = (a * b).sum(-1).clamp(-1.0, 1.0)
+    drift = torch.arccos(cos)
+    frac = ((drift - BINDING).abs() <= tol).float().mean()
+    return {"mean": drift.mean().item(), "std": drift.std().item(),
+            "per_row": drift, "binding_fraction": frac.item()}
+
+
+# -------------------------------------------------------------------------------- cv
+@torch.no_grad()
+def _pentachoron_volumes(pts: torch.Tensor) -> torch.Tensor:
+    """Batched Cayley-Menger 4-simplex volumes. pts: (B, 5, D) -> (B,) volumes.
+    One float64 det over all samples (vol^2 = -det(CM)/9216 for n=4). Built-in
+    for speed (the per-sample reference path is ~260x slower in a vitals loop);
+    geovocab2 remains the formula's reference implementation, parity-checked
+    via cv_reference_check()."""
+    B = pts.shape[0]
+    d2 = torch.cdist(pts.double(), pts.double()).pow(2)          # (B,5,5)
+    cm = torch.ones(B, 6, 6, dtype=torch.float64, device=pts.device)
+    cm[:, 0, 0] = 0.0
+    cm[:, 1:, 1:] = d2
+    det = torch.linalg.det(cm)
+    return (-det / 9216.0).clamp_min(0.0).sqrt().float()
+
+
+@torch.no_grad()
+def pentachoron_cv(rows: torch.Tensor, n_samples: int = 200,
+                   generator: torch.Generator | None = None) -> float:
+    """CV (std/mean) of Cayley-Menger 4-simplex volumes over n_samples random
+    5-row subsets. Rows are row-normalized before measurement. Uses the built-in
+    batched CM (float64 det); validate against geovocab2 with
+    cv_reference_check() after any change to the volume math."""
+    x = torch.nn.functional.normalize(rows.float(), dim=-1)
+    n = x.shape[0]
+    if n < 5:
+        raise ValueError(f"pentachoron_cv needs >=5 rows, got {n}")
+    g = generator or torch.Generator(device="cpu").manual_seed(0)
+    idx = torch.stack([torch.randperm(n, generator=g)[:5]
+                       for _ in range(n_samples)])               # (B,5)
+    v = _pentachoron_volumes(x[idx].cpu())
+    return (v.std() / v.mean().clamp_min(1e-12)).item()
+
+
+@torch.no_grad()
+def cv_reference_check(n_trials: int = 50, tol: float = 1e-5) -> float:
+    """Parity check of the built-in batched CM against geovocab2's reference
+    implementation (the formula's source of truth). Returns max |rel diff|;
+    raises if geovocab2 is absent or parity fails. Run after touching
+    _pentachoron_volumes."""
+    try:
+        from geovocab2.shapes.formula.symbolic.cayley_menger import (
+            CayleyMengerFromSimplex)
+    except Exception as e:  # pragma: no cover
+        raise ImportError(
+            "cv_reference_check requires geovocab2 (install via the geolip-svae "
+            "umbrella: pip install git+https://github.com/AbstractEyes/"
+            "geolip-svae).") from e
+    ref = CayleyMengerFromSimplex()
+    g = torch.Generator().manual_seed(0)
+    pts = torch.nn.functional.normalize(
+        torch.randn(n_trials, 5, 4, generator=g), dim=-1)
+    mine = _pentachoron_volumes(pts)
+    # compare at float64: the reference computes in the INPUT dtype, and fp32
+    # dets lose up to ~4% on near-degenerate pentachora (measured 2026-07-11)
+    theirs = torch.stack([ref.forward(p.double())["volume"].float() for p in pts])
+    rel = ((mine - theirs).abs() / theirs.abs().clamp_min(1e-12)).max().item()
+    if rel > tol:
+        raise AssertionError(f"CM parity vs geovocab2 failed: max rel {rel}")
+    return rel
+
+
+# ------------------------------------------------------------------------- aliveness
+@torch.no_grad()
+def axis_aliveness(oriented_weights: torch.Tensor, alive_thresh: float = 1e-3) -> dict:
+    """`oriented_weights`: (..., 2K) nonnegative oriented-softmax address rows
+    (sum to 1 on the last dim). Returns axes-alive count, mean-usage perplexity
+    (hppl analogue; healthy hosted reference 125-126/128), and a collapse flag.
+    Reference behavior: near-uniform aliveness at div_weight=0 (discovery #22)."""
+    w = oriented_weights.reshape(-1, oriented_weights.shape[-1]).float()
+    usage = w.mean(0)
+    usage = usage / usage.sum().clamp_min(1e-12)
+    # an axis is alive if its mean usage exceeds alive_thresh x the uniform share
+    alive = int((usage > alive_thresh * (1.0 / usage.numel())).sum())
+    ent = -(usage.clamp_min(1e-12) * usage.clamp_min(1e-12).log()).sum()
+    ppl = float(ent.exp())
+    return {"axes_total": usage.numel(), "axes_alive": alive, "usage_ppl": ppl,
+            "collapsed": ppl < 0.05 * usage.numel()}
+
+
+# ------------------------------------------------------------------------------ gates
+@torch.no_grad()
+def gate_stats(gates: torch.Tensor) -> dict:
+    """Gate values (post-sigmoid/clamp). Reports mean and whether it sits in the
+    0.012-0.03 band (read-only — the band is a candidate invariant, never a target)."""
+    g = gates.float().flatten()
+    m = g.mean().item()
+    return {"mean": m, "std": g.std().item(),
+            "in_band": GATE_BAND[0] <= m <= GATE_BAND[1]}
+
+
+# ------------------------------------------------------------------------------ paths
+@torch.no_grad()
+def path_diversity(ids: torch.Tensor) -> dict:
+    """Unique-path counting with the FIXED multiplicative hash:
+    ((ids * 2654435761) % 2^32) >> 16 — Knuth needs the HIGH bits; the low-16
+    variant produced a retracted ~1,500 path ceiling in a prior campaign.
+    `ids`: integer tensor, one composed path id per row (any shape)."""
+    x = ids.reshape(-1).to(torch.int64)
+    hashed = ((x * KNUTH32) % (1 << 32)) >> 16
+    return {"n": int(x.numel()),
+            "unique_raw": int(torch.unique(x).numel()),
+            "unique_hashed": int(torch.unique(hashed).numel())}
+
+
+@torch.no_grad()
+def compose_path_ids(stage_indices: list[torch.Tensor], radix: int) -> torch.Tensor:
+    """Compose per-stage discrete indices (each (...,) int in [0, radix)) into a
+    single path id, positional base-`radix` — construction, not hashing."""
+    out = torch.zeros_like(stage_indices[0], dtype=torch.int64)
+    for s in stage_indices:
+        out = out * radix + s.to(torch.int64)
+    return out
+
+
+# --------------------------------------------------------------------- grad democracy
+@torch.no_grad()
+def grad_norm_spread(groups: dict[str, list[torch.nn.Parameter]]) -> dict:
+    """Gradient-democracy monitor. `groups`: name -> params of one parallel member
+    (tower/expert). Reports per-group grad norms and the orders-of-magnitude spread.
+    Reference: unequalized heterogeneous towers spread ~20 orders (fibonacci dead at
+    2.25e-21 under helix); equalized ~0.0 (geofractal gradient-democracy result)."""
+    norms = {}
+    for name, params in groups.items():
+        gs = [p.grad for p in params if p.grad is not None]
+        norms[name] = float(torch.sqrt(sum((g.float() ** 2).sum() for g in gs)).item()) \
+            if gs else 0.0
+    vals = [v for v in norms.values() if v > 0]
+    spread = (math.log10(max(vals)) - math.log10(min(vals))) if len(vals) >= 2 else 0.0
+    return {"norms": norms, "spread_orders": spread, "dead": [k for k, v in norms.items() if v == 0.0]}
+
+
+# ----------------------------------------------------------------------------- screen
+class CVScreen:
+    """CV@N early band screen (tri-band ft1): record pentachoron CV at `step_mark`
+    batches; classify <0.30 LOW / 0.35-0.50 MID / >0.80 HIGH. Turns ~2h/config
+    into ~7min. Readout only."""
+    def __init__(self, step_mark: int = 1000):
+        self.step_mark = step_mark
+        self.recorded: float | None = None
+
+    def maybe_record(self, step: int, rows: torch.Tensor) -> float | None:
+        if self.recorded is None and step >= self.step_mark:
+            self.recorded = pentachoron_cv(rows)
+        return self.recorded
+
+    @property
+    def band(self) -> str | None:
+        c = self.recorded
+        if c is None:
+            return None
+        if c < 0.30:
+            return "LOW"
+        if 0.35 <= c <= 0.50:
+            return "MID"
+        if c > 0.80:
+            return "HIGH"
+        return "BETWEEN"
+
+
+# ------------------------------------------------------------------------------ smoke
+if __name__ == "__main__":  # shapes/parse smoke ONLY — no training, ever.
+    g = torch.Generator().manual_seed(0)
+    K, D = 64, 4
+    init = torch.nn.functional.normalize(torch.randn(K, D, generator=g), dim=-1)
+    cur = torch.nn.functional.normalize(init + 0.29 * torch.randn(K, D, generator=g), dim=-1)
+    print("drift:", {k: v for k, v in anchor_drift(cur, init).items() if k != "per_row"})
+    w = torch.softmax(torch.randn(32, 2 * K, generator=g), dim=-1)
+    print("aliveness:", axis_aliveness(w))
+    print("gates:", gate_stats(torch.full((8,), 0.024)))
+    ids = compose_path_ids([torch.randint(0, 16, (4096,), generator=g) for _ in range(4)], 16)
+    print("paths:", path_diversity(ids))
+    lin = torch.nn.Linear(8, 8)
+    lin(torch.randn(4, 8)).sum().backward()
+    print("democracy:", grad_norm_spread({"a": list(lin.parameters())}))
+    print("OK — vitals smoke passed (pentachoron_cv needs geovocab2; run on GPU env)")

exp018_r12/read_codebook.py

@@ -0,0 +1,159 @@
+"""read_codebook.py — projective reading of cultivated aleph codebooks.
+Antipodal-collapse extraction on trained codebooks + projective statistics on
+RP^(D-1) — applied to the exp012 AR-bed specimens.
+
+Recipe per the Polygonal Omega article (geometric-tri-band-ft2): collapse = (row_i - row_j)/2 normalized for each MUTUAL-STRONGEST
+pair with cos < -0.9 — "a deterministic tensor operation," not clustering.
+Projective metric ALWAYS arccos|<a,b>| (metric-alignment rule, reading-voids-ft1).
+D=4 scope is the validated regime (D=5 walked back; axis count grows with D).
+
+Readouts per specimen:
+  pairs / n_axes / unpaired          — antipodal structure
+  proj_angle mean vs uniform baseline, deviation  — near-uniform RP^(D-1)?
+  drift from home + binding fraction @0.29154     — cultivation record
+  erank of the axis set                            — spectral occupancy
+  verdict: PROJECTIVE-CLEAN (|dev|<0.05, util>0.95, secondary pairs<=3) /
+           -MOSTLY / STRUCTURED / DEGENERATE (per Polygonal Omega thresholds)
+
+Usage (terminal): python read_codebook.py <ckpt_or_dir> [more paths...]
+Colab: paste geolip_vitals.py cell first (optional), then this file, then
+       read_all(r"/content/data/ar_ckpts").
+"""
+from __future__ import annotations
+import math
+import sys
+import torch
+import torch.nn.functional as F
+
+BINDING = 0.29154
+
+
+@torch.no_grad()
+def antipodal_collapse(codebook: torch.Tensor, thresh: float = -0.9) -> dict:
+    """Mutual-strongest antipodal pairing + collapse to axes on RP^(D-1)."""
+    A = F.normalize(codebook.float(), dim=-1)
+    K = A.shape[0]
+    cos = A @ A.T
+    cos.fill_diagonal_(2.0)                      # exclude self from minima
+    nearest_neg = cos.argmin(dim=-1)             # most-antipodal partner
+    pairs = []
+    used = set()
+    for i in range(K):
+        j = int(nearest_neg[i])
+        if i < j and int(nearest_neg[j]) == i and cos[i, j] < thresh:
+            pairs.append((i, j))
+            used.update((i, j))
+    axes = [F.normalize((A[i] - A[j]) / 2.0, dim=-1) for i, j in pairs]
+    axes += [A[i] for i in range(K) if i not in used]   # unpaired rows as axes
+    axes = torch.stack(axes) if axes else A[:0]
+    # sign-canon onto RP: first nonzero coordinate positive
+    for r in range(axes.shape[0]):
+        nz = torch.nonzero(axes[r].abs() > 1e-8)
+        if nz.numel() and axes[r, nz[0, 0]] < 0:
+            axes[r] = -axes[r]
+    return {"pairs": len(pairs), "n_axes": axes.shape[0],
+            "unpaired": K - 2 * len(pairs), "axes": axes}
+
+
+@torch.no_grad()
+def projective_stats(axes: torch.Tensor, n_baseline: int = 20000,
+                     seed: int = 0) -> dict:
+    """Mean projective angle arccos|<a,b>| vs a uniform-RP baseline at same (n, D)."""
+    n, D = axes.shape
+    if n < 2:
+        return {"proj_angle_mean": None, "uniform_baseline": None,
+                "deviation": None, "erank": None}
+    def mean_angle(rows):
+        c = (rows @ rows.T).abs().clamp(max=1.0)
+        iu = torch.triu_indices(rows.shape[0], rows.shape[0], offset=1)
+        return torch.arccos(c[iu[0], iu[1]]).mean().item()
+    obs = mean_angle(axes)
+    g = torch.Generator().manual_seed(seed)
+    base_angles = []
+    m = max(2, n)
+    for _ in range(max(1, n_baseline // max(1, m * (m - 1) // 2))):
+        r = F.normalize(torch.randn(m, D, generator=g), dim=-1)
+        base_angles.append(mean_angle(r))
+    base = sum(base_angles) / len(base_angles)
+    s = torch.linalg.svdvals(axes)
+    p = (s / s.sum().clamp_min(1e-12))
+    erank = float(torch.exp(-(p.clamp_min(1e-12) * p.clamp_min(1e-12).log()).sum()))
+    return {"proj_angle_mean": round(obs, 4), "uniform_baseline": round(base, 4),
+            "deviation": round(obs - base, 4), "erank": round(erank, 3)}
+
+
+@torch.no_grad()
+def read_specimen(path: str) -> dict:
+    ck = torch.load(path, map_location="cpu", weights_only=True)
+    out = {"file": path.split("\\")[-1].split("/")[-1],
+           "arm": ck.get("arm"), "seed": ck.get("seed"),
+           "steps": ck.get("steps"), "val_bpb": round(ck.get("val_bpb", -1), 4)}
+    if "state_dict" in ck:            # full specimen checkpoint
+        sd = ck["state_dict"]
+        books = {k[:-len(".codebook")]: sd[k] for k in sd
+                 if k.endswith("addr.codebook") or k.endswith("head_addr.codebook")}
+        homes = {k[:-len(".home")]: sd[k] for k in sd if k.endswith(".home")}
+    else:                             # bare genome dict (exp014+ champion files):
+        # books under flat/root/branch* keys; *_proj entries are projections
+        books = {k: v for k, v in ck.items()
+                 if torch.is_tensor(v) and v.ndim == 2
+                 and (k in ("flat", "root") or k.startswith("branch"))}
+        homes = {}
+    reads = {}
+    for name, cb in books.items():
+        col = antipodal_collapse(cb)
+        stats = projective_stats(col["axes"])
+        home = homes.get(name)
+        drift = None
+        binding = None
+        if home is not None and home.shape == cb.shape:
+            a = F.normalize(cb.float(), dim=-1)
+            b = F.normalize(home.float(), dim=-1)
+            dr = torch.arccos((a * b).sum(-1).clamp(-1, 1))
+            drift = round(dr.mean().item(), 4)
+            binding = round(((dr - BINDING).abs() <= 0.05).float().mean().item(), 4)
+        util = col["n_axes"] / cb.shape[0]
+        dev = stats["deviation"]
+        if dev is not None and abs(dev) < 0.05 and util > 0.95 and col["pairs"] <= 3:
+            verdict = "PROJECTIVE-CLEAN"
+        elif dev is not None and abs(dev) < 0.05:
+            verdict = "PROJECTIVE-MOSTLY"
+        elif dev is not None and dev > 0.05:
+            verdict = "STRUCTURED(repulsive)"
+        else:
+            verdict = "DEGENERATE/CLUMPED" if dev is not None else "TOO-FEW-AXES"
+        reads[name] = {
+            "pairs": col["pairs"], "n_axes": col["n_axes"], **stats,
+            "drift": drift, "binding_frac": binding, "verdict": verdict}
+    out["codebooks"] = reads
+    return out
+
+
+def read_all(root: str) -> list:
+    import glob, os
+    results = []
+    for p in sorted(glob.glob(os.path.join(root, "*.pt"))):
+        r = read_specimen(p)
+        print(r, flush=True)
+        results.append(r)
+    return results
+
+
+def _in_notebook() -> bool:
+    try:
+        get_ipython()  # type: ignore[name-defined]  # noqa: F821
+        return True
+    except NameError:
+        return False
+
+
+if __name__ == "__main__":
+    if _in_notebook():
+        print("Notebook mode: call read_all(r'<data_root>/ar_ckpts') in the next cell.")
+    else:
+        args = [a for a in sys.argv[1:] if not a.startswith("-")]
+        if not args:
+            print("usage: python read_codebook.py <ckpt_or_dir> [...]")
+        for a in args:
+            import os
+            read_all(a) if os.path.isdir(a) else print(read_specimen(a))

exp018_r12/repro.py

@@ -0,0 +1,27 @@
+"""repro.py — standalone loader/runner for exp018_r12. Code dependencies live
+in THIS folder (geolip_vitals.py, ar_differentiation_bed.py,
+exp014_genetic_distillation.py, exp018_reran12.py, read_codebook.py).
+
+  python repro.py            # CPU smoke: pentachoron regularity + arm shapes
+  python repro.py --run      # all 4 arms x 2 seeds (GPU, ~40 min)
+
+Data lands in ./data (override with GEOLIP_DATA). The farmed_init arm needs
+the exp012 donor specimen: ../exp012_ar/specimens/addr_msl64_s0_t2000.pt
+(present in this repo) or set GEOLIP_FARMED_SPECIMEN to a path.
+"""
+import os
+import sys
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, HERE)
+
+if __name__ == "__main__":
+    import geolip_vitals                       # noqa: F401  (paste order)
+    import ar_differentiation_bed              # noqa: F401
+    import exp014_genetic_distillation         # noqa: F401
+    import exp018_reran12 as r12
+    if "--run" in sys.argv[1:]:
+        r12.run_rerun()
+    else:
+        r12.smoke()
+        print("repro smoke passed — run with --run for the arms (GPU)")

exp018_r12/results/ledger.jsonl

@@ -0,0 +1,8 @@
+{"exp": "18", "arm": "penta_init", "seed": 0, "steps": 2000, "bpb": 2.4957, "drift": 0.2417, "binding_frac": 0.25}
+{"exp": "18", "arm": "farmed_init", "seed": 0, "steps": 2000, "bpb": 2.4934, "drift": 0.1787, "binding_frac": 0.2031}
+{"exp": "18", "arm": "tied", "seed": 0, "steps": 2000, "bpb": 3.5131, "drift": 0.0188, "binding_frac": 0.0}
+{"exp": "18", "arm": "keystone", "seed": 0, "steps": 2000, "bpb": 3.5169, "drift": 0.0203, "binding_frac": 0.0}
+{"exp": "18", "arm": "penta_init", "seed": 1, "steps": 2000, "bpb": 2.4389, "drift": 0.2114, "binding_frac": 0.2969}
+{"exp": "18", "arm": "farmed_init", "seed": 1, "steps": 2000, "bpb": 2.4614, "drift": 0.1986, "binding_frac": 0.2812}
+{"exp": "18", "arm": "tied", "seed": 1, "steps": 2000, "bpb": 3.4997, "drift": 0.0203, "binding_frac": 0.0}
+{"exp": "18", "arm": "keystone", "seed": 1, "steps": 2000, "bpb": 3.5006, "drift": 0.0208, "binding_frac": 0.0}

exp018_r12/results/results.json

@@ -0,0 +1,34 @@
+{
+ "farmed_init_s0": {
+  "bpb": 2.4934,
+  "drift": 0.1787
+ },
+ "farmed_init_s1": {
+  "bpb": 2.4614,
+  "drift": 0.1986
+ },
+ "keystone_s0": {
+  "bpb": 3.5169,
+  "drift": 0.0203
+ },
+ "keystone_s1": {
+  "bpb": 3.5006,
+  "drift": 0.0208
+ },
+ "penta_init_s0": {
+  "bpb": 2.4957,
+  "drift": 0.2417
+ },
+ "penta_init_s1": {
+  "bpb": 2.4389,
+  "drift": 0.2114
+ },
+ "tied_s0": {
+  "bpb": 3.5131,
+  "drift": 0.0188
+ },
+ "tied_s1": {
+  "bpb": 3.4997,
+  "drift": 0.0203
+ }
+}

exp018_r12/specimens/r12_farmed_init_s0.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:863c95c2ada021129ed01776dd0505df338f1c3ba0134f7a2ff036f7bd535890
+size 7977645

exp018_r12/specimens/r12_farmed_init_s1.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0ef0870f9a5ec4067e72dcf1950e183dd65e526d0e5a21316865681853798a16
+size 7977645

exp018_r12/specimens/r12_keystone_s0.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5b4700cd47a40d15928ea8e3f5cc2fbe6a86aa42368e6d9cb7090c8d972a9477
+size 7713726

exp018_r12/specimens/r12_keystone_s1.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1183c1dc78f0c1a2f20b277922103fb7192134d09939265575ecade8b87f524a
+size 7713726

exp018_r12/specimens/r12_penta_init_s0.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6e73f0554426e45fffcabeea895eff4e7d7a47076ca7a57f552c1962d6d11df7
+size 7977590

exp018_r12/specimens/r12_penta_init_s1.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f8b615f8a3ce5358b1286b5184f20c91aa055eb7b0a5b417f0c3b81d78f554f5
+size 7977590

exp018_r12/specimens/r12_tied_s0.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f12ee10ac833b18a3821ca9273ebc575713e334baa2fad06e93d732bace80222
+size 7713514

exp018_r12/specimens/r12_tied_s1.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c1d8da581864f4fb18458b86d51148357c91b5cb7af0f958aae72a190912ae6f
+size 7713514

exp019_cr/README.md

@@ -0,0 +1,82 @@
+# exp019_cr — the capacity for distilled content retention (+ generalization)
+
+When content is **distilled** rather than directly learned, how much transfers,
+how much is retained, and for how long? Sequel to [exp016](../exp016_ct/) and
+the [exp014](../exp014_gd/) memory-substrate studies; the weak-to-strong
+distillation cell made real (the teacher holds content the student lacks —
+true headroom on the content axis).
+
+**Instrument**: N fact records `\n@<key6>=<value12>\n` (random alphanumeric —
+uncompletable from language statistics, so exact-match greedy completion IS
+retention), mixed into the wikitext byte stream at rate 0.5. Teacher =
+addr_msl64 bed model, 4000 steps, gated on its own recall. Channels (fresh
+student, 2000 steps): `direct` (ground truth; ceiling) | `kd_facts` (fact rows
+supervised ONLY by teacher logits — pure distilled content, α=1.0) |
+`kd_general` (KD on clean text only — leakage probe) | `book_implant`
+(teacher's trained codebook into a fresh student) | `none` (floor). Axes:
+N ∈ {64, 256, 1024}; retention re-measured after 1000 further clean-stream
+steps (interference). The **19b block** swaps rote facts for **rule-bearing
+content** (value = fixed substitution cipher of the key; 256 train keys, 128
+held out) plus prompt-format variants.
+
+`build_results.py` re-asserts every claim below from `results/ledger.jsonl`
+(36 rows).
+
+## Findings — retention sweep
+
+1. **Capacity curve**: teacher recall at 4k steps = 1.00 (N=64), 0.99 (N=256),
+   0.01–0.20 (N=1024) — the ~1.9M model holds ~256 facts near-perfectly and
+   hits a cliff before 1024 (cliff edge seed-chaotic).
+2. **The distillation tax is zero-to-negative.** Where the teacher knows the
+   content, teacher logits alone transfer it at parity with ground truth
+   (N=64: exact 1.0 = 1.0, both seeds) or better (N=256: 0.953 vs 0.871 s0;
+   0.859 vs 0.856 s1). Soft targets from a teacher with headroom are at least
+   as content-efficient as the data itself. The cost is general modeling:
+   kd students' clean bpb 4.0–4.3 vs direct 2.8–3.1 vs floor 2.47.
+3. **No logit leakage**: KD on clean text transfers zero facts (0.000, 6/6
+   cells) — content does not cross without exposure at this scale.
+4. **Anchors carry no bytes**: the trained codebook of a teacher that knows
+   256 facts, implanted into a fresh student, transfers **none** of them
+   (0.000, both seeds). The codebook organizes addressing; content lives in
+   the trunk.
+5. **Universal catastrophic forgetting**: after 1000 clean-stream steps, every
+   channel's recall is exactly 0.000 — including perfectly-learned direct
+   students. At this scale nothing persists without pressure; **persistence,
+   not transfer, is the unsolved axis of the memory substrate.**
+
+## Findings — 19b generalization block (rule content)
+
+6. **Rules are learned fragmentarily**: teachers memorize the rule-pairs
+   near-perfectly (train exact 0.98–1.00) but reach only ~0.25–0.27 held-out
+   byte accuracy (~10× chance) with **zero** exact completions — character
+   mappings absorbed, the full cipher never.
+7. **The logit channel beats direct learning on structured content, 2/2
+   seeds** (train exact 0.758/0.844 vs 0.652/0.773) and transfers the partial
+   rule at full fidelity — the dark-knowledge advantage, certified on rules.
+8. **Content is format-locked** — variant-format prompts collapse recall to
+   ~0 even on trained keys — but **KD students are consistently less
+   format-locked** than direct students (variant byte 0.077–0.091 vs
+   0.000–0.024): soft targets bind content less rigidly to surface form.
+9. Interference erases the rule too — structure forgets like instances.
+
+## Files
+- `exp019_content_retention.py` — fact/rule corpora, streams, exact-match
+  recall (with format variants), channel training, both runners, smoke.
+- `geolip_vitals.py` / `ar_differentiation_bed.py` /
+  `exp014_genetic_distillation.py` / `read_codebook.py` — this package's own
+  harness copies. Standalone.
+- `repro.py`, `build_results.py`, `results/ledger.jsonl` (36 rows),
+  `specimens/` (6 fact teachers + 2 rule teachers + 6 rule students).
+
+## Reproduce (from inside this folder)
+```bash
+pip install torch --index-url https://download.pytorch.org/whl/cu128
+pip install pyarrow huggingface_hub
+python repro.py            # CPU smoke
+python repro.py --run      # retention sweep (GPU, ~3h)
+python repro.py --run19b   # rule/generalization block (GPU, ~1h)
+python build_results.py    # re-assert every claim from the ledger
+```
+Data lands in `./data` (override with `GEOLIP_DATA`).
+
+License: MIT · AbstractPhil + Claude Fable 5 · July 11, 2026

exp019_cr/ar_differentiation_bed.py

@@ -0,0 +1,487 @@
+"""ar_differentiation_bed.py — exp012: autoregressive differentiation of the aleph.
+
+Differentiation is cultivated by PREDICTIVE pressure along the sequence — the
+address parameterizing the next-byte distribution (Law 2: chain-rule advantage pays
+ONLY where the composed address directly parameterizes the predictive distribution).
+This bed puts the aleph in the autoregressive gradient path and measures what
+differentiates. The head arms enforce the employment law at its maximum: the
+ENTIRE next-byte distribution is parameterized by the address.
+
+Byte-level causal LM on wikitext-2-raw (HF parquet, CDN-fast), block 256. ARMS:
+  sdpa       — standard causal transformer control (matched trunk).
+  hub        — attention replaced by CAUSAL HUB: linear attention whose feature map
+               is the 2K-oriented aleph address, prefix-sum memories (no selection
+               event; O(n*K*d)). Differentiation cultivated INSIDE attention.
+  addr_head  — sdpa trunk, but the OUTPUT HEAD reads ONLY the signed aleph
+               coefficient vector w_k = sinh(u_k)/sum_j cosh(u_j) of the final
+               hidden state (K -> 256 logits). The address MUST carry every bit of
+               next-byte information — the hardest Law-2 bottleneck.
+
+JUDGED BY: val bits-per-byte per arm (task) + CULTIVATION VITALS on every aleph
+codebook (readouts, never losses): axis aliveness/hppl, drift-from-init +
+binding fraction @0.29154, winner-|cos| saturation (sign-code emergence), shadow
+path diversity (fixed high-bits hash). Never by recon.
+
+Riders: pure Adam wd=0; no BN/Dropout/GAP on geometric paths; orthogonal init;
+Colab-cell-safe (paste-ahead imports, no bare argparse, no __file__ reliance);
+GPU-only for verdict runs.
+
+Terminal:  python ar_differentiation_bed.py            # shapes/parse smoke
+           python ar_differentiation_bed.py --train    # verdict run
+Colab:     paste geolip_vitals.py cell, then this file (smoke auto-runs),
+           then  train(steps=2000, data_root="/content/data")  in the next cell.
+"""
+from __future__ import annotations
+import math
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+if "anchor_drift" not in globals():
+    try:
+        from geolip_vitals import anchor_drift, axis_aliveness, path_diversity
+    except ImportError:
+        _here = globals().get("__file__")
+        if _here is not None:
+            import sys, pathlib
+            sys.path.insert(0, str(pathlib.Path(_here).parent))
+            from geolip_vitals import anchor_drift, axis_aliveness, path_diversity
+        else:
+            raise ImportError(
+                "geolip_vitals not found — paste/run its cell first, or "
+                "hf_hub_download exp012_ar/geolip_vitals.py from "
+                "AbstractPhil/geolip-aleph-differentiation.")
+
+VOCAB = 256  # bytes
+
+
+# ------------------------------------------------------------------ aleph address
+def _super_fibonacci_s3(n: int) -> torch.Tensor:
+    """Near-uniform unit quaternions (Alexa CVPR'22) —
+    starts the codebook INSIDE the RP^3 attractor basin. D=4 only."""
+    PHI, PSI = math.sqrt(2.0), 1.533751168755204288118041
+    i = torch.arange(n, dtype=torch.float64)
+    s = (i + 0.5) / n
+    r, R = torch.sqrt(s), torch.sqrt(1.0 - s)
+    a, b = 2 * math.pi * i / PHI, 2 * math.pi * i / PSI
+    q = torch.stack([r * torch.sin(a), r * torch.cos(a),
+                     R * torch.sin(b), R * torch.cos(b)], dim=-1)
+    return F.normalize(q, dim=-1).float()
+
+
+class AlephAddress(nn.Module):
+    """Closed-form aleph over 2K oriented half-axes (aleph-void article).
+    signed(x): (..., K) w_k = sinh(u_k)/sum_j cosh(u_j)   — the Law-2 head feature.
+    oriented(x): ((..., K), (..., K)) positive halves of the 2K softmax — HUB map."""
+
+    def __init__(self, K: int, D: int, tau: float = 0.1, init: str = "random"):
+        super().__init__()
+        self.K, self.D, self.tau = K, D, tau
+        if init == "fibonacci":
+            assert D == 4, "fibonacci init lives on S^3 (D=4)"
+            A = _super_fibonacci_s3(K)
+        else:
+            A = F.normalize(torch.randn(K, D), dim=-1)
+        self.codebook = nn.Parameter(A)
+        self.register_buffer("home", self.codebook.detach().clone())
+
+    def _u(self, x):
+        A = F.normalize(self.codebook, dim=-1)
+        return (F.normalize(x, dim=-1) @ A.transpose(-1, -2)) / self.tau
+
+    def oriented(self, x):
+        u = self._u(x)
+        m = u.abs().amax(dim=-1, keepdim=True)
+        ep, en = torch.exp(u - m), torch.exp(-u - m)
+        Z = (ep + en).sum(dim=-1, keepdim=True)
+        return ep / Z, en / Z
+
+    def signed(self, x):
+        u = self._u(x)
+        m = u.abs().amax(dim=-1, keepdim=True)
+        ep, en = torch.exp(u - m), torch.exp(-u - m)
+        return (ep - en) / (ep + en).sum(dim=-1, keepdim=True)
+
+    def signed_at(self, x, taus):
+        """Multi-tau stroboscope (rule of 3): signed coefficients at several
+        temperatures, concatenated — softer taus keep the vector dense while a
+        hard tau supplies the sign-code sharpness. v2 refinement (b)."""
+        A = F.normalize(self.codebook, dim=-1)
+        cos = F.normalize(x, dim=-1) @ A.transpose(-1, -2)
+        outs = []
+        for t in taus:
+            u = cos / t
+            m = u.abs().amax(dim=-1, keepdim=True)
+            ep, en = torch.exp(u - m), torch.exp(-u - m)
+            outs.append((ep - en) / (ep + en).sum(dim=-1, keepdim=True))
+        return torch.cat(outs, dim=-1)
+
+    def m_hat(self, x):
+        """Closed-form soft read (decoders read M_hat, never M). v2 control (c)."""
+        u = self._u(x)
+        m = u.abs().amax(dim=-1, keepdim=True)
+        ep, en = torch.exp(u - m), torch.exp(-u - m)
+        A = F.normalize(self.codebook, dim=-1)
+        return ((ep - en) @ A) / (ep + en).sum(dim=-1, keepdim=True)
+
+    def m_hard_ste(self, x):
+        """Hard mode (aleph-void article): M_hard = sign(cos_win) * A[win], straight-through to
+        the soft read — forward fully discrete SIGN CODE, backward soft gradient.
+        Legal per theme A (reconstructive sign code, not a one-hot roster pick)."""
+        u = self._u(x)
+        soft = self.m_hat(x)
+        win = u.abs().argmax(dim=-1)
+        A = F.normalize(self.codebook, dim=-1)
+        sign = torch.sign(torch.gather(u, -1, win.unsqueeze(-1))).squeeze(-1)
+        hard = sign.unsqueeze(-1) * A[win]
+        return hard + soft - soft.detach()
+
+    @torch.no_grad()
+    def vitals(self, x_sample) -> dict:
+        u = self._u(x_sample.reshape(-1, x_sample.shape[-1]))
+        p, n = self.oriented(x_sample.reshape(-1, x_sample.shape[-1]))
+        two_k = torch.cat([p, n], dim=-1)
+        win = two_k.argmax(dim=-1)
+        cos_win = (u.abs().amax(dim=-1) * self.tau)  # winner |cos| — sign-code sat.
+        d = anchor_drift(self.codebook, self.home)
+        return {"drift": round(d["mean"], 4),
+                "binding_frac": round(d["binding_fraction"], 4),
+                "aliveness": axis_aliveness(two_k),
+                "win_cos_mean": round(cos_win.mean().item(), 4),
+                "paths": path_diversity(win)}
+
+
+# ------------------------------------------------------------------------- blocks
+class CausalSDPA(nn.Module):
+    def __init__(self, d: int, heads: int = 4):
+        super().__init__()
+        self.h = heads
+        self.qkv = nn.Linear(d, 3 * d, bias=False)
+        self.o = nn.Linear(d, d, bias=False)
+        nn.init.orthogonal_(self.qkv.weight); nn.init.orthogonal_(self.o.weight)
+
+    def forward(self, x):
+        B, n, d = x.shape
+        q, k, v = self.qkv(x).chunk(3, dim=-1)
+        q, k, v = (t.view(B, n, self.h, d // self.h).transpose(1, 2) for t in (q, k, v))
+        y = F.scaled_dot_product_attention(q, k, v, is_causal=True)
+        return self.o(y.transpose(1, 2).reshape(B, n, d))
+
+
+class CausalHUB(nn.Module):
+    """Causal aleph linear attention: prefix-sum memories over the two K-wide
+    halves of the oriented address; 2K never materialized; no selection event."""
+
+    def __init__(self, d: int, K: int = 32, D: int = 4, tau: float = 0.1):
+        super().__init__()
+        self.addr = AlephAddress(K, D, tau)
+        self.q = nn.Linear(d, D, bias=False)
+        self.k = nn.Linear(d, D, bias=False)
+        self.v = nn.Linear(d, d, bias=False)
+        self.o = nn.Linear(d, d, bias=False)
+        for m in (self.q, self.k, self.v, self.o):
+            nn.init.orthogonal_(m.weight)
+
+    def forward(self, x):
+        qp, qn = self.addr.oriented(self.q(x))          # (B, n, K)
+        kp, kn = self.addr.oriented(self.k(x))
+        v = self.v(x)                                    # (B, n, d)
+        Sp = torch.cumsum(torch.einsum("bnk,bnd->bnkd", kp, v), dim=1)
+        Sn = torch.cumsum(torch.einsum("bnk,bnd->bnkd", kn, v), dim=1)
+        zp = torch.cumsum(kp, dim=1)
+        zn = torch.cumsum(kn, dim=1)
+        num = torch.einsum("bnk,bnkd->bnd", qp, Sp) + torch.einsum("bnk,bnkd->bnd", qn, Sn)
+        den = (qp * zp).sum(-1, keepdim=True) + (qn * zn).sum(-1, keepdim=True)
+        return self.o(num / den.clamp_min(1e-12))
+
+
+class MslRelay(nn.Module):
+    """Depth-composition unit (chain-rule probe): multi-slot M_hat read entering
+    the trunk as a NEAR-ZERO gated residual (gate init -3.0, sigma~0.047 — theme D:
+    geometry enters as a nudge and grows only if it earns gradient)."""
+
+    def __init__(self, d: int, n_slots: int = 16, K: int = 64):
+        super().__init__()
+        self.n_slots = n_slots
+        self.proj = nn.Linear(d, n_slots * 4, bias=False)
+        self.out = nn.Linear(n_slots * 4, d, bias=False)
+        nn.init.orthogonal_(self.proj.weight)
+        nn.init.orthogonal_(self.out.weight)
+        self.addr = AlephAddress(K, 4)
+        self.gate = nn.Parameter(torch.tensor(-3.0))
+
+    def forward(self, x):
+        B, n, _ = x.shape
+        slots = self.proj(x).view(B, n, self.n_slots, 4)
+        m = self.addr.m_hat(slots).reshape(B, n, -1)
+        return x + self.gate.sigmoid() * self.out(m)
+
+
+class Block(nn.Module):
+    def __init__(self, d: int, attn: nn.Module):
+        super().__init__()
+        self.n1, self.n2 = nn.LayerNorm(d), nn.LayerNorm(d)
+        self.attn = attn
+        self.mlp = nn.Sequential(nn.Linear(d, 4 * d), nn.GELU(), nn.Linear(4 * d, d))
+
+    def forward(self, x):
+        x = x + self.attn(self.n1(x))
+        return x + self.mlp(self.n2(x))
+
+
+class ByteLM(nn.Module):
+    def __init__(self, arm: str, d: int = 192, layers: int = 4, block: int = 256,
+                 K: int = 32, D: int = 4):
+        super().__init__()
+        # "<arm>_tri" suffix = trigram byte embedding (AlephLM byte_emb x3 lineage):
+        # token embedding is the sum of embeddings of bytes t, t-1, t-2.
+        self.trigram = arm.endswith("_tri")
+        if self.trigram:
+            arm = arm[:-4]
+        # "_fib" = super-Fibonacci S^3 codebook init (basin test: starts INSIDE
+        # the RP^3 attractor; primary observable is init->final geodesic drift).
+        self.fib = arm.endswith("_fib")
+        if self.fib:
+            arm = arm[:-4]
+        # "relay*" = stacked addresses in depth: MslRelay after every block.
+        # relay -> sdpa trunk + standard head; relay_msl64 -> + addressed head.
+        self.use_relay = arm.startswith("relay")
+        if arm == "relay":
+            arm = "sdpa"
+        elif arm == "relay_msl64":
+            arm = "addr_msl64"
+        self.arm, self.block = arm, block
+        self.emb = nn.Embedding(VOCAB, d)
+        if self.trigram:
+            self.emb1 = nn.Embedding(VOCAB, d)
+            self.emb2 = nn.Embedding(VOCAB, d)
+        self.pos = nn.Parameter(torch.zeros(1, block, d) + 0.01 * torch.randn(1, block, d))
+        mk_attn = (lambda: CausalHUB(d, K, D)) if arm == "hub" else (lambda: CausalSDPA(d))
+        self.blocks = nn.ModuleList([Block(d, mk_attn()) for _ in range(layers)])
+        if self.use_relay:
+            self.relays = nn.ModuleList([MslRelay(d) for _ in range(layers)])
+        self.nf = nn.LayerNorm(d)
+        if arm == "addr_head":
+            self.head_addr = AlephAddress(K, d)  # v1: codebook in model dim — COLLAPSED
+            self.head = nn.Linear(K, VOCAB, bias=True)
+        elif arm in ("addr_d4", "addr_3tau", "addr_mhat"):
+            # v2 refinements: LOW-D HOME — learned projection to the native D=4 home
+            # before addressing (mirrors the healthy HUB arms), K=64.
+            self.head_proj = nn.Linear(d, 4, bias=False)
+            nn.init.orthogonal_(self.head_proj.weight)
+            self.head_addr = AlephAddress(64, 4)
+            if arm == "addr_d4":
+                self.head = nn.Linear(64, VOCAB, bias=True)      # w alone, D=4 home
+            elif arm == "addr_3tau":
+                self.taus = (0.05, 0.1, 0.3)                     # rule-of-3 strobe
+                self.head = nn.Linear(64 * 3, VOCAB, bias=True)
+            else:                                                 # addr_mhat
+                self.head = nn.Linear(4, VOCAB, bias=True)       # tightest: M_hat
+        elif arm.startswith("addr_msl"):
+            # v3: MULTI-SLOT heads — the 16s funnel widening: P parallel D=4 slots
+            # over a SHARED codebook. addr_msl consumes the reconstructive M_hat per
+            # slot (Px4 dims); addr_msl_w consumes signed w per slot (Px64) — tests
+            # whether slot-parallel consumption alone rescues the coefficient path.
+            # addr_msl<P> = slot-count dose-response. addr_mslh<P> = HARD sign-code
+            # consumption (straight-through M_hard per slot).
+            self.hard = arm.startswith("addr_mslh")
+            if arm in ("addr_msl", "addr_msl_w"):
+                self.n_slots = 16
+            else:
+                self.n_slots = int(arm[len("addr_mslh" if self.hard else "addr_msl"):])
+            self.head_proj = nn.Linear(d, self.n_slots * 4, bias=False)
+            nn.init.orthogonal_(self.head_proj.weight)
+            self.head_addr = AlephAddress(
+                64, 4, init="fibonacci" if self.fib else "random")
+            width = self.n_slots * (64 if arm == "addr_msl_w" else 4)
+            self.head = nn.Linear(width, VOCAB, bias=True)
+        elif arm == "addr_3tau_mhat":
+            # v3: combine the two v2 winners — 3-tau stroboscope + reconstructive read.
+            self.head_proj = nn.Linear(d, 4, bias=False)
+            nn.init.orthogonal_(self.head_proj.weight)
+            self.head_addr = AlephAddress(64, 4)
+            self.taus = (0.05, 0.1, 0.3)
+            self.head = nn.Linear(64 * 3 + 4, VOCAB, bias=True)
+        else:
+            self.head = nn.Linear(d, VOCAB, bias=True)
+        self._last_h = None
+
+    def forward(self, idx):
+        x = self.emb(idx)
+        if self.trigram:  # past-only shifts — causality preserved
+            x = x + self.emb1(F.pad(idx, (1, 0), value=0)[:, :-1]) \
+                  + self.emb2(F.pad(idx, (2, 0), value=0)[:, :-2])
+        x = x + self.pos[:, : idx.shape[1]]
+        if self.use_relay:
+            for b, r in zip(self.blocks, self.relays):
+                x = r(b(x))
+        else:
+            for b in self.blocks:
+                x = b(x)
+        h = self.nf(x)
+        self._last_h = h.detach()
+        if self.arm == "addr_head":
+            return self.head(self.head_addr.signed(h))
+        if self.arm == "addr_d4":
+            return self.head(self.head_addr.signed(self.head_proj(h)))
+        if self.arm == "addr_3tau":
+            return self.head(self.head_addr.signed_at(self.head_proj(h), self.taus))
+        if self.arm == "addr_mhat":
+            return self.head(self.head_addr.m_hat(self.head_proj(h)))
+        if self.arm.startswith("addr_msl"):
+            B, n, _ = h.shape
+            slots = self.head_proj(h).view(B, n, self.n_slots, 4)
+            if self.arm == "addr_msl_w":
+                feats = self.head_addr.signed(slots).reshape(B, n, -1)
+            elif getattr(self, "hard", False):
+                feats = self.head_addr.m_hard_ste(slots).reshape(B, n, -1)
+            else:
+                feats = self.head_addr.m_hat(slots).reshape(B, n, -1)
+            return self.head(feats)
+        if self.arm == "addr_3tau_mhat":
+            p = self.head_proj(h)
+            feats = torch.cat([self.head_addr.signed_at(p, self.taus),
+                               self.head_addr.m_hat(p)], dim=-1)
+            return self.head(feats)
+        return self.head(h)
+
+    @torch.no_grad()
+    def vitals(self) -> dict:
+        out = {}
+        if self.arm == "hub":
+            for i, b in enumerate(self.blocks):
+                if self._last_h is not None:
+                    out[f"L{i}"] = b.attn.addr.vitals(b.attn.q(self._last_h[:2]))
+        elif self.arm == "addr_head" and self._last_h is not None:
+            out["head"] = self.head_addr.vitals(self._last_h[:2])
+        elif self.arm in ("addr_d4", "addr_3tau", "addr_mhat",
+                          "addr_3tau_mhat") and self._last_h is not None:
+            out["head"] = self.head_addr.vitals(self.head_proj(self._last_h[:2]))
+        elif self.arm.startswith("addr_msl") and self._last_h is not None:
+            slots = self.head_proj(self._last_h[:2])
+            out["head"] = self.head_addr.vitals(
+                slots.reshape(*slots.shape[:-1], self.n_slots, 4))
+        if self.use_relay and self._last_h is not None:
+            for i, r in enumerate(self.relays):
+                s = r.proj(self._last_h[:2])
+                v = r.addr.vitals(s.reshape(*s.shape[:-1], r.n_slots, 4))
+                out[f"relay{i}"] = {"gate": round(r.gate.sigmoid().item(), 4),
+                                    "drift": v["drift"],
+                                    "binding_frac": v["binding_frac"],
+                                    "ppl": round(v["aliveness"]["usage_ppl"], 1)}
+        return out
+
+
+# --------------------------------------------------------------------------- data
+def _wikitext_bytes(data_root: str):
+    """wikitext-2-raw as flat uint8 tensors via the HF parquet CDN."""
+    from huggingface_hub import hf_hub_download
+    import pyarrow.parquet as pq
+
+    def load(split):
+        p = hf_hub_download("Salesforce/wikitext",
+                            f"wikitext-2-raw-v1/{split}-00000-of-00001.parquet",
+                            repo_type="dataset", local_dir=data_root)
+        text = "".join(pq.read_table(p).column("text").to_pylist())
+        return torch.frombuffer(bytearray(text.encode("utf-8")), dtype=torch.uint8).clone()
+
+    return load("train"), load("validation")
+
+
+def _batch(data: torch.Tensor, batch: int, block: int, device, g: torch.Generator):
+    ix = torch.randint(0, data.numel() - block - 1, (batch,), generator=g)
+    x = torch.stack([data[i:i + block] for i in ix]).long().to(device)
+    y = torch.stack([data[i + 1:i + block + 1] for i in ix]).long().to(device)
+    return x, y
+
+
+# -------------------------------------------------------------------- train/smoke
+def train(arms=("sdpa", "hub", "addr_head"), steps: int = 2000, batch: int = 32,
+          block: int = 256, device: str = "cuda", data_root: str = "./data",
+          seed: int = 0, eval_every: int = 500, save: bool = True):
+    """Verdict run — GPU only. Pure Adam wd=0. Reports val bits-per-byte + vitals.
+    save=True writes {data_root}/ar_ckpts/{arm}_s{seed}_t{steps}.pt per arm —
+    the cultivated codebooks are SPECIMENS for the projective reading instruments."""
+    import os
+    if device == "cuda" and not torch.cuda.is_available():
+        raise RuntimeError("Verdict runs are GPU-only (never CPU-train for accuracy).")
+    ckpt_dir = os.path.join(data_root, "ar_ckpts")
+    os.makedirs(ckpt_dir, exist_ok=True)
+    tr, va = _wikitext_bytes(data_root)
+    print(f"data ready: train {tr.numel():,} bytes, val {va.numel():,} bytes", flush=True)
+    results = {}
+    for arm in arms:
+        torch.manual_seed(seed)
+        g = torch.Generator().manual_seed(seed)
+        model = ByteLM(arm, block=block).to(device)
+        n_params = sum(p.numel() for p in model.parameters())
+        opt = torch.optim.Adam(model.parameters(), lr=3e-4, weight_decay=0.0)
+        for step in range(1, steps + 1):
+            x, y = _batch(tr, batch, block, device, g)
+            logits = model(x)
+            loss = F.cross_entropy(logits.reshape(-1, VOCAB), y.reshape(-1))
+            opt.zero_grad(set_to_none=True)
+            loss.backward()
+            opt.step()
+            if step % eval_every == 0 or step == steps:
+                model.eval()
+                with torch.no_grad():
+                    losses = []
+                    for _ in range(20):
+                        xv, yv = _batch(va, batch, block, device, g)
+                        lv = F.cross_entropy(model(xv).reshape(-1, VOCAB),
+                                             yv.reshape(-1))
+                        losses.append(lv.item())
+                bpb = sum(losses) / len(losses) / math.log(2)
+                print(f"[{arm}] step {step} val_bpb={bpb:.4f} vitals={model.vitals()}",
+                      flush=True)
+                model.train()
+        results[arm] = {"val_bpb": bpb, "params": n_params, "vitals": model.vitals()}
+        if save:
+            path = os.path.join(ckpt_dir, f"{arm}_s{seed}_t{steps}.pt")
+            torch.save({"arm": arm, "seed": seed, "steps": steps, "val_bpb": bpb,
+                        "state_dict": {k: v.cpu() for k, v in
+                                       model.state_dict().items()}}, path)
+            print(f"saved specimen: {path}", flush=True)
+    print(results, flush=True)
+    return results
+
+
+def smoke():
+    """Shapes/parse only — no accuracy claims."""
+    x = torch.randint(0, VOCAB, (2, 64))
+    for arm in ("sdpa", "hub", "addr_head"):
+        m = ByteLM(arm, d=96, layers=2, block=64, K=16)
+        logits = m(x)
+        assert logits.shape == (2, 64, VOCAB)
+        logits.sum().backward()
+        # causality check: future byte must not affect past logits
+        with torch.no_grad():
+            a = m(x)[0, 10]
+            x2 = x.clone(); x2[0, 40] = (x2[0, 40] + 7) % 256
+            b = m(x2)[0, 10]
+        assert torch.allclose(a, b, atol=1e-4), f"{arm} leaks future context"
+        print(f"{arm}: OK params={sum(p.numel() for p in m.parameters()):,} "
+              f"vitals={m.vitals()}", flush=True)
+    print("OK — AR bed smoke passed (verdict run: train() on GPU)", flush=True)
+
+
+def _in_notebook() -> bool:
+    try:
+        get_ipython()  # type: ignore[name-defined]  # noqa: F821
+        return True
+    except NameError:
+        return False
+
+
+if __name__ == "__main__":
+    if _in_notebook():
+        smoke()
+        print("Notebook mode: call  train(steps=2000)  in the next cell (GPU).")
+    else:
+        import argparse
+        ap = argparse.ArgumentParser()
+        ap.add_argument("--train", action="store_true")
+        ap.add_argument("--steps", type=int, default=2000)
+        a, _ = ap.parse_known_args()
+        train(steps=a.steps) if a.train else smoke()

exp019_cr/build_results.py

@@ -0,0 +1,81 @@
+"""build_results.py — exp019_cr: read results/ledger.jsonl and RE-ASSERT every
+claim in the README (retention sweep + 19b generalization block).
+Run from inside this folder: python build_results.py
+"""
+import json
+import os
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+rows = [json.loads(l) for l in
+        open(os.path.join(HERE, "results", "ledger.jsonl"), encoding="utf-8")]
+a = [r for r in rows if r["exp"] == "19"]
+b = [r for r in rows if r["exp"] == "19b"]
+assert len(a) == 28 and len(b) == 8
+
+def cellA(ch, n, s):
+    return next(r for r in a if r["channel"] == ch and r["n"] == n
+                and r["seed"] == s)
+
+def cellB(ch, s):
+    return next(r for r in b if r["channel"] == ch and r["seed"] == s)
+
+# retention claim 1: capacity curve — teachers near-perfect through N=256,
+# cliff before 1024
+for s in (0, 1):
+    assert cellA("teacher", 64, s)["recall"]["exact"] == 1.0
+    assert cellA("teacher", 256, s)["recall"]["exact"] > 0.98
+    assert cellA("teacher", 1024, s)["recall"]["exact"] < 0.20
+
+# retention claim 2: distillation tax zero-to-negative where the teacher knows
+# the content (kd_facts >= direct - 0.01 at N=64/256, both seeds)
+for s in (0, 1):
+    for n in (64, 256):
+        kd = cellA("kd_facts", n, s)["recall"]["exact"]
+        di = cellA("direct", n, s)["recall"]["exact"]
+        assert kd >= di - 0.01, (n, s, kd, di)
+
+# retention claim 3: no logit leakage on clean text (kd_general exact 0.0 all)
+for r in a:
+    if r["channel"] == "kd_general":
+        assert r["recall"]["exact"] == 0.0
+
+# retention claim 4: anchors carry no bytes (book_implant exact 0.0, both seeds)
+for s in (0, 1):
+    assert cellA("book_implant", 256, s)["recall"]["exact"] == 0.0
+
+# retention claim 5: universal catastrophic forgetting (every student channel
+# -> 0.0 exact after 1k clean steps)
+for r in a:
+    if "recall_interf" in r and r["recall_interf"] is not None:
+        assert r["recall_interf"]["exact"] == 0.0, r
+
+# 19b claim 1: partial rule learning — teachers memorize, held-out byte acc
+# ~10x chance but exact 0
+for s in (0, 1):
+    t = cellB("teacher", s)["gauges"]
+    assert t["train"]["exact"] > 0.98
+    assert 0.15 < t["heldout"]["byte_acc"] < 0.35
+    assert t["heldout"]["exact"] == 0.0
+    # format lock: variant-format recall collapses even on train keys
+    assert t["train_varfmt"]["byte_acc"] < 0.05
+
+# 19b claim 2: the logit channel beats direct on rule content, both seeds,
+# and transfers the partial rule at full fidelity
+for s in (0, 1):
+    kd, di = cellB("kd_facts", s)["gauges"], cellB("direct", s)["gauges"]
+    assert kd["train"]["exact"] > di["train"]["exact"], s
+    assert kd["heldout"]["byte_acc"] > 0.24
+    # kd students are less format-locked than direct students
+    assert kd["train_varfmt"]["byte_acc"] > di["train_varfmt"]["byte_acc"], s
+
+out = {"capacity_curve": {f"N{n}_s{s}": cellA("teacher", n, s)["recall"]["exact"]
+                          for n in (64, 256, 1024) for s in (0, 1)},
+       "kd_vs_direct_rule_train_exact": {
+           f"s{s}": [cellB("kd_facts", s)["gauges"]["train"]["exact"],
+                     cellB("direct", s)["gauges"]["train"]["exact"]]
+           for s in (0, 1)},
+       "n_rows": len(rows)}
+json.dump(out, open(os.path.join(HERE, "results", "results.json"), "w",
+                    encoding="utf-8"), indent=1)
+print(f"{len(rows)} rows -> results/results.json")
+print("all README claims asserted OK")

exp019_cr/exp014_genetic_distillation.py

@@ -0,0 +1,515 @@
+"""exp014_genetic_distillation.py — genetic distillation + memory substrate.
+14_a: multi-generational tournament (GM3 paradigm) where the aleph codebook is the
+      explicit heritable genome. Lineages: ALEPH-FLAT (consensus book + KD) |
+      ALEPH-TREE (structured genome: root book + branch books) | MLP-KD
+      (traditional: best-parent weights + KD) | NO-INHERIT (evolution floor).
+      Both sides intentionally inherit logits (KD); only ours inherits geometry.
+      Consensus = Procrustes/GPA alignment of parents' books to mean shape
+      (placement by construction — replaces GM3's k-means-on-consensus init).
+14_b: memory substrate — the D=4 home makes books size-agnostic. Implant books
+      cultivated in a small organism into a larger one (frozen / trainable), and
+      into GPT-2 relay adapters (cross-architecture frozen distillation).
+
+Riders: pure Adam wd=0; KD = KL to detached teacher probs (predictive pressure, no
+contrastive); tree routing is DENSE SOFT (oriented weights; collapse monitor on the
+root); drift-check precedes every freeze claim; GPU-only verdict runs; Colab-safe.
+Founders share a COMMON-ANCESTOR book so GPA row correspondence is inherited.
+
+Colab paste order: geolip_vitals.py -> ar_differentiation_bed.py ->
+exp013_augmentation_bed.py (only for run_b2) -> this file.
+"""
+from __future__ import annotations
+import copy
+import json
+import math
+import os
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+if "anchor_drift" not in globals():
+    try:
+        from geolip_vitals import anchor_drift, axis_aliveness, path_diversity
+    except ImportError:
+        _here = globals().get("__file__")
+        if _here is None:
+            raise ImportError("paste/run geolip_vitals.py first")
+        import sys, pathlib
+        sys.path.insert(0, str(pathlib.Path(_here).parent))
+        from geolip_vitals import anchor_drift, axis_aliveness, path_diversity
+if "ByteLM" not in globals():
+    try:
+        from ar_differentiation_bed import (ByteLM, AlephAddress, _wikitext_bytes,
+                                            _batch, VOCAB)
+    except ImportError:
+        raise ImportError("paste/run ar_differentiation_bed.py first")
+
+DATA_ROOT = os.environ.get("GEOLIP_DATA", "./data")
+EXP_DIR = os.path.join(DATA_ROOT, "exp014")
+
+
+class SquaredReLU(nn.Module):
+    def forward(self, x):
+        return F.relu(x) ** 2
+
+
+# ===================================================== consensus (the germline) ===
+@torch.no_grad()
+def procrustes_rotation(A: torch.Tensor, M: torch.Tensor) -> torch.Tensor:
+    """Orthogonal R minimizing ||A R - M||_F (rows correspond)."""
+    U, _, Vt = torch.linalg.svd(A.T.double() @ M.double())
+    return (U @ Vt).float()
+
+
+@torch.no_grad()
+def align_to(A: torch.Tensor, ref: torch.Tensor, iters: int = 20) -> torch.Tensor:
+    """Projective Procrustes (rows correspond, signs free): alternate the
+    orthogonal rotation and per-row sign flips (books live on RP^(D-1))."""
+    s = torch.ones(A.shape[0], 1)
+    for _ in range(iters):
+        R = procrustes_rotation(s * A, ref)
+        AR = (s * A) @ R
+        s_upd = torch.where((AR * ref).sum(-1, keepdim=True) < 0, -s, s)
+        if torch.equal(s_upd, s):
+            return AR
+        s = s_upd
+    return (s * A) @ procrustes_rotation(s * A, ref)
+
+
+@torch.no_grad()
+def consensus_codebook(books: list, iters: int = 50, tol: float = 1e-8):
+    """GPA to mean shape (GM3 machinery, applied to aleph books), anchored to the
+    FIRST parent's frame. Rows must correspond (common-ancestor convention); signs
+    are projective. Returns (consensus, n_iters, delta)."""
+    # device-pin to CPU: parent models may live on CUDA after KD teacher moves
+    Bs = [F.normalize(b.detach().float().cpu(), dim=-1).clone() for b in books]
+    # pairwise projective alignment to parent-0's frame, THEN GPA refinement
+    aligned = [Bs[0]] + [align_to(b, Bs[0]) for b in Bs[1:]]
+    M = F.normalize(torch.stack(aligned).mean(0), dim=-1)
+    delta, it = 0.0, 0
+    for it in range(1, iters + 1):
+        aligned = [align_to(b, M) for b in Bs]
+        M_new = F.normalize(torch.stack(aligned).mean(0), dim=-1)
+        delta = (M_new - M).norm().item()
+        M = M_new
+        if delta < tol:
+            break
+    # re-anchor to parent-0 (GPA drift of the global frame stays measurable)
+    M = align_to(M, Bs[0])
+    return M, it, delta
+
+
+@torch.no_grad()
+def implant_book(addr: "AlephAddress", book: torch.Tensor, trainable: bool = True):
+    """Load a book into an AlephAddress: codebook + home (drift measured from the
+    implant). Freeze only via trainable=False AFTER a drift-check justifies it."""
+    b = F.normalize(book.float(), dim=-1).to(addr.codebook.device)
+    assert b.shape == addr.codebook.shape, (b.shape, addr.codebook.shape)
+    addr.codebook.data.copy_(b)
+    addr.home.copy_(b)
+    addr.codebook.requires_grad_(trainable)
+
+
+# ============================================================= tree head ==========
+class TreeHead(nn.Module):
+    """Autoregressive tree (the constellation-anchor analogue, exp011 TREE operator
+    in the healthy consumption regime): a ROOT aleph (K=2, D=4) yields the 4
+    oriented weights (2K half-axes = the 4 branches, dense soft, sums to 1);
+    each BRANCH is a 64-slot... shared slot projection read by a branch-specific
+    book (K=64, D=4); output = branch-weighted mixture of branch reads -> vocab.
+    Heritable genome: root book (2,4) + 4 branch books (64,4)."""
+
+    ROOT_SLOTS = 4          # slot-parallel root consumption (the collapse cure)
+    ROOT_TAU = 0.3          # softer root temperature (wave-1 fix: single hard-tau
+                            # root partially collapsed, usage [.85,.12,.01,.02])
+
+    def __init__(self, d: int, vocab: int = 256, n_slots: int = 16):
+        super().__init__()
+        self.n_slots = n_slots
+        self.root_proj = nn.Linear(d, self.ROOT_SLOTS * 4, bias=False)
+        self.slot_proj = nn.Linear(d, n_slots * 4, bias=False)
+        nn.init.orthogonal_(self.root_proj.weight)
+        nn.init.orthogonal_(self.slot_proj.weight)
+        self.root = AlephAddress(2, 4, tau=self.ROOT_TAU)
+        self.branches = nn.ModuleList([AlephAddress(64, 4) for _ in range(4)])
+        self.out = nn.Linear(n_slots * 4, vocab, bias=True)
+        self._last_root = None
+
+    def forward(self, h):
+        B, n, _ = h.shape
+        rs = self.root_proj(h).view(B, n, self.ROOT_SLOTS, 4)
+        p, m = self.root.oriented(rs)                      # (B,n,S,2) x2
+        w = torch.cat([p, m], dim=-1).mean(dim=-2)          # slot-avg -> (B,n,4)
+        self._last_root = w.detach()
+        slots = self.slot_proj(h).view(B, n, self.n_slots, 4)
+        mix = 0
+        for b, br in enumerate(self.branches):
+            mix = mix + w[..., b:b + 1] * br.m_hat(slots).reshape(B, n, -1)
+        return self.out(mix)
+
+    def genome(self):
+        return {"root": self.root.codebook.detach().clone(),
+                **{f"branch{i}": br.codebook.detach().clone()
+                   for i, br in enumerate(self.branches)}}
+
+    @torch.no_grad()
+    def inherit(self, genomes: list):
+        c, it, dl = consensus_codebook([g["root"] for g in genomes])
+        implant_book(self.root, c)
+        for i, br in enumerate(self.branches):
+            c, _, _ = consensus_codebook([g[f"branch{i}"] for g in genomes])
+            implant_book(br, c)
+
+    @torch.no_grad()
+    def vitals(self):
+        out = {"root_drift": round(anchor_drift(self.root.codebook,
+                                                self.root.home)["mean"], 4)}
+        if self._last_root is not None:
+            w = self._last_root.reshape(-1, 4)
+            usage = w.mean(0)
+            usage = usage / usage.sum()
+            out["root_usage"] = [round(float(u), 3) for u in usage]
+            ent = -(usage.clamp_min(1e-9) * usage.clamp_min(1e-9).log()).sum()
+            out["root_ppl4"] = round(float(ent.exp()), 3)
+        d = [anchor_drift(br.codebook, br.home)["mean"] for br in self.branches]
+        out["branch_drift"] = [round(x, 3) for x in d]
+        return out
+
+
+# ============================================================ organisms ===========
+def make_organism(lineage: str, d: int = 192, layers: int = 4, block: int = 256,
+                  seed: int = 0):
+    """lineage in {aleph_flat, aleph_tree, mlp_kd, no_inherit}. no_inherit uses the
+    aleph_flat architecture (the control isolates INHERITANCE, not architecture)."""
+    torch.manual_seed(seed)
+    if lineage in ("aleph_flat", "no_inherit", "aleph_full", "aleph_weights"):
+        return ByteLM("addr_msl64", d=d, layers=layers, block=block)
+    if lineage == "aleph_tree":
+        m = ByteLM("sdpa", d=d, layers=layers, block=block)
+        m.head = TreeHead(d)
+        return m
+    if lineage == "mlp_kd":
+        m = ByteLM("sdpa", d=d, layers=layers, block=block)
+        m.head = nn.Sequential(nn.Linear(d, 224), SquaredReLU(),
+                               nn.LayerNorm(224), nn.Linear(224, VOCAB))
+        return m
+    raise ValueError(lineage)
+
+
+def genome_of(model):
+    """The heritable organ = co-adapted (projection, book) pair(s). Books inherit
+    by CONSENSUS (the geometric germline); projections inherit from the BEST
+    parent (weight copy) — implanting a book against a random projection puts the
+    child below random init (campaign-v2 lesson)."""
+    if isinstance(model.head, TreeHead):
+        g = model.head.genome()
+        g["root_proj"] = model.head.root_proj.weight.detach().cpu().clone()
+        g["slot_proj"] = model.head.slot_proj.weight.detach().cpu().clone()
+        return g
+    if hasattr(model, "head_addr"):
+        return {"flat": model.head_addr.codebook.detach().cpu().clone(),
+                "proj": model.head_proj.weight.detach().cpu().clone()}
+    return None
+
+
+@torch.no_grad()
+def inherit_genome(model, genomes: list):
+    """genomes[0] = the BEST parent (selection order matters)."""
+    if isinstance(model.head, TreeHead):
+        model.head.inherit(genomes)
+        model.head.root_proj.weight.copy_(genomes[0]["root_proj"].to(
+            model.head.root_proj.weight.device))
+        model.head.slot_proj.weight.copy_(genomes[0]["slot_proj"].to(
+            model.head.slot_proj.weight.device))
+    elif hasattr(model, "head_addr"):
+        c, it, dl = consensus_codebook([g["flat"] for g in genomes])
+        implant_book(model.head_addr, c)
+        model.head_proj.weight.copy_(genomes[0]["proj"].to(
+            model.head_proj.weight.device))
+
+
+def organism_vitals(model):
+    if isinstance(model.head, TreeHead):
+        return model.head.vitals()
+    return model.vitals() if hasattr(model, "vitals") else {}
+
+
+# ========================================================= train one member ======
+def train_member(model, tr, va, steps=2000, batch=32, block=256, device="cuda",
+                 seed=0, teachers=None, kd_alpha=1.0):
+    """CE (+ KL to detached mean teacher probs when teachers given). Pure Adam."""
+    g = torch.Generator().manual_seed(seed)
+    model = model.to(device)
+    opt = torch.optim.Adam(model.parameters(), lr=3e-4, weight_decay=0.0)
+    if teachers:
+        teachers = [t.to(device).eval() for t in teachers]
+    for step in range(1, steps + 1):
+        x, y = _batch(tr, batch, block, device, g)
+        logits = model(x)
+        loss = F.cross_entropy(logits.reshape(-1, VOCAB), y.reshape(-1))
+        if teachers:
+            with torch.no_grad():
+                tp = torch.stack([F.softmax(t(x), -1) for t in teachers]).mean(0)
+            loss = loss + kd_alpha * F.kl_div(
+                F.log_softmax(logits, -1), tp, reduction="batchmean")
+        opt.zero_grad(set_to_none=True); loss.backward(); opt.step()
+    model.eval()
+    with torch.no_grad():
+        ls = []
+        for _ in range(20):
+            xv, yv = _batch(va, batch, block, device, g)
+            ls.append(F.cross_entropy(model(xv).reshape(-1, VOCAB),
+                                      yv.reshape(-1)).item())
+    return sum(ls) / len(ls) / math.log(2)          # bpb
+
+
+# ============================================================ the tournament ======
+def run_tournament(lineage: str, gens: int = 4, pop: int = 4, steps: int = 2000,
+                   seed: int = 0, device: str = "cuda",
+                   catastrophic_at: int | None = None):
+    """One lineage, one tournament seed. Logs per-gen to the ledger; saves the
+    champion genome per generation. catastrophic_at=G injects a 0-step random
+    parent into the consensus at generation G (the GM3 robustness probe)."""
+    if not torch.cuda.is_available():
+        raise RuntimeError("verdict runs are GPU-only")
+    os.makedirs(EXP_DIR, exist_ok=True)
+    tr, va = _wikitext_bytes(DATA_ROOT)
+    ledger = open(os.path.join(EXP_DIR, "ledger.jsonl"), "a", encoding="utf-8")
+    # common ancestor: every founder book starts identical within a tournament
+    torch.manual_seed(9000 + seed)
+    ancestor = make_organism(lineage, seed=9000 + seed)
+    anc_genome = genome_of(ancestor)
+    parents, parent_models, champion_genomes = [], [], []
+    for gen in range(gens):
+        members = []
+        for i in range(pop):
+            mseed = seed * 1000 + gen * 100 + i
+            m = make_organism(lineage, seed=mseed)
+            if anc_genome and gen == 0:
+                inherit_genome(m, [anc_genome])            # common ancestor
+            if gen > 0:
+                is_fresh = (i == pop - 1)                   # gene flow founder
+                if not is_fresh:
+                    if lineage in ("aleph_flat", "aleph_tree"):
+                        gs = [genome_of(pm) for pm in parent_models]
+                        if catastrophic_at == gen:
+                            bad = make_organism(lineage, seed=666 + i)
+                            gs = gs + [genome_of(bad)]
+                        inherit_genome(m, gs)
+                    elif lineage == "aleph_full":
+                        # v4 arm (v3 lesson: continuity is what pays) — inherit the
+                        # WHOLE best parent, then overwrite the book with the
+                        # two-parent consensus: germline ON TOP of continuity.
+                        m.load_state_dict(copy.deepcopy(
+                            parent_models[0].state_dict()))
+                        gs = [genome_of(pm) for pm in parent_models]
+                        if catastrophic_at == gen:
+                            bad = make_organism(lineage, seed=666 + i)
+                            gs = gs + [genome_of(bad)]
+                        c, _, _ = consensus_codebook([g["flat"] for g in gs])
+                        implant_book(m.head_addr, c)
+                    elif lineage in ("mlp_kd", "aleph_weights"):
+                        # pure continuity (no germline op) — aleph_weights is the
+                        # within-architecture control for aleph_full
+                        m.load_state_dict(copy.deepcopy(
+                            parent_models[0].state_dict()))
+                    # no_inherit: nothing
+            # KD: alpha 0.25 (campaign-v2 lesson: alpha=1.0 from near-parity
+            # teachers COMPOUNDS DOWNWARD — inverse evolution; fresh-founder
+            # control isolated it). Fresh founders get NO KD (clean gene flow).
+            is_fresh_now = (gen > 0 and i == pop - 1)
+            teachers = parent_models if (gen > 0 and not is_fresh_now
+                                          and lineage != "no_inherit") else None
+            bpb = train_member(m, tr, va, steps=steps, device=device,
+                               seed=mseed, teachers=teachers, kd_alpha=0.25)
+            vit = organism_vitals(m)
+            members.append((bpb, m))
+            rec = {"exp": "14a", "lineage": lineage, "tseed": seed, "gen": gen,
+                   "member": i, "fresh": gen > 0 and i == pop - 1,
+                   "catastrophic": catastrophic_at == gen, "bpb": round(bpb, 4),
+                   "vitals": vit}
+            ledger.write(json.dumps(rec) + "\n"); ledger.flush()
+            print(f"[14a {lineage} t{seed} g{gen} m{i}] bpb={bpb:.4f} {vit}",
+                  flush=True)
+        members.sort(key=lambda t: t[0])
+        parent_models = [members[0][1].cpu(), members[1][1].cpu()]
+        best = members[0][0]
+        gene = genome_of(members[0][1])
+        if gene:
+            torch.save(gene, os.path.join(
+                EXP_DIR, f"champion_{lineage}_t{seed}_g{gen}.pt"))
+            champion_genomes.append(gene)
+        print(f"[14a {lineage} t{seed} g{gen}] BEST={best:.4f} "
+              f"mean={sum(b for b, _ in members)/pop:.4f}", flush=True)
+        for _, mm in members[2:]:
+            del mm
+        torch.cuda.empty_cache()
+    ledger.close()
+    return best
+
+
+# ============================================================ 14_b implants ======
+def run_b1(steps: int = 2000, seed: int = 0, device: str = "cuda",
+           donor_book: torch.Tensor | None = None, tag: str = "small_cultivated"):
+    """Cross-size: donor book (default: cultivate in a small organism) implanted
+    into a LARGE organism. Arms: fresh | implant-trainable | implant-frozen | mlp."""
+    if not torch.cuda.is_available():
+        raise RuntimeError("verdict runs are GPU-only")
+    os.makedirs(EXP_DIR, exist_ok=True)
+    tr, va = _wikitext_bytes(DATA_ROOT)
+    ledger = open(os.path.join(EXP_DIR, "ledger.jsonl"), "a", encoding="utf-8")
+    if donor_book is None:
+        small = make_organism("aleph_flat", d=128, layers=2, seed=seed)
+        bpb_small = train_member(small, tr, va, steps=steps, device=device, seed=seed)
+        donor_book = genome_of(small)["flat"]
+        print(f"[14b donor small] bpb={bpb_small:.4f}", flush=True)
+    results = {}
+    for arm in ("fresh", "implant_train", "implant_frozen", "mlp"):
+        lineage = "mlp_kd" if arm == "mlp" else "aleph_flat"
+        m = make_organism(lineage, d=384, layers=6, seed=seed + 10)
+        if arm.startswith("implant"):
+            implant_book(m.head_addr, donor_book, trainable=(arm == "implant_train"))
+        bpb = train_member(m, tr, va, steps=steps, device=device, seed=seed + 10)
+        vit = organism_vitals(m)
+        results[arm] = {"bpb": round(bpb, 4), "vitals": vit}
+        rec = {"exp": "14b1", "arm": arm, "donor": tag, "seed": seed,
+               "bpb": round(bpb, 4), "vitals": vit}
+        ledger.write(json.dumps(rec) + "\n"); ledger.flush()
+        print(f"[14b1 {arm} donor={tag}] bpb={bpb:.4f} {vit}", flush=True)
+        del m; torch.cuda.empty_cache()
+    ledger.close()
+    return results, donor_book
+
+
+def run_b2(donor_book: torch.Tensor, steps: int = 1500, seed: int = 0,
+           device: str = "cuda", tag: str = "small_cultivated"):
+    """Cross-architecture: implant the donor book into every GPT-2 relay adapter
+    (exp013 Track C bed) vs random-init relays. Books are (64,4) — size-agnostic."""
+    from exp013_augmentation_bed import _wikitext_lines
+    from transformers import GPT2LMHeadModel, GPT2TokenizerFast
+    if "MslRelay" not in globals():
+        from ar_differentiation_bed import MslRelay
+    from exp013_augmentation_bed import _BlockWithAdapter
+    tok = GPT2TokenizerFast.from_pretrained("gpt2")
+    tr_lines, va_lines = _wikitext_lines(DATA_ROOT)
+    stream_tr = tok("\n\n".join(tr_lines[:8000]), return_tensors="pt").input_ids[0]
+    stream_va = tok("\n\n".join(va_lines[:1000]), return_tensors="pt").input_ids[0]
+    ledger = open(os.path.join(EXP_DIR, "ledger.jsonl"), "a", encoding="utf-8")
+    out = {}
+    for arm in ("random_relays", "implanted_relays"):
+        torch.manual_seed(seed)
+        g = torch.Generator().manual_seed(seed)
+        model = GPT2LMHeadModel.from_pretrained("gpt2").to(device)
+        for p in model.parameters():
+            p.requires_grad_(False)
+        adapters = []
+        for i, blk in enumerate(model.transformer.h):
+            ad = MslRelay(model.config.n_embd).to(device)
+            if arm == "implanted_relays":
+                implant_book(ad.addr, donor_book, trainable=True)
+            model.transformer.h[i] = _BlockWithAdapter(blk, ad)
+            adapters.append(ad)
+        params = [p for ad in adapters for p in ad.parameters()
+                  if p.requires_grad]
+        opt = torch.optim.Adam(params, lr=1e-3, weight_decay=0.0)
+        block = 256
+        for step in range(1, steps + 1):
+            ix = torch.randint(0, stream_tr.numel() - block - 1, (8,), generator=g)
+            x = torch.stack([stream_tr[i:i + block] for i in ix]).to(device)
+            loss = model(x, labels=x).loss
+            opt.zero_grad(set_to_none=True); loss.backward(); opt.step()
+        model.eval()
+        with torch.no_grad():
+            ls = []
+            for j in range(0, stream_va.numel() - block - 1, block * 4):
+                x = stream_va[j:j + block].unsqueeze(0).to(device)
+                ls.append(model(x, labels=x).loss.item())
+        ppl = math.exp(sum(ls) / len(ls))
+        gates = [round(ad.gate.sigmoid().item(), 4) for ad in adapters]
+        drifts = [round(anchor_drift(ad.addr.codebook, ad.addr.home)["mean"], 3)
+                  for ad in adapters]
+        out[arm] = {"ppl": round(ppl, 3), "gates": gates, "drift": drifts}
+        rec = {"exp": "14b2", "arm": arm, "donor": tag, "seed": seed,
+               "ppl": round(ppl, 3), "gates": gates, "drift": drifts}
+        ledger.write(json.dumps(rec) + "\n"); ledger.flush()
+        print(f"[14b2 {arm} donor={tag}] ppl={ppl:.3f} gates={gates[:3]}.. "
+              f"drift={drifts[:3]}..", flush=True)
+        del model; torch.cuda.empty_cache()
+    ledger.close()
+    return out
+
+
+# ================================================================ smoke ===========
+def smoke():
+    """CPU shapes/parse only: GPA ground truth, tree causality, implant, KD path."""
+    g = torch.Generator().manual_seed(0)
+    # GPA: two rotated (+row-sign-flipped) copies of one book must align back to it
+    A = F.normalize(torch.randn(64, 4, generator=g), dim=-1)
+    q, _ = torch.linalg.qr(torch.randn(4, 4, generator=g))
+    B = A @ q
+    B[::3] = -B[::3]
+    C, it, dl = consensus_codebook([A, B])
+    cos = (F.normalize(C, dim=-1) * A).sum(-1).abs().mean()
+    assert cos > 0.999, cos
+    print(f"GPA OK (iters={it}, delta={dl:.2e}, |cos to truth|={cos:.5f})")
+    x = torch.randint(0, 256, (2, 64))
+    for lineage in ("aleph_flat", "aleph_tree", "mlp_kd", "no_inherit"):
+        m = make_organism(lineage, d=96, layers=2, block=64, seed=0)
+        lg = m(x); assert lg.shape == (2, 64, 256); lg.sum().backward()
+        with torch.no_grad():
+            a = m(x)[0, 10]; x2 = x.clone(); x2[0, 40] = (x2[0, 40] + 7) % 256
+            b = m(x2)[0, 10]
+        assert torch.allclose(a, b, atol=1e-4), lineage + " leaks"
+        gnm = genome_of(m)
+        if gnm:
+            inherit_genome(m, [gnm, gnm])       # self-consensus = identity-ish
+        print(lineage, "OK params",
+              f"{sum(p.numel() for p in m.parameters()):,}",
+              organism_vitals(m) if lineage != "mlp_kd" else {})
+    # KD path: teacher forward + KL backward
+    t = make_organism("mlp_kd", d=96, layers=2, block=64, seed=1)
+    s = make_organism("aleph_flat", d=96, layers=2, block=64, seed=2)
+    tp = F.softmax(t(x), -1).detach()
+    loss = F.kl_div(F.log_softmax(s(x), -1), tp, reduction="batchmean")
+    loss.backward()
+    print("KD OK — exp014 smoke passed (tournament on GPU: run_tournament(...))")
+
+
+def _in_notebook():
+    try:
+        get_ipython()  # type: ignore[name-defined]  # noqa: F821
+        return True
+    except NameError:
+        return False
+
+
+if __name__ == "__main__":
+    if _in_notebook():
+        smoke()
+        print("Notebook: run_tournament('aleph_flat'), run_b1(), run_b2(book).")
+    else:
+        import argparse
+        ap = argparse.ArgumentParser()
+        ap.add_argument("--mode", default="smoke",
+                        choices=["smoke", "tournament", "b1", "b2"])
+        ap.add_argument("--lineage", default="aleph_full",
+                        help="tournament lineage: aleph_flat|aleph_full|"
+                             "aleph_weights|aleph_tree|mlp_kd|no_inherit")
+        ap.add_argument("--seed", type=int, default=0)
+        ap.add_argument("--steps", type=int, default=2000)
+        ap.add_argument("--genome", default="genomes/champion_aleph_full_t0_g3.pt",
+                        help="donor genome .pt for --mode b1/b2 (uses its 'flat' book)")
+        a, _ = ap.parse_known_args()
+        if a.mode == "smoke":
+            smoke()
+        elif a.mode == "tournament":
+            run_tournament(a.lineage, steps=a.steps, seed=a.seed)
+        elif a.mode == "b1":
+            donor = (torch.load(a.genome, map_location="cpu")["flat"]
+                     if os.path.exists(a.genome) else None)
+            run_b1(steps=a.steps, seed=a.seed, donor_book=donor,
+                   tag=os.path.basename(a.genome) if donor is not None
+                   else "small_cultivated")
+        elif a.mode == "b2":
+            donor = torch.load(a.genome, map_location="cpu")["flat"]
+            run_b2(donor, seed=a.seed, tag=os.path.basename(a.genome))

exp019_cr/exp019_content_retention.py

@@ -0,0 +1,402 @@
+"""exp019_content_retention.py — CAPACITY FOR DISTILLED CONTENT RETENTION.
+When content is DISTILLED rather than directly learned, how much is retained,
+through which channel, and for how long? The memory-substrate compass made a
+measurable instrument — and the weak-to-strong distillation cell made real: the
+teacher holds content the student lacks (true headroom on the content axis).
+
+THE CONTENT: N fact records "\n@<key6>=<value12>\n" with random alphanumeric
+keys/values — uncompletable from language statistics, so exact-match completion
+IS retention. Facts are mixed into the byte stream (fact-packed blocks at
+FACT_RATE against wikitext blocks).
+
+THE TEACHER: the certified bed model (addr_msl64 aleph substrate) trained
+TEACHER_STEPS on the mix; gated on its own recall (the gate doubles as the
+substrate's DIRECT capacity datum at each N).
+
+THE CHANNELS (fresh student each, STUDENT_STEPS budget):
+  direct       — ground-truth CE on the mix (ceiling: learning, not distillation)
+  kd_facts     — CE on wikitext blocks; on fact blocks the ONLY signal is the
+                 teacher's logits (KL) — pure distilled content
+  kd_general   — CE + KL to teacher on CLEAN wikitext only; facts never shown —
+                 does content leak through logits without exposure?
+  book_implant — teacher's farmed codebook implanted (trainable) into a fresh
+                 student, clean-stream training — do the anchors carry
+                 byte-content? (the open question from the exp014 implant studies, asked directly)
+  none         — clean-stream only (floor)
+THE AXES: capacity N in {64, 256, 1024} (main channels); retention = recall
+right after training AND after INTERFERE_STEPS further clean-stream steps
+(the forgetting measurement). KD alpha 1.0 here is LEGAL: the teacher has real
+headroom on the content axis (the inverse-evolution failure was alpha 1.0 at
+NEAR-PARITY — regime, not constant).
+
+Preregistered forks:
+  F1 capacity curve: direct recall vs N = the substrate's raw content capacity.
+  F2 distillation tax: kd_facts vs direct at each N (what survives the logit
+     channel).
+  F3 leakage: kd_general recall > floor => content crosses on clean text alone.
+  F4 anchors: book_implant recall ~ floor => codebooks do not carry byte
+     content (mean-shape/content question closed in the direct sense).
+  F5 half-life: post-interference retention per channel (does distilled content
+     decay faster than learned content?).
+Riders: pure Adam wd=0; GPU-only verdicts; >=2 seeds; Colab-safe. Paste order:
+geolip_vitals -> ar_differentiation_bed -> exp014_genetic_distillation ->
+this file.
+"""
+from __future__ import annotations
+import json
+import math
+import os
+import string
+import torch
+import torch.nn.functional as F
+
+if "ByteLM" not in globals():
+    try:
+        from ar_differentiation_bed import ByteLM, _wikitext_bytes, _batch, VOCAB
+        from exp014_genetic_distillation import implant_book
+        from geolip_vitals import anchor_drift
+    except ImportError:
+        _here = globals().get("__file__")
+        if _here is None:
+            raise ImportError("paste geolip_vitals + ar_differentiation_bed + "
+                              "exp014_genetic_distillation first")
+        import sys, pathlib
+        sys.path.insert(0, str(pathlib.Path(_here).parent))
+        from ar_differentiation_bed import ByteLM, _wikitext_bytes, _batch, VOCAB
+        from exp014_genetic_distillation import implant_book
+        from geolip_vitals import anchor_drift
+
+DATA_ROOT = os.environ.get("GEOLIP_DATA", "./data")
+EXP19_DIR = os.path.join(DATA_ROOT, "exp019")
+
+KEY_LEN, VAL_LEN = 6, 12
+FACT_RATE = 0.5              # fraction of training blocks drawn from fact stream
+TEACHER_STEPS = 4000
+STUDENT_STEPS = 2000
+INTERFERE_STEPS = 1000
+ALNUM = (string.ascii_lowercase + string.digits).encode()
+
+
+def make_facts(n: int, seed: int = 0):
+    """N records '\\n@<key>=<value>\\n'; returns (records list, fact byte stream)."""
+    g = torch.Generator().manual_seed(4000 + seed)
+    recs = []
+    seen = set()
+    while len(recs) < n:
+        k = bytes(ALNUM[i] for i in torch.randint(len(ALNUM), (KEY_LEN,),
+                                                  generator=g))
+        if k in seen:
+            continue
+        seen.add(k)
+        v = bytes(ALNUM[i] for i in torch.randint(len(ALNUM), (VAL_LEN,),
+                                                  generator=g))
+        recs.append((k, v))
+    return recs
+
+
+def fact_stream(recs, copies: int = 50, seed: int = 0) -> torch.Tensor:
+    """Byte stream of shuffled fact records (each record appears `copies` times)."""
+    g = torch.Generator().manual_seed(5000 + seed)
+    order = torch.cat([torch.randperm(len(recs), generator=g)
+                       for _ in range(copies)])
+    blob = b"".join(b"\n@" + recs[i][0] + b"=" + recs[i][1] + b"\n"
+                    for i in order.tolist())
+    return torch.frombuffer(bytearray(blob), dtype=torch.uint8).clone()
+
+
+def _mix_batch(tr, fs, batch, block, device, g):
+    """Blocks drawn from the fact stream with prob FACT_RATE, else wikitext.
+    Returns (x, y, fact_mask (B,)) — mask marks fact-sourced rows."""
+    xw, yw = _batch(tr, batch, block, device, g)
+    xf, yf = _batch(fs, batch, block, device, g)
+    m = (torch.rand(batch, generator=g) < FACT_RATE).to(device)
+    x = torch.where(m[:, None], xf, xw)
+    y = torch.where(m[:, None], yf, yw)
+    return x, y, m
+
+
+@torch.no_grad()
+def recall(model, recs, device="cuda", max_eval: int = 256,
+           batch: int = 64) -> dict:
+    """Exact-match greedy completion: prompt '\\n@<key>=' -> VAL_LEN bytes."""
+    model = model.to(device).eval()
+    recs = recs[:max_eval]
+    prompts = torch.stack([torch.frombuffer(
+        bytearray(b"\n@" + k + b"="), dtype=torch.uint8).long()
+        for k, _ in recs]).to(device)
+    outs = []
+    for i in range(0, len(recs), batch):
+        x = prompts[i:i + batch]
+        for _ in range(VAL_LEN):
+            nxt = model(x)[:, -1].argmax(-1, keepdim=True)
+            x = torch.cat([x, nxt], dim=1)
+        outs.append(x[:, -VAL_LEN:].cpu())
+    got = torch.cat(outs)
+    tgt = torch.stack([torch.frombuffer(bytearray(v), dtype=torch.uint8).long()
+                       for _, v in recs])
+    byte_acc = (got == tgt).float().mean().item()
+    exact = (got == tgt).all(dim=1).float().mean().item()
+    return {"exact": round(exact, 4), "byte_acc": round(byte_acc, 4)}
+
+
+def train_stream(model, tr, va, fs=None, teacher=None, channel="direct",
+                 steps=2000, batch=32, block=256, device="cuda", seed=0):
+    """One training run under a channel's signal routing (docstring above)."""
+    g = torch.Generator().manual_seed(seed)
+    model = model.to(device)
+    if teacher is not None:
+        teacher = teacher.to(device).eval()
+    opt = torch.optim.Adam(model.parameters(), lr=3e-4, weight_decay=0.0)
+    for step in range(1, steps + 1):
+        if channel in ("direct", "kd_facts") and fs is not None:
+            x, y, m = _mix_batch(tr, fs, batch, block, device, g)
+        else:                                   # clean wikitext stream
+            x, y = _batch(tr, batch, block, device, g)
+            m = torch.zeros(batch, dtype=torch.bool, device=device)
+        logits = model(x)
+        if channel == "kd_facts":
+            # ground truth on wiki rows only; teacher logits are the ONLY
+            # signal on fact rows (pure distilled content)
+            ce_rows = ~m
+            loss = torch.tensor(0.0, device=device)
+            if ce_rows.any():
+                loss = F.cross_entropy(logits[ce_rows].reshape(-1, VOCAB),
+                                       y[ce_rows].reshape(-1))
+            if m.any():
+                with torch.no_grad():
+                    tp = F.softmax(teacher(x[m]), -1)
+                loss = loss + F.kl_div(F.log_softmax(logits[m], -1), tp,
+                                       reduction="batchmean")
+        elif channel == "kd_general":
+            loss = F.cross_entropy(logits.reshape(-1, VOCAB), y.reshape(-1))
+            with torch.no_grad():
+                tp = F.softmax(teacher(x), -1)
+            loss = loss + F.kl_div(F.log_softmax(logits, -1), tp,
+                                   reduction="batchmean")
+        else:                                   # direct / book_implant / none
+            loss = F.cross_entropy(logits.reshape(-1, VOCAB), y.reshape(-1))
+        opt.zero_grad(set_to_none=True); loss.backward(); opt.step()
+    model.eval()
+    with torch.no_grad():
+        ls = []
+        for _ in range(10):
+            xv, yv = _batch(va, batch, block, device, g)
+            ls.append(F.cross_entropy(model(xv).reshape(-1, VOCAB),
+                                      yv.reshape(-1)).item())
+    return sum(ls) / len(ls) / math.log(2)
+
+
+def run_retention(n_facts=(64, 256, 1024), seeds=(0, 1), device="cuda"):
+    if not torch.cuda.is_available():
+        raise RuntimeError("verdict runs are GPU-only")
+    os.makedirs(EXP19_DIR, exist_ok=True)
+    tr, va = _wikitext_bytes(DATA_ROOT)
+    ledger = open(os.path.join(EXP19_DIR, "ledger.jsonl"), "a", encoding="utf-8")
+
+    def log(rec):
+        ledger.write(json.dumps(rec) + "\n"); ledger.flush()
+        print(f"[19 {rec['channel']} N={rec['n']} s{rec['seed']}] "
+              f"recall={rec['recall']} after_interf={rec.get('recall_interf')} "
+              f"bpb={rec['bpb']}", flush=True)
+
+    for seed in seeds:
+        for n in n_facts:
+            recs = make_facts(n, seed=seed)
+            fs = fact_stream(recs, seed=seed)
+            # ---- teacher (also the DIRECT capacity datum at TEACHER_STEPS)
+            torch.manual_seed(seed)
+            teacher = ByteLM("addr_msl64")
+            t_bpb = train_stream(teacher, tr, va, fs=fs, channel="direct",
+                                 steps=TEACHER_STEPS, device=device, seed=seed)
+            t_rec = recall(teacher, recs, device=device)
+            log({"exp": "19", "channel": "teacher", "n": n, "seed": seed,
+                 "steps": TEACHER_STEPS, "recall": t_rec, "bpb": round(t_bpb, 4)})
+            torch.save({"n": n, "seed": seed,
+                        "state_dict": {k: v.cpu() for k, v in
+                                       teacher.state_dict().items()}},
+                       os.path.join(EXP19_DIR, f"teacher_N{n}_s{seed}.pt"))
+            # ---- channels
+            chans = ["direct", "kd_facts", "kd_general"]
+            if n == 256:
+                chans += ["book_implant", "none"]
+            for ch in chans:
+                torch.manual_seed(1000 + seed)
+                m = ByteLM("addr_msl64")
+                if ch == "book_implant":
+                    implant_book(m.head_addr,
+                                 teacher.head_addr.codebook.detach().cpu())
+                bpb = train_stream(
+                    m, tr, va, fs=fs if ch in ("direct", "kd_facts") else None,
+                    teacher=teacher if ch.startswith("kd") else None,
+                    channel=ch, steps=STUDENT_STEPS, device=device,
+                    seed=1000 + seed)
+                r0 = recall(m, recs, device=device)
+                # retention under interference: further CLEAN-stream training
+                bpb2 = train_stream(m, tr, va, channel="none",
+                                    steps=INTERFERE_STEPS, device=device,
+                                    seed=2000 + seed)
+                r1 = recall(m, recs, device=device)
+                log({"exp": "19", "channel": ch, "n": n, "seed": seed,
+                     "steps": STUDENT_STEPS, "recall": r0, "recall_interf": r1,
+                     "bpb": round(bpb, 4), "bpb_after_interf": round(bpb2, 4)})
+                del m
+                torch.cuda.empty_cache()
+            del teacher
+            torch.cuda.empty_cache()
+    ledger.close()
+
+
+# ==================== exp019b — GENERALIZATION block =========================
+# Rule-bearing content: value = fixed random substitution cipher applied to the
+# key, extended to VAL_LEN (v[i] = subst(k[i % KEY_LEN])). Teacher sees
+# N_TRAIN rule-keys; N_TEST keys are HELD OUT. Held-out recall = the RULE
+# generalizing, not the list. Sharp question: does the logit channel transfer
+# the rule better than it transfers the rote list? Plus prompt-format variants
+# (content vs surface form disentangled).
+
+def make_rule_facts(n_train: int = 256, n_test: int = 128, seed: int = 0):
+    g = torch.Generator().manual_seed(6000 + seed)
+    subst = {ALNUM[i]: ALNUM[j] for i, j in
+             enumerate(torch.randperm(len(ALNUM), generator=g).tolist())}
+    keys, seen = [], set()
+    while len(keys) < n_train + n_test:
+        k = bytes(ALNUM[i] for i in torch.randint(len(ALNUM), (KEY_LEN,),
+                                                  generator=g))
+        if k not in seen:
+            seen.add(k)
+            keys.append(k)
+    def val(k):
+        return bytes(subst[k[i % KEY_LEN]] for i in range(VAL_LEN))
+    train = [(k, val(k)) for k in keys[:n_train]]
+    test = [(k, val(k)) for k in keys[n_train:]]
+    return train, test
+
+
+@torch.no_grad()
+def recall_fmt(model, recs, fmt: bytes = b"\n@%s=", device="cuda",
+               max_eval: int = 256, batch: int = 64) -> dict:
+    """recall() under an arbitrary prompt format (b'\\n@%s=' = the training
+    format; variants probe surface-form generalization)."""
+    model = model.to(device).eval()
+    recs = recs[:max_eval]
+    proms = [torch.frombuffer(bytearray(fmt.replace(b"%s", k)),
+                              dtype=torch.uint8).long() for k, _ in recs]
+    L = max(p.numel() for p in proms)
+    # left-pad with newlines to equal length (causal — padding is prefix noise)
+    prompts = torch.stack([torch.cat([torch.full((L - p.numel(),), 10,
+                                                 dtype=torch.long), p])
+                           for p in proms]).to(device)
+    outs = []
+    for i in range(0, len(recs), batch):
+        x = prompts[i:i + batch]
+        for _ in range(VAL_LEN):
+            nxt = model(x)[:, -1].argmax(-1, keepdim=True)
+            x = torch.cat([x, nxt], dim=1)
+        outs.append(x[:, -VAL_LEN:].cpu())
+    got = torch.cat(outs)
+    tgt = torch.stack([torch.frombuffer(bytearray(v), dtype=torch.uint8).long()
+                       for _, v in recs])
+    return {"exact": round((got == tgt).all(dim=1).float().mean().item(), 4),
+            "byte_acc": round((got == tgt).float().mean().item(), 4)}
+
+
+FMT_TRAIN = b"\n@%s="
+FMT_VARIANT = b" @%s= "          # never seen in training: pure format shift
+
+
+def run_generalization(n_train: int = 256, n_test: int = 128, seeds=(0, 1),
+                       device="cuda"):
+    if not torch.cuda.is_available():
+        raise RuntimeError("verdict runs are GPU-only")
+    os.makedirs(EXP19_DIR, exist_ok=True)
+    tr, va = _wikitext_bytes(DATA_ROOT)
+    ledger = open(os.path.join(EXP19_DIR, "ledger.jsonl"), "a", encoding="utf-8")
+
+    def gauges(model, train_recs, test_recs):
+        return {"train": recall_fmt(model, train_recs, FMT_TRAIN, device=device),
+                "heldout": recall_fmt(model, test_recs, FMT_TRAIN, device=device),
+                "train_varfmt": recall_fmt(model, train_recs, FMT_VARIANT,
+                                           device=device)}
+
+    for seed in seeds:
+        train_recs, test_recs = make_rule_facts(n_train, n_test, seed=seed)
+        fs = fact_stream(train_recs, seed=seed)         # held-out NEVER streamed
+        torch.manual_seed(seed)
+        teacher = ByteLM("addr_msl64")
+        t_bpb = train_stream(teacher, tr, va, fs=fs, channel="direct",
+                             steps=TEACHER_STEPS, device=device, seed=seed)
+        gt = gauges(teacher, train_recs, test_recs)
+        rec = {"exp": "19b", "channel": "teacher", "n": n_train, "seed": seed,
+               "steps": TEACHER_STEPS, "gauges": gt, "bpb": round(t_bpb, 4)}
+        ledger.write(json.dumps(rec) + "\n"); ledger.flush()
+        print(f"[19b teacher s{seed}] {gt} bpb={t_bpb:.4f}", flush=True)
+        torch.save({"seed": seed, "state_dict": {k: v.cpu() for k, v in
+                                                 teacher.state_dict().items()}},
+                   os.path.join(EXP19_DIR, f"rule_teacher_s{seed}.pt"))
+        for ch in ("direct", "kd_facts", "kd_general"):
+            torch.manual_seed(1000 + seed)
+            m = ByteLM("addr_msl64")
+            bpb = train_stream(
+                m, tr, va, fs=fs if ch in ("direct", "kd_facts") else None,
+                teacher=teacher if ch.startswith("kd") else None,
+                channel=ch, steps=STUDENT_STEPS, device=device, seed=1000 + seed)
+            g0 = gauges(m, train_recs, test_recs)
+            bpb2 = train_stream(m, tr, va, channel="none",
+                                steps=INTERFERE_STEPS, device=device,
+                                seed=2000 + seed)
+            g1 = gauges(m, train_recs, test_recs)
+            rec = {"exp": "19b", "channel": ch, "n": n_train, "seed": seed,
+                   "steps": STUDENT_STEPS, "gauges": g0, "gauges_interf": g1,
+                   "bpb": round(bpb, 4), "bpb_after_interf": round(bpb2, 4)}
+            ledger.write(json.dumps(rec) + "\n"); ledger.flush()
+            print(f"[19b {ch} s{seed}] {g0} interf_heldout="
+                  f"{g1['heldout']} bpb={bpb:.4f}", flush=True)
+            torch.save({"channel": ch, "seed": seed,
+                        "state_dict": {k: v.cpu() for k, v in
+                                       m.state_dict().items()}},
+                       os.path.join(EXP19_DIR, f"rule_{ch}_s{seed}.pt"))
+            del m
+            torch.cuda.empty_cache()
+        del teacher
+        torch.cuda.empty_cache()
+    ledger.close()
+
+
+def smoke():
+    recs = make_facts(8, seed=0)
+    assert len(recs) == 8 and all(len(k) == KEY_LEN and len(v) == VAL_LEN
+                                  for k, v in recs)
+    fs = fact_stream(recs, copies=3, seed=0)
+    assert fs.dtype == torch.uint8 and fs.numel() == 3 * 8 * (KEY_LEN + VAL_LEN + 4)
+    m = ByteLM("addr_msl64", d=96, layers=2, block=64)
+    r = recall(m, recs, device="cpu", max_eval=8, batch=4)
+    assert 0.0 <= r["exact"] <= 1.0 and 0.0 <= r["byte_acc"] <= 1.0
+    g = torch.Generator().manual_seed(0)
+    x, y, mask = _mix_batch(torch.randint(0, 256, (50000,),
+                                          dtype=torch.uint8, generator=g),
+                            fs, 8, 64, "cpu", g)
+    assert x.shape == (8, 64) and mask.shape == (8,)
+    assert (x[:, 1:] == y[:, :-1]).all()          # stream alignment
+    # 19b: rule facts are rule-consistent + disjoint; variant recall runs
+    tr8, te4 = make_rule_facts(8, 4, seed=0)
+    assert len(tr8) == 8 and len(te4) == 4
+    assert not set(k for k, _ in tr8) & set(k for k, _ in te4)
+    k0, v0 = tr8[0]
+    assert len(v0) == VAL_LEN and v0[:KEY_LEN] == v0[KEY_LEN:2 * KEY_LEN]
+    rv = recall_fmt(m, tr8, FMT_VARIANT, device="cpu", max_eval=8, batch=4)
+    assert 0.0 <= rv["exact"] <= 1.0
+    print(f"exp019 smoke passed (untrained recall exact={r['exact']} "
+          f"byte={r['byte_acc']} ~ chance; 19b rule+variant OK)")
+
+
+def _in_notebook():
+    try:
+        get_ipython()  # type: ignore[name-defined]  # noqa: F821
+        return True
+    except NameError:
+        return False
+
+
+if __name__ == "__main__":
+    smoke() if not _in_notebook() else (smoke(),
+        print("Notebook: run_retention() on GPU."))

exp019_cr/geolip_vitals.py

@@ -0,0 +1,219 @@
+"""geolip_vitals.py — shared diagnostic harness for the GeoLIP aleph experiments.
+ALL functions are READOUTS: no gradients, no losses. CV is a readout, never a
+force. Addressing is judged by drift->0.29154 and CV->0.20, never by recon cosine
+(judgment criteria per the aleph-void article: https://huggingface.co/blog/AbstractPhil/geometric-vocabulary-patchwork-aleph-void).
+
+Vitals provided:
+  anchor_drift        — geodesic drift of anchors from init; binding fraction @0.29154
+  pentachoron_cv      — CM 4-volume CV over random 5-row subsets (geovocab2 import)
+  axis_aliveness      — oriented-address usage: axes alive, hppl, collapse flag
+  gate_stats          — gate means vs the 0.012-0.03 band
+  path_diversity      — unique-path counting, FIXED high-bits hash (low-16 bug is the
+                        retracted artifact — never use the low bits)
+  grad_norm_spread    — gradient democracy monitor (orders-of-magnitude spread)
+  CVScreen            — CV@1000-batch early band screen (<0.30 LOW / .35-.50 MID / >.80 HIGH)
+
+Smoke on a torch-capable env:  python geolip_vitals.py
+"""
+from __future__ import annotations
+import math
+import torch
+
+BINDING = 0.29154            # radians; the binding/separation constant
+CV_BAND = (0.13, 0.30)       # CM CV band (discovery_catalog #4)
+GATE_BAND = (0.012, 0.03)    # live invariant candidate (acd_campaign)
+KNUTH32 = 2654435761
+
+
+# ----------------------------------------------------------------------------- drift
+@torch.no_grad()
+def anchor_drift(current: torch.Tensor, init: torch.Tensor, tol: float = 0.05) -> dict:
+    """Geodesic drift (radians) of each row of `current` from its row in `init`,
+    both row-normalized. Returns mean/std/per-row drift and the fraction of rows
+    within +/-tol of BINDING (the GLFM '46%' readout)."""
+    a = torch.nn.functional.normalize(current.float(), dim=-1)
+    b = torch.nn.functional.normalize(init.float(), dim=-1)
+    cos = (a * b).sum(-1).clamp(-1.0, 1.0)
+    drift = torch.arccos(cos)
+    frac = ((drift - BINDING).abs() <= tol).float().mean()
+    return {"mean": drift.mean().item(), "std": drift.std().item(),
+            "per_row": drift, "binding_fraction": frac.item()}
+
+
+# -------------------------------------------------------------------------------- cv
+@torch.no_grad()
+def _pentachoron_volumes(pts: torch.Tensor) -> torch.Tensor:
+    """Batched Cayley-Menger 4-simplex volumes. pts: (B, 5, D) -> (B,) volumes.
+    One float64 det over all samples (vol^2 = -det(CM)/9216 for n=4). Built-in
+    for speed (the per-sample reference path is ~260x slower in a vitals loop);
+    geovocab2 remains the formula's reference implementation, parity-checked
+    via cv_reference_check()."""
+    B = pts.shape[0]
+    d2 = torch.cdist(pts.double(), pts.double()).pow(2)          # (B,5,5)
+    cm = torch.ones(B, 6, 6, dtype=torch.float64, device=pts.device)
+    cm[:, 0, 0] = 0.0
+    cm[:, 1:, 1:] = d2
+    det = torch.linalg.det(cm)
+    return (-det / 9216.0).clamp_min(0.0).sqrt().float()
+
+
+@torch.no_grad()
+def pentachoron_cv(rows: torch.Tensor, n_samples: int = 200,
+                   generator: torch.Generator | None = None) -> float:
+    """CV (std/mean) of Cayley-Menger 4-simplex volumes over n_samples random
+    5-row subsets. Rows are row-normalized before measurement. Uses the built-in
+    batched CM (float64 det); validate against geovocab2 with
+    cv_reference_check() after any change to the volume math."""
+    x = torch.nn.functional.normalize(rows.float(), dim=-1)
+    n = x.shape[0]
+    if n < 5:
+        raise ValueError(f"pentachoron_cv needs >=5 rows, got {n}")
+    g = generator or torch.Generator(device="cpu").manual_seed(0)
+    idx = torch.stack([torch.randperm(n, generator=g)[:5]
+                       for _ in range(n_samples)])               # (B,5)
+    v = _pentachoron_volumes(x[idx].cpu())
+    return (v.std() / v.mean().clamp_min(1e-12)).item()
+
+
+@torch.no_grad()
+def cv_reference_check(n_trials: int = 50, tol: float = 1e-5) -> float:
+    """Parity check of the built-in batched CM against geovocab2's reference
+    implementation (the formula's source of truth). Returns max |rel diff|;
+    raises if geovocab2 is absent or parity fails. Run after touching
+    _pentachoron_volumes."""
+    try:
+        from geovocab2.shapes.formula.symbolic.cayley_menger import (
+            CayleyMengerFromSimplex)
+    except Exception as e:  # pragma: no cover
+        raise ImportError(
+            "cv_reference_check requires geovocab2 (install via the geolip-svae "
+            "umbrella: pip install git+https://github.com/AbstractEyes/"
+            "geolip-svae).") from e
+    ref = CayleyMengerFromSimplex()
+    g = torch.Generator().manual_seed(0)
+    pts = torch.nn.functional.normalize(
+        torch.randn(n_trials, 5, 4, generator=g), dim=-1)
+    mine = _pentachoron_volumes(pts)
+    # compare at float64: the reference computes in the INPUT dtype, and fp32
+    # dets lose up to ~4% on near-degenerate pentachora (measured 2026-07-11)
+    theirs = torch.stack([ref.forward(p.double())["volume"].float() for p in pts])
+    rel = ((mine - theirs).abs() / theirs.abs().clamp_min(1e-12)).max().item()
+    if rel > tol:
+        raise AssertionError(f"CM parity vs geovocab2 failed: max rel {rel}")
+    return rel
+
+
+# ------------------------------------------------------------------------- aliveness
+@torch.no_grad()
+def axis_aliveness(oriented_weights: torch.Tensor, alive_thresh: float = 1e-3) -> dict:
+    """`oriented_weights`: (..., 2K) nonnegative oriented-softmax address rows
+    (sum to 1 on the last dim). Returns axes-alive count, mean-usage perplexity
+    (hppl analogue; healthy hosted reference 125-126/128), and a collapse flag.
+    Reference behavior: near-uniform aliveness at div_weight=0 (discovery #22)."""
+    w = oriented_weights.reshape(-1, oriented_weights.shape[-1]).float()
+    usage = w.mean(0)
+    usage = usage / usage.sum().clamp_min(1e-12)
+    # an axis is alive if its mean usage exceeds alive_thresh x the uniform share
+    alive = int((usage > alive_thresh * (1.0 / usage.numel())).sum())
+    ent = -(usage.clamp_min(1e-12) * usage.clamp_min(1e-12).log()).sum()
+    ppl = float(ent.exp())
+    return {"axes_total": usage.numel(), "axes_alive": alive, "usage_ppl": ppl,
+            "collapsed": ppl < 0.05 * usage.numel()}
+
+
+# ------------------------------------------------------------------------------ gates
+@torch.no_grad()
+def gate_stats(gates: torch.Tensor) -> dict:
+    """Gate values (post-sigmoid/clamp). Reports mean and whether it sits in the
+    0.012-0.03 band (read-only — the band is a candidate invariant, never a target)."""
+    g = gates.float().flatten()
+    m = g.mean().item()
+    return {"mean": m, "std": g.std().item(),
+            "in_band": GATE_BAND[0] <= m <= GATE_BAND[1]}
+
+
+# ------------------------------------------------------------------------------ paths
+@torch.no_grad()
+def path_diversity(ids: torch.Tensor) -> dict:
+    """Unique-path counting with the FIXED multiplicative hash:
+    ((ids * 2654435761) % 2^32) >> 16 — Knuth needs the HIGH bits; the low-16
+    variant produced a retracted ~1,500 path ceiling in a prior campaign.
+    `ids`: integer tensor, one composed path id per row (any shape)."""
+    x = ids.reshape(-1).to(torch.int64)
+    hashed = ((x * KNUTH32) % (1 << 32)) >> 16
+    return {"n": int(x.numel()),
+            "unique_raw": int(torch.unique(x).numel()),
+            "unique_hashed": int(torch.unique(hashed).numel())}
+
+
+@torch.no_grad()
+def compose_path_ids(stage_indices: list[torch.Tensor], radix: int) -> torch.Tensor:
+    """Compose per-stage discrete indices (each (...,) int in [0, radix)) into a
+    single path id, positional base-`radix` — construction, not hashing."""
+    out = torch.zeros_like(stage_indices[0], dtype=torch.int64)
+    for s in stage_indices:
+        out = out * radix + s.to(torch.int64)
+    return out
+
+
+# --------------------------------------------------------------------- grad democracy
+@torch.no_grad()
+def grad_norm_spread(groups: dict[str, list[torch.nn.Parameter]]) -> dict:
+    """Gradient-democracy monitor. `groups`: name -> params of one parallel member
+    (tower/expert). Reports per-group grad norms and the orders-of-magnitude spread.
+    Reference: unequalized heterogeneous towers spread ~20 orders (fibonacci dead at
+    2.25e-21 under helix); equalized ~0.0 (geofractal gradient-democracy result)."""
+    norms = {}
+    for name, params in groups.items():
+        gs = [p.grad for p in params if p.grad is not None]
+        norms[name] = float(torch.sqrt(sum((g.float() ** 2).sum() for g in gs)).item()) \
+            if gs else 0.0
+    vals = [v for v in norms.values() if v > 0]
+    spread = (math.log10(max(vals)) - math.log10(min(vals))) if len(vals) >= 2 else 0.0
+    return {"norms": norms, "spread_orders": spread, "dead": [k for k, v in norms.items() if v == 0.0]}
+
+
+# ----------------------------------------------------------------------------- screen
+class CVScreen:
+    """CV@N early band screen (tri-band ft1): record pentachoron CV at `step_mark`
+    batches; classify <0.30 LOW / 0.35-0.50 MID / >0.80 HIGH. Turns ~2h/config
+    into ~7min. Readout only."""
+    def __init__(self, step_mark: int = 1000):
+        self.step_mark = step_mark
+        self.recorded: float | None = None
+
+    def maybe_record(self, step: int, rows: torch.Tensor) -> float | None:
+        if self.recorded is None and step >= self.step_mark:
+            self.recorded = pentachoron_cv(rows)
+        return self.recorded
+
+    @property
+    def band(self) -> str | None:
+        c = self.recorded
+        if c is None:
+            return None
+        if c < 0.30:
+            return "LOW"
+        if 0.35 <= c <= 0.50:
+            return "MID"
+        if c > 0.80:
+            return "HIGH"
+        return "BETWEEN"
+
+
+# ------------------------------------------------------------------------------ smoke
+if __name__ == "__main__":  # shapes/parse smoke ONLY — no training, ever.
+    g = torch.Generator().manual_seed(0)
+    K, D = 64, 4
+    init = torch.nn.functional.normalize(torch.randn(K, D, generator=g), dim=-1)
+    cur = torch.nn.functional.normalize(init + 0.29 * torch.randn(K, D, generator=g), dim=-1)
+    print("drift:", {k: v for k, v in anchor_drift(cur, init).items() if k != "per_row"})
+    w = torch.softmax(torch.randn(32, 2 * K, generator=g), dim=-1)
+    print("aliveness:", axis_aliveness(w))
+    print("gates:", gate_stats(torch.full((8,), 0.024)))
+    ids = compose_path_ids([torch.randint(0, 16, (4096,), generator=g) for _ in range(4)], 16)
+    print("paths:", path_diversity(ids))
+    lin = torch.nn.Linear(8, 8)
+    lin(torch.randn(4, 8)).sum().backward()
+    print("democracy:", grad_norm_spread({"a": list(lin.parameters())}))
+    print("OK — vitals smoke passed (pentachoron_cv needs geovocab2; run on GPU env)")

exp019_cr/read_codebook.py

@@ -0,0 +1,159 @@
+"""read_codebook.py — projective reading of cultivated aleph codebooks.
+Antipodal-collapse extraction on trained codebooks + projective statistics on
+RP^(D-1) — applied to the exp012 AR-bed specimens.
+
+Recipe per the Polygonal Omega article (geometric-tri-band-ft2): collapse = (row_i - row_j)/2 normalized for each MUTUAL-STRONGEST
+pair with cos < -0.9 — "a deterministic tensor operation," not clustering.
+Projective metric ALWAYS arccos|<a,b>| (metric-alignment rule, reading-voids-ft1).
+D=4 scope is the validated regime (D=5 walked back; axis count grows with D).
+
+Readouts per specimen:
+  pairs / n_axes / unpaired          — antipodal structure
+  proj_angle mean vs uniform baseline, deviation  — near-uniform RP^(D-1)?
+  drift from home + binding fraction @0.29154     — cultivation record
+  erank of the axis set                            — spectral occupancy
+  verdict: PROJECTIVE-CLEAN (|dev|<0.05, util>0.95, secondary pairs<=3) /
+           -MOSTLY / STRUCTURED / DEGENERATE (per Polygonal Omega thresholds)
+
+Usage (terminal): python read_codebook.py <ckpt_or_dir> [more paths...]
+Colab: paste geolip_vitals.py cell first (optional), then this file, then
+       read_all(r"/content/data/ar_ckpts").
+"""
+from __future__ import annotations
+import math
+import sys
+import torch
+import torch.nn.functional as F
+
+BINDING = 0.29154
+
+
+@torch.no_grad()
+def antipodal_collapse(codebook: torch.Tensor, thresh: float = -0.9) -> dict:
+    """Mutual-strongest antipodal pairing + collapse to axes on RP^(D-1)."""
+    A = F.normalize(codebook.float(), dim=-1)
+    K = A.shape[0]
+    cos = A @ A.T
+    cos.fill_diagonal_(2.0)                      # exclude self from minima
+    nearest_neg = cos.argmin(dim=-1)             # most-antipodal partner
+    pairs = []
+    used = set()
+    for i in range(K):
+        j = int(nearest_neg[i])
+        if i < j and int(nearest_neg[j]) == i and cos[i, j] < thresh:
+            pairs.append((i, j))
+            used.update((i, j))
+    axes = [F.normalize((A[i] - A[j]) / 2.0, dim=-1) for i, j in pairs]
+    axes += [A[i] for i in range(K) if i not in used]   # unpaired rows as axes
+    axes = torch.stack(axes) if axes else A[:0]
+    # sign-canon onto RP: first nonzero coordinate positive
+    for r in range(axes.shape[0]):
+        nz = torch.nonzero(axes[r].abs() > 1e-8)
+        if nz.numel() and axes[r, nz[0, 0]] < 0:
+            axes[r] = -axes[r]
+    return {"pairs": len(pairs), "n_axes": axes.shape[0],
+            "unpaired": K - 2 * len(pairs), "axes": axes}
+
+
+@torch.no_grad()
+def projective_stats(axes: torch.Tensor, n_baseline: int = 20000,
+                     seed: int = 0) -> dict:
+    """Mean projective angle arccos|<a,b>| vs a uniform-RP baseline at same (n, D)."""
+    n, D = axes.shape
+    if n < 2:
+        return {"proj_angle_mean": None, "uniform_baseline": None,
+                "deviation": None, "erank": None}
+    def mean_angle(rows):
+        c = (rows @ rows.T).abs().clamp(max=1.0)
+        iu = torch.triu_indices(rows.shape[0], rows.shape[0], offset=1)
+        return torch.arccos(c[iu[0], iu[1]]).mean().item()
+    obs = mean_angle(axes)
+    g = torch.Generator().manual_seed(seed)
+    base_angles = []
+    m = max(2, n)
+    for _ in range(max(1, n_baseline // max(1, m * (m - 1) // 2))):
+        r = F.normalize(torch.randn(m, D, generator=g), dim=-1)
+        base_angles.append(mean_angle(r))
+    base = sum(base_angles) / len(base_angles)
+    s = torch.linalg.svdvals(axes)
+    p = (s / s.sum().clamp_min(1e-12))
+    erank = float(torch.exp(-(p.clamp_min(1e-12) * p.clamp_min(1e-12).log()).sum()))
+    return {"proj_angle_mean": round(obs, 4), "uniform_baseline": round(base, 4),
+            "deviation": round(obs - base, 4), "erank": round(erank, 3)}
+
+
+@torch.no_grad()
+def read_specimen(path: str) -> dict:
+    ck = torch.load(path, map_location="cpu", weights_only=True)
+    out = {"file": path.split("\\")[-1].split("/")[-1],
+           "arm": ck.get("arm"), "seed": ck.get("seed"),
+           "steps": ck.get("steps"), "val_bpb": round(ck.get("val_bpb", -1), 4)}
+    if "state_dict" in ck:            # full specimen checkpoint
+        sd = ck["state_dict"]
+        books = {k[:-len(".codebook")]: sd[k] for k in sd
+                 if k.endswith("addr.codebook") or k.endswith("head_addr.codebook")}
+        homes = {k[:-len(".home")]: sd[k] for k in sd if k.endswith(".home")}
+    else:                             # bare genome dict (exp014+ champion files):
+        # books under flat/root/branch* keys; *_proj entries are projections
+        books = {k: v for k, v in ck.items()
+                 if torch.is_tensor(v) and v.ndim == 2
+                 and (k in ("flat", "root") or k.startswith("branch"))}
+        homes = {}
+    reads = {}
+    for name, cb in books.items():
+        col = antipodal_collapse(cb)
+        stats = projective_stats(col["axes"])
+        home = homes.get(name)
+        drift = None
+        binding = None
+        if home is not None and home.shape == cb.shape:
+            a = F.normalize(cb.float(), dim=-1)
+            b = F.normalize(home.float(), dim=-1)
+            dr = torch.arccos((a * b).sum(-1).clamp(-1, 1))
+            drift = round(dr.mean().item(), 4)
+            binding = round(((dr - BINDING).abs() <= 0.05).float().mean().item(), 4)
+        util = col["n_axes"] / cb.shape[0]
+        dev = stats["deviation"]
+        if dev is not None and abs(dev) < 0.05 and util > 0.95 and col["pairs"] <= 3:
+            verdict = "PROJECTIVE-CLEAN"
+        elif dev is not None and abs(dev) < 0.05:
+            verdict = "PROJECTIVE-MOSTLY"
+        elif dev is not None and dev > 0.05:
+            verdict = "STRUCTURED(repulsive)"
+        else:
+            verdict = "DEGENERATE/CLUMPED" if dev is not None else "TOO-FEW-AXES"
+        reads[name] = {
+            "pairs": col["pairs"], "n_axes": col["n_axes"], **stats,
+            "drift": drift, "binding_frac": binding, "verdict": verdict}
+    out["codebooks"] = reads
+    return out
+
+
+def read_all(root: str) -> list:
+    import glob, os
+    results = []
+    for p in sorted(glob.glob(os.path.join(root, "*.pt"))):
+        r = read_specimen(p)
+        print(r, flush=True)
+        results.append(r)
+    return results
+
+
+def _in_notebook() -> bool:
+    try:
+        get_ipython()  # type: ignore[name-defined]  # noqa: F821
+        return True
+    except NameError:
+        return False
+
+
+if __name__ == "__main__":
+    if _in_notebook():
+        print("Notebook mode: call read_all(r'<data_root>/ar_ckpts') in the next cell.")
+    else:
+        args = [a for a in sys.argv[1:] if not a.startswith("-")]
+        if not args:
+            print("usage: python read_codebook.py <ckpt_or_dir> [...]")
+        for a in args:
+            import os
+            read_all(a) if os.path.isdir(a) else print(read_specimen(a))

exp019_cr/repro.py

@@ -0,0 +1,29 @@
+"""repro.py — standalone loader/runner for exp019_cr. Code dependencies live
+in THIS folder (geolip_vitals.py, ar_differentiation_bed.py,
+exp014_genetic_distillation.py, exp019_content_retention.py, read_codebook.py).
+
+  python repro.py            # CPU smoke: facts, streams, recall, rule block
+  python repro.py --run      # retention sweep (2 seeds x 3 N x channels, ~3h GPU)
+  python repro.py --run19b   # generalization block (rule content, ~1h GPU)
+
+Data lands in ./data (override with GEOLIP_DATA); ledger + checkpoints in
+./data/exp019.
+"""
+import os
+import sys
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, HERE)
+
+if __name__ == "__main__":
+    import geolip_vitals                       # noqa: F401  (paste order)
+    import ar_differentiation_bed              # noqa: F401
+    import exp014_genetic_distillation         # noqa: F401
+    import exp019_content_retention as cr
+    if "--run" in sys.argv[1:]:
+        cr.run_retention()
+    elif "--run19b" in sys.argv[1:]:
+        cr.run_generalization()
+    else:
+        cr.smoke()
+        print("repro smoke passed — --run (retention) / --run19b (rule block)")

exp019_cr/results/ledger.jsonl

@@ -0,0 +1,36 @@
+{"exp": "19", "channel": "teacher", "n": 64, "seed": 0, "steps": 4000, "recall": {"exact": 1.0, "byte_acc": 1.0}, "bpb": 2.3987}
+{"exp": "19", "channel": "direct", "n": 64, "seed": 0, "steps": 2000, "recall": {"exact": 1.0, "byte_acc": 1.0}, "recall_interf": {"exact": 0.0, "byte_acc": 0.0221}, "bpb": 2.7867, "bpb_after_interf": 2.3879}
+{"exp": "19", "channel": "kd_facts", "n": 64, "seed": 0, "steps": 2000, "recall": {"exact": 1.0, "byte_acc": 1.0}, "recall_interf": {"exact": 0.0, "byte_acc": 0.0013}, "bpb": 4.0938, "bpb_after_interf": 2.5318}
+{"exp": "19", "channel": "kd_general", "n": 64, "seed": 0, "steps": 2000, "recall": {"exact": 0.0, "byte_acc": 0.0}, "recall_interf": {"exact": 0.0, "byte_acc": 0.0065}, "bpb": 2.5001, "bpb_after_interf": 2.2824}
+{"exp": "19", "channel": "teacher", "n": 256, "seed": 0, "steps": 4000, "recall": {"exact": 0.9883, "byte_acc": 0.9938}, "bpb": 2.4127}
+{"exp": "19", "channel": "direct", "n": 256, "seed": 0, "steps": 2000, "recall": {"exact": 0.8711, "byte_acc": 0.9095}, "recall_interf": {"exact": 0.0, "byte_acc": 0.0072}, "bpb": 2.8685, "bpb_after_interf": 2.3991}
+{"exp": "19", "channel": "kd_facts", "n": 256, "seed": 0, "steps": 2000, "recall": {"exact": 0.9531, "byte_acc": 0.9694}, "recall_interf": {"exact": 0.0, "byte_acc": 0.0186}, "bpb": 4.1136, "bpb_after_interf": 2.5174}
+{"exp": "19", "channel": "kd_general", "n": 256, "seed": 0, "steps": 2000, "recall": {"exact": 0.0, "byte_acc": 0.0}, "recall_interf": {"exact": 0.0, "byte_acc": 0.0091}, "bpb": 2.5322, "bpb_after_interf": 2.3352}
+{"exp": "19", "channel": "book_implant", "n": 256, "seed": 0, "steps": 2000, "recall": {"exact": 0.0, "byte_acc": 0.0085}, "recall_interf": {"exact": 0.0, "byte_acc": 0.0075}, "bpb": 2.4608, "bpb_after_interf": 2.2463}
+{"exp": "19", "channel": "none", "n": 256, "seed": 0, "steps": 2000, "recall": {"exact": 0.0, "byte_acc": 0.0101}, "recall_interf": {"exact": 0.0, "byte_acc": 0.0078}, "bpb": 2.4685, "bpb_after_interf": 2.2399}
+{"exp": "19", "channel": "teacher", "n": 1024, "seed": 0, "steps": 4000, "recall": {"exact": 0.0117, "byte_acc": 0.0693}, "bpb": 2.5179}
+{"exp": "19", "channel": "direct", "n": 1024, "seed": 0, "steps": 2000, "recall": {"exact": 0.0, "byte_acc": 0.0319}, "recall_interf": {"exact": 0.0, "byte_acc": 0.0065}, "bpb": 3.0269, "bpb_after_interf": 2.489}
+{"exp": "19", "channel": "kd_facts", "n": 1024, "seed": 0, "steps": 2000, "recall": {"exact": 0.0, "byte_acc": 0.0352}, "recall_interf": {"exact": 0.0, "byte_acc": 0.0199}, "bpb": 4.1922, "bpb_after_interf": 2.6121}
+{"exp": "19", "channel": "kd_general", "n": 1024, "seed": 0, "steps": 2000, "recall": {"exact": 0.0, "byte_acc": 0.0}, "recall_interf": {"exact": 0.0, "byte_acc": 0.0013}, "bpb": 2.5957, "bpb_after_interf": 2.3458}
+{"exp": "19", "channel": "teacher", "n": 64, "seed": 1, "steps": 4000, "recall": {"exact": 1.0, "byte_acc": 1.0}, "bpb": 2.3943}
+{"exp": "19", "channel": "direct", "n": 64, "seed": 1, "steps": 2000, "recall": {"exact": 1.0, "byte_acc": 1.0}, "recall_interf": {"exact": 0.0, "byte_acc": 0.013}, "bpb": 2.752, "bpb_after_interf": 2.3639}
+{"exp": "19", "channel": "kd_facts", "n": 64, "seed": 1, "steps": 2000, "recall": {"exact": 1.0, "byte_acc": 1.0}, "recall_interf": {"exact": 0.0, "byte_acc": 0.0052}, "bpb": 3.9946, "bpb_after_interf": 2.5456}
+{"exp": "19", "channel": "kd_general", "n": 64, "seed": 1, "steps": 2000, "recall": {"exact": 0.0, "byte_acc": 0.0}, "recall_interf": {"exact": 0.0, "byte_acc": 0.0}, "bpb": 2.5233, "bpb_after_interf": 2.3492}
+{"exp": "19", "channel": "teacher", "n": 256, "seed": 1, "steps": 4000, "recall": {"exact": 0.9922, "byte_acc": 0.9961}, "bpb": 2.3974}
+{"exp": "19", "channel": "direct", "n": 256, "seed": 1, "steps": 2000, "recall": {"exact": 0.8555, "byte_acc": 0.9108}, "recall_interf": {"exact": 0.0, "byte_acc": 0.0179}, "bpb": 2.9598, "bpb_after_interf": 2.4577}
+{"exp": "19", "channel": "kd_facts", "n": 256, "seed": 1, "steps": 2000, "recall": {"exact": 0.8594, "byte_acc": 0.891}, "recall_interf": {"exact": 0.0, "byte_acc": 0.0104}, "bpb": 4.149, "bpb_after_interf": 2.5129}
+{"exp": "19", "channel": "kd_general", "n": 256, "seed": 1, "steps": 2000, "recall": {"exact": 0.0, "byte_acc": 0.0}, "recall_interf": {"exact": 0.0, "byte_acc": 0.0}, "bpb": 2.5208, "bpb_after_interf": 2.3414}
+{"exp": "19", "channel": "book_implant", "n": 256, "seed": 1, "steps": 2000, "recall": {"exact": 0.0, "byte_acc": 0.0052}, "recall_interf": {"exact": 0.0, "byte_acc": 0.0065}, "bpb": 2.4782, "bpb_after_interf": 2.2825}
+{"exp": "19", "channel": "none", "n": 256, "seed": 1, "steps": 2000, "recall": {"exact": 0.0, "byte_acc": 0.0016}, "recall_interf": {"exact": 0.0, "byte_acc": 0.0}, "bpb": 2.4772, "bpb_after_interf": 2.274}
+{"exp": "19", "channel": "teacher", "n": 1024, "seed": 1, "steps": 4000, "recall": {"exact": 0.1992, "byte_acc": 0.3747}, "bpb": 2.4916}
+{"exp": "19", "channel": "direct", "n": 1024, "seed": 1, "steps": 2000, "recall": {"exact": 0.0, "byte_acc": 0.0286}, "recall_interf": {"exact": 0.0, "byte_acc": 0.0026}, "bpb": 3.0763, "bpb_after_interf": 2.5039}
+{"exp": "19", "channel": "kd_facts", "n": 1024, "seed": 1, "steps": 2000, "recall": {"exact": 0.0, "byte_acc": 0.0319}, "recall_interf": {"exact": 0.0, "byte_acc": 0.0179}, "bpb": 4.2629, "bpb_after_interf": 2.6531}
+{"exp": "19", "channel": "kd_general", "n": 1024, "seed": 1, "steps": 2000, "recall": {"exact": 0.0, "byte_acc": 0.0003}, "recall_interf": {"exact": 0.0, "byte_acc": 0.001}, "bpb": 2.5645, "bpb_after_interf": 2.3509}
+{"exp": "19b", "channel": "teacher", "n": 256, "seed": 0, "steps": 4000, "gauges": {"train": {"exact": 1.0, "byte_acc": 1.0}, "heldout": {"exact": 0.0, "byte_acc": 0.2702}, "train_varfmt": {"exact": 0.0, "byte_acc": 0.016}}, "bpb": 2.3906}
+{"exp": "19b", "channel": "direct", "n": 256, "seed": 0, "steps": 2000, "gauges": {"train": {"exact": 0.6523, "byte_acc": 0.8337}, "heldout": {"exact": 0.0, "byte_acc": 0.2695}, "train_varfmt": {"exact": 0.0, "byte_acc": 0.0241}}, "gauges_interf": {"train": {"exact": 0.0, "byte_acc": 0.0391}, "heldout": {"exact": 0.0, "byte_acc": 0.0228}, "train_varfmt": {"exact": 0.0, "byte_acc": 0.0033}}, "bpb": 2.8785, "bpb_after_interf": 2.4644}
+{"exp": "19b", "channel": "kd_facts", "n": 256, "seed": 0, "steps": 2000, "gauges": {"train": {"exact": 0.7578, "byte_acc": 0.8981}, "heldout": {"exact": 0.0, "byte_acc": 0.2637}, "train_varfmt": {"exact": 0.0, "byte_acc": 0.0908}}, "gauges_interf": {"train": {"exact": 0.0, "byte_acc": 0.0247}, "heldout": {"exact": 0.0, "byte_acc": 0.0176}, "train_varfmt": {"exact": 0.0, "byte_acc": 0.0225}}, "bpb": 4.1461, "bpb_after_interf": 2.5325}
+{"exp": "19b", "channel": "kd_general", "n": 256, "seed": 0, "steps": 2000, "gauges": {"train": {"exact": 0.0, "byte_acc": 0.0}, "heldout": {"exact": 0.0, "byte_acc": 0.0}, "train_varfmt": {"exact": 0.0, "byte_acc": 0.0}}, "gauges_interf": {"train": {"exact": 0.0, "byte_acc": 0.0029}, "heldout": {"exact": 0.0, "byte_acc": 0.0039}, "train_varfmt": {"exact": 0.0, "byte_acc": 0.0094}}, "bpb": 2.5091, "bpb_after_interf": 2.3152}
+{"exp": "19b", "channel": "teacher", "n": 256, "seed": 1, "steps": 4000, "gauges": {"train": {"exact": 0.9844, "byte_acc": 0.9948}, "heldout": {"exact": 0.0, "byte_acc": 0.2448}, "train_varfmt": {"exact": 0.0, "byte_acc": 0.002}}, "bpb": 2.4099}
+{"exp": "19b", "channel": "direct", "n": 256, "seed": 1, "steps": 2000, "gauges": {"train": {"exact": 0.7734, "byte_acc": 0.9027}, "heldout": {"exact": 0.0, "byte_acc": 0.2559}, "train_varfmt": {"exact": 0.0, "byte_acc": 0.0}}, "gauges_interf": {"train": {"exact": 0.0, "byte_acc": 0.0238}, "heldout": {"exact": 0.0, "byte_acc": 0.0221}, "train_varfmt": {"exact": 0.0, "byte_acc": 0.0029}}, "bpb": 2.928, "bpb_after_interf": 2.4109}
+{"exp": "19b", "channel": "kd_facts", "n": 256, "seed": 1, "steps": 2000, "gauges": {"train": {"exact": 0.8438, "byte_acc": 0.932}, "heldout": {"exact": 0.0, "byte_acc": 0.2786}, "train_varfmt": {"exact": 0.0, "byte_acc": 0.0771}}, "gauges_interf": {"train": {"exact": 0.0, "byte_acc": 0.0075}, "heldout": {"exact": 0.0, "byte_acc": 0.0085}, "train_varfmt": {"exact": 0.0, "byte_acc": 0.0163}}, "bpb": 4.0264, "bpb_after_interf": 2.5571}
+{"exp": "19b", "channel": "kd_general", "n": 256, "seed": 1, "steps": 2000, "gauges": {"train": {"exact": 0.0, "byte_acc": 0.0}, "heldout": {"exact": 0.0, "byte_acc": 0.0}, "train_varfmt": {"exact": 0.0, "byte_acc": 0.0}}, "gauges_interf": {"train": {"exact": 0.0, "byte_acc": 0.0}, "heldout": {"exact": 0.0, "byte_acc": 0.0}, "train_varfmt": {"exact": 0.0, "byte_acc": 0.0013}}, "bpb": 2.5298, "bpb_after_interf": 2.3408}

exp019_cr/results/results.json

@@ -0,0 +1,21 @@
+{
+ "capacity_curve": {
+  "N64_s0": 1.0,
+  "N64_s1": 1.0,
+  "N256_s0": 0.9883,
+  "N256_s1": 0.9922,
+  "N1024_s0": 0.0117,
+  "N1024_s1": 0.1992
+ },
+ "kd_vs_direct_rule_train_exact": {
+  "s0": [
+   0.7578,
+   0.6523
+  ],
+  "s1": [
+   0.8438,
+   0.7734
+  ]
+ },
+ "n_rows": 36
+}

exp019_cr/specimens/rule_direct_s0.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7cb0de713dc1277787f40717c4de271815ed5e8480500c9fc5aab8ed12b35e91
+size 7977425

exp019_cr/specimens/rule_direct_s1.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b63fcab4464246727a8dff2fa2208c4e304e50557397dce45ee5962ef3acc7e6
+size 7977425

exp019_cr/specimens/rule_kd_facts_s0.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:637f1a4de3270b34ed59b589fa083516faf1bcf93c7a96d6118ebcc14cdea7c0
+size 7977535

exp019_cr/specimens/rule_kd_facts_s1.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:771d084ad26ddb878371e385ef91f7d433ac31cfb14412aef4bc171529bf423f
+size 7977535

exp019_cr/specimens/rule_kd_general_s0.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c9ad649e1a8fb6fcacd67866757eb7f26c5e561dfd94f42b3e470f84b374b3dc
+size 7977645

exp019_cr/specimens/rule_kd_general_s1.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:56acd7c7ef2291bfceae6106902b90a3376a7f4fbbd00ab1e81b8fb2731dd9fb
+size 7977645

exp019_cr/specimens/rule_teacher_s0.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9e2fd2b00e87f8e380e45169830225adb15b7c7883b6e6fb027a4e5c973c2154
+size 7977480

exp019_cr/specimens/rule_teacher_s1.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9394e030f940e21b8f4cb9ffc4637bc2db1961c90040d01dca94d4fa66543b1b
+size 7977480

exp019_cr/specimens/teacher_N1024_s0.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:af3c50e397e9443ebbaa1f2e7b9a231ee48e05eb1a9cadd8576f2c7ae162ba51
+size 7977535

exp019_cr/specimens/teacher_N1024_s1.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:41211d812d569c081998188e7ba209bf6e411592dc300919a943ba32a42356c4
+size 7977535

exp019_cr/specimens/teacher_N256_s0.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f33ce09f77188f0275b71d35abb510e58e6855242c8a0faf75e459b4d2420ff0
+size 7977480

exp019_cr/specimens/teacher_N256_s1.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7e6d6917c2c1a78172b5ccd7f73b8f5ba34674224f0dae0c548191b18a95ba6f
+size 7977480

exp019_cr/specimens/teacher_N64_s0.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c171d410e06adb6eb5e9a4d078095d92ba54f91598f5b24e3e5e406dc72c165f
+size 7977425

exp019_cr/specimens/teacher_N64_s1.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ead81b62b73c759c75af1a84b02c477380cec45b835062fad06b64f427524f6c
+size 7977425

exp020_gen/README.md

@@ -0,0 +1,73 @@
+# exp020_gen — generalization: structure vs capacity on a hidden rule
+
+Sequel to [exp019](../exp019_cr/), whose 19b block found rules learned only
+fragmentarily (held-out byte ~0.26, exact 0.000) and content locked to its
+surface format. exp020 races the program's structural methodologies —
+codebooks and constellations — on that same rule task, against the honest
+capacity control, asking what (if anything) unlocks generalization.
+
+**Task** (identical to 19b): value = fixed random substitution cipher of the
+key; 256 train keys in-stream, 128 held out; 4000 steps direct training.
+**Judge**: held-out recall (rule induction), variant-format recall (the
+lock), clean bpb.
+
+## The bakeoff (held-out byte accuracy; exact = 0.000 in all 12 cells)
+
+| arm | head params | s0 | s1 | clean bpb |
+|---|---|---|---|---|
+| **aleph** (addr_msl64 bottleneck) | 115,200 | **.2611** | **.2493** | 2.40 / 2.41 |
+| relay (addresses in depth) | 214,532 | .2305 | .2493 | 2.36 / 2.41 |
+| aleph_fmtdiv (3 fact formats in-stream) | 115,200 | .2148 | .2363 | 2.35 / 2.40 |
+| mlp (param-matched free head) | 115,261 | .1992 | .2044 | 2.39 / 2.42 |
+| aleph_tri (trigram byte embeddings) | 115,200 | .1634 | .1582 | 2.37 / 2.30 |
+| const (constellation 768 address) | 1,978,432 | .1133 | .1309 | **2.26 / 2.23** |
+
+`build_results.py` re-asserts every claim below from `results/ledger.jsonl`.
+
+## Findings
+
+1. **The plateau is not a structure problem.** No methodology in the toolkit
+   lifts held-out accuracy off the ~0.26 byte plateau, and no cell produces a
+   single exact held-out completion. Cracking rule induction here needs
+   scale, budget, or curriculum — not a different head.
+2. **The aleph bottleneck is the best generalizer — certified both seeds** —
+   beating its param-matched free head by ~25% relative at a head budget
+   matched to within 0.2%. Structure beats capacity for generalization even
+   while losing on bpb.
+3. **The inverse law**: generalization ordering roughly REVERSES modeling
+   strength, both seeds. The constellation head (best clean bpb, 17× larger)
+   generalizes worst; the trigram memorizer lineage second-worst; the
+   tightest bottleneck best. **Memorization ease substitutes for rule
+   induction** — surplus representational capacity soaks the instances and
+   removes the pressure to induce. (This measured memorization↔generalization
+   axis is the empirical foundation for slider/registry-style composites
+   where blocks are graded by this property and gated accordingly.)
+4. **Format diversity generalizes across trained surface forms, not to novel
+   ones**: the diverse-format arm completes held-out keys at full rule level
+   in its *seen* alternate format (byte .205/.260) while the *unseen* format
+   stays locked (.017/.041).
+5. **Depth relays ≈ the head bottleneck** (no lift, no cost) — distributing
+   the address through depth neither helps nor hurts rule induction.
+
+## Files
+- `exp020_generalization.py` — the six arms, format-diverse fact streams,
+  matched-head construction, bakeoff runner, smoke.
+- `geolip_vitals.py` / `ar_differentiation_bed.py` /
+  `exp014_genetic_distillation.py` / `exp017_aleph_constellation.py` /
+  `exp019_content_retention.py` / `read_codebook.py` — this package's own
+  harness copies (the bed, the constellation head, the rule-task machinery).
+  Standalone.
+- `repro.py`, `build_results.py`, `results/ledger.jsonl` (12 rows),
+  `specimens/` (all 12 checkpoints).
+
+## Reproduce (from inside this folder)
+```bash
+pip install torch --index-url https://download.pytorch.org/whl/cu128
+pip install pyarrow huggingface_hub
+python repro.py            # CPU smoke
+python repro.py --run      # the bakeoff (GPU, ~2h)
+python build_results.py    # re-assert every claim from the ledger
+```
+Data lands in `./data` (override with `GEOLIP_DATA`).
+
+License: MIT · AbstractPhil + Claude Fable 5 · July 11, 2026

exp020_gen/ar_differentiation_bed.py

@@ -0,0 +1,487 @@
+"""ar_differentiation_bed.py — exp012: autoregressive differentiation of the aleph.
+
+Differentiation is cultivated by PREDICTIVE pressure along the sequence — the
+address parameterizing the next-byte distribution (Law 2: chain-rule advantage pays
+ONLY where the composed address directly parameterizes the predictive distribution).
+This bed puts the aleph in the autoregressive gradient path and measures what
+differentiates. The head arms enforce the employment law at its maximum: the
+ENTIRE next-byte distribution is parameterized by the address.
+
+Byte-level causal LM on wikitext-2-raw (HF parquet, CDN-fast), block 256. ARMS:
+  sdpa       — standard causal transformer control (matched trunk).
+  hub        — attention replaced by CAUSAL HUB: linear attention whose feature map
+               is the 2K-oriented aleph address, prefix-sum memories (no selection
+               event; O(n*K*d)). Differentiation cultivated INSIDE attention.
+  addr_head  — sdpa trunk, but the OUTPUT HEAD reads ONLY the signed aleph
+               coefficient vector w_k = sinh(u_k)/sum_j cosh(u_j) of the final
+               hidden state (K -> 256 logits). The address MUST carry every bit of
+               next-byte information — the hardest Law-2 bottleneck.
+
+JUDGED BY: val bits-per-byte per arm (task) + CULTIVATION VITALS on every aleph
+codebook (readouts, never losses): axis aliveness/hppl, drift-from-init +
+binding fraction @0.29154, winner-|cos| saturation (sign-code emergence), shadow
+path diversity (fixed high-bits hash). Never by recon.
+
+Riders: pure Adam wd=0; no BN/Dropout/GAP on geometric paths; orthogonal init;
+Colab-cell-safe (paste-ahead imports, no bare argparse, no __file__ reliance);
+GPU-only for verdict runs.
+
+Terminal:  python ar_differentiation_bed.py            # shapes/parse smoke
+           python ar_differentiation_bed.py --train    # verdict run
+Colab:     paste geolip_vitals.py cell, then this file (smoke auto-runs),
+           then  train(steps=2000, data_root="/content/data")  in the next cell.
+"""
+from __future__ import annotations
+import math
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+if "anchor_drift" not in globals():
+    try:
+        from geolip_vitals import anchor_drift, axis_aliveness, path_diversity
+    except ImportError:
+        _here = globals().get("__file__")
+        if _here is not None:
+            import sys, pathlib
+            sys.path.insert(0, str(pathlib.Path(_here).parent))
+            from geolip_vitals import anchor_drift, axis_aliveness, path_diversity
+        else:
+            raise ImportError(
+                "geolip_vitals not found — paste/run its cell first, or "
+                "hf_hub_download exp012_ar/geolip_vitals.py from "
+                "AbstractPhil/geolip-aleph-differentiation.")
+
+VOCAB = 256  # bytes
+
+
+# ------------------------------------------------------------------ aleph address
+def _super_fibonacci_s3(n: int) -> torch.Tensor:
+    """Near-uniform unit quaternions (Alexa CVPR'22) —
+    starts the codebook INSIDE the RP^3 attractor basin. D=4 only."""
+    PHI, PSI = math.sqrt(2.0), 1.533751168755204288118041
+    i = torch.arange(n, dtype=torch.float64)
+    s = (i + 0.5) / n
+    r, R = torch.sqrt(s), torch.sqrt(1.0 - s)
+    a, b = 2 * math.pi * i / PHI, 2 * math.pi * i / PSI
+    q = torch.stack([r * torch.sin(a), r * torch.cos(a),
+                     R * torch.sin(b), R * torch.cos(b)], dim=-1)
+    return F.normalize(q, dim=-1).float()
+
+
+class AlephAddress(nn.Module):
+    """Closed-form aleph over 2K oriented half-axes (aleph-void article).
+    signed(x): (..., K) w_k = sinh(u_k)/sum_j cosh(u_j)   — the Law-2 head feature.
+    oriented(x): ((..., K), (..., K)) positive halves of the 2K softmax — HUB map."""
+
+    def __init__(self, K: int, D: int, tau: float = 0.1, init: str = "random"):
+        super().__init__()
+        self.K, self.D, self.tau = K, D, tau
+        if init == "fibonacci":
+            assert D == 4, "fibonacci init lives on S^3 (D=4)"
+            A = _super_fibonacci_s3(K)
+        else:
+            A = F.normalize(torch.randn(K, D), dim=-1)
+        self.codebook = nn.Parameter(A)
+        self.register_buffer("home", self.codebook.detach().clone())
+
+    def _u(self, x):
+        A = F.normalize(self.codebook, dim=-1)
+        return (F.normalize(x, dim=-1) @ A.transpose(-1, -2)) / self.tau
+
+    def oriented(self, x):
+        u = self._u(x)
+        m = u.abs().amax(dim=-1, keepdim=True)
+        ep, en = torch.exp(u - m), torch.exp(-u - m)
+        Z = (ep + en).sum(dim=-1, keepdim=True)
+        return ep / Z, en / Z
+
+    def signed(self, x):
+        u = self._u(x)
+        m = u.abs().amax(dim=-1, keepdim=True)
+        ep, en = torch.exp(u - m), torch.exp(-u - m)
+        return (ep - en) / (ep + en).sum(dim=-1, keepdim=True)
+
+    def signed_at(self, x, taus):
+        """Multi-tau stroboscope (rule of 3): signed coefficients at several
+        temperatures, concatenated — softer taus keep the vector dense while a
+        hard tau supplies the sign-code sharpness. v2 refinement (b)."""
+        A = F.normalize(self.codebook, dim=-1)
+        cos = F.normalize(x, dim=-1) @ A.transpose(-1, -2)
+        outs = []
+        for t in taus:
+            u = cos / t
+            m = u.abs().amax(dim=-1, keepdim=True)
+            ep, en = torch.exp(u - m), torch.exp(-u - m)
+            outs.append((ep - en) / (ep + en).sum(dim=-1, keepdim=True))
+        return torch.cat(outs, dim=-1)
+
+    def m_hat(self, x):
+        """Closed-form soft read (decoders read M_hat, never M). v2 control (c)."""
+        u = self._u(x)
+        m = u.abs().amax(dim=-1, keepdim=True)
+        ep, en = torch.exp(u - m), torch.exp(-u - m)
+        A = F.normalize(self.codebook, dim=-1)
+        return ((ep - en) @ A) / (ep + en).sum(dim=-1, keepdim=True)
+
+    def m_hard_ste(self, x):
+        """Hard mode (aleph-void article): M_hard = sign(cos_win) * A[win], straight-through to
+        the soft read — forward fully discrete SIGN CODE, backward soft gradient.
+        Legal per theme A (reconstructive sign code, not a one-hot roster pick)."""
+        u = self._u(x)
+        soft = self.m_hat(x)
+        win = u.abs().argmax(dim=-1)
+        A = F.normalize(self.codebook, dim=-1)
+        sign = torch.sign(torch.gather(u, -1, win.unsqueeze(-1))).squeeze(-1)
+        hard = sign.unsqueeze(-1) * A[win]
+        return hard + soft - soft.detach()
+
+    @torch.no_grad()
+    def vitals(self, x_sample) -> dict:
+        u = self._u(x_sample.reshape(-1, x_sample.shape[-1]))
+        p, n = self.oriented(x_sample.reshape(-1, x_sample.shape[-1]))
+        two_k = torch.cat([p, n], dim=-1)
+        win = two_k.argmax(dim=-1)
+        cos_win = (u.abs().amax(dim=-1) * self.tau)  # winner |cos| — sign-code sat.
+        d = anchor_drift(self.codebook, self.home)
+        return {"drift": round(d["mean"], 4),
+                "binding_frac": round(d["binding_fraction"], 4),
+                "aliveness": axis_aliveness(two_k),
+                "win_cos_mean": round(cos_win.mean().item(), 4),
+                "paths": path_diversity(win)}
+
+
+# ------------------------------------------------------------------------- blocks
+class CausalSDPA(nn.Module):
+    def __init__(self, d: int, heads: int = 4):
+        super().__init__()
+        self.h = heads
+        self.qkv = nn.Linear(d, 3 * d, bias=False)
+        self.o = nn.Linear(d, d, bias=False)
+        nn.init.orthogonal_(self.qkv.weight); nn.init.orthogonal_(self.o.weight)
+
+    def forward(self, x):
+        B, n, d = x.shape
+        q, k, v = self.qkv(x).chunk(3, dim=-1)
+        q, k, v = (t.view(B, n, self.h, d // self.h).transpose(1, 2) for t in (q, k, v))
+        y = F.scaled_dot_product_attention(q, k, v, is_causal=True)
+        return self.o(y.transpose(1, 2).reshape(B, n, d))
+
+
+class CausalHUB(nn.Module):
+    """Causal aleph linear attention: prefix-sum memories over the two K-wide
+    halves of the oriented address; 2K never materialized; no selection event."""
+
+    def __init__(self, d: int, K: int = 32, D: int = 4, tau: float = 0.1):
+        super().__init__()
+        self.addr = AlephAddress(K, D, tau)
+        self.q = nn.Linear(d, D, bias=False)
+        self.k = nn.Linear(d, D, bias=False)
+        self.v = nn.Linear(d, d, bias=False)
+        self.o = nn.Linear(d, d, bias=False)
+        for m in (self.q, self.k, self.v, self.o):
+            nn.init.orthogonal_(m.weight)
+
+    def forward(self, x):
+        qp, qn = self.addr.oriented(self.q(x))          # (B, n, K)
+        kp, kn = self.addr.oriented(self.k(x))
+        v = self.v(x)                                    # (B, n, d)
+        Sp = torch.cumsum(torch.einsum("bnk,bnd->bnkd", kp, v), dim=1)
+        Sn = torch.cumsum(torch.einsum("bnk,bnd->bnkd", kn, v), dim=1)
+        zp = torch.cumsum(kp, dim=1)
+        zn = torch.cumsum(kn, dim=1)
+        num = torch.einsum("bnk,bnkd->bnd", qp, Sp) + torch.einsum("bnk,bnkd->bnd", qn, Sn)
+        den = (qp * zp).sum(-1, keepdim=True) + (qn * zn).sum(-1, keepdim=True)
+        return self.o(num / den.clamp_min(1e-12))
+
+
+class MslRelay(nn.Module):
+    """Depth-composition unit (chain-rule probe): multi-slot M_hat read entering
+    the trunk as a NEAR-ZERO gated residual (gate init -3.0, sigma~0.047 — theme D:
+    geometry enters as a nudge and grows only if it earns gradient)."""
+
+    def __init__(self, d: int, n_slots: int = 16, K: int = 64):
+        super().__init__()
+        self.n_slots = n_slots
+        self.proj = nn.Linear(d, n_slots * 4, bias=False)
+        self.out = nn.Linear(n_slots * 4, d, bias=False)
+        nn.init.orthogonal_(self.proj.weight)
+        nn.init.orthogonal_(self.out.weight)
+        self.addr = AlephAddress(K, 4)
+        self.gate = nn.Parameter(torch.tensor(-3.0))
+
+    def forward(self, x):
+        B, n, _ = x.shape
+        slots = self.proj(x).view(B, n, self.n_slots, 4)
+        m = self.addr.m_hat(slots).reshape(B, n, -1)
+        return x + self.gate.sigmoid() * self.out(m)
+
+
+class Block(nn.Module):
+    def __init__(self, d: int, attn: nn.Module):
+        super().__init__()
+        self.n1, self.n2 = nn.LayerNorm(d), nn.LayerNorm(d)
+        self.attn = attn
+        self.mlp = nn.Sequential(nn.Linear(d, 4 * d), nn.GELU(), nn.Linear(4 * d, d))
+
+    def forward(self, x):
+        x = x + self.attn(self.n1(x))
+        return x + self.mlp(self.n2(x))
+
+
+class ByteLM(nn.Module):
+    def __init__(self, arm: str, d: int = 192, layers: int = 4, block: int = 256,
+                 K: int = 32, D: int = 4):
+        super().__init__()
+        # "<arm>_tri" suffix = trigram byte embedding (AlephLM byte_emb x3 lineage):
+        # token embedding is the sum of embeddings of bytes t, t-1, t-2.
+        self.trigram = arm.endswith("_tri")
+        if self.trigram:
+            arm = arm[:-4]
+        # "_fib" = super-Fibonacci S^3 codebook init (basin test: starts INSIDE
+        # the RP^3 attractor; primary observable is init->final geodesic drift).
+        self.fib = arm.endswith("_fib")
+        if self.fib:
+            arm = arm[:-4]
+        # "relay*" = stacked addresses in depth: MslRelay after every block.
+        # relay -> sdpa trunk + standard head; relay_msl64 -> + addressed head.
+        self.use_relay = arm.startswith("relay")
+        if arm == "relay":
+            arm = "sdpa"
+        elif arm == "relay_msl64":
+            arm = "addr_msl64"
+        self.arm, self.block = arm, block
+        self.emb = nn.Embedding(VOCAB, d)
+        if self.trigram:
+            self.emb1 = nn.Embedding(VOCAB, d)
+            self.emb2 = nn.Embedding(VOCAB, d)
+        self.pos = nn.Parameter(torch.zeros(1, block, d) + 0.01 * torch.randn(1, block, d))
+        mk_attn = (lambda: CausalHUB(d, K, D)) if arm == "hub" else (lambda: CausalSDPA(d))
+        self.blocks = nn.ModuleList([Block(d, mk_attn()) for _ in range(layers)])
+        if self.use_relay:
+            self.relays = nn.ModuleList([MslRelay(d) for _ in range(layers)])
+        self.nf = nn.LayerNorm(d)
+        if arm == "addr_head":
+            self.head_addr = AlephAddress(K, d)  # v1: codebook in model dim — COLLAPSED
+            self.head = nn.Linear(K, VOCAB, bias=True)
+        elif arm in ("addr_d4", "addr_3tau", "addr_mhat"):
+            # v2 refinements: LOW-D HOME — learned projection to the native D=4 home
+            # before addressing (mirrors the healthy HUB arms), K=64.
+            self.head_proj = nn.Linear(d, 4, bias=False)
+            nn.init.orthogonal_(self.head_proj.weight)
+            self.head_addr = AlephAddress(64, 4)
+            if arm == "addr_d4":
+                self.head = nn.Linear(64, VOCAB, bias=True)      # w alone, D=4 home
+            elif arm == "addr_3tau":
+                self.taus = (0.05, 0.1, 0.3)                     # rule-of-3 strobe
+                self.head = nn.Linear(64 * 3, VOCAB, bias=True)
+            else:                                                 # addr_mhat
+                self.head = nn.Linear(4, VOCAB, bias=True)       # tightest: M_hat
+        elif arm.startswith("addr_msl"):
+            # v3: MULTI-SLOT heads — the 16s funnel widening: P parallel D=4 slots
+            # over a SHARED codebook. addr_msl consumes the reconstructive M_hat per
+            # slot (Px4 dims); addr_msl_w consumes signed w per slot (Px64) — tests
+            # whether slot-parallel consumption alone rescues the coefficient path.
+            # addr_msl<P> = slot-count dose-response. addr_mslh<P> = HARD sign-code
+            # consumption (straight-through M_hard per slot).
+            self.hard = arm.startswith("addr_mslh")
+            if arm in ("addr_msl", "addr_msl_w"):
+                self.n_slots = 16
+            else:
+                self.n_slots = int(arm[len("addr_mslh" if self.hard else "addr_msl"):])
+            self.head_proj = nn.Linear(d, self.n_slots * 4, bias=False)
+            nn.init.orthogonal_(self.head_proj.weight)
+            self.head_addr = AlephAddress(
+                64, 4, init="fibonacci" if self.fib else "random")
+            width = self.n_slots * (64 if arm == "addr_msl_w" else 4)
+            self.head = nn.Linear(width, VOCAB, bias=True)
+        elif arm == "addr_3tau_mhat":
+            # v3: combine the two v2 winners — 3-tau stroboscope + reconstructive read.
+            self.head_proj = nn.Linear(d, 4, bias=False)
+            nn.init.orthogonal_(self.head_proj.weight)
+            self.head_addr = AlephAddress(64, 4)
+            self.taus = (0.05, 0.1, 0.3)
+            self.head = nn.Linear(64 * 3 + 4, VOCAB, bias=True)
+        else:
+            self.head = nn.Linear(d, VOCAB, bias=True)
+        self._last_h = None
+
+    def forward(self, idx):
+        x = self.emb(idx)
+        if self.trigram:  # past-only shifts — causality preserved
+            x = x + self.emb1(F.pad(idx, (1, 0), value=0)[:, :-1]) \
+                  + self.emb2(F.pad(idx, (2, 0), value=0)[:, :-2])
+        x = x + self.pos[:, : idx.shape[1]]
+        if self.use_relay:
+            for b, r in zip(self.blocks, self.relays):
+                x = r(b(x))
+        else:
+            for b in self.blocks:
+                x = b(x)
+        h = self.nf(x)
+        self._last_h = h.detach()
+        if self.arm == "addr_head":
+            return self.head(self.head_addr.signed(h))
+        if self.arm == "addr_d4":
+            return self.head(self.head_addr.signed(self.head_proj(h)))
+        if self.arm == "addr_3tau":
+            return self.head(self.head_addr.signed_at(self.head_proj(h), self.taus))
+        if self.arm == "addr_mhat":
+            return self.head(self.head_addr.m_hat(self.head_proj(h)))
+        if self.arm.startswith("addr_msl"):
+            B, n, _ = h.shape
+            slots = self.head_proj(h).view(B, n, self.n_slots, 4)
+            if self.arm == "addr_msl_w":
+                feats = self.head_addr.signed(slots).reshape(B, n, -1)
+            elif getattr(self, "hard", False):
+                feats = self.head_addr.m_hard_ste(slots).reshape(B, n, -1)
+            else:
+                feats = self.head_addr.m_hat(slots).reshape(B, n, -1)
+            return self.head(feats)
+        if self.arm == "addr_3tau_mhat":
+            p = self.head_proj(h)
+            feats = torch.cat([self.head_addr.signed_at(p, self.taus),
+                               self.head_addr.m_hat(p)], dim=-1)
+            return self.head(feats)
+        return self.head(h)
+
+    @torch.no_grad()
+    def vitals(self) -> dict:
+        out = {}
+        if self.arm == "hub":
+            for i, b in enumerate(self.blocks):
+                if self._last_h is not None:
+                    out[f"L{i}"] = b.attn.addr.vitals(b.attn.q(self._last_h[:2]))
+        elif self.arm == "addr_head" and self._last_h is not None:
+            out["head"] = self.head_addr.vitals(self._last_h[:2])
+        elif self.arm in ("addr_d4", "addr_3tau", "addr_mhat",
+                          "addr_3tau_mhat") and self._last_h is not None:
+            out["head"] = self.head_addr.vitals(self.head_proj(self._last_h[:2]))
+        elif self.arm.startswith("addr_msl") and self._last_h is not None:
+            slots = self.head_proj(self._last_h[:2])
+            out["head"] = self.head_addr.vitals(
+                slots.reshape(*slots.shape[:-1], self.n_slots, 4))
+        if self.use_relay and self._last_h is not None:
+            for i, r in enumerate(self.relays):
+                s = r.proj(self._last_h[:2])
+                v = r.addr.vitals(s.reshape(*s.shape[:-1], r.n_slots, 4))
+                out[f"relay{i}"] = {"gate": round(r.gate.sigmoid().item(), 4),
+                                    "drift": v["drift"],
+                                    "binding_frac": v["binding_frac"],
+                                    "ppl": round(v["aliveness"]["usage_ppl"], 1)}
+        return out
+
+
+# --------------------------------------------------------------------------- data
+def _wikitext_bytes(data_root: str):
+    """wikitext-2-raw as flat uint8 tensors via the HF parquet CDN."""
+    from huggingface_hub import hf_hub_download
+    import pyarrow.parquet as pq
+
+    def load(split):
+        p = hf_hub_download("Salesforce/wikitext",
+                            f"wikitext-2-raw-v1/{split}-00000-of-00001.parquet",
+                            repo_type="dataset", local_dir=data_root)
+        text = "".join(pq.read_table(p).column("text").to_pylist())
+        return torch.frombuffer(bytearray(text.encode("utf-8")), dtype=torch.uint8).clone()
+
+    return load("train"), load("validation")
+
+
+def _batch(data: torch.Tensor, batch: int, block: int, device, g: torch.Generator):
+    ix = torch.randint(0, data.numel() - block - 1, (batch,), generator=g)
+    x = torch.stack([data[i:i + block] for i in ix]).long().to(device)
+    y = torch.stack([data[i + 1:i + block + 1] for i in ix]).long().to(device)
+    return x, y
+
+
+# -------------------------------------------------------------------- train/smoke
+def train(arms=("sdpa", "hub", "addr_head"), steps: int = 2000, batch: int = 32,
+          block: int = 256, device: str = "cuda", data_root: str = "./data",
+          seed: int = 0, eval_every: int = 500, save: bool = True):
+    """Verdict run — GPU only. Pure Adam wd=0. Reports val bits-per-byte + vitals.
+    save=True writes {data_root}/ar_ckpts/{arm}_s{seed}_t{steps}.pt per arm —
+    the cultivated codebooks are SPECIMENS for the projective reading instruments."""
+    import os
+    if device == "cuda" and not torch.cuda.is_available():
+        raise RuntimeError("Verdict runs are GPU-only (never CPU-train for accuracy).")
+    ckpt_dir = os.path.join(data_root, "ar_ckpts")
+    os.makedirs(ckpt_dir, exist_ok=True)
+    tr, va = _wikitext_bytes(data_root)
+    print(f"data ready: train {tr.numel():,} bytes, val {va.numel():,} bytes", flush=True)
+    results = {}
+    for arm in arms:
+        torch.manual_seed(seed)
+        g = torch.Generator().manual_seed(seed)
+        model = ByteLM(arm, block=block).to(device)
+        n_params = sum(p.numel() for p in model.parameters())
+        opt = torch.optim.Adam(model.parameters(), lr=3e-4, weight_decay=0.0)
+        for step in range(1, steps + 1):
+            x, y = _batch(tr, batch, block, device, g)
+            logits = model(x)
+            loss = F.cross_entropy(logits.reshape(-1, VOCAB), y.reshape(-1))
+            opt.zero_grad(set_to_none=True)
+            loss.backward()
+            opt.step()
+            if step % eval_every == 0 or step == steps:
+                model.eval()
+                with torch.no_grad():
+                    losses = []
+                    for _ in range(20):
+                        xv, yv = _batch(va, batch, block, device, g)
+                        lv = F.cross_entropy(model(xv).reshape(-1, VOCAB),
+                                             yv.reshape(-1))
+                        losses.append(lv.item())
+                bpb = sum(losses) / len(losses) / math.log(2)
+                print(f"[{arm}] step {step} val_bpb={bpb:.4f} vitals={model.vitals()}",
+                      flush=True)
+                model.train()
+        results[arm] = {"val_bpb": bpb, "params": n_params, "vitals": model.vitals()}
+        if save:
+            path = os.path.join(ckpt_dir, f"{arm}_s{seed}_t{steps}.pt")
+            torch.save({"arm": arm, "seed": seed, "steps": steps, "val_bpb": bpb,
+                        "state_dict": {k: v.cpu() for k, v in
+                                       model.state_dict().items()}}, path)
+            print(f"saved specimen: {path}", flush=True)
+    print(results, flush=True)
+    return results
+
+
+def smoke():
+    """Shapes/parse only — no accuracy claims."""
+    x = torch.randint(0, VOCAB, (2, 64))
+    for arm in ("sdpa", "hub", "addr_head"):
+        m = ByteLM(arm, d=96, layers=2, block=64, K=16)
+        logits = m(x)
+        assert logits.shape == (2, 64, VOCAB)
+        logits.sum().backward()
+        # causality check: future byte must not affect past logits
+        with torch.no_grad():
+            a = m(x)[0, 10]
+            x2 = x.clone(); x2[0, 40] = (x2[0, 40] + 7) % 256
+            b = m(x2)[0, 10]
+        assert torch.allclose(a, b, atol=1e-4), f"{arm} leaks future context"
+        print(f"{arm}: OK params={sum(p.numel() for p in m.parameters()):,} "
+              f"vitals={m.vitals()}", flush=True)
+    print("OK — AR bed smoke passed (verdict run: train() on GPU)", flush=True)
+
+
+def _in_notebook() -> bool:
+    try:
+        get_ipython()  # type: ignore[name-defined]  # noqa: F821
+        return True
+    except NameError:
+        return False
+
+
+if __name__ == "__main__":
+    if _in_notebook():
+        smoke()
+        print("Notebook mode: call  train(steps=2000)  in the next cell (GPU).")
+    else:
+        import argparse
+        ap = argparse.ArgumentParser()
+        ap.add_argument("--train", action="store_true")
+        ap.add_argument("--steps", type=int, default=2000)
+        a, _ = ap.parse_known_args()
+        train(steps=a.steps) if a.train else smoke()

exp020_gen/build_results.py

@@ -0,0 +1,52 @@
+"""build_results.py — exp020_gen: read results/ledger.jsonl and RE-ASSERT every
+claim in the README. Run from inside this folder: python build_results.py
+"""
+import json
+import os
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+rows = [json.loads(l) for l in
+        open(os.path.join(HERE, "results", "ledger.jsonl"), encoding="utf-8")]
+assert all(r["exp"] == "20" for r in rows) and len(rows) == 12
+cell = {(r["arm"], r["seed"]): r for r in rows}
+
+def held(arm, s):
+    return cell[(arm, s)]["gauges"]["heldout"]["byte_acc"]
+
+# claim 1: no arm lifts rule induction off the plateau — held-out EXACT is
+# 0.000 in all 12 cells, byte acc <= 0.27 everywhere
+for r in rows:
+    assert r["gauges"]["heldout"]["exact"] == 0.0
+    assert r["gauges"]["heldout"]["byte_acc"] <= 0.27
+
+# claim 2: the aleph bottleneck beats its param-matched free head, both seeds,
+# at matched head budget (within 0.2%)
+for s in (0, 1):
+    assert held("aleph", s) > held("mlp", s), s
+p_al, p_ml = cell[("aleph", 0)]["head_params"], cell[("mlp", 0)]["head_params"]
+assert abs(p_al - p_ml) / p_al < 0.002, (p_al, p_ml)
+
+# claim 3 (the inverse law): the best clean-bpb arm (const) generalizes WORST,
+# and the memorizer lineage (trigram) is second-worst — both seeds
+for s in (0, 1):
+    bpbs = {a: cell[(a, s)]["bpb"] for a, _ in cell if _ == s}
+    assert min(bpbs, key=bpbs.get) == "const", s
+    order = sorted((held(a, s), a) for a, ss in cell if ss == s)
+    assert order[0][1] == "const" and order[1][1] == "aleph_tri", (s, order)
+    assert order[-1][1] in ("aleph", "relay"), (s, order)
+
+# claim 4: format diversity teaches the SEEN alternate format at rule level
+# but does NOT unlock the unseen variant
+for s in (0, 1):
+    g = cell[("aleph_fmtdiv", s)]["gauges"]
+    assert g["heldout_r1"]["byte_acc"] > 0.20, s        # seen format: rule-level
+    assert g["train_varfmt"]["byte_acc"] < 0.06, s      # unseen: still locked
+
+out = {"heldout_byte": {f"{a}_s{s}": held(a, s) for (a, s) in sorted(cell)},
+       "head_params": {a: cell[(a, 0)]["head_params"]
+                       for a in {k[0] for k in cell}},
+       "n_rows": len(rows)}
+json.dump(out, open(os.path.join(HERE, "results", "results.json"), "w",
+                    encoding="utf-8"), indent=1)
+print(f"{len(rows)} rows -> results/results.json")
+print("all README claims asserted OK")

exp020_gen/exp014_genetic_distillation.py

@@ -0,0 +1,515 @@
+"""exp014_genetic_distillation.py — genetic distillation + memory substrate.
+14_a: multi-generational tournament (GM3 paradigm) where the aleph codebook is the
+      explicit heritable genome. Lineages: ALEPH-FLAT (consensus book + KD) |
+      ALEPH-TREE (structured genome: root book + branch books) | MLP-KD
+      (traditional: best-parent weights + KD) | NO-INHERIT (evolution floor).
+      Both sides intentionally inherit logits (KD); only ours inherits geometry.
+      Consensus = Procrustes/GPA alignment of parents' books to mean shape
+      (placement by construction — replaces GM3's k-means-on-consensus init).
+14_b: memory substrate — the D=4 home makes books size-agnostic. Implant books
+      cultivated in a small organism into a larger one (frozen / trainable), and
+      into GPT-2 relay adapters (cross-architecture frozen distillation).
+
+Riders: pure Adam wd=0; KD = KL to detached teacher probs (predictive pressure, no
+contrastive); tree routing is DENSE SOFT (oriented weights; collapse monitor on the
+root); drift-check precedes every freeze claim; GPU-only verdict runs; Colab-safe.
+Founders share a COMMON-ANCESTOR book so GPA row correspondence is inherited.
+
+Colab paste order: geolip_vitals.py -> ar_differentiation_bed.py ->
+exp013_augmentation_bed.py (only for run_b2) -> this file.
+"""
+from __future__ import annotations
+import copy
+import json
+import math
+import os
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+if "anchor_drift" not in globals():
+    try:
+        from geolip_vitals import anchor_drift, axis_aliveness, path_diversity
+    except ImportError:
+        _here = globals().get("__file__")
+        if _here is None:
+            raise ImportError("paste/run geolip_vitals.py first")
+        import sys, pathlib
+        sys.path.insert(0, str(pathlib.Path(_here).parent))
+        from geolip_vitals import anchor_drift, axis_aliveness, path_diversity
+if "ByteLM" not in globals():
+    try:
+        from ar_differentiation_bed import (ByteLM, AlephAddress, _wikitext_bytes,
+                                            _batch, VOCAB)
+    except ImportError:
+        raise ImportError("paste/run ar_differentiation_bed.py first")
+
+DATA_ROOT = os.environ.get("GEOLIP_DATA", "./data")
+EXP_DIR = os.path.join(DATA_ROOT, "exp014")
+
+
+class SquaredReLU(nn.Module):
+    def forward(self, x):
+        return F.relu(x) ** 2
+
+
+# ===================================================== consensus (the germline) ===
+@torch.no_grad()
+def procrustes_rotation(A: torch.Tensor, M: torch.Tensor) -> torch.Tensor:
+    """Orthogonal R minimizing ||A R - M||_F (rows correspond)."""
+    U, _, Vt = torch.linalg.svd(A.T.double() @ M.double())
+    return (U @ Vt).float()
+
+
+@torch.no_grad()
+def align_to(A: torch.Tensor, ref: torch.Tensor, iters: int = 20) -> torch.Tensor:
+    """Projective Procrustes (rows correspond, signs free): alternate the
+    orthogonal rotation and per-row sign flips (books live on RP^(D-1))."""
+    s = torch.ones(A.shape[0], 1)
+    for _ in range(iters):
+        R = procrustes_rotation(s * A, ref)
+        AR = (s * A) @ R
+        s_upd = torch.where((AR * ref).sum(-1, keepdim=True) < 0, -s, s)
+        if torch.equal(s_upd, s):
+            return AR
+        s = s_upd
+    return (s * A) @ procrustes_rotation(s * A, ref)
+
+
+@torch.no_grad()
+def consensus_codebook(books: list, iters: int = 50, tol: float = 1e-8):
+    """GPA to mean shape (GM3 machinery, applied to aleph books), anchored to the
+    FIRST parent's frame. Rows must correspond (common-ancestor convention); signs
+    are projective. Returns (consensus, n_iters, delta)."""
+    # device-pin to CPU: parent models may live on CUDA after KD teacher moves
+    Bs = [F.normalize(b.detach().float().cpu(), dim=-1).clone() for b in books]
+    # pairwise projective alignment to parent-0's frame, THEN GPA refinement
+    aligned = [Bs[0]] + [align_to(b, Bs[0]) for b in Bs[1:]]
+    M = F.normalize(torch.stack(aligned).mean(0), dim=-1)
+    delta, it = 0.0, 0
+    for it in range(1, iters + 1):
+        aligned = [align_to(b, M) for b in Bs]
+        M_new = F.normalize(torch.stack(aligned).mean(0), dim=-1)
+        delta = (M_new - M).norm().item()
+        M = M_new
+        if delta < tol:
+            break
+    # re-anchor to parent-0 (GPA drift of the global frame stays measurable)
+    M = align_to(M, Bs[0])
+    return M, it, delta
+
+
+@torch.no_grad()
+def implant_book(addr: "AlephAddress", book: torch.Tensor, trainable: bool = True):
+    """Load a book into an AlephAddress: codebook + home (drift measured from the
+    implant). Freeze only via trainable=False AFTER a drift-check justifies it."""
+    b = F.normalize(book.float(), dim=-1).to(addr.codebook.device)
+    assert b.shape == addr.codebook.shape, (b.shape, addr.codebook.shape)
+    addr.codebook.data.copy_(b)
+    addr.home.copy_(b)
+    addr.codebook.requires_grad_(trainable)
+
+
+# ============================================================= tree head ==========
+class TreeHead(nn.Module):
+    """Autoregressive tree (the constellation-anchor analogue, exp011 TREE operator
+    in the healthy consumption regime): a ROOT aleph (K=2, D=4) yields the 4
+    oriented weights (2K half-axes = the 4 branches, dense soft, sums to 1);
+    each BRANCH is a 64-slot... shared slot projection read by a branch-specific
+    book (K=64, D=4); output = branch-weighted mixture of branch reads -> vocab.
+    Heritable genome: root book (2,4) + 4 branch books (64,4)."""
+
+    ROOT_SLOTS = 4          # slot-parallel root consumption (the collapse cure)
+    ROOT_TAU = 0.3          # softer root temperature (wave-1 fix: single hard-tau
+                            # root partially collapsed, usage [.85,.12,.01,.02])
+
+    def __init__(self, d: int, vocab: int = 256, n_slots: int = 16):
+        super().__init__()
+        self.n_slots = n_slots
+        self.root_proj = nn.Linear(d, self.ROOT_SLOTS * 4, bias=False)
+        self.slot_proj = nn.Linear(d, n_slots * 4, bias=False)
+        nn.init.orthogonal_(self.root_proj.weight)
+        nn.init.orthogonal_(self.slot_proj.weight)
+        self.root = AlephAddress(2, 4, tau=self.ROOT_TAU)
+        self.branches = nn.ModuleList([AlephAddress(64, 4) for _ in range(4)])
+        self.out = nn.Linear(n_slots * 4, vocab, bias=True)
+        self._last_root = None
+
+    def forward(self, h):
+        B, n, _ = h.shape
+        rs = self.root_proj(h).view(B, n, self.ROOT_SLOTS, 4)
+        p, m = self.root.oriented(rs)                      # (B,n,S,2) x2
+        w = torch.cat([p, m], dim=-1).mean(dim=-2)          # slot-avg -> (B,n,4)
+        self._last_root = w.detach()
+        slots = self.slot_proj(h).view(B, n, self.n_slots, 4)
+        mix = 0
+        for b, br in enumerate(self.branches):
+            mix = mix + w[..., b:b + 1] * br.m_hat(slots).reshape(B, n, -1)
+        return self.out(mix)
+
+    def genome(self):
+        return {"root": self.root.codebook.detach().clone(),
+                **{f"branch{i}": br.codebook.detach().clone()
+                   for i, br in enumerate(self.branches)}}
+
+    @torch.no_grad()
+    def inherit(self, genomes: list):
+        c, it, dl = consensus_codebook([g["root"] for g in genomes])
+        implant_book(self.root, c)
+        for i, br in enumerate(self.branches):
+            c, _, _ = consensus_codebook([g[f"branch{i}"] for g in genomes])
+            implant_book(br, c)
+
+    @torch.no_grad()
+    def vitals(self):
+        out = {"root_drift": round(anchor_drift(self.root.codebook,
+                                                self.root.home)["mean"], 4)}
+        if self._last_root is not None:
+            w = self._last_root.reshape(-1, 4)
+            usage = w.mean(0)
+            usage = usage / usage.sum()
+            out["root_usage"] = [round(float(u), 3) for u in usage]
+            ent = -(usage.clamp_min(1e-9) * usage.clamp_min(1e-9).log()).sum()
+            out["root_ppl4"] = round(float(ent.exp()), 3)
+        d = [anchor_drift(br.codebook, br.home)["mean"] for br in self.branches]
+        out["branch_drift"] = [round(x, 3) for x in d]
+        return out
+
+
+# ============================================================ organisms ===========
+def make_organism(lineage: str, d: int = 192, layers: int = 4, block: int = 256,
+                  seed: int = 0):
+    """lineage in {aleph_flat, aleph_tree, mlp_kd, no_inherit}. no_inherit uses the
+    aleph_flat architecture (the control isolates INHERITANCE, not architecture)."""
+    torch.manual_seed(seed)
+    if lineage in ("aleph_flat", "no_inherit", "aleph_full", "aleph_weights"):
+        return ByteLM("addr_msl64", d=d, layers=layers, block=block)
+    if lineage == "aleph_tree":
+        m = ByteLM("sdpa", d=d, layers=layers, block=block)
+        m.head = TreeHead(d)
+        return m
+    if lineage == "mlp_kd":
+        m = ByteLM("sdpa", d=d, layers=layers, block=block)
+        m.head = nn.Sequential(nn.Linear(d, 224), SquaredReLU(),
+                               nn.LayerNorm(224), nn.Linear(224, VOCAB))
+        return m
+    raise ValueError(lineage)
+
+
+def genome_of(model):
+    """The heritable organ = co-adapted (projection, book) pair(s). Books inherit
+    by CONSENSUS (the geometric germline); projections inherit from the BEST
+    parent (weight copy) — implanting a book against a random projection puts the
+    child below random init (campaign-v2 lesson)."""
+    if isinstance(model.head, TreeHead):
+        g = model.head.genome()
+        g["root_proj"] = model.head.root_proj.weight.detach().cpu().clone()
+        g["slot_proj"] = model.head.slot_proj.weight.detach().cpu().clone()
+        return g
+    if hasattr(model, "head_addr"):
+        return {"flat": model.head_addr.codebook.detach().cpu().clone(),
+                "proj": model.head_proj.weight.detach().cpu().clone()}
+    return None
+
+
+@torch.no_grad()
+def inherit_genome(model, genomes: list):
+    """genomes[0] = the BEST parent (selection order matters)."""
+    if isinstance(model.head, TreeHead):
+        model.head.inherit(genomes)
+        model.head.root_proj.weight.copy_(genomes[0]["root_proj"].to(
+            model.head.root_proj.weight.device))
+        model.head.slot_proj.weight.copy_(genomes[0]["slot_proj"].to(
+            model.head.slot_proj.weight.device))
+    elif hasattr(model, "head_addr"):
+        c, it, dl = consensus_codebook([g["flat"] for g in genomes])
+        implant_book(model.head_addr, c)
+        model.head_proj.weight.copy_(genomes[0]["proj"].to(
+            model.head_proj.weight.device))
+
+
+def organism_vitals(model):
+    if isinstance(model.head, TreeHead):
+        return model.head.vitals()
+    return model.vitals() if hasattr(model, "vitals") else {}
+
+
+# ========================================================= train one member ======
+def train_member(model, tr, va, steps=2000, batch=32, block=256, device="cuda",
+                 seed=0, teachers=None, kd_alpha=1.0):
+    """CE (+ KL to detached mean teacher probs when teachers given). Pure Adam."""
+    g = torch.Generator().manual_seed(seed)
+    model = model.to(device)
+    opt = torch.optim.Adam(model.parameters(), lr=3e-4, weight_decay=0.0)
+    if teachers:
+        teachers = [t.to(device).eval() for t in teachers]
+    for step in range(1, steps + 1):
+        x, y = _batch(tr, batch, block, device, g)
+        logits = model(x)
+        loss = F.cross_entropy(logits.reshape(-1, VOCAB), y.reshape(-1))
+        if teachers:
+            with torch.no_grad():
+                tp = torch.stack([F.softmax(t(x), -1) for t in teachers]).mean(0)
+            loss = loss + kd_alpha * F.kl_div(
+                F.log_softmax(logits, -1), tp, reduction="batchmean")
+        opt.zero_grad(set_to_none=True); loss.backward(); opt.step()
+    model.eval()
+    with torch.no_grad():
+        ls = []
+        for _ in range(20):
+            xv, yv = _batch(va, batch, block, device, g)
+            ls.append(F.cross_entropy(model(xv).reshape(-1, VOCAB),
+                                      yv.reshape(-1)).item())
+    return sum(ls) / len(ls) / math.log(2)          # bpb
+
+
+# ============================================================ the tournament ======
+def run_tournament(lineage: str, gens: int = 4, pop: int = 4, steps: int = 2000,
+                   seed: int = 0, device: str = "cuda",
+                   catastrophic_at: int | None = None):
+    """One lineage, one tournament seed. Logs per-gen to the ledger; saves the
+    champion genome per generation. catastrophic_at=G injects a 0-step random
+    parent into the consensus at generation G (the GM3 robustness probe)."""
+    if not torch.cuda.is_available():
+        raise RuntimeError("verdict runs are GPU-only")
+    os.makedirs(EXP_DIR, exist_ok=True)
+    tr, va = _wikitext_bytes(DATA_ROOT)
+    ledger = open(os.path.join(EXP_DIR, "ledger.jsonl"), "a", encoding="utf-8")
+    # common ancestor: every founder book starts identical within a tournament
+    torch.manual_seed(9000 + seed)
+    ancestor = make_organism(lineage, seed=9000 + seed)
+    anc_genome = genome_of(ancestor)
+    parents, parent_models, champion_genomes = [], [], []
+    for gen in range(gens):
+        members = []
+        for i in range(pop):
+            mseed = seed * 1000 + gen * 100 + i
+            m = make_organism(lineage, seed=mseed)
+            if anc_genome and gen == 0:
+                inherit_genome(m, [anc_genome])            # common ancestor
+            if gen > 0:
+                is_fresh = (i == pop - 1)                   # gene flow founder
+                if not is_fresh:
+                    if lineage in ("aleph_flat", "aleph_tree"):
+                        gs = [genome_of(pm) for pm in parent_models]
+                        if catastrophic_at == gen:
+                            bad = make_organism(lineage, seed=666 + i)
+                            gs = gs + [genome_of(bad)]
+                        inherit_genome(m, gs)
+                    elif lineage == "aleph_full":
+                        # v4 arm (v3 lesson: continuity is what pays) — inherit the
+                        # WHOLE best parent, then overwrite the book with the
+                        # two-parent consensus: germline ON TOP of continuity.
+                        m.load_state_dict(copy.deepcopy(
+                            parent_models[0].state_dict()))
+                        gs = [genome_of(pm) for pm in parent_models]
+                        if catastrophic_at == gen:
+                            bad = make_organism(lineage, seed=666 + i)
+                            gs = gs + [genome_of(bad)]
+                        c, _, _ = consensus_codebook([g["flat"] for g in gs])
+                        implant_book(m.head_addr, c)
+                    elif lineage in ("mlp_kd", "aleph_weights"):
+                        # pure continuity (no germline op) — aleph_weights is the
+                        # within-architecture control for aleph_full
+                        m.load_state_dict(copy.deepcopy(
+                            parent_models[0].state_dict()))
+                    # no_inherit: nothing
+            # KD: alpha 0.25 (campaign-v2 lesson: alpha=1.0 from near-parity
+            # teachers COMPOUNDS DOWNWARD — inverse evolution; fresh-founder
+            # control isolated it). Fresh founders get NO KD (clean gene flow).
+            is_fresh_now = (gen > 0 and i == pop - 1)
+            teachers = parent_models if (gen > 0 and not is_fresh_now
+                                          and lineage != "no_inherit") else None
+            bpb = train_member(m, tr, va, steps=steps, device=device,
+                               seed=mseed, teachers=teachers, kd_alpha=0.25)
+            vit = organism_vitals(m)
+            members.append((bpb, m))
+            rec = {"exp": "14a", "lineage": lineage, "tseed": seed, "gen": gen,
+                   "member": i, "fresh": gen > 0 and i == pop - 1,
+                   "catastrophic": catastrophic_at == gen, "bpb": round(bpb, 4),
+                   "vitals": vit}
+            ledger.write(json.dumps(rec) + "\n"); ledger.flush()
+            print(f"[14a {lineage} t{seed} g{gen} m{i}] bpb={bpb:.4f} {vit}",
+                  flush=True)
+        members.sort(key=lambda t: t[0])
+        parent_models = [members[0][1].cpu(), members[1][1].cpu()]
+        best = members[0][0]
+        gene = genome_of(members[0][1])
+        if gene:
+            torch.save(gene, os.path.join(
+                EXP_DIR, f"champion_{lineage}_t{seed}_g{gen}.pt"))
+            champion_genomes.append(gene)
+        print(f"[14a {lineage} t{seed} g{gen}] BEST={best:.4f} "
+              f"mean={sum(b for b, _ in members)/pop:.4f}", flush=True)
+        for _, mm in members[2:]:
+            del mm
+        torch.cuda.empty_cache()
+    ledger.close()
+    return best
+
+
+# ============================================================ 14_b implants ======
+def run_b1(steps: int = 2000, seed: int = 0, device: str = "cuda",
+           donor_book: torch.Tensor | None = None, tag: str = "small_cultivated"):
+    """Cross-size: donor book (default: cultivate in a small organism) implanted
+    into a LARGE organism. Arms: fresh | implant-trainable | implant-frozen | mlp."""
+    if not torch.cuda.is_available():
+        raise RuntimeError("verdict runs are GPU-only")
+    os.makedirs(EXP_DIR, exist_ok=True)
+    tr, va = _wikitext_bytes(DATA_ROOT)
+    ledger = open(os.path.join(EXP_DIR, "ledger.jsonl"), "a", encoding="utf-8")
+    if donor_book is None:
+        small = make_organism("aleph_flat", d=128, layers=2, seed=seed)
+        bpb_small = train_member(small, tr, va, steps=steps, device=device, seed=seed)
+        donor_book = genome_of(small)["flat"]
+        print(f"[14b donor small] bpb={bpb_small:.4f}", flush=True)
+    results = {}
+    for arm in ("fresh", "implant_train", "implant_frozen", "mlp"):
+        lineage = "mlp_kd" if arm == "mlp" else "aleph_flat"
+        m = make_organism(lineage, d=384, layers=6, seed=seed + 10)
+        if arm.startswith("implant"):
+            implant_book(m.head_addr, donor_book, trainable=(arm == "implant_train"))
+        bpb = train_member(m, tr, va, steps=steps, device=device, seed=seed + 10)
+        vit = organism_vitals(m)
+        results[arm] = {"bpb": round(bpb, 4), "vitals": vit}
+        rec = {"exp": "14b1", "arm": arm, "donor": tag, "seed": seed,
+               "bpb": round(bpb, 4), "vitals": vit}
+        ledger.write(json.dumps(rec) + "\n"); ledger.flush()
+        print(f"[14b1 {arm} donor={tag}] bpb={bpb:.4f} {vit}", flush=True)
+        del m; torch.cuda.empty_cache()
+    ledger.close()
+    return results, donor_book
+
+
+def run_b2(donor_book: torch.Tensor, steps: int = 1500, seed: int = 0,
+           device: str = "cuda", tag: str = "small_cultivated"):
+    """Cross-architecture: implant the donor book into every GPT-2 relay adapter
+    (exp013 Track C bed) vs random-init relays. Books are (64,4) — size-agnostic."""
+    from exp013_augmentation_bed import _wikitext_lines
+    from transformers import GPT2LMHeadModel, GPT2TokenizerFast
+    if "MslRelay" not in globals():
+        from ar_differentiation_bed import MslRelay
+    from exp013_augmentation_bed import _BlockWithAdapter
+    tok = GPT2TokenizerFast.from_pretrained("gpt2")
+    tr_lines, va_lines = _wikitext_lines(DATA_ROOT)
+    stream_tr = tok("\n\n".join(tr_lines[:8000]), return_tensors="pt").input_ids[0]
+    stream_va = tok("\n\n".join(va_lines[:1000]), return_tensors="pt").input_ids[0]
+    ledger = open(os.path.join(EXP_DIR, "ledger.jsonl"), "a", encoding="utf-8")
+    out = {}
+    for arm in ("random_relays", "implanted_relays"):
+        torch.manual_seed(seed)
+        g = torch.Generator().manual_seed(seed)
+        model = GPT2LMHeadModel.from_pretrained("gpt2").to(device)
+        for p in model.parameters():
+            p.requires_grad_(False)
+        adapters = []
+        for i, blk in enumerate(model.transformer.h):
+            ad = MslRelay(model.config.n_embd).to(device)
+            if arm == "implanted_relays":
+                implant_book(ad.addr, donor_book, trainable=True)
+            model.transformer.h[i] = _BlockWithAdapter(blk, ad)
+            adapters.append(ad)
+        params = [p for ad in adapters for p in ad.parameters()
+                  if p.requires_grad]
+        opt = torch.optim.Adam(params, lr=1e-3, weight_decay=0.0)
+        block = 256
+        for step in range(1, steps + 1):
+            ix = torch.randint(0, stream_tr.numel() - block - 1, (8,), generator=g)
+            x = torch.stack([stream_tr[i:i + block] for i in ix]).to(device)
+            loss = model(x, labels=x).loss
+            opt.zero_grad(set_to_none=True); loss.backward(); opt.step()
+        model.eval()
+        with torch.no_grad():
+            ls = []
+            for j in range(0, stream_va.numel() - block - 1, block * 4):
+                x = stream_va[j:j + block].unsqueeze(0).to(device)
+                ls.append(model(x, labels=x).loss.item())
+        ppl = math.exp(sum(ls) / len(ls))
+        gates = [round(ad.gate.sigmoid().item(), 4) for ad in adapters]
+        drifts = [round(anchor_drift(ad.addr.codebook, ad.addr.home)["mean"], 3)
+                  for ad in adapters]
+        out[arm] = {"ppl": round(ppl, 3), "gates": gates, "drift": drifts}
+        rec = {"exp": "14b2", "arm": arm, "donor": tag, "seed": seed,
+               "ppl": round(ppl, 3), "gates": gates, "drift": drifts}
+        ledger.write(json.dumps(rec) + "\n"); ledger.flush()
+        print(f"[14b2 {arm} donor={tag}] ppl={ppl:.3f} gates={gates[:3]}.. "
+              f"drift={drifts[:3]}..", flush=True)
+        del model; torch.cuda.empty_cache()
+    ledger.close()
+    return out
+
+
+# ================================================================ smoke ===========
+def smoke():
+    """CPU shapes/parse only: GPA ground truth, tree causality, implant, KD path."""
+    g = torch.Generator().manual_seed(0)
+    # GPA: two rotated (+row-sign-flipped) copies of one book must align back to it
+    A = F.normalize(torch.randn(64, 4, generator=g), dim=-1)
+    q, _ = torch.linalg.qr(torch.randn(4, 4, generator=g))
+    B = A @ q
+    B[::3] = -B[::3]
+    C, it, dl = consensus_codebook([A, B])
+    cos = (F.normalize(C, dim=-1) * A).sum(-1).abs().mean()
+    assert cos > 0.999, cos
+    print(f"GPA OK (iters={it}, delta={dl:.2e}, |cos to truth|={cos:.5f})")
+    x = torch.randint(0, 256, (2, 64))
+    for lineage in ("aleph_flat", "aleph_tree", "mlp_kd", "no_inherit"):
+        m = make_organism(lineage, d=96, layers=2, block=64, seed=0)
+        lg = m(x); assert lg.shape == (2, 64, 256); lg.sum().backward()
+        with torch.no_grad():
+            a = m(x)[0, 10]; x2 = x.clone(); x2[0, 40] = (x2[0, 40] + 7) % 256
+            b = m(x2)[0, 10]
+        assert torch.allclose(a, b, atol=1e-4), lineage + " leaks"
+        gnm = genome_of(m)
+        if gnm:
+            inherit_genome(m, [gnm, gnm])       # self-consensus = identity-ish
+        print(lineage, "OK params",
+              f"{sum(p.numel() for p in m.parameters()):,}",
+              organism_vitals(m) if lineage != "mlp_kd" else {})
+    # KD path: teacher forward + KL backward
+    t = make_organism("mlp_kd", d=96, layers=2, block=64, seed=1)
+    s = make_organism("aleph_flat", d=96, layers=2, block=64, seed=2)
+    tp = F.softmax(t(x), -1).detach()
+    loss = F.kl_div(F.log_softmax(s(x), -1), tp, reduction="batchmean")
+    loss.backward()
+    print("KD OK — exp014 smoke passed (tournament on GPU: run_tournament(...))")
+
+
+def _in_notebook():
+    try:
+        get_ipython()  # type: ignore[name-defined]  # noqa: F821
+        return True
+    except NameError:
+        return False
+
+
+if __name__ == "__main__":
+    if _in_notebook():
+        smoke()
+        print("Notebook: run_tournament('aleph_flat'), run_b1(), run_b2(book).")
+    else:
+        import argparse
+        ap = argparse.ArgumentParser()
+        ap.add_argument("--mode", default="smoke",
+                        choices=["smoke", "tournament", "b1", "b2"])
+        ap.add_argument("--lineage", default="aleph_full",
+                        help="tournament lineage: aleph_flat|aleph_full|"
+                             "aleph_weights|aleph_tree|mlp_kd|no_inherit")
+        ap.add_argument("--seed", type=int, default=0)
+        ap.add_argument("--steps", type=int, default=2000)
+        ap.add_argument("--genome", default="genomes/champion_aleph_full_t0_g3.pt",
+                        help="donor genome .pt for --mode b1/b2 (uses its 'flat' book)")
+        a, _ = ap.parse_known_args()
+        if a.mode == "smoke":
+            smoke()
+        elif a.mode == "tournament":
+            run_tournament(a.lineage, steps=a.steps, seed=a.seed)
+        elif a.mode == "b1":
+            donor = (torch.load(a.genome, map_location="cpu")["flat"]
+                     if os.path.exists(a.genome) else None)
+            run_b1(steps=a.steps, seed=a.seed, donor_book=donor,
+                   tag=os.path.basename(a.genome) if donor is not None
+                   else "small_cultivated")
+        elif a.mode == "b2":
+            donor = torch.load(a.genome, map_location="cpu")["flat"]
+            run_b2(donor, seed=a.seed, tag=os.path.basename(a.genome))

exp020_gen/exp017_aleph_constellation.py

@@ -0,0 +1,266 @@
+"""exp017_aleph_constellation.py — PROTOTYPE ALEPH CONSTELLATION.
+The constellation element for the aleph address: the 16s bridge (per the
+constellation-diffusion-bottleneck article: 16 anchors x 16 patches x 3
+stroboscope SLERP phases = the 768 address; aleph D=4 home lifted to the S^15
+measurement sphere via 16 = 4^2) implemented as a byte-LM head — the first
+configuration in the AR bed where the constellation gauges legitimately apply.
+
+Funnel (per position, the 16s numerology intact on the aleph D=4 home):
+  h(d) -> proj -> 16 patches x 32 rows of D=4          (in_per_patch = 32*4 = 128)
+       -> AlephAddress M_hat read per row               (farms the codebook)
+       -> crush MLP 128 -> 48 -> 16, SquaredReLU        (8x squeeze, rule-of-3 hidden)
+       -> row-normalize = S^15 point per patch          (the measurement sphere; 16 = 4^2)
+       -> triangulate 16 constellation anchors x 3 SLERP strobe phases
+          tri_k(t) = cos((1-t) * theta_k), t in {0, 1/3, 2/3}   (acos in fp32)
+       -> address 16 patches x 16 anchors x 3 = 768
+       -> patchwork Linear(768,1536) -> SquaredReLU -> LN -> Linear(1536, VOCAB)
+Constellation rules honored (per the Constellation Forms Catalogue,
+AbstractPhil/geolip-constellation-activations): SquaredReLU in
+all constellation paths (never GELU); patchwork spec; anchor dropout 30%;
+Procrustes CALIBRATION of the anchor init (non-negotiable rule; ablated in
+const_uncal); acos fp32; Adam wd=0. No gate: this is the whole output path, not
+a residual entry.
+
+JUDGED BY (16s law): constellation anchor drift -> 0.29154, crushed CV -> 0.20,
+and task bpb — NEVER recon cosine. The aleph codebook underneath keeps its own
+regime (CV~0.9 volatile home; recon/CE gradient the only pressure on it).
+
+Arms:
+  const       — CV strictly a readout (aleph-side discipline)
+  const_cv    — + micro CV loss 1e-3 on the constellation bank (Form 3:
+                "CV ON THE BANK is load-bearing"; forward loss, never backward
+                injection) — tests whether the constellation rule transfers
+  const_uncal — calibration ablation (random anchors, no Procrustes calibration;
+                the "without: 1/256 anchors" rule test)
+Baselines (exp012 certified ledger, cited not rerun): addr_msl64 2.4990,
+sdpa 2.5182 @2k/seed0. Head is NOT param-matched to addr_msl64 (~2.0M vs ~114K)
+— the prototype question is health + gauge placement, not a matched win.
+Riders: pure Adam wd=0; GPU-only verdicts; >=2 seeds; Colab-safe. Paste order:
+geolip_vitals -> ar_differentiation_bed -> this file.
+"""
+from __future__ import annotations
+import json
+import math
+import os
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+if "ByteLM" not in globals():
+    try:
+        from ar_differentiation_bed import (ByteLM, AlephAddress, _wikitext_bytes,
+                                            _batch, VOCAB)
+        from geolip_vitals import anchor_drift, pentachoron_cv, BINDING
+    except ImportError:
+        _here = globals().get("__file__")
+        if _here is None:
+            raise ImportError("paste geolip_vitals.py + ar_differentiation_bed.py first")
+        import sys, pathlib
+        sys.path.insert(0, str(pathlib.Path(_here).parent))
+        from ar_differentiation_bed import (ByteLM, AlephAddress, _wikitext_bytes,
+                                            _batch, VOCAB)
+        from geolip_vitals import anchor_drift, pentachoron_cv, BINDING
+
+DATA_ROOT = os.environ.get("GEOLIP_DATA", "./data")
+EXP17_DIR = os.path.join(DATA_ROOT, "exp017")
+
+N_PATCHES, N_ANCH, V_ROWS, GEO = 16, 16, 32, 16      # 16 = 4^2 = d^2 (16s law)
+PHASES = (0.0, 1.0 / 3.0, 2.0 / 3.0)                 # stroboscope SLERP, rule of 3
+
+
+class SquaredReLU(nn.Module):
+    def forward(self, x):
+        return F.relu(x) ** 2
+
+
+class ConstellationHead(nn.Module):
+    """The 16s funnel over the aleph address (docstring above)."""
+
+    def __init__(self, d: int, vocab: int = 256, calibrated: bool = True,
+                 anchor_dropout: float = 0.30):
+        super().__init__()
+        self.calibrated = calibrated
+        self.anchor_dropout = anchor_dropout
+        self.proj = nn.Linear(d, N_PATCHES * V_ROWS * 4, bias=False)
+        nn.init.orthogonal_(self.proj.weight)
+        self.addr = AlephAddress(64, 4)               # the aleph layer beneath
+        self.crush = nn.Sequential(                   # 128 -> 48 -> 16 (8x squeeze)
+            nn.Linear(V_ROWS * 4, GEO * 3), SquaredReLU(),
+            nn.Linear(GEO * 3, GEO))
+        A = F.normalize(torch.randn(N_ANCH, GEO), dim=-1)
+        self.anchors = nn.Parameter(A)                # S^15 constellation bank
+        self.register_buffer("anchors_home", A.clone())
+        tri = N_PATCHES * N_ANCH * len(PHASES)        # 768, the address
+        self.patchwork = nn.Sequential(
+            nn.Linear(tri, tri * 2), SquaredReLU(),
+            nn.LayerNorm(tri * 2), nn.Linear(tri * 2, vocab))
+        self._calibrated_done = not calibrated
+
+    @torch.no_grad()
+    def calibrate(self, h_sample: torch.Tensor):
+        """Procrustes calibration of the anchor init (NON-NEGOTIABLE constellation
+        rule): rotate the anchor template into the principal frame of the actual
+        crushed S^15 activations, then re-home. Runs once, before training."""
+        x = self._crushed(h_sample.reshape(-1, h_sample.shape[-1]))   # (N, P, GEO)
+        x = x.reshape(-1, GEO).float()
+        # data frame: eigenvectors of the crushed covariance (fp64)
+        C = (x.T.double() @ x.double()) / x.shape[0]
+        _, Vd = torch.linalg.eigh(C)
+        A = self.anchors.double()
+        Ca = (A.T @ A) / A.shape[0]
+        _, Va = torch.linalg.eigh(Ca)
+        R = Va @ Vd.T                                  # template frame -> data frame
+        A_cal = F.normalize((A @ R).float(), dim=-1)
+        self.anchors.data.copy_(A_cal)
+        self.anchors_home.copy_(A_cal)
+        self._calibrated_done = True
+
+    def _crushed(self, h):
+        rows = self.proj(h).view(*h.shape[:-1], N_PATCHES, V_ROWS, 4)
+        m_hat = self.addr.m_hat(rows)                  # aleph read per row
+        flat = m_hat.reshape(*h.shape[:-1], N_PATCHES, V_ROWS * 4)
+        return F.normalize(self.crush(flat), dim=-1)   # (..., P, GEO) on S^15
+
+    def forward(self, h):
+        x = self._crushed(h)                                        # (..., P, GEO)
+        A = F.normalize(self.anchors, dim=-1)
+        cos = (x @ A.T).clamp(-1 + 1e-6, 1 - 1e-6)                  # (..., P, K)
+        theta = torch.acos(cos.float())                             # acos in fp32
+        tri = torch.cat([torch.cos((1.0 - t) * theta) for t in PHASES],
+                        dim=-1).to(h.dtype)                         # (..., P, K*3)
+        if self.training and self.anchor_dropout > 0:
+            keep = (torch.rand(N_ANCH, device=h.device)
+                    > self.anchor_dropout).float()
+            tri = tri * keep.repeat(len(PHASES))
+        return self.patchwork(tri.reshape(*h.shape[:-1],
+                                          N_PATCHES * N_ANCH * len(PHASES)))
+
+    @torch.no_grad()
+    def constellation_vitals(self) -> dict:
+        d = anchor_drift(self.anchors, self.anchors_home)
+        return {"anchor_drift": round(d["mean"], 4),
+                "binding_frac": round(d["binding_fraction"], 4),
+                "crushed_cv": round(pentachoron_cv(self.anchors.detach()), 4),
+                "aleph": {"drift": round(anchor_drift(
+                    self.addr.codebook, self.addr.home)["mean"], 4)}}
+
+
+def make_const_model(arm: str, d: int = 192, layers: int = 4,
+                        block: int = 256, seed: int = 0):
+    torch.manual_seed(seed)
+    m = ByteLM("sdpa", d=d, layers=layers, block=block)
+    m.head = ConstellationHead(d, calibrated=(arm != "const_uncal"))
+    return m
+
+
+def cv_bank_loss(head: ConstellationHead) -> torch.Tensor:
+    """Micro CV loss on the CONSTELLATION bank only (const_cv arm; Form 3).
+    Forward loss (differentiable through the anchors); never touches the aleph
+    codebook, whose only pressure stays the CE gradient through M_hat."""
+    A = F.normalize(head.anchors, dim=-1)
+    n = A.shape[0]
+    g = torch.Generator(device="cpu").manual_seed(0)
+    idx = torch.stack([torch.randperm(n, generator=g)[:5] for _ in range(64)])
+    pts = A[idx]                                       # (64, 5, GEO)
+    d2 = torch.cdist(pts.double(), pts.double()).pow(2)
+    cm = torch.ones(64, 6, 6, dtype=torch.float64, device=A.device)
+    cm[:, 0, 0] = 0.0
+    cm[:, 1:, 1:] = d2
+    v = (-torch.linalg.det(cm) / 9216.0).clamp_min(1e-24).sqrt()
+    return (v.std() / v.mean().clamp_min(1e-12)).float()
+
+
+def train_const(model, tr, va, arm: str, steps=2000, batch=32, block=256,
+                device="cuda", seed=0, cv_weight=1e-3, log_every=500,
+                ledger=None, tag=None):
+    g = torch.Generator().manual_seed(seed)
+    model = model.to(device)
+    if not model.head._calibrated_done:               # calibration pass (1 batch)
+        x, _ = _batch(tr, batch, block, device, g)
+        model(x)
+        model.head.calibrate(model._last_h)
+    opt = torch.optim.Adam(model.parameters(), lr=3e-4, weight_decay=0.0)
+    for step in range(1, steps + 1):
+        x, y = _batch(tr, batch, block, device, g)
+        logits = model(x)
+        loss = F.cross_entropy(logits.reshape(-1, VOCAB), y.reshape(-1))
+        if arm == "const_cv":
+            loss = loss + cv_weight * cv_bank_loss(model.head)
+        opt.zero_grad(set_to_none=True); loss.backward(); opt.step()
+        if step % log_every == 0:
+            cv = model.head.constellation_vitals()
+            print(f"[17 {tag or arm} step {step}] {cv}", flush=True)
+    model.eval()
+    with torch.no_grad():
+        ls = []
+        for _ in range(20):
+            xv, yv = _batch(va, batch, block, device, g)
+            ls.append(F.cross_entropy(model(xv).reshape(-1, VOCAB),
+                                      yv.reshape(-1)).item())
+    bpb = sum(ls) / len(ls) / math.log(2)
+    cv = model.head.constellation_vitals()
+    if ledger is not None:
+        rec = {"exp": "17", "arm": arm, "seed": seed, "steps": steps,
+               "bpb": round(bpb, 4), "constellation": cv}
+        ledger.write(json.dumps(rec) + "\n"); ledger.flush()
+    print(f"[17 {tag or arm} s{seed}] FINAL bpb={bpb:.4f} {cv}", flush=True)
+    return bpb
+
+
+def run_prototype(arms=("const", "const_cv", "const_uncal"), seeds=(0, 1),
+                  steps=2000, device="cuda"):
+    if not torch.cuda.is_available():
+        raise RuntimeError("verdict runs are GPU-only")
+    os.makedirs(EXP17_DIR, exist_ok=True)
+    tr, va = _wikitext_bytes(DATA_ROOT)
+    ledger = open(os.path.join(EXP17_DIR, "ledger.jsonl"), "a", encoding="utf-8")
+    for seed in seeds:
+        for arm in arms:
+            m = make_const_model(arm, seed=seed)
+            train_const(m, tr, va, arm, steps=steps, device=device, seed=seed,
+                        ledger=ledger, tag=f"{arm}")
+            torch.save({"arm": arm, "seed": seed, "steps": steps,
+                        "state_dict": {k: v.cpu() for k, v in
+                                       m.state_dict().items()}},
+                       os.path.join(EXP17_DIR, f"const_{arm}_s{seed}.pt"))
+            del m
+            torch.cuda.empty_cache()
+    ledger.close()
+
+
+def smoke():
+    x = torch.randint(0, 256, (2, 64))
+    m = make_const_model("const", d=96, layers=2, block=64, seed=0)
+    lg = m(x)
+    assert lg.shape == (2, 64, 256)
+    lg.sum().backward()
+    assert m.head.addr.codebook.grad is not None        # aleph farms through M_hat
+    assert m.head.anchors.grad is not None              # constellation trains
+    m.zero_grad()
+    m(x)
+    m.head.calibrate(m._last_h)                          # calibration runs
+    cv = m.head.constellation_vitals()
+    assert "crushed_cv" in cv and cv["anchor_drift"] == 0.0
+    l = cv_bank_loss(m.head)
+    assert l.requires_grad and l.item() > 0
+    # causality: future byte must not affect past logits
+    x2 = x.clone(); x2[:, -1] = (x2[:, -1] + 1) % 256
+    m.eval()
+    with torch.no_grad():
+        a, b = m(x), m(x2)
+    assert torch.allclose(a[:, :-1], b[:, :-1], atol=1e-5)
+    print("exp017 smoke passed —", {k: cv[k] for k in ("crushed_cv",
+                                                       "binding_frac")})
+
+
+def _in_notebook():
+    try:
+        get_ipython()  # type: ignore[name-defined]  # noqa: F821
+        return True
+    except NameError:
+        return False
+
+
+if __name__ == "__main__":
+    smoke() if not _in_notebook() else (smoke(),
+        print("Notebook: run_prototype() on GPU."))

exp020_gen/exp019_content_retention.py

@@ -0,0 +1,402 @@
+"""exp019_content_retention.py — CAPACITY FOR DISTILLED CONTENT RETENTION.
+When content is DISTILLED rather than directly learned, how much is retained,
+through which channel, and for how long? The memory-substrate compass made a
+measurable instrument — and the weak-to-strong distillation cell made real: the
+teacher holds content the student lacks (true headroom on the content axis).
+
+THE CONTENT: N fact records "\n@<key6>=<value12>\n" with random alphanumeric
+keys/values — uncompletable from language statistics, so exact-match completion
+IS retention. Facts are mixed into the byte stream (fact-packed blocks at
+FACT_RATE against wikitext blocks).
+
+THE TEACHER: the certified bed model (addr_msl64 aleph substrate) trained
+TEACHER_STEPS on the mix; gated on its own recall (the gate doubles as the
+substrate's DIRECT capacity datum at each N).
+
+THE CHANNELS (fresh student each, STUDENT_STEPS budget):
+  direct       — ground-truth CE on the mix (ceiling: learning, not distillation)
+  kd_facts     — CE on wikitext blocks; on fact blocks the ONLY signal is the
+                 teacher's logits (KL) — pure distilled content
+  kd_general   — CE + KL to teacher on CLEAN wikitext only; facts never shown —
+                 does content leak through logits without exposure?
+  book_implant — teacher's farmed codebook implanted (trainable) into a fresh
+                 student, clean-stream training — do the anchors carry
+                 byte-content? (the open question from the exp014 implant studies, asked directly)
+  none         — clean-stream only (floor)
+THE AXES: capacity N in {64, 256, 1024} (main channels); retention = recall
+right after training AND after INTERFERE_STEPS further clean-stream steps
+(the forgetting measurement). KD alpha 1.0 here is LEGAL: the teacher has real
+headroom on the content axis (the inverse-evolution failure was alpha 1.0 at
+NEAR-PARITY — regime, not constant).
+
+Preregistered forks:
+  F1 capacity curve: direct recall vs N = the substrate's raw content capacity.
+  F2 distillation tax: kd_facts vs direct at each N (what survives the logit
+     channel).
+  F3 leakage: kd_general recall > floor => content crosses on clean text alone.
+  F4 anchors: book_implant recall ~ floor => codebooks do not carry byte
+     content (mean-shape/content question closed in the direct sense).
+  F5 half-life: post-interference retention per channel (does distilled content
+     decay faster than learned content?).
+Riders: pure Adam wd=0; GPU-only verdicts; >=2 seeds; Colab-safe. Paste order:
+geolip_vitals -> ar_differentiation_bed -> exp014_genetic_distillation ->
+this file.
+"""
+from __future__ import annotations
+import json
+import math
+import os
+import string
+import torch
+import torch.nn.functional as F
+
+if "ByteLM" not in globals():
+    try:
+        from ar_differentiation_bed import ByteLM, _wikitext_bytes, _batch, VOCAB
+        from exp014_genetic_distillation import implant_book
+        from geolip_vitals import anchor_drift
+    except ImportError:
+        _here = globals().get("__file__")
+        if _here is None:
+            raise ImportError("paste geolip_vitals + ar_differentiation_bed + "
+                              "exp014_genetic_distillation first")
+        import sys, pathlib
+        sys.path.insert(0, str(pathlib.Path(_here).parent))
+        from ar_differentiation_bed import ByteLM, _wikitext_bytes, _batch, VOCAB
+        from exp014_genetic_distillation import implant_book
+        from geolip_vitals import anchor_drift
+
+DATA_ROOT = os.environ.get("GEOLIP_DATA", "./data")
+EXP19_DIR = os.path.join(DATA_ROOT, "exp019")
+
+KEY_LEN, VAL_LEN = 6, 12
+FACT_RATE = 0.5              # fraction of training blocks drawn from fact stream
+TEACHER_STEPS = 4000
+STUDENT_STEPS = 2000
+INTERFERE_STEPS = 1000
+ALNUM = (string.ascii_lowercase + string.digits).encode()
+
+
+def make_facts(n: int, seed: int = 0):
+    """N records '\\n@<key>=<value>\\n'; returns (records list, fact byte stream)."""
+    g = torch.Generator().manual_seed(4000 + seed)
+    recs = []
+    seen = set()
+    while len(recs) < n:
+        k = bytes(ALNUM[i] for i in torch.randint(len(ALNUM), (KEY_LEN,),
+                                                  generator=g))
+        if k in seen:
+            continue
+        seen.add(k)
+        v = bytes(ALNUM[i] for i in torch.randint(len(ALNUM), (VAL_LEN,),
+                                                  generator=g))
+        recs.append((k, v))
+    return recs
+
+
+def fact_stream(recs, copies: int = 50, seed: int = 0) -> torch.Tensor:
+    """Byte stream of shuffled fact records (each record appears `copies` times)."""
+    g = torch.Generator().manual_seed(5000 + seed)
+    order = torch.cat([torch.randperm(len(recs), generator=g)
+                       for _ in range(copies)])
+    blob = b"".join(b"\n@" + recs[i][0] + b"=" + recs[i][1] + b"\n"
+                    for i in order.tolist())
+    return torch.frombuffer(bytearray(blob), dtype=torch.uint8).clone()
+
+
+def _mix_batch(tr, fs, batch, block, device, g):
+    """Blocks drawn from the fact stream with prob FACT_RATE, else wikitext.
+    Returns (x, y, fact_mask (B,)) — mask marks fact-sourced rows."""
+    xw, yw = _batch(tr, batch, block, device, g)
+    xf, yf = _batch(fs, batch, block, device, g)
+    m = (torch.rand(batch, generator=g) < FACT_RATE).to(device)
+    x = torch.where(m[:, None], xf, xw)
+    y = torch.where(m[:, None], yf, yw)
+    return x, y, m
+
+
+@torch.no_grad()
+def recall(model, recs, device="cuda", max_eval: int = 256,
+           batch: int = 64) -> dict:
+    """Exact-match greedy completion: prompt '\\n@<key>=' -> VAL_LEN bytes."""
+    model = model.to(device).eval()
+    recs = recs[:max_eval]
+    prompts = torch.stack([torch.frombuffer(
+        bytearray(b"\n@" + k + b"="), dtype=torch.uint8).long()
+        for k, _ in recs]).to(device)
+    outs = []
+    for i in range(0, len(recs), batch):
+        x = prompts[i:i + batch]
+        for _ in range(VAL_LEN):
+            nxt = model(x)[:, -1].argmax(-1, keepdim=True)
+            x = torch.cat([x, nxt], dim=1)
+        outs.append(x[:, -VAL_LEN:].cpu())
+    got = torch.cat(outs)
+    tgt = torch.stack([torch.frombuffer(bytearray(v), dtype=torch.uint8).long()
+                       for _, v in recs])
+    byte_acc = (got == tgt).float().mean().item()
+    exact = (got == tgt).all(dim=1).float().mean().item()
+    return {"exact": round(exact, 4), "byte_acc": round(byte_acc, 4)}
+
+
+def train_stream(model, tr, va, fs=None, teacher=None, channel="direct",
+                 steps=2000, batch=32, block=256, device="cuda", seed=0):
+    """One training run under a channel's signal routing (docstring above)."""
+    g = torch.Generator().manual_seed(seed)
+    model = model.to(device)
+    if teacher is not None:
+        teacher = teacher.to(device).eval()
+    opt = torch.optim.Adam(model.parameters(), lr=3e-4, weight_decay=0.0)
+    for step in range(1, steps + 1):
+        if channel in ("direct", "kd_facts") and fs is not None:
+            x, y, m = _mix_batch(tr, fs, batch, block, device, g)
+        else:                                   # clean wikitext stream
+            x, y = _batch(tr, batch, block, device, g)
+            m = torch.zeros(batch, dtype=torch.bool, device=device)
+        logits = model(x)
+        if channel == "kd_facts":
+            # ground truth on wiki rows only; teacher logits are the ONLY
+            # signal on fact rows (pure distilled content)
+            ce_rows = ~m
+            loss = torch.tensor(0.0, device=device)
+            if ce_rows.any():
+                loss = F.cross_entropy(logits[ce_rows].reshape(-1, VOCAB),
+                                       y[ce_rows].reshape(-1))
+            if m.any():
+                with torch.no_grad():
+                    tp = F.softmax(teacher(x[m]), -1)
+                loss = loss + F.kl_div(F.log_softmax(logits[m], -1), tp,
+                                       reduction="batchmean")
+        elif channel == "kd_general":
+            loss = F.cross_entropy(logits.reshape(-1, VOCAB), y.reshape(-1))
+            with torch.no_grad():
+                tp = F.softmax(teacher(x), -1)
+            loss = loss + F.kl_div(F.log_softmax(logits, -1), tp,
+                                   reduction="batchmean")
+        else:                                   # direct / book_implant / none
+            loss = F.cross_entropy(logits.reshape(-1, VOCAB), y.reshape(-1))
+        opt.zero_grad(set_to_none=True); loss.backward(); opt.step()
+    model.eval()
+    with torch.no_grad():
+        ls = []
+        for _ in range(10):
+            xv, yv = _batch(va, batch, block, device, g)
+            ls.append(F.cross_entropy(model(xv).reshape(-1, VOCAB),
+                                      yv.reshape(-1)).item())
+    return sum(ls) / len(ls) / math.log(2)
+
+
+def run_retention(n_facts=(64, 256, 1024), seeds=(0, 1), device="cuda"):
+    if not torch.cuda.is_available():
+        raise RuntimeError("verdict runs are GPU-only")
+    os.makedirs(EXP19_DIR, exist_ok=True)
+    tr, va = _wikitext_bytes(DATA_ROOT)
+    ledger = open(os.path.join(EXP19_DIR, "ledger.jsonl"), "a", encoding="utf-8")
+
+    def log(rec):
+        ledger.write(json.dumps(rec) + "\n"); ledger.flush()
+        print(f"[19 {rec['channel']} N={rec['n']} s{rec['seed']}] "
+              f"recall={rec['recall']} after_interf={rec.get('recall_interf')} "
+              f"bpb={rec['bpb']}", flush=True)
+
+    for seed in seeds:
+        for n in n_facts:
+            recs = make_facts(n, seed=seed)
+            fs = fact_stream(recs, seed=seed)
+            # ---- teacher (also the DIRECT capacity datum at TEACHER_STEPS)
+            torch.manual_seed(seed)
+            teacher = ByteLM("addr_msl64")
+            t_bpb = train_stream(teacher, tr, va, fs=fs, channel="direct",
+                                 steps=TEACHER_STEPS, device=device, seed=seed)
+            t_rec = recall(teacher, recs, device=device)
+            log({"exp": "19", "channel": "teacher", "n": n, "seed": seed,
+                 "steps": TEACHER_STEPS, "recall": t_rec, "bpb": round(t_bpb, 4)})
+            torch.save({"n": n, "seed": seed,
+                        "state_dict": {k: v.cpu() for k, v in
+                                       teacher.state_dict().items()}},
+                       os.path.join(EXP19_DIR, f"teacher_N{n}_s{seed}.pt"))
+            # ---- channels
+            chans = ["direct", "kd_facts", "kd_general"]
+            if n == 256:
+                chans += ["book_implant", "none"]
+            for ch in chans:
+                torch.manual_seed(1000 + seed)
+                m = ByteLM("addr_msl64")
+                if ch == "book_implant":
+                    implant_book(m.head_addr,
+                                 teacher.head_addr.codebook.detach().cpu())
+                bpb = train_stream(
+                    m, tr, va, fs=fs if ch in ("direct", "kd_facts") else None,
+                    teacher=teacher if ch.startswith("kd") else None,
+                    channel=ch, steps=STUDENT_STEPS, device=device,
+                    seed=1000 + seed)
+                r0 = recall(m, recs, device=device)
+                # retention under interference: further CLEAN-stream training
+                bpb2 = train_stream(m, tr, va, channel="none",
+                                    steps=INTERFERE_STEPS, device=device,
+                                    seed=2000 + seed)
+                r1 = recall(m, recs, device=device)
+                log({"exp": "19", "channel": ch, "n": n, "seed": seed,
+                     "steps": STUDENT_STEPS, "recall": r0, "recall_interf": r1,
+                     "bpb": round(bpb, 4), "bpb_after_interf": round(bpb2, 4)})
+                del m
+                torch.cuda.empty_cache()
+            del teacher
+            torch.cuda.empty_cache()
+    ledger.close()
+
+
+# ==================== exp019b — GENERALIZATION block =========================
+# Rule-bearing content: value = fixed random substitution cipher applied to the
+# key, extended to VAL_LEN (v[i] = subst(k[i % KEY_LEN])). Teacher sees
+# N_TRAIN rule-keys; N_TEST keys are HELD OUT. Held-out recall = the RULE
+# generalizing, not the list. Sharp question: does the logit channel transfer
+# the rule better than it transfers the rote list? Plus prompt-format variants
+# (content vs surface form disentangled).
+
+def make_rule_facts(n_train: int = 256, n_test: int = 128, seed: int = 0):
+    g = torch.Generator().manual_seed(6000 + seed)
+    subst = {ALNUM[i]: ALNUM[j] for i, j in
+             enumerate(torch.randperm(len(ALNUM), generator=g).tolist())}
+    keys, seen = [], set()
+    while len(keys) < n_train + n_test:
+        k = bytes(ALNUM[i] for i in torch.randint(len(ALNUM), (KEY_LEN,),
+                                                  generator=g))
+        if k not in seen:
+            seen.add(k)
+            keys.append(k)
+    def val(k):
+        return bytes(subst[k[i % KEY_LEN]] for i in range(VAL_LEN))
+    train = [(k, val(k)) for k in keys[:n_train]]
+    test = [(k, val(k)) for k in keys[n_train:]]
+    return train, test
+
+
+@torch.no_grad()
+def recall_fmt(model, recs, fmt: bytes = b"\n@%s=", device="cuda",
+               max_eval: int = 256, batch: int = 64) -> dict:
+    """recall() under an arbitrary prompt format (b'\\n@%s=' = the training
+    format; variants probe surface-form generalization)."""
+    model = model.to(device).eval()
+    recs = recs[:max_eval]
+    proms = [torch.frombuffer(bytearray(fmt.replace(b"%s", k)),
+                              dtype=torch.uint8).long() for k, _ in recs]
+    L = max(p.numel() for p in proms)
+    # left-pad with newlines to equal length (causal — padding is prefix noise)
+    prompts = torch.stack([torch.cat([torch.full((L - p.numel(),), 10,
+                                                 dtype=torch.long), p])
+                           for p in proms]).to(device)
+    outs = []
+    for i in range(0, len(recs), batch):
+        x = prompts[i:i + batch]
+        for _ in range(VAL_LEN):
+            nxt = model(x)[:, -1].argmax(-1, keepdim=True)
+            x = torch.cat([x, nxt], dim=1)
+        outs.append(x[:, -VAL_LEN:].cpu())
+    got = torch.cat(outs)
+    tgt = torch.stack([torch.frombuffer(bytearray(v), dtype=torch.uint8).long()
+                       for _, v in recs])
+    return {"exact": round((got == tgt).all(dim=1).float().mean().item(), 4),
+            "byte_acc": round((got == tgt).float().mean().item(), 4)}
+
+
+FMT_TRAIN = b"\n@%s="
+FMT_VARIANT = b" @%s= "          # never seen in training: pure format shift
+
+
+def run_generalization(n_train: int = 256, n_test: int = 128, seeds=(0, 1),
+                       device="cuda"):
+    if not torch.cuda.is_available():
+        raise RuntimeError("verdict runs are GPU-only")
+    os.makedirs(EXP19_DIR, exist_ok=True)
+    tr, va = _wikitext_bytes(DATA_ROOT)
+    ledger = open(os.path.join(EXP19_DIR, "ledger.jsonl"), "a", encoding="utf-8")
+
+    def gauges(model, train_recs, test_recs):
+        return {"train": recall_fmt(model, train_recs, FMT_TRAIN, device=device),
+                "heldout": recall_fmt(model, test_recs, FMT_TRAIN, device=device),
+                "train_varfmt": recall_fmt(model, train_recs, FMT_VARIANT,
+                                           device=device)}
+
+    for seed in seeds:
+        train_recs, test_recs = make_rule_facts(n_train, n_test, seed=seed)
+        fs = fact_stream(train_recs, seed=seed)         # held-out NEVER streamed
+        torch.manual_seed(seed)
+        teacher = ByteLM("addr_msl64")
+        t_bpb = train_stream(teacher, tr, va, fs=fs, channel="direct",
+                             steps=TEACHER_STEPS, device=device, seed=seed)
+        gt = gauges(teacher, train_recs, test_recs)
+        rec = {"exp": "19b", "channel": "teacher", "n": n_train, "seed": seed,
+               "steps": TEACHER_STEPS, "gauges": gt, "bpb": round(t_bpb, 4)}
+        ledger.write(json.dumps(rec) + "\n"); ledger.flush()
+        print(f"[19b teacher s{seed}] {gt} bpb={t_bpb:.4f}", flush=True)
+        torch.save({"seed": seed, "state_dict": {k: v.cpu() for k, v in
+                                                 teacher.state_dict().items()}},
+                   os.path.join(EXP19_DIR, f"rule_teacher_s{seed}.pt"))
+        for ch in ("direct", "kd_facts", "kd_general"):
+            torch.manual_seed(1000 + seed)
+            m = ByteLM("addr_msl64")
+            bpb = train_stream(
+                m, tr, va, fs=fs if ch in ("direct", "kd_facts") else None,
+                teacher=teacher if ch.startswith("kd") else None,
+                channel=ch, steps=STUDENT_STEPS, device=device, seed=1000 + seed)
+            g0 = gauges(m, train_recs, test_recs)
+            bpb2 = train_stream(m, tr, va, channel="none",
+                                steps=INTERFERE_STEPS, device=device,
+                                seed=2000 + seed)
+            g1 = gauges(m, train_recs, test_recs)
+            rec = {"exp": "19b", "channel": ch, "n": n_train, "seed": seed,
+                   "steps": STUDENT_STEPS, "gauges": g0, "gauges_interf": g1,
+                   "bpb": round(bpb, 4), "bpb_after_interf": round(bpb2, 4)}
+            ledger.write(json.dumps(rec) + "\n"); ledger.flush()
+            print(f"[19b {ch} s{seed}] {g0} interf_heldout="
+                  f"{g1['heldout']} bpb={bpb:.4f}", flush=True)
+            torch.save({"channel": ch, "seed": seed,
+                        "state_dict": {k: v.cpu() for k, v in
+                                       m.state_dict().items()}},
+                       os.path.join(EXP19_DIR, f"rule_{ch}_s{seed}.pt"))
+            del m
+            torch.cuda.empty_cache()
+        del teacher
+        torch.cuda.empty_cache()
+    ledger.close()
+
+
+def smoke():
+    recs = make_facts(8, seed=0)
+    assert len(recs) == 8 and all(len(k) == KEY_LEN and len(v) == VAL_LEN
+                                  for k, v in recs)
+    fs = fact_stream(recs, copies=3, seed=0)
+    assert fs.dtype == torch.uint8 and fs.numel() == 3 * 8 * (KEY_LEN + VAL_LEN + 4)
+    m = ByteLM("addr_msl64", d=96, layers=2, block=64)
+    r = recall(m, recs, device="cpu", max_eval=8, batch=4)
+    assert 0.0 <= r["exact"] <= 1.0 and 0.0 <= r["byte_acc"] <= 1.0
+    g = torch.Generator().manual_seed(0)
+    x, y, mask = _mix_batch(torch.randint(0, 256, (50000,),
+                                          dtype=torch.uint8, generator=g),
+                            fs, 8, 64, "cpu", g)
+    assert x.shape == (8, 64) and mask.shape == (8,)
+    assert (x[:, 1:] == y[:, :-1]).all()          # stream alignment
+    # 19b: rule facts are rule-consistent + disjoint; variant recall runs
+    tr8, te4 = make_rule_facts(8, 4, seed=0)
+    assert len(tr8) == 8 and len(te4) == 4
+    assert not set(k for k, _ in tr8) & set(k for k, _ in te4)
+    k0, v0 = tr8[0]
+    assert len(v0) == VAL_LEN and v0[:KEY_LEN] == v0[KEY_LEN:2 * KEY_LEN]
+    rv = recall_fmt(m, tr8, FMT_VARIANT, device="cpu", max_eval=8, batch=4)
+    assert 0.0 <= rv["exact"] <= 1.0
+    print(f"exp019 smoke passed (untrained recall exact={r['exact']} "
+          f"byte={r['byte_acc']} ~ chance; 19b rule+variant OK)")
+
+
+def _in_notebook():
+    try:
+        get_ipython()  # type: ignore[name-defined]  # noqa: F821
+        return True
+    except NameError:
+        return False
+
+
+if __name__ == "__main__":
+    smoke() if not _in_notebook() else (smoke(),
+        print("Notebook: run_retention() on GPU."))

exp020_gen/exp020_generalization.py

@@ -0,0 +1,231 @@
+"""exp020_generalization.py — GENERALIZATION via the program's best structural
+methodologies (codebooks + constellations), raced on the exp019b rule task.
+exp019b established the failure modes: teachers learn a substitution cipher
+only fragmentarily (held-out byte ~0.26, exact 0.000) and bind content to its
+surface format. exp020 asks what UNLOCKS generalization: geometric structure
+(aleph codebook reads, trigram character embeddings, addresses in depth, the
+constellation 768 address) and data-side format diversity — against the honest
+capacity control (the exp017 lesson: always run the matched free head).
+
+TASK (identical to exp019b for comparability): value = fixed random
+substitution cipher of the key (v[i] = subst(k[i % 6]), VAL_LEN 12); 256
+train keys in the stream at FACT_RATE 0.5, 128 keys HELD OUT; 4000 steps
+direct training. JUDGE: held-out exact/byte (rule induction), train recall,
+variant-format recall (the format lock), clean bpb.
+
+ARMS (2 seeds each):
+  aleph        — ByteLM('addr_msl64')          (the exp019b reference, in-harness)
+  aleph_tri    — ByteLM('addr_msl64_tri')      (trigram byte embeddings: certified
+                                                -10% bpb; character structure is
+                                                the cipher's own factorization)
+  relay        — ByteLM('relay_msl64')         (addresses in depth, GPT-2-certified
+                                                methodology on the co-trained bed)
+  const        — ByteLM('sdpa') + ConstellationHead (exp017: the 768 address;
+                                                params NOT matched — recorded)
+  mlp          — matched free head (params == aleph head budget; capacity control)
+  aleph_fmtdiv — addr_msl64 with FORMAT-DIVERSE fact rendering (3 formats in the
+                 stream; the exp019b format-lock finding turned into a training
+                 methodology) — judged on the base format + the UNSEEN variant
+Preregistered forks:
+  F1 does ANY structural arm lift held-out byte acc off the flat ~0.26 plateau
+     (rule induction unlocked by geometry)?
+  F2 structure vs capacity: const/aleph vs mlp on held-out at recorded budgets.
+  F3 trigram: strongest prior for a per-character cipher.
+  F4 format diversity: does it break the format lock (variant recall >> 0) and
+     does breaking the lock ALSO lift rule induction?
+  F5 relays in depth: does distributed addressing help where the head alone
+     plateaus?
+Riders: pure Adam wd=0; GPU-only verdicts; >=2 seeds; Colab-safe. Paste order:
+geolip_vitals -> ar_differentiation_bed -> exp014_genetic_distillation ->
+exp017_aleph_constellation -> exp019_content_retention -> this file.
+"""
+from __future__ import annotations
+import json
+import math
+import os
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+if "make_rule_facts" not in globals():
+    try:
+        from ar_differentiation_bed import ByteLM, _wikitext_bytes, _batch, VOCAB
+        from exp017_aleph_constellation import ConstellationHead, SquaredReLU
+        from exp019_content_retention import (
+            make_rule_facts, recall_fmt, FMT_TRAIN, FMT_VARIANT,
+            KEY_LEN, VAL_LEN, FACT_RATE, ALNUM)
+    except ImportError:
+        _here = globals().get("__file__")
+        if _here is None:
+            raise ImportError("paste the stack (vitals, bed, exp017, exp019) first")
+        import sys, pathlib
+        sys.path.insert(0, str(pathlib.Path(_here).parent))
+        from ar_differentiation_bed import ByteLM, _wikitext_bytes, _batch, VOCAB
+        from exp017_aleph_constellation import ConstellationHead, SquaredReLU
+        from exp019_content_retention import (
+            make_rule_facts, recall_fmt, FMT_TRAIN, FMT_VARIANT,
+            KEY_LEN, VAL_LEN, FACT_RATE, ALNUM)
+
+DATA_ROOT = os.environ.get("GEOLIP_DATA", "./data")
+EXP20_DIR = os.path.join(DATA_ROOT, "exp020")
+STEPS = 4000
+
+# fact renderers: index 0 is the base format (matches FMT_TRAIN prompts);
+# fmtdiv streams all three. FMT_VARIANT (" @%s= ") stays UNSEEN by every arm.
+RENDERERS = (lambda k, v: b"\n@" + k + b"=" + v + b"\n",
+             lambda k, v: b"\n" + k + b" -> " + v + b"\n",
+             lambda k, v: b"\n<" + k + b"|" + v + b">\n")
+FMT_R1 = b"\n%s -> "                     # prompt form of renderer 1 (fmtdiv-seen)
+
+
+def fact_stream_fmt(recs, renderers, copies: int = 50, seed: int = 0):
+    g = torch.Generator().manual_seed(5000 + seed)
+    order = torch.cat([torch.randperm(len(recs), generator=g)
+                       for _ in range(copies)])
+    rsel = torch.randint(len(renderers), (order.numel(),), generator=g)
+    blob = b"".join(renderers[rsel[i].item()](*recs[order[i].item()])
+                    for i in range(order.numel()))
+    return torch.frombuffer(bytearray(blob), dtype=torch.uint8).clone()
+
+
+def make_arm(arm: str, seed: int, d: int = 192, layers: int = 4,
+             block: int = 256):
+    torch.manual_seed(seed)
+    if arm in ("aleph", "aleph_fmtdiv"):
+        return ByteLM("addr_msl64", d=d, layers=layers, block=block)
+    if arm == "aleph_tri":
+        return ByteLM("addr_msl64_tri", d=d, layers=layers, block=block)
+    if arm == "relay":
+        return ByteLM("relay_msl64", d=d, layers=layers, block=block)
+    if arm == "const":
+        m = ByteLM("sdpa", d=d, layers=layers, block=block)
+        m.head = ConstellationHead(d)
+        return m
+    if arm == "mlp":
+        m = ByteLM("sdpa", d=d, layers=layers, block=block)
+        ref = ByteLM("addr_msl64", d=d, layers=layers, block=block)
+        target = (sum(p.numel() for p in ref.head_proj.parameters())
+                  + sum(p.numel() for p in ref.head_addr.parameters())
+                  + sum(p.numel() for p in ref.head.parameters()))
+        h = max(8, round((target - VOCAB) / (d + 1 + 2 + VOCAB)))
+        m.head = nn.Sequential(nn.Linear(d, h), SquaredReLU(),
+                               nn.LayerNorm(h), nn.Linear(h, VOCAB))
+        del ref
+        return m
+    raise ValueError(arm)
+
+
+def head_params(m) -> int:
+    tot = 0
+    for name in ("head", "head_proj", "head_addr"):
+        mod = getattr(m, name, None)
+        if mod is not None and isinstance(mod, nn.Module):
+            tot += sum(p.numel() for p in mod.parameters())
+    if hasattr(m, "relays"):
+        tot += sum(p.numel() for p in m.relays.parameters())
+    return tot
+
+
+def train_direct(model, tr, va, fs, steps=STEPS, batch=32, block=256,
+                 device="cuda", seed=0, needs_calibration=False):
+    g = torch.Generator().manual_seed(seed)
+    model = model.to(device)
+    if needs_calibration:
+        xw, _ = _batch(tr, batch, block, device, g)
+        model(xw)
+        model.head.calibrate(model._last_h)
+    opt = torch.optim.Adam(model.parameters(), lr=3e-4, weight_decay=0.0)
+    for step in range(1, steps + 1):
+        xw, yw = _batch(tr, batch, block, device, g)
+        xf, yf = _batch(fs, batch, block, device, g)
+        mk = (torch.rand(batch, generator=g) < FACT_RATE).to(device)
+        x = torch.where(mk[:, None], xf, xw)
+        y = torch.where(mk[:, None], yf, yw)
+        loss = F.cross_entropy(model(x).reshape(-1, VOCAB), y.reshape(-1))
+        opt.zero_grad(set_to_none=True); loss.backward(); opt.step()
+    model.eval()
+    with torch.no_grad():
+        ls = []
+        for _ in range(10):
+            xv, yv = _batch(va, batch, block, device, g)
+            ls.append(F.cross_entropy(model(xv).reshape(-1, VOCAB),
+                                      yv.reshape(-1)).item())
+    return sum(ls) / len(ls) / math.log(2)
+
+
+ARMS = ("aleph", "aleph_tri", "relay", "const", "mlp", "aleph_fmtdiv")
+
+
+def run_bakeoff(arms=ARMS, seeds=(0, 1), device="cuda"):
+    if not torch.cuda.is_available():
+        raise RuntimeError("verdict runs are GPU-only")
+    os.makedirs(EXP20_DIR, exist_ok=True)
+    tr, va = _wikitext_bytes(DATA_ROOT)
+    ledger = open(os.path.join(EXP20_DIR, "ledger.jsonl"), "a", encoding="utf-8")
+    for seed in seeds:
+        train_recs, test_recs = make_rule_facts(256, 128, seed=seed)
+        fs_base = fact_stream_fmt(train_recs, RENDERERS[:1], seed=seed)
+        fs_div = fact_stream_fmt(train_recs, RENDERERS, seed=seed)
+        for arm in arms:
+            m = make_arm(arm, seed=seed)
+            hp = head_params(m)
+            bpb = train_direct(m, tr, va,
+                               fs_div if arm == "aleph_fmtdiv" else fs_base,
+                               device=device, seed=seed,
+                               needs_calibration=(arm == "const"))
+            gz = {"train": recall_fmt(m, train_recs, FMT_TRAIN, device=device),
+                  "heldout": recall_fmt(m, test_recs, FMT_TRAIN, device=device),
+                  "train_varfmt": recall_fmt(m, train_recs, FMT_VARIANT,
+                                             device=device)}
+            if arm == "aleph_fmtdiv":
+                gz["heldout_r1"] = recall_fmt(m, test_recs, FMT_R1,
+                                              device=device)
+            rec = {"exp": "20", "arm": arm, "seed": seed, "steps": STEPS,
+                   "head_params": hp, "gauges": gz, "bpb": round(bpb, 4)}
+            ledger.write(json.dumps(rec) + "\n"); ledger.flush()
+            print(f"[20 {arm} s{seed}] heldout={gz['heldout']} "
+                  f"train={gz['train']['exact']} varfmt="
+                  f"{gz['train_varfmt']['byte_acc']} bpb={bpb:.4f} "
+                  f"hp={hp}", flush=True)
+            torch.save({"arm": arm, "seed": seed,
+                        "state_dict": {k: v.cpu() for k, v in
+                                       m.state_dict().items()}},
+                       os.path.join(EXP20_DIR, f"gen_{arm}_s{seed}.pt"))
+            del m
+            torch.cuda.empty_cache()
+    ledger.close()
+
+
+def smoke():
+    recs, test = make_rule_facts(8, 4, seed=0)
+    fs = fact_stream_fmt(recs, RENDERERS, copies=3, seed=0)
+    assert fs.dtype == torch.uint8 and fs.numel() > 0
+    blob = bytes(fs.tolist())
+    assert b"->" in blob and b"<" in blob and b"@" in blob   # all renderers hit
+    x = torch.randint(0, 256, (2, 64))
+    for arm in ARMS:
+        m = make_arm(arm, seed=0, d=96, layers=2, block=64)
+        lg = m(x)
+        assert lg.shape == (2, 64, 256), arm
+        lg.sum().backward()
+        assert head_params(m) > 0, arm
+        m.zero_grad()
+        del m
+    ref = make_arm("aleph", seed=0, d=96, layers=2, block=64)
+    mm = make_arm("mlp", seed=0, d=96, layers=2, block=64)
+    rp, mp = head_params(ref), head_params(mm)
+    assert abs(rp - mp) / rp < 0.05, (rp, mp)               # matched within 5%
+    print(f"exp020 smoke passed (mlp head {mp} ~ aleph head {rp})")
+
+
+def _in_notebook():
+    try:
+        get_ipython()  # type: ignore[name-defined]  # noqa: F821
+        return True
+    except NameError:
+        return False
+
+
+if __name__ == "__main__":
+    smoke() if not _in_notebook() else (smoke(),
+        print("Notebook: run_bakeoff() on GPU."))