exp015_ch package (content-bearing heredity: 5 brackets, content gauge, 20 genomes) + repro retrofit: every package standalone (own harness copies, portable data roots, real CLIs, repro.py loaders, genome-aware reader) - all README snippets verified by execution

README.md

@@ -145,6 +145,33 @@ Unifying insight: near-uniform books are near-interchangeable scaffolds — gene
 methods pay only where the book's CONTENT is load-bearing. Write-up:
 [exp014_gd/article.md](./exp014_gd/article.md); ledger + 23 champion genomes included.
 
+## exp015 — content-bearing heredity (July 10, 2026)
+
+[`exp015_ch/`](./exp015_ch): exp014's compass executed — tournaments where the
+prediction channel consumes book IDENTITY (the sign-code head: features are the
+±A\[win\] rows themselves), plus the tree lineage under fair full-weight
+inheritance. Verdicts: content consumption cultivates LSH fidelity by itself
+(0.942 → 0.954 with no germline), compressing the germline's score headroom to
+founder-luck scale; the lineage fixed point replicates on the discrete channel
+and LOCKS fidelity (<0.001 inter-member spread); the tree inherits under
+continuity (both lineages monotone; whole-structure fixed point by gen 2);
+branch revival belongs to continuity — the germline's stationarity freezes
+routing at zero score cost; and heredity maintains root-routing health that
+every fresh founder loses. The content gauge separates heredity from lottery
+far more cleanly than score does. 80-run ledger + 20 champion genomes;
+write-up in [exp015_ch/README.md](./exp015_ch/README.md).
+
+## Reproducibility
+
+Every experiment package (`exp012_ar/`, `exp013_aug/`, `exp014_gd/`,
+`exp015_ch/`) is **standalone**: it carries its own copies of the shared
+harness (`geolip_vitals.py`, `ar_differentiation_bed.py`, `read_codebook.py`)
+and a `repro.py` loader — `python repro.py` smokes on CPU, flags forward to
+verdict runs on GPU. Data roots default to `./data` (override with
+`GEOLIP_DATA`). Each README's snippet has been verified by execution; the
+exp013 track-b1 snippet reproduces its published table exactly from a fresh
+cache.
+
 ## Relation to prior work
 
 Residual-expert quantization (RQ-MoE, SwitchCodec/REVQ), hierarchical

exp012_ar/README.md

@@ -20,18 +20,22 @@ transit point · projective-codebook law holds under pure predictive pressure.
   pentachoron-CV via geovocab2).
 - `read_codebook.py` — antipodal-collapse projective reader (Polygonal Omega recipe),
   validated on planted pairs. `python read_codebook.py specimens/` reads everything.
+- `repro.py` — loads the code files from this folder and runs them (smoke or
+  `--train`).
 - `build_results.py` → `results/results.json` — the complete 48-run ledger; running
   it re-asserts every certified aggregate against the per-run rows.
 - `results/specimen_reads.json` — projective reads of all 17 specimens.
 - `specimens/*.pt` — trained models, `{arm}_s{seed}_t{steps}.pt` (~134MB total).
 
-## Quick start (GPU)
+## Quick start
 ```bash
 pip install torch --index-url https://download.pytorch.org/whl/cu128
 pip install pyarrow huggingface_hub
-python ar_differentiation_bed.py --train        # the original three arms
+python repro.py                                 # CPU smoke: parse + shapes + causality
+python repro.py --train                         # the original three arms (GPU)
 python -c "from ar_differentiation_bed import train; train(arms=('sdpa','addr_msl64'), steps=8000)"
-python read_codebook.py ./data/ar_ckpts
+python read_codebook.py specimens/              # projective reads of shipped specimens
+python read_codebook.py ./data/ar_ckpts         # ...or of your own trained arms
 ```
 Bed constants: wikitext-2-raw bytes (HF parquet), block 256, batch 32, pure Adam
 lr 3e-4 wd 0, d=192, 4 layers. Single RTX 4090: 3–15 min per arm.

exp012_ar/read_codebook.py

@@ -85,13 +85,20 @@ def projective_stats(axes: torch.Tensor, n_baseline: int = 20000,
 @torch.no_grad()
 def read_specimen(path: str) -> dict:
     ck = torch.load(path, map_location="cpu", weights_only=True)
-    sd = ck["state_dict"]
     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)}
-    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")}
+    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)

exp012_ar/repro.py

@@ -0,0 +1,29 @@
+"""repro.py — standalone loader/runner for exp012_ar. Every code dependency
+lives in THIS folder (geolip_vitals.py, ar_differentiation_bed.py,
+read_codebook.py) — no cross-package paths.
+
+  python repro.py                     # CPU smoke: parse + shapes + causality
+  python repro.py --train             # the original three-arm verdict run (GPU)
+  python repro.py --train --steps 8000
+
+Data + checkpoints land in ./data (checkpoints under ./data/ar_ckpts).
+Reading the shipped specimens:
+  python read_codebook.py specimens/
+"""
+import os
+import runpy
+import sys
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, HERE)
+
+if __name__ == "__main__":
+    if len(sys.argv) == 1:
+        import geolip_vitals                      # noqa: F401  (paste order)
+        import ar_differentiation_bed as bed
+        bed.smoke()
+        print("repro smoke passed — run with --train for verdict runs")
+    else:
+        target = os.path.join(HERE, "ar_differentiation_bed.py")
+        sys.argv = [target] + sys.argv[1:]
+        runpy.run_path(target, run_name="__main__")

exp013_aug/README.md

@@ -79,16 +79,28 @@ pretrained trunk* and on pooled semantic embeddings.
 
 ## Files
 - `exp013_augmentation_bed.py` — the bed (all tracks/arms, caching, vitals,
-  specimen saving). Requires `exp012_ar/geolip_vitals.py` and
-  `exp012_ar/ar_differentiation_bed.py` on path (paste those cells first in Colab).
+  specimen saving).
+- `geolip_vitals.py` / `ar_differentiation_bed.py` / `read_codebook.py` — this
+  package's own copies of the shared harness (readout diagnostics; the
+  AlephAddress + MslRelay attention mechanisms; the projective specimen
+  reader). Identical to the `exp012_ar/` copies — the package is standalone.
+- `repro.py` — loads the code files from this folder and runs them.
 - `build_results.py` → `results/results.json` — full ledger, self-asserting.
 - `results/specimen_reads.json` — projective reads of all specimens.
 
+## Reproduce (from inside this folder)
 ```bash
 pip install torch --index-url https://download.pytorch.org/whl/cu128
 pip install transformers tokenizers pyarrow huggingface_hub
-python exp013_augmentation_bed.py --track b1     # gate + baselines
-python -c "from exp013_augmentation_bed import track_a, track_c; track_a(); track_c()"
+python repro.py                        # CPU smoke: parse + shapes, no downloads
+python repro.py --track b1             # the gate + baselines (GPU)
+python repro.py --track a              # CLIP-L dual-layer token-AR (GPU)
+python repro.py --track c              # GPT-2 relay augmentation (GPU)
+python read_codebook.py specimens/     # projective reads of shipped specimens
 ```
+Data + model caches land in `./data` (override with the `GEOLIP_DATA` env var);
+the first verdict run downloads CLIP-L / BERT / GPT-2 from the Hub. In Colab,
+paste `geolip_vitals.py`, `ar_differentiation_bed.py`, then the bed into cells
+in that order — same files, no path setup.
 
 License: MIT · AbstractPhil + Claude Fable 5 · July 10, 2026

exp013_aug/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()

exp013_aug/exp013_augmentation_bed.py

@@ -48,6 +48,8 @@ if "AlephAddress" not in globals():
             raise ImportError("paste/run ar_differentiation_bed.py first")
         from ar_differentiation_bed import AlephAddress, MslRelay, _wikitext_bytes
 
+DATA_ROOT = os.environ.get("GEOLIP_DATA", "./data")
+
 
 class SquaredReLU(nn.Module):
     def forward(self, x):
@@ -205,7 +207,7 @@ def cache_word_embeddings(data_root, n_words=10000, device="cuda", batch=256):
 # ============================================================ track A =============
 def track_a(arms=("linear", "mlp", "aleph", "sign"), layers=("final", "penult"),
             steps=1500, batch=64, seed=0, device="cuda",
-            data_root=r"E:\mirel\data", eval_every=500, save=True):
+            data_root=DATA_ROOT, eval_every=500, save=True):
     """Next-CLIP-token prediction from frozen CLIP-L hidden states."""
     if not torch.cuda.is_available():
         raise RuntimeError("verdict runs are GPU-only")
@@ -298,7 +300,7 @@ class CharDecoder(nn.Module):
 
 def track_b1(arms=("linear", "mlp"), substrates=("clip_final", "clip_penult",
              "bert_cls", "bert_mean"), steps=3000, batch=128, seed=0,
-             device="cuda", data_root=r"E:\mirel\data", save=True):
+             device="cuda", data_root=DATA_ROOT, save=True):
     """Spelling-AR from pooled embeddings. Run baselines first (the GATE:
     qualify the task only if linear/mlp exact-match < 0.50), then aleph/sign."""
     if not torch.cuda.is_available():
@@ -387,7 +389,7 @@ class _BlockWithAdapter(nn.Module):
 
 
 def track_c(arms=("frozen", "aleph", "mlp"), steps=1500, batch=8, block=256,
-            seed=0, device="cuda", data_root=r"E:\mirel\data",
+            seed=0, device="cuda", data_root=DATA_ROOT,
             eval_every=500, save=True):
     """GPT-2 124M frozen; adapters after every block; train adapters only."""
     from transformers import GPT2LMHeadModel, GPT2TokenizerFast

exp013_aug/geolip_vitals.py

@@ -0,0 +1,184 @@
+"""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_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. CM comes from geovocab2 — never inlined (program rule);
+    fp32 det only. Rows are row-normalized before measurement."""
+    try:
+        from geovocab2.formula.cayley_menger import simplex_volume  # noqa: F401
+    except Exception as e:  # pragma: no cover
+        raise ImportError(
+            "pentachoron_cv requires geovocab2 (CM must be imported, never inlined "
+            "— program rule). Install/point PYTHONPATH at geovocab2; expected "
+            "geovocab2.formula.cayley_menger.simplex_volume(points fp32)."
+        ) from e
+    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)
+    vols = []
+    for _ in range(n_samples):
+        idx = torch.randperm(n, generator=g)[:5]
+        vols.append(simplex_volume(x[idx].to(torch.float32)))
+    v = torch.stack([torch.as_tensor(v, dtype=torch.float32) for v in vols])
+    return (v.std() / v.mean().clamp_min(1e-12)).item()
+
+
+# ------------------------------------------------------------------------- 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)")

exp013_aug/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))

exp013_aug/repro.py

@@ -0,0 +1,32 @@
+"""repro.py — standalone loader/runner for exp013_aug. Every code dependency
+lives in THIS folder (geolip_vitals.py, ar_differentiation_bed.py,
+exp013_augmentation_bed.py, read_codebook.py) — no cross-package paths.
+
+  python repro.py                     # CPU smoke: parse + shapes, no downloads
+  python repro.py --track b1          # the gate + baselines (GPU; caches models)
+  python repro.py --track a           # CLIP-L dual-layer token-AR (GPU)
+  python repro.py --track c           # GPT-2 relay augmentation (GPU)
+
+Data + caches land in ./data (override with the GEOLIP_DATA env var).
+Verdict-run costs on one RTX 4090: caching ~5-10 min (downloads CLIP-L/BERT/GPT-2
+on first run), track b1 ~20 min, track a ~30 min, track c ~40 min.
+"""
+import os
+import runpy
+import sys
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, HERE)
+
+if __name__ == "__main__":
+    if len(sys.argv) == 1:
+        import geolip_vitals                      # noqa: F401  (paste order)
+        import ar_differentiation_bed as bed
+        import exp013_augmentation_bed as aug
+        bed.smoke()
+        aug.smoke()
+        print("repro smoke passed — run with --track {a,b1,c} for verdict runs")
+    else:
+        target = os.path.join(HERE, "exp013_augmentation_bed.py")
+        sys.argv = [target] + sys.argv[1:]
+        runpy.run_path(target, run_name="__main__")

exp014_gd/README.md

@@ -17,13 +17,34 @@ parity; nothing accelerates).
 - `article.md` — the write-up.
 - `exp014_genetic_distillation.py` — consensus operator (projective ICP + GPA,
   planted-truth validated), TreeHead (slot-parallel root), KD inheritance,
-  tournament + implant runners. Requires `exp012_ar/geolip_vitals.py` and
-  `exp012_ar/ar_differentiation_bed.py` on path (paste those first in Colab).
+  tournament + implant runners, real CLI (`--mode tournament|b1|b2`).
+- `geolip_vitals.py` / `ar_differentiation_bed.py` /
+  `exp013_augmentation_bed.py` / `read_codebook.py` — this package's own copies
+  of the shared harness (readout diagnostics; the ByteLM organism + AlephAddress
+  + MslRelay attention mechanisms; the GPT-2 relay bed used by `run_b2`; the
+  projective specimen reader). Identical to the copies in their home packages —
+  the package is standalone.
+- `repro.py` — loads the code files from this folder and runs them.
 - `build_results.py` → `results/results.json` — reads the ledger and RE-ASSERTS
   every article claim (keep-last dedupe; superseded rows = the aborted-campaign
   inverse-evolution record, preserved on purpose).
 - `results/ledger.jsonl` — the append-only per-member record (138 rows).
-- `genomes/` — 23 per-generation champion codebooks (the germline fossil record;
-  read with `exp012_ar/read_codebook.py`).
+- `genomes/` — 23 per-generation champion codebooks (the germline fossil record).
+
+## Reproduce (from inside this folder)
+```bash
+pip install torch --index-url https://download.pytorch.org/whl/cu128
+pip install pyarrow huggingface_hub          # + transformers for --mode b2
+python repro.py                              # CPU smoke: parse + shapes + GPA sanity
+python repro.py --mode tournament --lineage aleph_full   # one bracket (GPU)
+python repro.py --mode b1                    # cross-size implants (GPU)
+python repro.py --mode b2 --genome genomes/champion_aleph_full_t0_g3.pt  # GPT-2 relays
+python read_codebook.py genomes/             # read the germline fossil record
+python build_results.py                      # re-assert every article claim
+```
+Data lands in `./data` (override with the `GEOLIP_DATA` env var); tournament
+ledgers + champion genomes in `./data/exp014`. In Colab, paste
+`geolip_vitals.py`, `ar_differentiation_bed.py` (+ `exp013_augmentation_bed.py`
+for b2), then `exp014_genetic_distillation.py` into cells in that order.
 
 License: MIT · AbstractPhil + Claude Fable 5 · July 10, 2026

exp014_gd/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()

exp014_gd/article.md

@@ -175,18 +175,29 @@ logged as vitals, not deep-read.
 
 ## 6. Reproduction
 
+The package is standalone — every code dependency ships in
+[`exp014_gd/`](https://huggingface.co/AbstractPhil/geolip-aleph-differentiation/tree/main/exp014_gd)
+itself (`geolip_vitals.py`, `ar_differentiation_bed.py`,
+`exp013_augmentation_bed.py` for the GPT-2 relays, `read_codebook.py`).
+From inside the folder:
+
 ```bash
 pip install torch --index-url https://download.pytorch.org/whl/cu128
-pip install pyarrow huggingface_hub
-# paste order / path: exp012_ar/geolip_vitals.py, exp012_ar/ar_differentiation_bed.py,
-# then exp014_gd/exp014_genetic_distillation.py
-python -c "from exp014_genetic_distillation import run_tournament, run_b1, run_b2; \
-           run_tournament('aleph_full')"
+pip install pyarrow huggingface_hub          # + transformers for --mode b2
+python repro.py                              # CPU smoke: parse + shapes + GPA sanity
+python repro.py --mode tournament --lineage aleph_full   # one bracket (GPU, ~20 min)
+python repro.py --mode b1                    # cross-size implants (GPU)
+python repro.py --mode b2 --genome genomes/champion_aleph_full_t0_g3.pt
 python build_results.py   # re-asserts every claim in this article from the ledger
 ```
 
+Data lands in `./data` (override with `GEOLIP_DATA`). In Colab, paste
+`geolip_vitals.py`, `ar_differentiation_bed.py`, then
+`exp014_genetic_distillation.py` into cells in that order and call the runners
+directly.
+
 `genomes/` holds the 23 per-generation champion books (`champion_{lineage}_t{seed}_g{gen}.pt`)
-— the germline fossil record, readable with `exp012_ar/read_codebook.py`.
+— the germline fossil record: `python read_codebook.py genomes/`.
 
 ## Citations
 

exp014_gd/exp013_augmentation_bed.py

@@ -0,0 +1,506 @@
+"""exp013_augmentation_bed.py — augmenting pretrained models with the aleph.
+Three tracks, one file (sequel to exp012's ar_differentiation_bed):
+
+  A. AUTOREGRESSION FROM CLIP-L: next-token prediction over CLIP-tokenized text,
+     reading FROZEN openai/clip-vit-large-patch14 text-tower hidden states.
+     FACTOR: extraction layer in {final, penultimate} (the last two layers — the
+     penultimate is what diffusion stacks consume). Heads at ~matched params:
+     linear | mlp | aleph multi-slot M_hat (P=64, D=4, shared K=64 — the exp012
+     certified construction) | sign-code (straight-through).
+  B. JOINT-FAILURE PROBES on frozen pooled embeddings (CLIP-L both layers + BERT):
+     b1 SPELLING-AR — decode a word's characters from ONLY the head's read of its
+        pooled embedding (GATE: linear/mlp must fail <50% exact first);
+     b2 ORDER — original-vs-shuffled discrimination (secondary; info may be absent).
+  C. GPT-2 (124M) AUGMENTATION: frozen trunk + trainable adapters after every block —
+     aleph MslRelay adapters vs param-matched MLP adapters vs frozen baseline;
+     gate growth by depth is a first-class readout (exp012 depth-gradient law).
+
+Riders: pure Adam wd=0; no contrastive/InfoNCE into address paths; vitals are
+readouts; GPU-only for verdict runs; caches/specimens live OUTSIDE the repo.
+Colab: paste geolip_vitals.py, then ar_differentiation_bed.py, then this file.
+"""
+from __future__ import annotations
+import json
+import math
+import os
+import re
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+# ---- paste-ahead imports (notebook-safe) -----------------------------------------
+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 "AlephAddress" not in globals():
+    try:
+        from ar_differentiation_bed import AlephAddress, MslRelay, _wikitext_bytes
+    except ImportError:
+        _here = globals().get("__file__")
+        if _here is None:
+            raise ImportError("paste/run ar_differentiation_bed.py first")
+        from ar_differentiation_bed import AlephAddress, MslRelay, _wikitext_bytes
+
+DATA_ROOT = os.environ.get("GEOLIP_DATA", "./data")
+
+
+class SquaredReLU(nn.Module):
+    def forward(self, x):
+        return F.relu(x) ** 2
+
+
+# =============================================================== head arm family ==
+class HeadArm(nn.Module):
+    """Conditioning transform d_in -> F_OUT (256), then a shared-shape task head.
+    Arms: linear | mlp | aleph (multi-slot M_hat) | sign (straight-through M_hard).
+    The aleph arms are the exp012-certified construction: P=64 slots x D=4 over one
+    shared K=64 codebook."""
+    F_OUT = 256
+
+    def __init__(self, arm: str, d_in: int, mlp_hidden: int = 192):
+        # mlp_hidden=192 param-matches the aleph arm at d_in=768:
+        # mlp ~ 192*(768+256)+LN ~ 197K vs aleph proj 768*256 + codebook = 196.9K
+        super().__init__()
+        self.arm = arm
+        if arm == "linear":
+            self.net = nn.Linear(d_in, self.F_OUT, bias=False)
+        elif arm == "mlp":
+            self.net = nn.Sequential(nn.Linear(d_in, mlp_hidden), SquaredReLU(),
+                                     nn.LayerNorm(mlp_hidden),
+                                     nn.Linear(mlp_hidden, self.F_OUT))
+        elif arm in ("aleph", "sign"):
+            self.proj = nn.Linear(d_in, 64 * 4, bias=False)
+            nn.init.orthogonal_(self.proj.weight)
+            self.addr = AlephAddress(64, 4)
+        else:
+            raise ValueError(arm)
+
+    def forward(self, x):
+        if self.arm in ("linear", "mlp"):
+            return self.net(x)
+        slots = self.proj(x).reshape(*x.shape[:-1], 64, 4)
+        read = self.addr.m_hard_ste(slots) if self.arm == "sign" \
+            else self.addr.m_hat(slots)
+        return read.reshape(*x.shape[:-1], 256)
+
+    @torch.no_grad()
+    def vitals(self, x_sample) -> dict:
+        if self.arm in ("linear", "mlp"):
+            return {}
+        slots = self.proj(x_sample).reshape(*x_sample.shape[:-1], 64, 4)
+        p, n = self.addr.oriented(slots)
+        two_k = torch.cat([p, n], -1).reshape(-1, 128)
+        d = anchor_drift(self.addr.codebook, self.addr.home)
+        return {"drift": round(d["mean"], 4),
+                "binding_frac": round(d["binding_fraction"], 4),
+                "usage_ppl": round(axis_aliveness(two_k)["usage_ppl"], 1),
+                "paths": path_diversity(two_k.argmax(-1))["unique_hashed"]}
+
+    def param_count(self):
+        return sum(p.numel() for p in self.parameters())
+
+
+# ================================================================== caches ========
+def _wikitext_lines(data_root, min_chars=40, max_lines=None):
+    from huggingface_hub import hf_hub_download
+    import pyarrow.parquet as pq
+    out = {}
+    for split, cap in (("train", max_lines), ("validation", None)):
+        p = hf_hub_download("Salesforce/wikitext",
+                            f"wikitext-2-raw-v1/{split}-00000-of-00001.parquet",
+                            repo_type="dataset", local_dir=data_root)
+        lines = [t.strip() for t in pq.read_table(p).column("text").to_pylist()
+                 if len(t.strip()) >= min_chars]
+        out[split] = lines[:cap] if cap else lines
+    return out["train"], out["validation"]
+
+
+@torch.no_grad()
+def cache_clip(data_root, n_train=12000, n_val=1500, device="cuda", batch=64):
+    """CLIP-L text tower over wikitext lines; caches BOTH of the last two layers.
+    hidden_states[-1] == the final encoder layer output (pre final-LN),
+    last_hidden_state == final-LN(final layer). We cache:
+      'final'  = last_hidden_state (what the projection head consumes),
+      'penult' = hidden_states[-2] (the layer diffusion stacks consume).
+    Also caches pooled (EOS-position) vectors for both layers, and token ids."""
+    from transformers import CLIPTextModel, CLIPTokenizerFast
+    path = os.path.join(data_root, "exp013", "clip_cache.pt")
+    if os.path.exists(path):
+        return torch.load(path, map_location="cpu", weights_only=True)
+    os.makedirs(os.path.dirname(path), exist_ok=True)
+    tok = CLIPTokenizerFast.from_pretrained("openai/clip-vit-large-patch14")
+    model = CLIPTextModel.from_pretrained("openai/clip-vit-large-patch14").to(device).eval()
+    tr_lines, va_lines = _wikitext_lines(data_root, max_lines=n_train)
+    va_lines = va_lines[:n_val]
+    def encode(lines):
+        H_f, H_p, IDS, EOS = [], [], [], []
+        for i in range(0, len(lines), batch):
+            enc = tok(lines[i:i + batch], padding="max_length", truncation=True,
+                      max_length=77, return_tensors="pt").to(device)
+            out = model(**enc, output_hidden_states=True)
+            H_f.append(out.last_hidden_state.half().cpu())
+            H_p.append(out.hidden_states[-2].half().cpu())
+            IDS.append(enc.input_ids.cpu())
+            EOS.append(enc.input_ids.argmax(-1).cpu())  # EOT id is the max token id
+        return (torch.cat(H_f), torch.cat(H_p), torch.cat(IDS), torch.cat(EOS))
+    tr = encode(tr_lines)
+    va = encode(va_lines)
+    blob = {"train": {"final": tr[0], "penult": tr[1], "ids": tr[2], "eos": tr[3]},
+            "val":   {"final": va[0], "penult": va[1], "ids": va[2], "eos": va[3]},
+            "vocab": tok.vocab_size}
+    torch.save(blob, path)
+    print(f"clip cache: train {tr[0].shape}, val {va[0].shape} -> {path}", flush=True)
+    return blob
+
+
+@torch.no_grad()
+def cache_word_embeddings(data_root, n_words=10000, device="cuda", batch=256):
+    """Pooled embeddings of frequent wikitext words for the spelling probe:
+    CLIP-L final + penultimate (EOS-pooled) and BERT (CLS + mean of last layer)."""
+    from transformers import (CLIPTextModel, CLIPTokenizerFast,
+                              BertModel, BertTokenizerFast)
+    path = os.path.join(data_root, "exp013", "word_cache.pt")
+    if os.path.exists(path):
+        return torch.load(path, map_location="cpu", weights_only=True)
+    os.makedirs(os.path.dirname(path), exist_ok=True)
+    tr_lines, _ = _wikitext_lines(data_root)
+    from collections import Counter
+    cnt = Counter(w for l in tr_lines for w in re.findall(r"[a-z]{3,12}", l.lower()))
+    words = [w for w, _ in cnt.most_common(n_words)]
+    blob = {"words": words}
+    ct = CLIPTokenizerFast.from_pretrained("openai/clip-vit-large-patch14")
+    cm = CLIPTextModel.from_pretrained("openai/clip-vit-large-patch14").to(device).eval()
+    fin, pen = [], []
+    for i in range(0, len(words), batch):
+        enc = ct(words[i:i + batch], padding="max_length", truncation=True,
+                 max_length=77, return_tensors="pt").to(device)
+        out = cm(**enc, output_hidden_states=True)
+        eos = enc.input_ids.argmax(-1)
+        idx = torch.arange(eos.numel(), device=device)
+        fin.append(out.last_hidden_state[idx, eos].half().cpu())
+        pen.append(out.hidden_states[-2][idx, eos].half().cpu())
+    blob["clip_final"], blob["clip_penult"] = torch.cat(fin), torch.cat(pen)
+    del cm
+    bt = BertTokenizerFast.from_pretrained("bert-base-uncased")
+    bm = BertModel.from_pretrained("bert-base-uncased").to(device).eval()
+    cls, mean = [], []
+    for i in range(0, len(words), batch):
+        enc = bt(words[i:i + batch], padding=True, truncation=True,
+                 max_length=16, return_tensors="pt").to(device)
+        out = bm(**enc).last_hidden_state
+        m = enc.attention_mask.unsqueeze(-1)
+        cls.append(out[:, 0].half().cpu())
+        mean.append(((out * m).sum(1) / m.sum(1)).half().cpu())
+    blob["bert_cls"], blob["bert_mean"] = torch.cat(cls), torch.cat(mean)
+    torch.save(blob, path)
+    print(f"word cache: {len(words)} words -> {path}", flush=True)
+    return blob
+
+
+# ============================================================ track A =============
+def track_a(arms=("linear", "mlp", "aleph", "sign"), layers=("final", "penult"),
+            steps=1500, batch=64, seed=0, device="cuda",
+            data_root=DATA_ROOT, eval_every=500, save=True):
+    """Next-CLIP-token prediction from frozen CLIP-L hidden states."""
+    if not torch.cuda.is_available():
+        raise RuntimeError("verdict runs are GPU-only")
+    blob = cache_clip(data_root, device=device)
+    V = blob["vocab"]
+    results = {}
+    ck_dir = os.path.join(data_root, "exp013", "ckpts")
+    os.makedirs(ck_dir, exist_ok=True)
+    for layer in layers:
+        Htr = blob["train"][layer].float()
+        ids_tr = blob["train"]["ids"]
+        Hva = blob["val"][layer].float()
+        ids_va = blob["val"]["ids"]
+        for arm in arms:
+            torch.manual_seed(seed)
+            g = torch.Generator().manual_seed(seed)
+            head = HeadArm(arm, Htr.shape[-1]).to(device)
+            out_proj = nn.Linear(HeadArm.F_OUT, V).to(device)
+            params = list(head.parameters()) + list(out_proj.parameters())
+            opt = torch.optim.Adam(params, lr=3e-4, weight_decay=0.0)
+            n_par = sum(p.numel() for p in params)
+            for step in range(1, steps + 1):
+                ix = torch.randint(0, Htr.shape[0], (batch,), generator=g)
+                h = Htr[ix].to(device)
+                y = ids_tr[ix].to(device)
+                logits = out_proj(head(h[:, :-1]))
+                loss = F.cross_entropy(logits.reshape(-1, V), y[:, 1:].reshape(-1))
+                opt.zero_grad(set_to_none=True); loss.backward(); opt.step()
+                if step % eval_every == 0 or step == steps:
+                    with torch.no_grad():
+                        ls = []
+                        for j in range(0, min(1024, Hva.shape[0]), batch):
+                            h = Hva[j:j + batch].to(device)
+                            y = ids_va[j:j + batch].to(device)
+                            lg = out_proj(head(h[:, :-1]))
+                            ls.append(F.cross_entropy(
+                                lg.reshape(-1, V), y[:, 1:].reshape(-1)).item())
+                        ce = sum(ls) / len(ls)
+                    vit = head.vitals(Hva[:2, :8].to(device))
+                    print(f"[A {layer} {arm} s{seed}] step {step} val_ce={ce:.4f} "
+                          f"params={n_par:,} vitals={vit}", flush=True)
+            results[f"{layer}/{arm}/s{seed}"] = {"val_ce": ce, "params": n_par,
+                                                 "vitals": vit}
+            if save and arm in ("aleph", "sign"):
+                torch.save({"track": "A", "layer": layer, "arm": arm, "seed": seed,
+                            "val_ce": ce, "state_dict": {k: v.cpu() for k, v in
+                                                          head.state_dict().items()}},
+                           os.path.join(ck_dir, f"A_{layer}_{arm}_s{seed}.pt"))
+    print(results, flush=True)
+    return results
+
+
+# ============================================================ track B =============
+class CharDecoder(nn.Module):
+    """Tiny GRU char decoder conditioned ONLY on the arm's 256-d read."""
+    CHARS = "abcdefghijklmnopqrstuvwxyz"
+    def __init__(self, cond_dim=256, hidden=256):
+        super().__init__()
+        self.V = len(self.CHARS) + 2  # +BOS +EOS
+        self.emb = nn.Embedding(self.V, 64)
+        self.init = nn.Linear(cond_dim, hidden)
+        self.gru = nn.GRU(64, hidden, batch_first=True)
+        self.out = nn.Linear(hidden, self.V)
+
+    def encode_word(self, w):
+        return [1] + [2 + self.CHARS.index(c) for c in w] + [0]  # BOS..EOS(0)
+
+    def forward(self, cond, tgt):          # tgt: (B, L) int, teacher-forced
+        h0 = torch.tanh(self.init(cond)).unsqueeze(0)
+        x = self.emb(tgt[:, :-1])
+        y, _ = self.gru(x, h0)
+        return self.out(y)                  # predict tgt[:,1:]
+
+    @torch.no_grad()
+    def greedy(self, cond, max_len=14):
+        B = cond.shape[0]
+        h = torch.tanh(self.init(cond)).unsqueeze(0)
+        t = torch.ones(B, 1, dtype=torch.long, device=cond.device)
+        done = torch.zeros(B, dtype=torch.bool, device=cond.device)
+        outs = []
+        for _ in range(max_len):
+            y, h = self.gru(self.emb(t), h)
+            t = self.out(y).argmax(-1)
+            outs.append(t)
+            done |= (t.squeeze(1) == 0)
+            if done.all():
+                break
+        return torch.cat(outs, 1)
+
+
+def track_b1(arms=("linear", "mlp"), substrates=("clip_final", "clip_penult",
+             "bert_cls", "bert_mean"), steps=3000, batch=128, seed=0,
+             device="cuda", data_root=DATA_ROOT, save=True):
+    """Spelling-AR from pooled embeddings. Run baselines first (the GATE:
+    qualify the task only if linear/mlp exact-match < 0.50), then aleph/sign."""
+    if not torch.cuda.is_available():
+        raise RuntimeError("verdict runs are GPU-only")
+    blob = cache_word_embeddings(data_root, device=device)
+    words = blob["words"]
+    dec_tpl = CharDecoder()
+    enc = [dec_tpl.encode_word(w) for w in words]
+    L = max(len(e) for e in enc)
+    tgt = torch.zeros(len(enc), L, dtype=torch.long)
+    for i, e in enumerate(enc):
+        tgt[i, :len(e)] = torch.tensor(e)
+    g0 = torch.Generator().manual_seed(1234)          # fixed split across arms
+    perm = torch.randperm(len(words), generator=g0)
+    tr_ix, va_ix = perm[:9000], perm[9000:]
+    ck_dir = os.path.join(data_root, "exp013", "ckpts")
+    os.makedirs(ck_dir, exist_ok=True)
+    results = {}
+    for sub in substrates:
+        E = blob[sub].float()
+        for arm in arms:
+            torch.manual_seed(seed)
+            g = torch.Generator().manual_seed(seed)
+            head = HeadArm(arm, E.shape[-1]).to(device)
+            dec = CharDecoder().to(device)
+            params = list(head.parameters()) + list(dec.parameters())
+            opt = torch.optim.Adam(params, lr=1e-3, weight_decay=0.0)
+            for step in range(1, steps + 1):
+                ix = tr_ix[torch.randint(0, tr_ix.numel(), (batch,), generator=g)]
+                cond = head(E[ix].to(device))
+                t = tgt[ix].to(device)
+                lg = dec(cond, t)
+                mask = (t[:, 1:] != 0) | (torch.cumsum(t[:, 1:] == 0, 1) == 1)
+                loss = F.cross_entropy(lg[mask], t[:, 1:][mask])
+                opt.zero_grad(set_to_none=True); loss.backward(); opt.step()
+            with torch.no_grad():
+                cond = head(E[va_ix].to(device))
+                pred = dec.greedy(cond)
+                t = tgt[va_ix, 1:].to(device)
+                n = min(pred.shape[1], t.shape[1])
+                pad_ok = torch.ones_like(t[:, :n], dtype=torch.bool)
+                seen_eos = torch.cumsum(t[:, :n] == 0, 1) > 0
+                match = ((pred[:, :n] == t[:, :n]) | seen_eos).all(-1)
+                exact = match.float().mean().item()
+            vit = head.vitals(E[va_ix[:16]].to(device))
+            print(f"[B1 {sub} {arm} s{seed}] exact={exact:.4f} vitals={vit}", flush=True)
+            results[f"{sub}/{arm}/s{seed}"] = {"exact": exact, "vitals": vit}
+            if save and arm in ("aleph", "sign"):
+                torch.save({"track": "B1", "sub": sub, "arm": arm, "seed": seed,
+                            "exact": exact, "state_dict": {k: v.cpu() for k, v in
+                                                            head.state_dict().items()}},
+                           os.path.join(ck_dir, f"B1_{sub}_{arm}_s{seed}.pt"))
+    print(results, flush=True)
+    return results
+
+
+# ============================================================ track C =============
+class MLPAdapter(nn.Module):
+    """Param-matched plain adapter (the ablation twin of MslRelay).
+    hidden=64 matches MslRelay at d=768 (2*768*64=98.3K vs 98.6K incl codebook).
+    Output layer ZERO-INIT (standard adapter stabilization — the first version
+    diverged at lr 1e-3 with random init; the aleph relay needed no such aid,
+    which is itself a datapoint, but the control gets its best shot)."""
+    def __init__(self, d, hidden=64):
+        super().__init__()
+        out = nn.Linear(hidden, d)
+        nn.init.zeros_(out.weight)
+        nn.init.zeros_(out.bias)
+        self.net = nn.Sequential(nn.Linear(d, hidden), SquaredReLU(), out)
+        self.gate = nn.Parameter(torch.tensor(-3.0))
+
+    def forward(self, x):
+        return x + self.gate.sigmoid() * self.net(x)
+
+
+class _BlockWithAdapter(nn.Module):
+    def __init__(self, block, adapter):
+        super().__init__()
+        self.block, self.adapter = block, adapter
+
+    def forward(self, *a, **k):
+        out = self.block(*a, **k)
+        if isinstance(out, tuple):
+            return (self.adapter(out[0]),) + out[1:]
+        return self.adapter(out)
+
+
+def track_c(arms=("frozen", "aleph", "mlp"), steps=1500, batch=8, block=256,
+            seed=0, device="cuda", data_root=DATA_ROOT,
+            eval_every=500, save=True):
+    """GPT-2 124M frozen; adapters after every block; train adapters only."""
+    from transformers import GPT2LMHeadModel, GPT2TokenizerFast
+    if not torch.cuda.is_available():
+        raise RuntimeError("verdict runs are GPU-only")
+    tok = GPT2TokenizerFast.from_pretrained("gpt2")
+    tr_lines, va_lines = _wikitext_lines(data_root)
+    def to_stream(lines):
+        ids = tok("\n\n".join(lines), return_tensors="pt").input_ids[0]
+        return ids
+    stream_tr = to_stream(tr_lines[:8000])
+    stream_va = to_stream(va_lines[:1000])
+    ck_dir = os.path.join(data_root, "exp013", "ckpts")
+    os.makedirs(ck_dir, exist_ok=True)
+    results = {}
+    for arm in arms:
+        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 = []
+        if arm != "frozen":
+            d = model.config.n_embd
+            for i, blk in enumerate(model.transformer.h):
+                ad = (MslRelay(d) if arm == "aleph" else MLPAdapter(d)).to(device)
+                model.transformer.h[i] = _BlockWithAdapter(blk, ad)
+                adapters.append(ad)
+            params = [p for ad in adapters for p in ad.parameters()]
+            n_par = sum(p.numel() for p in params)
+            opt = torch.optim.Adam(params, lr=1e-3, weight_decay=0.0)
+        else:
+            params, n_par = [], 0
+        def eval_ppl():
+            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)
+                    out = model(x, labels=x)
+                    ls.append(out.loss.item())
+            model.train()
+            return math.exp(sum(ls) / len(ls))
+        if arm == "frozen":
+            ppl = eval_ppl()
+            print(f"[C frozen] ppl={ppl:.3f}", flush=True)
+            results["frozen"] = {"ppl": ppl}
+            continue
+        for step in range(1, steps + 1):
+            ix = torch.randint(0, stream_tr.numel() - block - 1, (batch,), 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()
+            if step % eval_every == 0 or step == steps:
+                ppl = eval_ppl()
+                gates = [round(ad.gate.sigmoid().item(), 4) for ad in adapters]
+                vit = {}
+                if arm == "aleph":
+                    drifts = [round(anchor_drift(ad.addr.codebook, ad.addr.home)
+                                    ["mean"], 3) for ad in adapters]
+                    vit = {"drift_by_depth": drifts}
+                print(f"[C {arm} s{seed}] step {step} ppl={ppl:.3f} "
+                      f"params={n_par:,} gates={gates} {vit}", flush=True)
+        results[f"{arm}/s{seed}"] = {"ppl": ppl, "params": n_par, "gates": gates,
+                                     **vit}
+        if save and arm == "aleph":
+            torch.save({"track": "C", "arm": arm, "seed": seed, "ppl": ppl,
+                        "state_dict": {f"relay{i}.{k}": v.cpu()
+                                       for i, ad in enumerate(adapters)
+                                       for k, v in ad.state_dict().items()}},
+                       os.path.join(ck_dir, f"C_{arm}_s{seed}.pt"))
+    print(results, flush=True)
+    return results
+
+
+# ================================================================ smoke ===========
+def smoke():
+    """Shapes/parse only — no substrates, no training."""
+    for arm in ("linear", "mlp", "aleph", "sign"):
+        h = HeadArm(arm, 768)
+        y = h(torch.randn(2, 10, 768))
+        assert y.shape == (2, 10, 256)
+        y.sum().backward()
+        print(arm, "OK", f"{h.param_count():,}", h.vitals(torch.randn(2, 4, 768)))
+    dec = CharDecoder()
+    t = torch.tensor([dec.encode_word("hello") + [0] * 3,
+                      dec.encode_word("worlds") + [0] * 2])
+    lg = dec(torch.randn(2, 256), t)
+    assert lg.shape[:2] == (2, t.shape[1] - 1)
+    print("decoder OK; greedy:", dec.greedy(torch.randn(2, 256)).shape)
+    ad = MLPAdapter(768)
+    assert ad(torch.randn(2, 4, 768)).shape == (2, 4, 768)
+    print("adapter OK — exp013 smoke passed (caches+tracks need GPU+transformers)")
+
+
+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: cache_clip()/cache_word_embeddings() then "
+              "track_b1() gate -> track_a() -> track_c().")
+    else:
+        import argparse
+        ap = argparse.ArgumentParser()
+        ap.add_argument("--track", default="smoke")
+        a, _ = ap.parse_known_args()
+        {"smoke": smoke, "a": track_a, "b1": track_b1, "c": track_c}[a.track]()

exp014_gd/exp014_genetic_distillation.py

@@ -44,7 +44,7 @@ if "ByteLM" not in globals():
     except ImportError:
         raise ImportError("paste/run ar_differentiation_bed.py first")
 
-DATA_ROOT = r"E:\mirel\data"
+DATA_ROOT = os.environ.get("GEOLIP_DATA", "./data")
 EXP_DIR = os.path.join(DATA_ROOT, "exp014")
 
 
@@ -490,6 +490,26 @@ if __name__ == "__main__":
     else:
         import argparse
         ap = argparse.ArgumentParser()
-        ap.add_argument("--mode", default="smoke")
+        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()
-        smoke() if a.mode == "smoke" else None
+        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))

exp014_gd/geolip_vitals.py

@@ -0,0 +1,184 @@
+"""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_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. CM comes from geovocab2 — never inlined (program rule);
+    fp32 det only. Rows are row-normalized before measurement."""
+    try:
+        from geovocab2.formula.cayley_menger import simplex_volume  # noqa: F401
+    except Exception as e:  # pragma: no cover
+        raise ImportError(
+            "pentachoron_cv requires geovocab2 (CM must be imported, never inlined "
+            "— program rule). Install/point PYTHONPATH at geovocab2; expected "
+            "geovocab2.formula.cayley_menger.simplex_volume(points fp32)."
+        ) from e
+    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)
+    vols = []
+    for _ in range(n_samples):
+        idx = torch.randperm(n, generator=g)[:5]
+        vols.append(simplex_volume(x[idx].to(torch.float32)))
+    v = torch.stack([torch.as_tensor(v, dtype=torch.float32) for v in vols])
+    return (v.std() / v.mean().clamp_min(1e-12)).item()
+
+
+# ------------------------------------------------------------------------- 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)")

exp014_gd/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))

exp014_gd/repro.py

@@ -0,0 +1,39 @@
+"""repro.py — standalone loader/runner for exp014_gd. Every code dependency
+lives in THIS folder (geolip_vitals.py, ar_differentiation_bed.py,
+exp013_augmentation_bed.py for run_b2, exp014_genetic_distillation.py,
+read_codebook.py) — no cross-package paths.
+
+  python repro.py                     # CPU smoke: parse + shapes + GPA sanity
+  python repro.py --mode tournament   # one full lineage bracket (GPU, ~20 min)
+  python repro.py --mode b1           # cross-size implants (GPU)
+  python repro.py --mode b2           # GPT-2 relay implants (GPU; downloads GPT-2)
+
+Or drive it directly, e.g. a specific lineage:
+  python -c "import sys; sys.path.insert(0, '.'); \
+             from exp014_genetic_distillation import run_tournament; \
+             run_tournament('aleph_full')"
+
+Data lands in ./data (override with the GEOLIP_DATA env var); the tournament
+ledger + champion genomes land in ./data/exp014. Reading the shipped genomes:
+  python read_codebook.py genomes/
+"""
+import os
+import runpy
+import sys
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, HERE)
+
+if __name__ == "__main__":
+    if len(sys.argv) == 1:
+        import geolip_vitals                      # noqa: F401  (paste order)
+        import ar_differentiation_bed as bed
+        import exp014_genetic_distillation as gd
+        bed.smoke()
+        gd.smoke()
+        print("repro smoke passed — run with --mode {tournament,b1,b2} for "
+              "verdict runs")
+    else:
+        target = os.path.join(HERE, "exp014_genetic_distillation.py")
+        sys.argv = [target] + sys.argv[1:]
+        runpy.run_path(target, run_name="__main__")

exp015_ch/README.md

@@ -0,0 +1,100 @@
+# exp015_ch — content-bearing heredity
+
+Sequel to [exp014](../exp014_gd/) ([article](../exp014_gd/article.md)), executing
+its closing compass. exp014 found that consensus-book heredity is task-neutral
+because any healthy near-uniform book is as good as another — so genetic methods
+can only pay where the book's **content** is load-bearing. exp015 makes content
+load-bearing in the consumption itself: organisms whose entire prediction channel
+is the **sign-code read** (features are literally the ±A\[win\] rows of the book),
+plus the tree lineage finally tested under fair full-weight inheritance. Every
+exp014 lesson is baked in (full-weight continuity everywhere, KD α=0.25 with
+founders exempt, consensus overwrite only on the `_full` lineages).
+
+New instrument — the **content gauge** `sign_fidelity`: Spearman correlation of
+book-Hamming distance vs true angle over random sphere pairs — the LSH
+faithfulness of the cultivated book, logged per member.
+
+## The brackets (best-of-generation, bits/byte; 4 gens × pop 4, seed 0)
+
+| lineage | inherits | g0 | g1 | g2 | g3 |
+|---|---|---|---|---|---|
+| sign_weights | full weights (continuity control) | 2.4542 | 2.4149 | 2.4110 | **2.4098** |
+| sign_full | full weights + consensus book | 2.4518 | 2.4120 | 2.4083 | **2.4081** |
+| tree_weights | full weights (tree control) | 2.6228 | 2.5889 | 2.5790 | **2.5721** |
+| tree_full | full weights + root+branch consensus | 2.6307 | 2.5901 | 2.5815 | **2.5750** |
+| sign_none | nothing (floor) | 2.4472 | 2.4448 | 2.4365 | 2.4152 |
+
+`build_results.py` re-asserts every claim below from `results/ledger.jsonl`.
+
+## Findings
+
+1. **Content consumption cultivates fidelity by itself — and that compresses the
+   germline's headroom.** The control lineage's books climb from 0.942 to a 0.954
+   fidelity plateau with no consensus operator anywhere; every fresh founder's
+   book sits at 0.910–0.935. Under sign-code consumption, task pressure aligns
+   with LSH faithfulness. Consequence: the germline is ahead on bpb in 3/3
+   post-divergence generations (+0.003, +0.003, +0.002) — directionally consistent
+   but at founder-luck scale (the g0 gap was 0.0024). Content **consumption**
+   prices book identity; training pays that price on its own. The compass now
+   points at content **tasks** (retrieval, spelling) rather than content channels.
+2. **The lineage fixed point replicates on the discrete channel, and it locks
+   fidelity.** Germline champion drift: 0.175 → 0.112 → 0.011 → 0.009 (stationary
+   by gen 2, exactly the exp014 dynamic); control champions drift ~0.20 every
+   generation forever. Germline heirs hold fidelity 0.9555–0.9558 with < 0.001
+   inter-member spread — all members carry the same stationary book — while the
+   control's plateau keeps wandering. The floor's luckiest draw gets within 0.007
+   bpb of the germline champion, but its best fidelity (0.9355) never approaches
+   the lineage plateau: **the content gauge separates heredity from lottery far
+   more cleanly than score does.**
+3. **The tree inherits — continuity was the missing ingredient.** Both tree
+   lineages ascend monotonically (−0.051 / −0.056) where exp014's organ-regime
+   tree never beat its founders. The whole structure hits the fixed point: root
+   drift 0.144 → 0.004 and all four branch drifts to ≤ 0.005 by gen 2, branch
+   fidelity locked at 0.945–0.962. Structured consensus works as a germline
+   operator; the ~0.16 architecture tax vs flat heads is unchanged.
+4. **Branch revival belongs to continuity, not the germline.** The control's
+   weakest branch rises from 8.8% to 13.3% usage (root routing entropy ppl4
+   3.28 → 3.77) while the germline's fixed point freezes routing at
+   \[0.41, 0.34, 0.087, 0.17\] (ppl4 3.47) — stationarity and adaptability trade
+   off directly, at zero score difference.
+5. **Heredity maintains routing health that fresh draws repeatedly lose.** Every
+   fresh tree founder develops root imbalance (one branch at 67–76% usage, ppl4
+   as low as 1.96); lineage champions never do (ppl4 ≥ 3.28, no branch below
+   8%). Selection + inheritance preserve a property that single-organism
+   training reliably fails to find.
+
+## Files
+- `exp015_content_heredity.py` — the bed: sign-code + tree organisms, fair
+  inheritance with optional consensus overwrite, the `sign_fidelity` content
+  gauge, the tournament runner.
+- `geolip_vitals.py` / `ar_differentiation_bed.py` /
+  `exp014_genetic_distillation.py` / `read_codebook.py` — this package's own
+  copies of the shared harness (readout diagnostics; the ByteLM organism +
+  attention mechanisms; the consensus operator + TreeHead; the projective
+  specimen/genome reader). The package is standalone.
+- `repro.py` — loads the code files from this folder and runs them.
+- `build_results.py` → `results/results.json` — re-asserts every claim above
+  from the ledger.
+- `results/ledger.jsonl` — the append-only per-member record (80 rows).
+- `genomes/` — 20 per-generation champion codebooks.
+
+## 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: parse + shapes + inheritance
+python repro.py --lineage sign_full      # one full bracket (GPU, ~20 min)
+python read_codebook.py genomes/         # read the germline fossil record
+python build_results.py                  # re-assert every claim from the ledger
+```
+Data lands in `./data` (override with the `GEOLIP_DATA` env var); bracket ledgers
++ champion genomes in `./data/exp015`. In Colab, paste `geolip_vitals.py`,
+`ar_differentiation_bed.py`, `exp014_genetic_distillation.py`, then
+`exp015_content_heredity.py` into cells in that order.
+
+## Limitations
+One tournament seed; one bed (wikitext-2 bytes); 2000-step organisms; the
+content gauge is a geometry readout (LSH faithfulness), not yet a content
+*task* — the retrieval/spelling-judged tournament is the named next step.
+
+License: MIT · AbstractPhil + Claude Fable 5 · July 10, 2026

exp015_ch/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()

exp015_ch/build_results.py

@@ -0,0 +1,100 @@
+"""build_results.py — exp015_ch: read results/ledger.jsonl, aggregate, 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__))
+LEDGER = os.path.join(HERE, "results", "ledger.jsonl")
+OUT = os.path.join(HERE, "results", "results.json")
+
+rows = [json.loads(l) for l in open(LEDGER, encoding="utf-8")]
+assert all(r["exp"] == "15" for r in rows)
+
+LINEAGES = ["sign_weights", "sign_full", "tree_weights", "tree_full", "sign_none"]
+best = {}      # lineage -> [best bpb per gen]
+champ = {}     # lineage -> [champion row per gen]
+fresh = {}     # lineage -> fresh-founder rows
+for lin in LINEAGES:
+    lr = [r for r in rows if r["lineage"] == lin]
+    gens = sorted({r["gen"] for r in lr})
+    assert gens == [0, 1, 2, 3], (lin, gens)
+    best[lin] = []
+    champ[lin] = []
+    for g in gens:
+        gr = [r for r in lr if r["gen"] == g]
+        assert len(gr) == 4, (lin, g, len(gr))
+        c = min(gr, key=lambda r: r["bpb"])
+        best[lin].append(round(c["bpb"], 4))
+        champ[lin].append(c)
+    fresh[lin] = [r for r in lr if r["fresh"]]
+
+# ---- claim 1: founder parity across the F1 pair (sign channel = healthy bed)
+g0_gap = abs(best["sign_weights"][0] - best["sign_full"][0])
+assert g0_gap <= 0.005, g0_gap
+assert 2.40 < best["sign_weights"][0] < 2.50
+
+# ---- claim 2: every inheriting lineage ascends monotonically (best-of-gen)
+for lin in ("sign_weights", "sign_full", "tree_weights", "tree_full"):
+    bs = best[lin]
+    assert all(bs[i + 1] < bs[i] for i in range(3)), (lin, bs)
+
+# ---- claim 3: germline directionally ahead 3/3 post-divergence gens on the
+#      sign channel, but margin stays at founder-luck scale (<= g0 gap + 0.002)
+margins = [best["sign_weights"][g] - best["sign_full"][g] for g in (1, 2, 3)]
+assert all(m > 0 for m in margins), margins
+assert all(m <= g0_gap + 0.002 for m in margins), (margins, g0_gap)
+
+# ---- claim 4: the fixed point — germline champion books stationary by gen 2,
+#      continuity champions drift ~0.2 every generation forever
+for g in (2, 3):
+    assert champ["sign_full"][g]["content"]["drift"] < 0.02
+    assert champ["sign_weights"][g]["content"]["drift"] > 0.15
+    tc = champ["tree_full"][g]["content"]
+    assert tc["root_drift"] < 0.02 and max(tc["branch_drift"]) < 0.02
+    tw = champ["tree_weights"][g]["content"]
+    assert tw["root_drift"] > 0.1 or max(tw["branch_drift"]) > 0.15
+
+# ---- claim 5: fidelity — content consumption cultivates it (heirs beat every
+#      fresh founder), and the germline locks it (near-zero inter-member spread)
+for lin in ("sign_weights", "sign_full"):
+    heir_fids = [r["content"]["book_fid"] for r in rows
+                 if r["lineage"] == lin and r["gen"] >= 1 and not r["fresh"]]
+    fresh_fids = [r["content"]["book_fid"] for r in fresh[lin]]
+    assert min(heir_fids) > max(fresh_fids), lin
+g3_full = [r["content"]["book_fid"] for r in rows if r["lineage"] == "sign_full"
+           and r["gen"] == 3 and not r["fresh"]]
+assert max(g3_full) - min(g3_full) < 0.001, g3_full
+
+# ---- claim 6: tree routing — every fresh tree founder develops root imbalance
+#      (ppl4 < 3.2); lineage champions never do (ppl4 > 3.2, no dead branch)
+for lin in ("tree_weights", "tree_full"):
+    for r in fresh[lin]:
+        assert r["content"]["root_ppl4"] < 3.2, r
+    for g in range(4):
+        c = champ[lin][g]["content"]
+        assert c["root_ppl4"] > 3.2 and min(c["root_usage"]) > 0.05, c
+
+# ---- claim 7: branch revival belongs to continuity — the control's weakest
+#      branch usage rises g0->g3; the germline's stays frozen after fixation
+tw0, tw3 = champ["tree_weights"][0]["content"], champ["tree_weights"][3]["content"]
+assert min(tw3["root_usage"]) > min(tw0["root_usage"]) + 0.02
+tf2, tf3 = champ["tree_full"][2]["content"], champ["tree_full"][3]["content"]
+assert abs(min(tf3["root_usage"]) - min(tf2["root_usage"])) < 0.02
+
+out = {"best_of_gen": best,
+       "g0_founder_gap_sign": round(g0_gap, 4),
+       "post_divergence_margins_sign": [round(m, 4) for m in margins],
+       "champion_drift": {lin: [c["content"].get("drift",
+                                c["content"].get("root_drift")) for c in champ[lin]]
+                          for lin in LINEAGES},
+       "champion_fid": {lin: [c["content"].get("book_fid") for c in champ[lin]]
+                        for lin in ("sign_weights", "sign_full", "sign_none")},
+       "tree_root_ppl4": {lin: [c["content"]["root_ppl4"] for c in champ[lin]]
+                          for lin in ("tree_weights", "tree_full")},
+       "n_rows": len(rows)}
+os.makedirs(os.path.dirname(OUT), exist_ok=True)
+json.dump(out, open(OUT, "w", encoding="utf-8"), indent=1)
+print(f"{len(rows)} rows -> results/results.json")
+print("all README claims asserted OK")

exp015_ch/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))

exp015_ch/exp015_content_heredity.py

@@ -0,0 +1,188 @@
+"""exp015_content_heredity.py — does the germline pay when CONTENT is load-bearing?
+Composes exp014-A (content-bearing heredity) + exp014-C (the tree in the continuity
+regime). exp014's verdict: near-uniform books are near-interchangeable scaffolds —
+the consensus germline was task-neutral because the soft task only consumed book
+HEALTH. exp015 changes the consumption: organisms whose prediction channel consumes
+book IDENTITY (the sign-code head: features are literally ±A[win] rows), plus the
+TreeHead lineage finally tested with fair (full-weight) inheritance.
+
+Lineages (all full-weight continuity; the exp014 lesson is baked in):
+  sign_weights — sign-code organism, pure continuity (control)
+  sign_full    — sign-code organism, continuity + consensus-book overwrite
+  tree_weights — tree organism, pure continuity (control)
+  tree_full    — tree organism, continuity + structured consensus (root+branches)
+  sign_none    — sign-code no-inheritance floor
+Per-member gauges: val bpb + CONTENT GAUGE (sign-code metric fidelity: Spearman of
+book Hamming distance vs true angle — the LSH faithfulness of the cultivated book)
++ standard vitals; tree lineages log root usage (branch-revival watch).
+Preregistered forks:
+  F1 sign_full > sign_weights on bpb (beyond seed noise) => the germline converts
+     its stability (the exp014 finding) into VALUE under content consumption.
+     Tie => content
+     consumption at this scale still doesn't price book identity — the compass
+     points to content TASKS (retrieval/spelling) rather than content CHANNELS.
+  F2 tree_full vs tree_weights: does structure inherit under fair conditions; do
+     weak branches revive across generations (root usage ppl trajectory)?
+  F3 fidelity trajectory: do germline lineages preserve LSH fidelity better than
+     continuity lineages across generations (stability -> measurable content)?
+Riders: pure Adam wd=0; KD alpha 0.25, never on founders; drift-check before any
+freeze; Colab-safe. Paste order: geolip_vitals -> ar_differentiation_bed ->
+exp014_genetic_distillation -> this file.
+"""
+from __future__ import annotations
+import copy
+import json
+import os
+import torch
+import torch.nn.functional as F
+
+if "run_tournament" not in globals():
+    try:
+        from exp014_genetic_distillation import (
+            TreeHead, consensus_codebook, implant_book, train_member,
+            genome_of, inherit_genome, EXP_DIR, DATA_ROOT)
+        from ar_differentiation_bed import ByteLM, _wikitext_bytes
+        from geolip_vitals import anchor_drift
+    except ImportError:
+        _here = globals().get("__file__")
+        if _here is None:
+            raise ImportError("paste exp014_genetic_distillation.py (and its deps) first")
+        import sys, pathlib
+        sys.path.insert(0, str(pathlib.Path(_here).parent))
+        from exp014_genetic_distillation import (
+            TreeHead, consensus_codebook, implant_book, train_member,
+            genome_of, inherit_genome, EXP_DIR, DATA_ROOT)
+        from ar_differentiation_bed import ByteLM, _wikitext_bytes
+        from geolip_vitals import anchor_drift
+
+EXP15_DIR = os.path.join(os.path.dirname(EXP_DIR), "exp015")
+
+
+# ---------------------------------------------------------------- content gauge ---
+@torch.no_grad()
+def sign_fidelity(book: torch.Tensor, n: int = 3000, seed: int = 0) -> float:
+    """LSH faithfulness of the book: Spearman(sign-code Hamming, true angle) over
+    random pairs on S^(D-1). The content gauge — measures whether the book's
+    IDENTITY still supports metric-faithful discrete reading."""
+    A = F.normalize(book.detach().float().cpu(), dim=-1)
+    g = torch.Generator().manual_seed(seed)
+    D = A.shape[1]
+    x = F.normalize(torch.randn(n, D, generator=g), dim=-1)
+    y = F.normalize(torch.randn(n, D, generator=g), dim=-1)
+    ang = torch.arccos((x * y).sum(-1).clamp(-1, 1))
+    ham = (torch.sign(x @ A.T) != torch.sign(y @ A.T)).float().mean(-1)
+    ra = ang.argsort().argsort().float()
+    rb = ham.argsort().argsort().float()
+    ra = (ra - ra.mean()) / ra.std()
+    rb = (rb - rb.mean()) / rb.std()
+    return round(float((ra * rb).mean()), 4)
+
+
+def make_organism(lineage: str, d: int = 192, layers: int = 4, block: int = 256,
+                  seed: int = 0):
+    torch.manual_seed(seed)
+    if lineage.startswith("sign"):
+        return ByteLM("addr_mslh64", d=d, layers=layers, block=block)
+    if lineage.startswith("tree"):
+        m = ByteLM("sdpa", d=d, layers=layers, block=block)
+        m.head = TreeHead(d)
+        return m
+    raise ValueError(lineage)
+
+
+def content_gauge(model) -> dict:
+    if isinstance(model.head, TreeHead):
+        out = {"root_fid": sign_fidelity(model.head.root.codebook)}
+        out["branch_fid"] = [sign_fidelity(b.codebook) for b in model.head.branches]
+        out.update(model.head.vitals())
+        return out
+    return {"book_fid": sign_fidelity(model.head_addr.codebook),
+            "drift": round(anchor_drift(model.head_addr.codebook,
+                                        model.head_addr.home)["mean"], 4)}
+
+
+@torch.no_grad()
+def inherit_15(model, lineage: str, parent_models: list, catastrophic: bool = False):
+    """Full-weight continuity from the best parent; *_full adds the consensus
+    overwrite (flat book, or root+branches for trees)."""
+    model.load_state_dict(copy.deepcopy(parent_models[0].state_dict()))
+    if lineage.endswith("_full"):
+        gs = [genome_of(pm) for pm in parent_models]
+        if catastrophic:
+            gs = gs + [genome_of(make_organism(lineage, seed=666))]
+        if isinstance(model.head, TreeHead):
+            model.head.inherit(gs)   # consensus per root/branch book
+        else:
+            c, _, _ = consensus_codebook([g["flat"] for g in gs])
+            implant_book(model.head_addr, c)
+
+
+def run_tournament_15(lineage: str, gens: int = 4, pop: int = 4, steps: int = 2000,
+                      seed: int = 0, device: str = "cuda"):
+    if not torch.cuda.is_available():
+        raise RuntimeError("verdict runs are GPU-only")
+    os.makedirs(EXP15_DIR, exist_ok=True)
+    tr, va = _wikitext_bytes(DATA_ROOT)
+    ledger = open(os.path.join(EXP15_DIR, "ledger.jsonl"), "a", encoding="utf-8")
+    torch.manual_seed(9000 + seed)
+    ancestor = make_organism(lineage, seed=9000 + seed)
+    anc = genome_of(ancestor)
+    parent_models = []
+    for gen in range(gens):
+        members = []
+        for i in range(pop):
+            mseed = seed * 1000 + gen * 100 + i
+            m = make_organism(lineage, seed=mseed)
+            if gen == 0 and anc and lineage != "sign_none":
+                inherit_genome(m, [anc])   # common ancestor (books + proj)
+            is_fresh = (gen > 0 and i == pop - 1)
+            if gen > 0 and not is_fresh and lineage != "sign_none":
+                inherit_15(m, lineage, parent_models)
+            teachers = parent_models if (gen > 0 and not is_fresh
+                                          and lineage != "sign_none") else None
+            bpb = train_member(m, tr, va, steps=steps, device=device,
+                               seed=mseed, teachers=teachers, kd_alpha=0.25)
+            cg = content_gauge(m)
+            members.append((bpb, m))
+            rec = {"exp": "15", "lineage": lineage, "tseed": seed, "gen": gen,
+                   "member": i, "fresh": is_fresh, "bpb": round(bpb, 4),
+                   "content": cg}
+            ledger.write(json.dumps(rec) + "\n"); ledger.flush()
+            print(f"[15 {lineage} t{seed} g{gen} m{i}] bpb={bpb:.4f} {cg}",
+                  flush=True)
+        members.sort(key=lambda t: t[0])
+        parent_models = [members[0][1].cpu(), members[1][1].cpu()]
+        gene = genome_of(members[0][1])
+        if gene:
+            torch.save(gene, os.path.join(
+                EXP15_DIR, f"champion_{lineage}_t{seed}_g{gen}.pt"))
+        print(f"[15 {lineage} t{seed} g{gen}] BEST={members[0][0]:.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()
+
+
+def smoke():
+    x = torch.randint(0, 256, (2, 64))
+    for lin in ("sign_weights", "sign_full", "tree_weights", "tree_full"):
+        m = make_organism(lin, d=96, layers=2, block=64, seed=0)
+        lg = m(x); assert lg.shape == (2, 64, 256); lg.sum().backward()
+        p = make_organism(lin, d=96, layers=2, block=64, seed=1)
+        inherit_15(m, lin, [p, p])
+        print(lin, "OK", content_gauge(m))
+    print("exp015 smoke passed")
+
+
+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_tournament_15('sign_full') etc."))

exp015_ch/genomes/champion_sign_full_t0_g0.pt

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

exp015_ch/genomes/champion_sign_full_t0_g1.pt

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

exp015_ch/genomes/champion_sign_full_t0_g2.pt

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

exp015_ch/genomes/champion_sign_full_t0_g3.pt

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

exp015_ch/genomes/champion_sign_none_t0_g0.pt

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

exp015_ch/genomes/champion_sign_none_t0_g1.pt

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

exp015_ch/genomes/champion_sign_none_t0_g2.pt

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

exp015_ch/genomes/champion_sign_none_t0_g3.pt

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

exp015_ch/genomes/champion_sign_weights_t0_g0.pt

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

exp015_ch/genomes/champion_sign_weights_t0_g1.pt

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

exp015_ch/genomes/champion_sign_weights_t0_g2.pt

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

exp015_ch/genomes/champion_sign_weights_t0_g3.pt

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

exp015_ch/genomes/champion_tree_full_t0_g0.pt

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

exp015_ch/genomes/champion_tree_full_t0_g1.pt

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

exp015_ch/genomes/champion_tree_full_t0_g2.pt

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

exp015_ch/genomes/champion_tree_full_t0_g3.pt

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

exp015_ch/genomes/champion_tree_weights_t0_g0.pt

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

exp015_ch/genomes/champion_tree_weights_t0_g1.pt

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

exp015_ch/genomes/champion_tree_weights_t0_g2.pt

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

exp015_ch/genomes/champion_tree_weights_t0_g3.pt

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

exp015_ch/geolip_vitals.py

@@ -0,0 +1,184 @@
+"""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_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. CM comes from geovocab2 — never inlined (program rule);
+    fp32 det only. Rows are row-normalized before measurement."""
+    try:
+        from geovocab2.formula.cayley_menger import simplex_volume  # noqa: F401
+    except Exception as e:  # pragma: no cover
+        raise ImportError(
+            "pentachoron_cv requires geovocab2 (CM must be imported, never inlined "
+            "— program rule). Install/point PYTHONPATH at geovocab2; expected "
+            "geovocab2.formula.cayley_menger.simplex_volume(points fp32)."
+        ) from e
+    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)
+    vols = []
+    for _ in range(n_samples):
+        idx = torch.randperm(n, generator=g)[:5]
+        vols.append(simplex_volume(x[idx].to(torch.float32)))
+    v = torch.stack([torch.as_tensor(v, dtype=torch.float32) for v in vols])
+    return (v.std() / v.mean().clamp_min(1e-12)).item()
+
+
+# ------------------------------------------------------------------------- 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)")

exp015_ch/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))

exp015_ch/repro.py

@@ -0,0 +1,39 @@
+"""repro.py — standalone loader/runner for exp015_ch. Every code dependency
+lives in THIS folder (geolip_vitals.py, ar_differentiation_bed.py,
+exp014_genetic_distillation.py, exp015_content_heredity.py, read_codebook.py)
+— no cross-package paths.
+
+  python repro.py                     # CPU smoke: parse + shapes + inheritance
+  python repro.py --lineage sign_full # one full bracket (GPU, ~20 min)
+     lineages: sign_weights | sign_full | tree_weights | tree_full | sign_none
+
+Data lands in ./data (override with the GEOLIP_DATA env var); the bracket
+ledger + champion genomes land in ./data/exp015. Reading the shipped genomes:
+  python read_codebook.py genomes/
+"""
+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 as bed
+    import exp014_genetic_distillation as gd  # noqa: F401
+    import exp015_content_heredity as ch
+    args = sys.argv[1:]
+    if not args:
+        ch.smoke()
+        print("repro smoke passed — run with --lineage <name> for a bracket")
+    else:
+        import argparse
+        ap = argparse.ArgumentParser()
+        ap.add_argument("--lineage", required=True,
+                        choices=["sign_weights", "sign_full", "tree_weights",
+                                 "tree_full", "sign_none"])
+        ap.add_argument("--seed", type=int, default=0)
+        ap.add_argument("--steps", type=int, default=2000)
+        ap.add_argument("--gens", type=int, default=4)
+        a, _ = ap.parse_known_args()
+        ch.run_tournament_15(a.lineage, gens=a.gens, steps=a.steps, seed=a.seed)

exp015_ch/results/ledger.jsonl

@@ -0,0 +1,80 @@
+{"exp": "15", "lineage": "sign_weights", "tseed": 0, "gen": 0, "member": 0, "fresh": false, "bpb": 2.4542, "content": {"book_fid": 0.9423, "drift": 0.1757}}
+{"exp": "15", "lineage": "sign_weights", "tseed": 0, "gen": 0, "member": 1, "fresh": false, "bpb": 2.4859, "content": {"book_fid": 0.9398, "drift": 0.1723}}
+{"exp": "15", "lineage": "sign_weights", "tseed": 0, "gen": 0, "member": 2, "fresh": false, "bpb": 2.4949, "content": {"book_fid": 0.9362, "drift": 0.185}}
+{"exp": "15", "lineage": "sign_weights", "tseed": 0, "gen": 0, "member": 3, "fresh": false, "bpb": 2.4667, "content": {"book_fid": 0.9482, "drift": 0.1538}}
+{"exp": "15", "lineage": "sign_weights", "tseed": 0, "gen": 1, "member": 0, "fresh": false, "bpb": 2.4149, "content": {"book_fid": 0.954, "drift": 0.196}}
+{"exp": "15", "lineage": "sign_weights", "tseed": 0, "gen": 1, "member": 1, "fresh": false, "bpb": 2.4248, "content": {"book_fid": 0.9531, "drift": 0.1959}}
+{"exp": "15", "lineage": "sign_weights", "tseed": 0, "gen": 1, "member": 2, "fresh": false, "bpb": 2.4286, "content": {"book_fid": 0.9528, "drift": 0.1968}}
+{"exp": "15", "lineage": "sign_weights", "tseed": 0, "gen": 1, "member": 3, "fresh": true, "bpb": 2.4833, "content": {"book_fid": 0.9102, "drift": 0.2017}}
+{"exp": "15", "lineage": "sign_weights", "tseed": 0, "gen": 2, "member": 0, "fresh": false, "bpb": 2.411, "content": {"book_fid": 0.9542, "drift": 0.1997}}
+{"exp": "15", "lineage": "sign_weights", "tseed": 0, "gen": 2, "member": 1, "fresh": false, "bpb": 2.4306, "content": {"book_fid": 0.9542, "drift": 0.1993}}
+{"exp": "15", "lineage": "sign_weights", "tseed": 0, "gen": 2, "member": 2, "fresh": false, "bpb": 2.4266, "content": {"book_fid": 0.9545, "drift": 0.1997}}
+{"exp": "15", "lineage": "sign_weights", "tseed": 0, "gen": 2, "member": 3, "fresh": true, "bpb": 2.4805, "content": {"book_fid": 0.9155, "drift": 0.2079}}
+{"exp": "15", "lineage": "sign_weights", "tseed": 0, "gen": 3, "member": 0, "fresh": false, "bpb": 2.4098, "content": {"book_fid": 0.9537, "drift": 0.2028}}
+{"exp": "15", "lineage": "sign_weights", "tseed": 0, "gen": 3, "member": 1, "fresh": false, "bpb": 2.423, "content": {"book_fid": 0.954, "drift": 0.203}}
+{"exp": "15", "lineage": "sign_weights", "tseed": 0, "gen": 3, "member": 2, "fresh": false, "bpb": 2.4285, "content": {"book_fid": 0.9539, "drift": 0.2028}}
+{"exp": "15", "lineage": "sign_weights", "tseed": 0, "gen": 3, "member": 3, "fresh": true, "bpb": 2.5037, "content": {"book_fid": 0.9343, "drift": 0.1828}}
+{"exp": "15", "lineage": "sign_full", "tseed": 0, "gen": 0, "member": 0, "fresh": false, "bpb": 2.4518, "content": {"book_fid": 0.9421, "drift": 0.1749}}
+{"exp": "15", "lineage": "sign_full", "tseed": 0, "gen": 0, "member": 1, "fresh": false, "bpb": 2.4885, "content": {"book_fid": 0.9405, "drift": 0.172}}
+{"exp": "15", "lineage": "sign_full", "tseed": 0, "gen": 0, "member": 2, "fresh": false, "bpb": 2.4917, "content": {"book_fid": 0.9363, "drift": 0.1871}}
+{"exp": "15", "lineage": "sign_full", "tseed": 0, "gen": 0, "member": 3, "fresh": false, "bpb": 2.4692, "content": {"book_fid": 0.9485, "drift": 0.1531}}
+{"exp": "15", "lineage": "sign_full", "tseed": 0, "gen": 1, "member": 0, "fresh": false, "bpb": 2.412, "content": {"book_fid": 0.9554, "drift": 0.1116}}
+{"exp": "15", "lineage": "sign_full", "tseed": 0, "gen": 1, "member": 1, "fresh": false, "bpb": 2.4231, "content": {"book_fid": 0.9555, "drift": 0.112}}
+{"exp": "15", "lineage": "sign_full", "tseed": 0, "gen": 1, "member": 2, "fresh": false, "bpb": 2.428, "content": {"book_fid": 0.9558, "drift": 0.1121}}
+{"exp": "15", "lineage": "sign_full", "tseed": 0, "gen": 1, "member": 3, "fresh": true, "bpb": 2.4718, "content": {"book_fid": 0.9116, "drift": 0.1985}}
+{"exp": "15", "lineage": "sign_full", "tseed": 0, "gen": 2, "member": 0, "fresh": false, "bpb": 2.4083, "content": {"book_fid": 0.9557, "drift": 0.0113}}
+{"exp": "15", "lineage": "sign_full", "tseed": 0, "gen": 2, "member": 1, "fresh": false, "bpb": 2.4274, "content": {"book_fid": 0.9556, "drift": 0.0116}}
+{"exp": "15", "lineage": "sign_full", "tseed": 0, "gen": 2, "member": 2, "fresh": false, "bpb": 2.4245, "content": {"book_fid": 0.9555, "drift": 0.0117}}
+{"exp": "15", "lineage": "sign_full", "tseed": 0, "gen": 2, "member": 3, "fresh": true, "bpb": 2.4783, "content": {"book_fid": 0.9159, "drift": 0.2064}}
+{"exp": "15", "lineage": "sign_full", "tseed": 0, "gen": 3, "member": 0, "fresh": false, "bpb": 2.4081, "content": {"book_fid": 0.9557, "drift": 0.0088}}
+{"exp": "15", "lineage": "sign_full", "tseed": 0, "gen": 3, "member": 1, "fresh": false, "bpb": 2.4215, "content": {"book_fid": 0.9558, "drift": 0.0087}}
+{"exp": "15", "lineage": "sign_full", "tseed": 0, "gen": 3, "member": 2, "fresh": false, "bpb": 2.4262, "content": {"book_fid": 0.9557, "drift": 0.0088}}
+{"exp": "15", "lineage": "sign_full", "tseed": 0, "gen": 3, "member": 3, "fresh": true, "bpb": 2.4945, "content": {"book_fid": 0.9351, "drift": 0.185}}
+{"exp": "15", "lineage": "tree_weights", "tseed": 0, "gen": 0, "member": 0, "fresh": false, "bpb": 2.6228, "content": {"root_fid": 0.477, "branch_fid": [0.9181, 0.9273, 0.9289, 0.9397], "root_drift": 0.1393, "root_usage": [0.389, 0.413, 0.11, 0.088], "root_ppl4": 3.284, "branch_drift": [0.418, 0.318, 0.294, 0.29]}}
+{"exp": "15", "lineage": "tree_weights", "tseed": 0, "gen": 0, "member": 1, "fresh": false, "bpb": 2.6412, "content": {"root_fid": 0.4639, "branch_fid": [0.9343, 0.9406, 0.9032, 0.9416], "root_drift": 0.1407, "root_usage": [0.373, 0.253, 0.32, 0.054], "root_ppl4": 3.45, "branch_drift": [0.341, 0.281, 0.414, 0.309]}}
+{"exp": "15", "lineage": "tree_weights", "tseed": 0, "gen": 0, "member": 2, "fresh": false, "bpb": 2.6378, "content": {"root_fid": 0.4849, "branch_fid": [0.9569, 0.9281, 0.906, 0.9432], "root_drift": 0.0785, "root_usage": [0.004, 0.122, 0.832, 0.042], "root_ppl4": 1.76, "branch_drift": [0.202, 0.376, 0.324, 0.273]}}
+{"exp": "15", "lineage": "tree_weights", "tseed": 0, "gen": 0, "member": 3, "fresh": false, "bpb": 2.6481, "content": {"root_fid": 0.4838, "branch_fid": [0.9411, 0.9522, 0.9024, 0.9202], "root_drift": 0.1247, "root_usage": [0.295, 0.024, 0.19, 0.492], "root_ppl4": 3.042, "branch_drift": [0.355, 0.236, 0.328, 0.337]}}
+{"exp": "15", "lineage": "tree_weights", "tseed": 0, "gen": 1, "member": 0, "fresh": false, "bpb": 2.5889, "content": {"root_fid": 0.4691, "branch_fid": [0.9331, 0.9456, 0.9397, 0.9505], "root_drift": 0.162, "root_usage": [0.293, 0.358, 0.221, 0.128], "root_ppl4": 3.758, "branch_drift": [0.395, 0.283, 0.284, 0.267]}}
+{"exp": "15", "lineage": "tree_weights", "tseed": 0, "gen": 1, "member": 1, "fresh": false, "bpb": 2.5988, "content": {"root_fid": 0.4745, "branch_fid": [0.9338, 0.9463, 0.939, 0.9494], "root_drift": 0.1611, "root_usage": [0.298, 0.364, 0.219, 0.119], "root_ppl4": 3.722, "branch_drift": [0.394, 0.281, 0.284, 0.268]}}
+{"exp": "15", "lineage": "tree_weights", "tseed": 0, "gen": 1, "member": 2, "fresh": false, "bpb": 2.6034, "content": {"root_fid": 0.472, "branch_fid": [0.9335, 0.9455, 0.9395, 0.9498], "root_drift": 0.17, "root_usage": [0.287, 0.372, 0.22, 0.121], "root_ppl4": 3.724, "branch_drift": [0.395, 0.283, 0.285, 0.267]}}
+{"exp": "15", "lineage": "tree_weights", "tseed": 0, "gen": 1, "member": 3, "fresh": true, "bpb": 2.6895, "content": {"root_fid": 0.4627, "branch_fid": [0.9124, 0.957, 0.943, 0.9067], "root_drift": 0.2238, "root_usage": [0.196, 0.008, 0.032, 0.764], "root_ppl4": 1.961, "branch_drift": [0.423, 0.247, 0.247, 0.333]}}
+{"exp": "15", "lineage": "tree_weights", "tseed": 0, "gen": 2, "member": 0, "fresh": false, "bpb": 2.579, "content": {"root_fid": 0.4731, "branch_fid": [0.9339, 0.9465, 0.9395, 0.9504], "root_drift": 0.1626, "root_usage": [0.294, 0.358, 0.221, 0.128], "root_ppl4": 3.759, "branch_drift": [0.394, 0.282, 0.285, 0.267]}}
+{"exp": "15", "lineage": "tree_weights", "tseed": 0, "gen": 2, "member": 1, "fresh": false, "bpb": 2.5976, "content": {"root_fid": 0.4714, "branch_fid": [0.9336, 0.9464, 0.9397, 0.9505], "root_drift": 0.1631, "root_usage": [0.29, 0.364, 0.223, 0.124], "root_ppl4": 3.742, "branch_drift": [0.394, 0.282, 0.285, 0.267]}}
+{"exp": "15", "lineage": "tree_weights", "tseed": 0, "gen": 2, "member": 2, "fresh": false, "bpb": 2.5942, "content": {"root_fid": 0.4725, "branch_fid": [0.9337, 0.9468, 0.9396, 0.9507], "root_drift": 0.1629, "root_usage": [0.296, 0.359, 0.218, 0.127], "root_ppl4": 3.751, "branch_drift": [0.394, 0.282, 0.284, 0.267]}}
+{"exp": "15", "lineage": "tree_weights", "tseed": 0, "gen": 2, "member": 3, "fresh": true, "bpb": 2.6505, "content": {"root_fid": 0.4673, "branch_fid": [0.9367, 0.9109, 0.934, 0.9522], "root_drift": 0.302, "root_usage": [0.188, 0.675, 0.115, 0.021], "root_ppl4": 2.484, "branch_drift": [0.294, 0.451, 0.31, 0.195]}}
+{"exp": "15", "lineage": "tree_weights", "tseed": 0, "gen": 3, "member": 0, "fresh": false, "bpb": 2.5721, "content": {"root_fid": 0.4719, "branch_fid": [0.9341, 0.9467, 0.9401, 0.9504], "root_drift": 0.1634, "root_usage": [0.301, 0.352, 0.214, 0.133], "root_ppl4": 3.77, "branch_drift": [0.394, 0.281, 0.285, 0.267]}}
+{"exp": "15", "lineage": "tree_weights", "tseed": 0, "gen": 3, "member": 1, "fresh": false, "bpb": 2.5821, "content": {"root_fid": 0.4717, "branch_fid": [0.9339, 0.9469, 0.9401, 0.9503], "root_drift": 0.1632, "root_usage": [0.295, 0.363, 0.216, 0.126], "root_ppl4": 3.743, "branch_drift": [0.394, 0.281, 0.285, 0.267]}}
+{"exp": "15", "lineage": "tree_weights", "tseed": 0, "gen": 3, "member": 2, "fresh": false, "bpb": 2.5872, "content": {"root_fid": 0.47, "branch_fid": [0.934, 0.9464, 0.9397, 0.9504], "root_drift": 0.1634, "root_usage": [0.293, 0.356, 0.218, 0.133], "root_ppl4": 3.773, "branch_drift": [0.394, 0.282, 0.285, 0.267]}}
+{"exp": "15", "lineage": "tree_weights", "tseed": 0, "gen": 3, "member": 3, "fresh": true, "bpb": 2.6506, "content": {"root_fid": 0.4679, "branch_fid": [0.9027, 0.9044, 0.9224, 0.9192], "root_drift": 0.0969, "root_usage": [0.184, 0.503, 0.268, 0.045], "root_ppl4": 3.158, "branch_drift": [0.26, 0.331, 0.313, 0.345]}}
+{"exp": "15", "lineage": "tree_full", "tseed": 0, "gen": 0, "member": 0, "fresh": false, "bpb": 2.6307, "content": {"root_fid": 0.4804, "branch_fid": [0.9218, 0.9276, 0.9287, 0.9395], "root_drift": 0.1437, "root_usage": [0.398, 0.406, 0.104, 0.092], "root_ppl4": 3.278, "branch_drift": [0.416, 0.318, 0.293, 0.292]}}
+{"exp": "15", "lineage": "tree_full", "tseed": 0, "gen": 0, "member": 1, "fresh": false, "bpb": 2.6418, "content": {"root_fid": 0.4641, "branch_fid": [0.9338, 0.941, 0.9024, 0.9413], "root_drift": 0.1385, "root_usage": [0.374, 0.253, 0.312, 0.061], "root_ppl4": 3.49, "branch_drift": [0.341, 0.28, 0.416, 0.31]}}
+{"exp": "15", "lineage": "tree_full", "tseed": 0, "gen": 0, "member": 2, "fresh": false, "bpb": 2.6517, "content": {"root_fid": 0.4861, "branch_fid": [0.9568, 0.9284, 0.9058, 0.9425], "root_drift": 0.0766, "root_usage": [0.005, 0.126, 0.834, 0.035], "root_ppl4": 1.742, "branch_drift": [0.204, 0.375, 0.323, 0.274]}}
+{"exp": "15", "lineage": "tree_full", "tseed": 0, "gen": 0, "member": 3, "fresh": false, "bpb": 2.6486, "content": {"root_fid": 0.4824, "branch_fid": [0.9413, 0.9517, 0.9017, 0.9207], "root_drift": 0.1234, "root_usage": [0.301, 0.025, 0.19, 0.485], "root_ppl4": 3.061, "branch_drift": [0.354, 0.236, 0.329, 0.336]}}
+{"exp": "15", "lineage": "tree_full", "tseed": 0, "gen": 1, "member": 0, "fresh": false, "bpb": 2.5901, "content": {"root_fid": 0.4789, "branch_fid": [0.9541, 0.9546, 0.9451, 0.9631], "root_drift": 0.0607, "root_usage": [0.414, 0.336, 0.084, 0.166], "root_ppl4": 3.449, "branch_drift": [0.13, 0.111, 0.106, 0.124]}}
+{"exp": "15", "lineage": "tree_full", "tseed": 0, "gen": 1, "member": 1, "fresh": false, "bpb": 2.6014, "content": {"root_fid": 0.4799, "branch_fid": [0.9535, 0.9547, 0.9444, 0.9624], "root_drift": 0.0539, "root_usage": [0.411, 0.347, 0.09, 0.153], "root_ppl4": 3.443, "branch_drift": [0.131, 0.111, 0.103, 0.12]}}
+{"exp": "15", "lineage": "tree_full", "tseed": 0, "gen": 1, "member": 2, "fresh": false, "bpb": 2.606, "content": {"root_fid": 0.4783, "branch_fid": [0.9542, 0.9541, 0.9444, 0.9629], "root_drift": 0.0556, "root_usage": [0.423, 0.332, 0.084, 0.161], "root_ppl4": 3.428, "branch_drift": [0.13, 0.111, 0.102, 0.12]}}
+{"exp": "15", "lineage": "tree_full", "tseed": 0, "gen": 1, "member": 3, "fresh": true, "bpb": 2.6897, "content": {"root_fid": 0.4652, "branch_fid": [0.9132, 0.9563, 0.9428, 0.9073], "root_drift": 0.2214, "root_usage": [0.217, 0.01, 0.037, 0.736], "root_ppl4": 2.064, "branch_drift": [0.423, 0.252, 0.248, 0.332]}}
+{"exp": "15", "lineage": "tree_full", "tseed": 0, "gen": 2, "member": 0, "fresh": false, "bpb": 2.5815, "content": {"root_fid": 0.4777, "branch_fid": [0.9548, 0.9546, 0.9451, 0.9627], "root_drift": 0.0042, "root_usage": [0.411, 0.338, 0.086, 0.165], "root_ppl4": 3.459, "branch_drift": [0.005, 0.005, 0.006, 0.005]}}
+{"exp": "15", "lineage": "tree_full", "tseed": 0, "gen": 2, "member": 1, "fresh": false, "bpb": 2.6007, "content": {"root_fid": 0.4772, "branch_fid": [0.9545, 0.9545, 0.9446, 0.9624], "root_drift": 0.0041, "root_usage": [0.411, 0.34, 0.084, 0.165], "root_ppl4": 3.448, "branch_drift": [0.005, 0.005, 0.006, 0.005]}}
+{"exp": "15", "lineage": "tree_full", "tseed": 0, "gen": 2, "member": 2, "fresh": false, "bpb": 2.5979, "content": {"root_fid": 0.4776, "branch_fid": [0.9548, 0.9544, 0.9447, 0.9627], "root_drift": 0.004, "root_usage": [0.408, 0.341, 0.087, 0.164], "root_ppl4": 3.46, "branch_drift": [0.005, 0.004, 0.006, 0.005]}}
+{"exp": "15", "lineage": "tree_full", "tseed": 0, "gen": 2, "member": 3, "fresh": true, "bpb": 2.6507, "content": {"root_fid": 0.4669, "branch_fid": [0.9357, 0.9107, 0.9348, 0.9522], "root_drift": 0.3004, "root_usage": [0.184, 0.673, 0.119, 0.025], "root_ppl4": 2.516, "branch_drift": [0.293, 0.452, 0.309, 0.195]}}
+{"exp": "15", "lineage": "tree_full", "tseed": 0, "gen": 3, "member": 0, "fresh": false, "bpb": 2.575, "content": {"root_fid": 0.4767, "branch_fid": [0.9549, 0.9541, 0.9448, 0.9623], "root_drift": 0.0029, "root_usage": [0.411, 0.335, 0.087, 0.167], "root_ppl4": 3.465, "branch_drift": [0.003, 0.003, 0.005, 0.004]}}
+{"exp": "15", "lineage": "tree_full", "tseed": 0, "gen": 3, "member": 1, "fresh": false, "bpb": 2.5855, "content": {"root_fid": 0.4781, "branch_fid": [0.955, 0.9541, 0.9447, 0.9623], "root_drift": 0.0035, "root_usage": [0.414, 0.338, 0.083, 0.165], "root_ppl4": 3.439, "branch_drift": [0.003, 0.003, 0.005, 0.004]}}
+{"exp": "15", "lineage": "tree_full", "tseed": 0, "gen": 3, "member": 2, "fresh": false, "bpb": 2.5915, "content": {"root_fid": 0.4765, "branch_fid": [0.9547, 0.9543, 0.9445, 0.9627], "root_drift": 0.0024, "root_usage": [0.405, 0.335, 0.089, 0.172], "root_ppl4": 3.49, "branch_drift": [0.003, 0.003, 0.005, 0.004]}}
+{"exp": "15", "lineage": "tree_full", "tseed": 0, "gen": 3, "member": 3, "fresh": true, "bpb": 2.6512, "content": {"root_fid": 0.4685, "branch_fid": [0.9029, 0.9062, 0.9225, 0.9219], "root_drift": 0.095, "root_usage": [0.186, 0.496, 0.277, 0.041], "root_ppl4": 3.147, "branch_drift": [0.26, 0.33, 0.312, 0.346]}}
+{"exp": "15", "lineage": "sign_none", "tseed": 0, "gen": 0, "member": 0, "fresh": false, "bpb": 2.5073, "content": {"book_fid": 0.9214, "drift": 0.18}}
+{"exp": "15", "lineage": "sign_none", "tseed": 0, "gen": 0, "member": 1, "fresh": false, "bpb": 2.4472, "content": {"book_fid": 0.9244, "drift": 0.183}}
+{"exp": "15", "lineage": "sign_none", "tseed": 0, "gen": 0, "member": 2, "fresh": false, "bpb": 2.473, "content": {"book_fid": 0.9296, "drift": 0.1964}}
+{"exp": "15", "lineage": "sign_none", "tseed": 0, "gen": 0, "member": 3, "fresh": false, "bpb": 2.5014, "content": {"book_fid": 0.9392, "drift": 0.1777}}
+{"exp": "15", "lineage": "sign_none", "tseed": 0, "gen": 1, "member": 0, "fresh": false, "bpb": 2.4823, "content": {"book_fid": 0.9347, "drift": 0.2046}}
+{"exp": "15", "lineage": "sign_none", "tseed": 0, "gen": 1, "member": 1, "fresh": false, "bpb": 2.4448, "content": {"book_fid": 0.927, "drift": 0.1658}}
+{"exp": "15", "lineage": "sign_none", "tseed": 0, "gen": 1, "member": 2, "fresh": false, "bpb": 2.5182, "content": {"book_fid": 0.9273, "drift": 0.1822}}
+{"exp": "15", "lineage": "sign_none", "tseed": 0, "gen": 1, "member": 3, "fresh": true, "bpb": 2.474, "content": {"book_fid": 0.9102, "drift": 0.1995}}
+{"exp": "15", "lineage": "sign_none", "tseed": 0, "gen": 2, "member": 0, "fresh": false, "bpb": 2.4365, "content": {"book_fid": 0.9279, "drift": 0.1765}}
+{"exp": "15", "lineage": "sign_none", "tseed": 0, "gen": 2, "member": 1, "fresh": false, "bpb": 2.5354, "content": {"book_fid": 0.9299, "drift": 0.1962}}
+{"exp": "15", "lineage": "sign_none", "tseed": 0, "gen": 2, "member": 2, "fresh": false, "bpb": 2.5406, "content": {"book_fid": 0.9189, "drift": 0.1976}}
+{"exp": "15", "lineage": "sign_none", "tseed": 0, "gen": 2, "member": 3, "fresh": true, "bpb": 2.4844, "content": {"book_fid": 0.916, "drift": 0.2046}}
+{"exp": "15", "lineage": "sign_none", "tseed": 0, "gen": 3, "member": 0, "fresh": false, "bpb": 2.4152, "content": {"book_fid": 0.9314, "drift": 0.1654}}
+{"exp": "15", "lineage": "sign_none", "tseed": 0, "gen": 3, "member": 1, "fresh": false, "bpb": 2.4916, "content": {"book_fid": 0.9355, "drift": 0.1693}}
+{"exp": "15", "lineage": "sign_none", "tseed": 0, "gen": 3, "member": 2, "fresh": false, "bpb": 2.5254, "content": {"book_fid": 0.9176, "drift": 0.1907}}
+{"exp": "15", "lineage": "sign_none", "tseed": 0, "gen": 3, "member": 3, "fresh": true, "bpb": 2.4981, "content": {"book_fid": 0.9351, "drift": 0.1865}}

exp015_ch/results/results.json

@@ -0,0 +1,107 @@
+{
+ "best_of_gen": {
+  "sign_weights": [
+   2.4542,
+   2.4149,
+   2.411,
+   2.4098
+  ],
+  "sign_full": [
+   2.4518,
+   2.412,
+   2.4083,
+   2.4081
+  ],
+  "tree_weights": [
+   2.6228,
+   2.5889,
+   2.579,
+   2.5721
+  ],
+  "tree_full": [
+   2.6307,
+   2.5901,
+   2.5815,
+   2.575
+  ],
+  "sign_none": [
+   2.4472,
+   2.4448,
+   2.4365,
+   2.4152
+  ]
+ },
+ "g0_founder_gap_sign": 0.0024,
+ "post_divergence_margins_sign": [
+  0.0029,
+  0.0027,
+  0.0017
+ ],
+ "champion_drift": {
+  "sign_weights": [
+   0.1757,
+   0.196,
+   0.1997,
+   0.2028
+  ],
+  "sign_full": [
+   0.1749,
+   0.1116,
+   0.0113,
+   0.0088
+  ],
+  "tree_weights": [
+   0.1393,
+   0.162,
+   0.1626,
+   0.1634
+  ],
+  "tree_full": [
+   0.1437,
+   0.0607,
+   0.0042,
+   0.0029
+  ],
+  "sign_none": [
+   0.183,
+   0.1658,
+   0.1765,
+   0.1654
+  ]
+ },
+ "champion_fid": {
+  "sign_weights": [
+   0.9423,
+   0.954,
+   0.9542,
+   0.9537
+  ],
+  "sign_full": [
+   0.9421,
+   0.9554,
+   0.9557,
+   0.9557
+  ],
+  "sign_none": [
+   0.9244,
+   0.927,
+   0.9279,
+   0.9314
+  ]
+ },
+ "tree_root_ppl4": {
+  "tree_weights": [
+   3.284,
+   3.758,
+   3.759,
+   3.77
+  ],
+  "tree_full": [
+   3.278,
+   3.449,
+   3.459,
+   3.465
+  ]
+ },
+ "n_rows": 80
+}