trainers/: full replication kit — 11 scrubbed standalone trainers + README (battery map, replication discipline, repair flags, gauge guidance, history caveats)

trainers/README.md

@@ -0,0 +1,53 @@
+# trainers/ — replication kit for the aleph-splat measurement record
+
+Every number in this repo's `battery/` directories was produced by a
+trainer in this directory, on a single consumer GPU (RTX 4090 class).
+Each trainer is a standalone file: `python <trainer>.py` with `HF_TOKEN`
+in the environment if you want results shipped to your own hub repo
+(uploads are optional — remove the `upload_file` calls or leave the token
+unset and save locally).
+
+## The trainers, mapped to their result directories
+
+| trainer | produces | battery dir |
+|---|---|---|
+| `splat_math_battery.py` | the B1–B9 static mathematical battery | `battery/` (splat_battery*.json) |
+| `ar_differentiation_bed.py` | the byte-AR bed all recall batteries build on (ByteLM, CausalHUB, AlephAddress) — also runs its own wikitext arms | (dependency; `./data/ar_ckpts` specimens) |
+| `geolip_vitals.py` | vitals helpers imported by the bed | (dependency) |
+| `v1_rank_army_battery.py` | rank-ladder × army-ladder under LDS filtering pressure | `battery/v1_rank_army/` |
+| `v1b_recall_army_battery.py` | the recall battery: rank-controlled in-context binding; the K/D ladders; clean-mask + selection gauges | `battery/v1b_recall_army/` |
+| `v1d_svae_graft.py` | SVAE-transformer graft arms (sphere/lens/α-grammar) | `battery/v1d_svae_graft/` |
+| `v1e_knit_battery.py` | conv-knit + patchwork graft arms | `battery/v1e_knit/` |
+| `v1f_consult_tier.py` | corrector tier: rownorm/auxalpha/strobe3/unigram/padfix | `battery/v1f_consult/` |
+| `v1g_svae_overlap_sweep.py` | 16-noise overlap sweep on the SVAE substrate | `battery/v1g_svae_overlap/` |
+| `v1i_validity_batteries.py` | dtype / optimizer / schedule batteries (Muon, Lion, fp8-sim…) | `battery/v1i_validity/` |
+| `trigram_bitspace_sweep.py` | byte-embedding bit-space analysis (CPU) | (analysis JSON) |
+
+## Replication discipline — read before running
+
+1. **Standing repairs (use them):** `ALEPH_TRI_PAD_FIX=1` (trigram pad
+   conflation fix; worth +.05–.11 and unlocks address consumption) and
+   `V1B_CLEAN_MASK=1` (drops window-truncated answer positions from the
+   4×-weighted loss). All *clean-protocol* numbers in the record use both.
+2. **Gauge choice matters:** `masked_eval` scores ~6% information-
+   theoretically unanswerable positions (window truncation) — it fakes
+   plateaus for near-ceiling models. `selection_eval` filters to the
+   answerable subset and additionally decomposes errors into wrong-pair
+   retrieval vs no-retrieval. Headline from `selection_eval`.
+3. **History caveat:** result directories produced before 2026-08-10 ran
+   without the pad fix and with the truncation-era gauge. Internal
+   comparisons within a battery remain valid (shared conditions); do not
+   compare absolute numbers across the repair boundary.
+4. **Optimizer:** the aleph mechanism is ~20× more optimizer-sensitive
+   than softmax attention; momentum-geometric optimizers (Muon-style,
+   SGD-momentum) beat Adam by ~.09 on it. `v1i_validity_batteries.py`
+   contains the Muon/Lion implementations used.
+5. **Precision:** train fp32/bf16; never through fp8; fp16 requires the
+   dtype-aware clamps already present in these files.
+6. **Data:** synthetic streams are generated deterministically by the
+   trainers themselves (seeded); `v1g` pulls the public
+   `AbstractPhil/geolip-svae-batteries` noise battery; the wikitext arms
+   pull `Salesforce/wikitext` parquet. Default data root is `./data`.
+
+All findings, including the failures and the two retracted constants,
+are summarized in the repo README and the technical companion.

trainers/ar_differentiation_bed.py

@@ -0,0 +1,499 @@
+"""ar_differentiation_bed.py — THE FOCUS (2026-07-09 redirect, AbstractPhil verbatim):
+"refining the autoregressive techniques for differentiation rather than attempting
+to just mash numbers together."
+
+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. It is the Law-2 construction (codebook-pressure C3) + Tree 3d in
+one harness; the Jun-19 "discuss before building" gate was resolved by the redirect.
+
+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; data_root OUTSIDE the mind repo.
+
+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 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 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 "
+                "keep geolip_vitals.py beside this file (ships in this directory).")
+
+VOCAB = 256  # bytes
+
+
+# ------------------------------------------------------------------ aleph address
+def _super_fibonacci_s3(n: int) -> torch.Tensor:
+    """Near-uniform unit quaternions (Alexa CVPR'22; constants per canon) —
+    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 (canon/aleph_core.md).
+    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):
+        """Canon hard mode: 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)
+        if den.dtype in (torch.float32, torch.float64):
+            cl = 1e-12
+        else:                       # fp16/bf16: 1e-12 flushes to 0 (landmine)
+            cl = torch.finfo(den.dtype).tiny * 8
+        return self.o(num / den.clamp_min(cl))
+
+
+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
+        # ALEPH_TRI_PAD_FIX=1 (opt-in, 2026-08-09 audit): trigram shift
+        # padding used byte 0 — a LEGAL byte (discovery #16: hard-zero
+        # padding starves/conflates). Fix = dedicated pad row 256.
+        self.pad_fix = os.environ.get("ALEPH_TRI_PAD_FIX") == "1"
+        pv = VOCAB + 1 if (self.trigram and self.pad_fix) else VOCAB
+        self.emb = nn.Embedding(VOCAB, d)
+        if self.trigram:
+            self.emb1 = nn.Embedding(pv, d)
+            self.emb2 = nn.Embedding(pv, 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 canon 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
+            pv = VOCAB if self.pad_fix else 0
+            x = x + self.emb1(F.pad(idx, (1, 0), value=pv)[:, :-1]) \
+                  + self.emb2(F.pad(idx, (2, 0), value=pv)[:, :-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()

trainers/geolip_vitals.py

@@ -0,0 +1,219 @@
+"""geolip_vitals.py — the shared diagnostic harness (progression plan Tree 7a).
+One implementation, every tree imports it. ALL functions are READOUTS: no gradients,
+no losses. CV is a readout, never a force (discovery_catalog #3). Judge addressing by
+drift->0.29154 and CV->0.20, never recon cosine (MANIFEST).
+
+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 (MANIFEST)
+CV_BAND = (0.13, 0.30)       # CM CV band (discovery_catalog #4)
+GATE_BAND = (0.012, 0.03)    # live invariant candidate (acd_campaign)
+KNUTH32 = 2654435761
+
+
+# ----------------------------------------------------------------------------- drift
+@torch.no_grad()
+def anchor_drift(current: torch.Tensor, init: torch.Tensor, tol: float = 0.05) -> dict:
+    """Geodesic drift (radians) of each row of `current` from its row in `init`,
+    both row-normalized. Returns mean/std/per-row drift and the fraction of rows
+    within +/-tol of BINDING (the GLFM '46%' readout)."""
+    a = torch.nn.functional.normalize(current.float(), dim=-1)
+    b = torch.nn.functional.normalize(init.float(), dim=-1)
+    cos = (a * b).sum(-1).clamp(-1.0, 1.0)
+    drift = torch.arccos(cos)
+    frac = ((drift - BINDING).abs() <= tol).float().mean()
+    return {"mean": drift.mean().item(), "std": drift.std().item(),
+            "per_row": drift, "binding_fraction": frac.item()}
+
+
+# -------------------------------------------------------------------------------- cv
+@torch.no_grad()
+def _pentachoron_volumes(pts: torch.Tensor) -> torch.Tensor:
+    """Batched Cayley-Menger 4-simplex volumes. pts: (B, 5, D) -> (B,) volumes.
+    One float64 det over all samples (vol^2 = -det(CM)/9216 for n=4). Built-in
+    per the 2026-07-11 rider amendment (AbstractPhil: the installed geovocab2 path is a
+    per-sample class call — too slow for a vitals loop); geovocab2 stays the
+    reference implementation, parity-checked via cv_reference_check()."""
+    B = pts.shape[0]
+    d2 = torch.cdist(pts.double(), pts.double()).pow(2)          # (B,5,5)
+    cm = torch.ones(B, 6, 6, dtype=torch.float64, device=pts.device)
+    cm[:, 0, 0] = 0.0
+    cm[:, 1:, 1:] = d2
+    det = torch.linalg.det(cm)
+    return (-det / 9216.0).clamp_min(0.0).sqrt().float()
+
+
+@torch.no_grad()
+def pentachoron_cv(rows: torch.Tensor, n_samples: int = 200,
+                   generator: torch.Generator | None = None) -> float:
+    """CV (std/mean) of Cayley-Menger 4-simplex volumes over n_samples random
+    5-row subsets. Rows are row-normalized before measurement. Uses the built-in
+    batched CM (float64 det); validate against geovocab2 with
+    cv_reference_check() after any change to the volume math."""
+    x = torch.nn.functional.normalize(rows.float(), dim=-1)
+    n = x.shape[0]
+    if n < 5:
+        raise ValueError(f"pentachoron_cv needs >=5 rows, got {n}")
+    g = generator or torch.Generator(device="cpu").manual_seed(0)
+    idx = torch.stack([torch.randperm(n, generator=g)[:5]
+                       for _ in range(n_samples)])               # (B,5)
+    v = _pentachoron_volumes(x[idx].cpu())
+    return (v.std() / v.mean().clamp_min(1e-12)).item()
+
+
+@torch.no_grad()
+def cv_reference_check(n_trials: int = 50, tol: float = 1e-5) -> float:
+    """Parity check of the built-in batched CM against geovocab2's reference
+    implementation (the formula's source of truth). Returns max |rel diff|;
+    raises if geovocab2 is absent or parity fails. Run after touching
+    _pentachoron_volumes."""
+    try:
+        from geovocab2.shapes.formula.symbolic.cayley_menger import (
+            CayleyMengerFromSimplex)
+    except Exception as e:  # pragma: no cover
+        raise ImportError(
+            "cv_reference_check requires geovocab2 (install via the geolip-svae "
+            "umbrella: pip install git+https://github.com/AbstractEyes/"
+            "geolip-svae).") from e
+    ref = CayleyMengerFromSimplex()
+    g = torch.Generator().manual_seed(0)
+    pts = torch.nn.functional.normalize(
+        torch.randn(n_trials, 5, 4, generator=g), dim=-1)
+    mine = _pentachoron_volumes(pts)
+    # compare at float64: the reference computes in the INPUT dtype, and fp32
+    # dets lose up to ~4% on near-degenerate pentachora (measured 2026-07-11)
+    theirs = torch.stack([ref.forward(p.double())["volume"].float() for p in pts])
+    rel = ((mine - theirs).abs() / theirs.abs().clamp_min(1e-12)).max().item()
+    if rel > tol:
+        raise AssertionError(f"CM parity vs geovocab2 failed: max rel {rel}")
+    return rel
+
+
+# ------------------------------------------------------------------------- aliveness
+@torch.no_grad()
+def axis_aliveness(oriented_weights: torch.Tensor, alive_thresh: float = 1e-3) -> dict:
+    """`oriented_weights`: (..., 2K) nonnegative oriented-softmax address rows
+    (sum to 1 on the last dim). Returns axes-alive count, mean-usage perplexity
+    (hppl analogue; healthy hosted reference 125-126/128), and a collapse flag.
+    Reference behavior: near-uniform aliveness at div_weight=0 (discovery #22)."""
+    w = oriented_weights.reshape(-1, oriented_weights.shape[-1]).float()
+    usage = w.mean(0)
+    usage = usage / usage.sum().clamp_min(1e-12)
+    # an axis is alive if its mean usage exceeds alive_thresh x the uniform share
+    alive = int((usage > alive_thresh * (1.0 / usage.numel())).sum())
+    ent = -(usage.clamp_min(1e-12) * usage.clamp_min(1e-12).log()).sum()
+    ppl = float(ent.exp())
+    return {"axes_total": usage.numel(), "axes_alive": alive, "usage_ppl": ppl,
+            "collapsed": ppl < 0.05 * usage.numel()}
+
+
+# ------------------------------------------------------------------------------ gates
+@torch.no_grad()
+def gate_stats(gates: torch.Tensor) -> dict:
+    """Gate values (post-sigmoid/clamp). Reports mean and whether it sits in the
+    0.012-0.03 band (read-only — the band is a candidate invariant, never a target)."""
+    g = gates.float().flatten()
+    m = g.mean().item()
+    return {"mean": m, "std": g.std().item(),
+            "in_band": GATE_BAND[0] <= m <= GATE_BAND[1]}
+
+
+# ------------------------------------------------------------------------------ paths
+@torch.no_grad()
+def path_diversity(ids: torch.Tensor) -> dict:
+    """Unique-path counting with the FIXED multiplicative hash:
+    ((ids * 2654435761) % 2^32) >> 16 — Knuth needs the HIGH bits; the low-16
+    variant produced the retracted ~1,500 path ceiling (sessions/2026-07-07).
+    `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 (canon/fibonacci_systems.md)."""
+    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)")

trainers/splat_math_battery.py

@@ -0,0 +1,644 @@
+# =========================================================================
+# splat_math_battery.py — B1-B6: the multi-aleph / splat hypothesis math
+# =========================================================================
+# Plan: history/plans/2026-08-06_splat_aleph_program.md (Rorschach
+# correction + battery authorization). AbstractPhil: "test the hypothesis states
+# for the mathematics before we structure the next attention mechanism."
+#
+# Every experiment uses AlephAddress VERBATIM (refine-don't-rewrite).
+# All synthetic, seeded, local-GPU, minutes-per-arm. No attention
+# mechanism anywhere in this file — measurement only.
+#
+#  B1 capacity     single-aleph capacity curves: K x D x tau x data-family
+#                  -> usage ppl, realized sign-codes, aliasing, m_hat
+#                  reconstruction, capacity per half-axis
+#  B2 product      M differentiated frames vs 1 monolith at EQUAL total
+#                  half-axes: joint code diversity, joint readback,
+#                  pairwise redundancy (the product-code hypothesis)
+#  B3 dynamics     does init-differentiation PERSIST under shared-task
+#                  training with NO diversity pressure? (basin-set-at-
+#                  init, multi-aleph edition; copies arm = collapse ctrl)
+#  B4 opinion      composition gating: uniform vs SELF-confidence (non-
+#                  comparative) vs softmax-over-alephs (LABELED
+#                  falsification control) vs oracle, on data built so
+#                  perspectives hold real differential advantage
+#  B5 blackboard   associative-recall capacity of write/read through the
+#                  codebook: P_max(K) at recall cos>=.7, single vs
+#                  M-differentiated; crosstalk spectra — the sizing
+#                  number for any future splat-attention head
+#  B6 boundary     positional splat supports: overlap ratio vs max solid
+#                  relay distance on long chains; tiling (zero overlap)
+#                  as the control that must reproduce the deep-line
+#                  tile-edge deadness
+#
+# RUN:  python tools\splat_math_battery.py            (all arms)
+#       ALEPH_SPLAT_ARM=B1..B6 for one; ALEPH_SPLAT_QUICK=1 smoke sizes
+# Ships splat_battery_<arm>.json to AbstractPhil/aleph-splat-0 (private).
+# =========================================================================
+
+import importlib
+import json
+import math
+import os
+import sys
+import time
+import zlib
+
+import numpy as np
+import torch
+import torch.nn.functional as F
+
+
+def _load(name):
+    if name in sys.modules:
+        return sys.modules[name]
+    try:
+        return importlib.import_module(name)
+    except ImportError:
+        here = globals().get("__file__")
+        if here is not None:
+            import pathlib
+            sys.path.insert(0, str(pathlib.Path(here).parent))
+            return importlib.import_module(name)
+        raise
+
+
+for _s in (sys.stdout, sys.stderr):
+    if hasattr(_s, "reconfigure"):
+        _s.reconfigure(encoding="utf-8", errors="replace")
+
+adb = _load("ar_differentiation_bed")
+AlephAddress = adb.AlephAddress
+
+DEV = "cuda" if torch.cuda.is_available() else "cpu"
+QUICK = os.environ.get("ALEPH_SPLAT_QUICK") == "1"
+ARM = os.environ.get("ALEPH_SPLAT_ARM", "ALL").upper()
+OUT_DIR = os.environ.get("ALEPH_SPLAT_OUT", "./data/aleph_splat"
+                         if os.name == "nt" else "./aleph_splat")
+HUB = os.environ.get("ALEPH_SPLAT_REPO", "AbstractPhil/aleph-splat-0")
+N = 20_000 if QUICK else 200_000
+SEED0 = zlib.crc32(b"aleph-splat-0") % (2 ** 31)
+
+
+def line(t=""):
+    print("-" * 78 if not t else f"-- {t} " + "-" * max(0, 74 - len(t)))
+
+
+def gen(family, n, D, seed, c_clusters=32, r_lowrank=None, ar=0.98):
+    """Synthetic unit-vector families. All seeded, all on DEV."""
+    g = torch.Generator(device="cpu").manual_seed(seed)
+    if family == "iso":
+        x = torch.randn(n, D, generator=g)
+    elif family == "clust":
+        cents = F.normalize(torch.randn(c_clusters, D, generator=g), dim=-1)
+        idx = torch.randint(0, c_clusters, (n,), generator=g)
+        x = cents[idx] + 0.25 * torch.randn(n, D, generator=g)
+    elif family == "lowrank":
+        r = r_lowrank or max(2, D // 4)
+        basis = torch.linalg.qr(torch.randn(D, r, generator=g))[0]
+        x = torch.randn(n, r, generator=g) @ basis.T
+    elif family == "seq":
+        steps = F.normalize(torch.randn(n, D, generator=g), dim=-1)
+        x = torch.empty(n, D)
+        x[0] = steps[0]
+        for i in range(1, n):
+            x[i] = ar * x[i - 1] + math.sqrt(1 - ar * ar) * steps[i]
+    else:
+        raise ValueError(family)
+    return F.normalize(x, dim=-1).to(DEV)
+
+
+@torch.no_grad()
+def read_stats(addr, x, pair_sample=4096):
+    """Single-aleph gauges: usage, realized codes, aliasing, recon."""
+    u = (F.normalize(x, dim=-1) @ F.normalize(addr.codebook, dim=-1).T) / addr.tau
+    p, nneg = addr.oriented(x)
+    two_k = torch.cat([p, nneg], dim=-1)
+    win = two_k.argmax(dim=-1)
+    hist = torch.bincount(win, minlength=2 * addr.K).float()
+    ppl = float(torch.exp(-(hist / hist.sum() * (hist / hist.sum() + 1e-12)
+                            .log()).sum()))
+    signs = (u > 0)
+    # realized full sign-codes via hashing
+    weights = (2 ** torch.arange(min(addr.K, 62), device=DEV))
+    code = (signs[:, :len(weights)].long() * weights).sum(-1)
+    n_codes = int(torch.unique(code).numel())
+    # aliasing: same full code -> how similar are inputs really?
+    order = torch.argsort(code)
+    cs, xs = code[order], x[order]
+    same = cs[1:] == cs[:-1]
+    if int(same.sum()) > 8:
+        i = torch.nonzero(same).squeeze(-1)
+        if i.numel() > pair_sample:
+            i = i[torch.randperm(i.numel(), device=DEV)[:pair_sample]]
+        alias_cos = float((xs[i] * xs[i + 1]).sum(-1).mean())
+    else:
+        alias_cos = float("nan")
+    m = addr.m_hat(x)
+    recon = float(F.cosine_similarity(m, x, dim=-1).mean())
+    win_cos = float((u.abs().amax(dim=-1) * addr.tau).mean())
+    return {"usage_ppl": round(ppl, 2), "n_codes": n_codes,
+            "codes_per_halfaxis_bits": round(math.log2(max(n_codes, 1))
+                                             / (2 * addr.K), 4),
+            "alias_within_code_cos": round(alias_cos, 4)
+            if alias_cos == alias_cos else None,
+            "mhat_recon_cos": round(recon, 4),
+            "win_cos_mean": round(win_cos, 4)}
+
+
+def b1_capacity():
+    line("B1 CAPACITY — single-aleph curves")
+    Ks = [4, 8, 16, 32, 64] if QUICK else [4, 8, 16, 32, 64, 128]
+    Ds = [8, 32] if QUICK else [4, 8, 16, 32, 64]
+    taus = [0.1] if QUICK else [0.05, 0.1, 0.2]
+    fams = ["iso", "clust", "lowrank"]
+    rows = []
+    for D in Ds:
+        for fam in fams:
+            x = gen(fam, N, D, SEED0 + D)
+            for K in Ks:
+                for tau in taus:
+                    torch.manual_seed(SEED0 + K * 7 + D)
+                    a = AlephAddress(K, D, tau=tau).to(DEV)
+                    r = read_stats(a, x)
+                    r.update({"K": K, "D": D, "tau": tau, "family": fam})
+                    rows.append(r)
+        print(f"   D={D} done ({len(rows)} rows)")
+    return {"rows": rows, "n": N}
+
+
+def _joint_stats(alephs, x):
+    """Multi-aleph joint gauges."""
+    wins, reads = [], []
+    with torch.no_grad():
+        for a in alephs:
+            p, nneg = a.oriented(x)
+            wins.append(torch.cat([p, nneg], -1).argmax(-1))
+            reads.append(a.m_hat(x))
+    joint = wins[0].clone()
+    base = 1
+    for w in wins[1:]:
+        base *= 2 * alephs[0].K + 1
+        joint = joint * (2 * alephs[0].K) + w
+    n_joint = int(torch.unique(joint).numel())
+    # pairwise redundancy: normalized mutual information of winner streams
+    def nmi(a_, b_):
+        K2 = 2 * alephs[0].K
+        jointc = torch.bincount(a_ * K2 + b_, minlength=K2 * K2).float()
+        pj = jointc / jointc.sum()
+        pa = pj.reshape(K2, K2).sum(1)
+        pb = pj.reshape(K2, K2).sum(0)
+        eps = 1e-12
+        mi = (pj * (pj + eps).log()).sum() - (pa * (pa + eps).log()).sum() \
+            - (pb * (pb + eps).log()).sum()
+        ha = -(pa * (pa + eps).log()).sum()
+        hb = -(pb * (pb + eps).log()).sum()
+        return float(mi / max(float(torch.minimum(ha, hb)), 1e-9))
+    nmis = [nmi(wins[i], wins[j]) for i in range(len(wins))
+            for j in range(i + 1, len(wins))]
+    # joint readback: least-squares x_hat from concatenated m_hats
+    R = torch.cat(reads, dim=-1)
+    sol = torch.linalg.lstsq(R, x).solution
+    recon = float(F.cosine_similarity(R @ sol, x, dim=-1).mean())
+    return {"n_joint_codes": n_joint,
+            "mean_pairwise_nmi": round(float(np.mean(nmis)), 4) if nmis else None,
+            "joint_readback_cos": round(recon, 4)}
+
+
+def _make_family(mode, M, K, D, seed):
+    """Init families for M perspectives."""
+    torch.manual_seed(seed)
+    alephs = []
+    if mode == "copies":
+        base = AlephAddress(K, D).to(DEV)
+        for _ in range(M):
+            a = AlephAddress(K, D).to(DEV)
+            a.codebook.data.copy_(base.codebook.data)
+            a.home.copy_(base.codebook.data)
+            alephs.append(a)
+    elif mode == "rotated":
+        base = AlephAddress(K, D).to(DEV)
+        for m in range(M):
+            a = AlephAddress(K, D).to(DEV)
+            Q = torch.linalg.qr(torch.randn(D, D, device=DEV))[0]
+            a.codebook.data.copy_(F.normalize(base.codebook.data @ Q, dim=-1))
+            a.home.copy_(a.codebook.data)
+            alephs.append(a)
+    else:  # independent
+        for m in range(M):
+            torch.manual_seed(seed + 977 * m)
+            alephs.append(AlephAddress(K, D).to(DEV))
+    return alephs
+
+
+def b2_product():
+    line("B2 PRODUCT CODE — M differentiated frames at equal half-axes")
+    D = 32
+    budget = 64                      # total K across alephs
+    splits = [(1, 64), (2, 32), (4, 16), (8, 8), (16, 4)]
+    fams = ["iso", "clust", "lowrank"]
+    rows = []
+    for fam in fams:
+        x = gen(fam, N, D, SEED0 + 11)
+        for M, K in splits:
+            for mode in ("independent", "rotated", "copies"):
+                alephs = _make_family(mode, M, K, D, SEED0 + M * 13 + K)
+                r = _joint_stats(alephs, x)
+                r.update({"M": M, "K": K, "mode": mode, "family": fam,
+                          "bits_per_halfaxis": round(
+                              math.log2(max(r["n_joint_codes"], 1))
+                              / (2 * budget), 4)})
+                rows.append(r)
+        print(f"   family={fam} done")
+    return {"rows": rows, "budget_halfaxes": 2 * budget, "n": N}
+
+
+def b3_dynamics():
+    line("B3 DIFFERENTIATION DYNAMICS — does distinctness persist?")
+    M, K, D, steps = 4, 16, 32, (300 if QUICK else 2000)
+    fams = {"clust": gen("clust", 50_000, D, SEED0 + 21)}
+    rows = []
+    for mode in ("independent", "copies"):
+        alephs = _make_family(mode, M, K, D, SEED0 + 31)
+        if mode == "copies":     # tiny symmetric-break noise, realistic init
+            for a in alephs:
+                a.codebook.data.add_(0.01 * torch.randn_like(a.codebook))
+        params = [a.codebook for a in alephs]
+        for p in params:
+            p.requires_grad_(True)
+        opt = torch.optim.Adam(params, lr=1e-3)     # pure Adam, house law
+        x = fams["clust"]
+        traj = []
+        def pdist():
+            ds = []
+            for i in range(M):
+                for j in range(i + 1, M):
+                    A = F.normalize(alephs[i].codebook.detach(), dim=-1)
+                    B = F.normalize(alephs[j].codebook.detach(), dim=-1)
+                    Q = torch.linalg.qr(torch.randn(D, D, device=DEV))[0] * 0
+                    # Procrustes-aligned distance
+                    U, _, Vt = torch.linalg.svd(B.T @ A)
+                    R = U @ Vt
+                    ds.append(float(1 - (F.normalize(B @ R, dim=-1)
+                                         * A).sum(-1).mean()))
+            return float(np.mean(ds))
+        for s in range(steps):
+            i = torch.randint(0, x.shape[0], (4096,), device=DEV)
+            xb = x[i]
+            read = sum(a.m_hat(xb) for a in alephs) / M
+            loss = (1 - F.cosine_similarity(read, xb, dim=-1)).mean()
+            opt.zero_grad()
+            loss.backward()
+            opt.step()
+            if s % max(1, steps // 10) == 0:
+                traj.append({"step": s, "loss": round(float(loss), 4),
+                             "pairwise_pdist": round(pdist(), 4)})
+        r_final = _joint_stats(alephs, x)
+        rows.append({"mode": mode, "traj": traj, "final": r_final,
+                     "final_pdist": round(pdist(), 4)})
+        print(f"   mode={mode}: final pdist {rows[-1]['final_pdist']}")
+    return {"rows": rows, "M": M, "K": K, "D": D, "steps": steps}
+
+
+def b4_opinion():
+    line("B4 OPINION GATING — self-confidence vs softmax (falsification)")
+    M, K, D = 4, 16, 32
+    torch.manual_seed(SEED0 + 41)
+    alephs = _make_family("independent", M, K, D, SEED0 + 41)
+    # data with REAL perspective advantage: cluster c is built FROM frame c
+    n_per = (N // 4) // M * M
+    xs, owner = [], []
+    for m, a in enumerate(alephs):
+        cents = F.normalize(a.codebook.detach(), dim=-1)
+        idx = torch.randint(0, K, (n_per // M,), device=DEV)
+        xs.append(F.normalize(cents[idx] + 0.35 * torch.randn(
+            n_per // M, D, device=DEV), dim=-1))
+        owner.append(torch.full((n_per // M,), m, device=DEV))
+    x = torch.cat(xs)
+    owner = torch.cat(owner)
+    with torch.no_grad():
+        reads = [a.m_hat(x) for a in alephs]
+        confs = [(F.normalize(x, dim=-1) @ F.normalize(
+            a.codebook, dim=-1).T).abs().amax(-1) for a in alephs]
+    C = torch.stack(confs, dim=-1)                     # (n, M)
+    def compose(gates):
+        R = sum(g.unsqueeze(-1) * r for g, r in zip(gates.unbind(-1), reads))
+        return float(F.cosine_similarity(R, x, dim=-1).mean())
+    results = {}
+    results["uniform"] = compose(torch.ones_like(C) / M)
+    results["self_confidence"] = compose(C / C.sum(-1, keepdim=True).clamp(min=1e-9))
+    results["softmax_comparative_CONTROL"] = compose(torch.softmax(C / 0.05, dim=-1))
+    oracle = F.one_hot(owner, M).float()
+    results["oracle"] = compose(oracle)
+    # accuracy of implied selection vs owner (diagnostic, not a selector)
+    results["self_conf_top1_matches_owner"] = float(
+        (C.argmax(-1) == owner).float().mean())
+    print(f"   {results}")
+    return {k: round(v, 4) for k, v in results.items()} | {"M": M, "K": K, "D": D}
+
+
+def b5_blackboard():
+    line("B5 BLACKBOARD — associative recall capacity through the address")
+    D = 32
+    Ks = [8, 16, 32, 64] if QUICK else [8, 16, 32, 64, 128]
+    Ps = [4, 8, 16, 32, 64, 128, 256, 512]
+    rows = []
+    for K in Ks:
+        torch.manual_seed(SEED0 + 51 + K)
+        single = AlephAddress(K, D).to(DEV)
+        multi = _make_family("independent", 4, max(K // 4, 2), D, SEED0 + 53 + K)
+        for tag, addrs in (("single", [single]), ("M4_product", multi)):
+            for P in Ps:
+                torch.manual_seed(SEED0 + P)
+                keys = F.normalize(torch.randn(P, D, device=DEV), dim=-1)
+                vals = F.normalize(torch.randn(P, D, device=DEV), dim=-1)
+                with torch.no_grad():
+                    w = torch.cat([a.signed(keys) for a in addrs], -1)  # (P, sumK)
+                    cells = w.T @ vals                                  # (sumK, D)
+                    q = F.normalize(keys + 0.05 * torch.randn_like(keys), dim=-1)
+                    wq = torch.cat([a.signed(q) for a in addrs], -1)
+                    out = wq @ cells
+                    rec = float(F.cosine_similarity(out, vals, dim=-1).mean())
+                rows.append({"K_total": sum(a.K for a in addrs), "form": tag,
+                             "P": P, "recall_cos": round(rec, 4)})
+        pmax_s = max([r["P"] for r in rows if r["form"] == "single"
+                      and r["K_total"] == K and r["recall_cos"] >= 0.7],
+                     default=0)
+        print(f"   K={K}: single P_max(cos>=.7) ~ {pmax_s}")
+    return {"rows": rows, "noise": 0.05, "D": D}
+
+
+def b6_boundary():
+    line("B6 BOUNDARY SOLIDITY — overlap ratio vs solid relay distance")
+    D, K, L = 32, 16, (512 if QUICK else 4096)
+    spacings = [64, 128, 256]
+    ratios = [0.0, 0.25, 0.5, 1.0, 2.0]      # sigma / spacing; 0 = tiling
+    torch.manual_seed(SEED0 + 61)
+    msg = F.normalize(torch.randn(D, device=DEV), dim=-1)
+    rows = []
+    for s in spacings:
+        centers = torch.arange(0, L, s, device=DEV).float()
+        for ratio in ratios:
+            sig = max(ratio * s, 1e-6)
+            pos = torch.arange(L, device=DEV).float()
+            if ratio == 0.0:   # hard tiling membership
+                gm = (pos.unsqueeze(0) - centers.unsqueeze(1)).abs() < (s / 2)
+                gm = gm.float()
+            else:
+                gm = torch.exp(-0.5 * ((pos.unsqueeze(0) - centers.unsqueeze(1))
+                                       / sig) ** 2)
+            gm = gm / gm.sum(0, keepdim=True).clamp(min=1e-9)   # local support
+            # relay: message injected at pos0 propagates via shared membership
+            # solidity(d) = sum_m g_m(0) g_m(d) / sqrt(sum g_m(0)^2 sum g_m(d)^2)
+            g0 = gm[:, 0]
+            sol = (gm.T @ g0) / (gm.norm(dim=0) * g0.norm()).clamp(min=1e-9)
+            # chained relay: two-hop through any intermediate position
+            Gn = gm / gm.norm(dim=0, keepdim=True).clamp(min=1e-9)
+            A1 = Gn.T @ Gn                     # position-position solidity
+            A2 = A1 @ A1 / A1.shape[0]
+            def maxd(v, thr=0.1):
+                idx = torch.nonzero(v > thr).squeeze(-1)
+                return int(idx.max()) if idx.numel() else 0
+            rows.append({"spacing": s, "overlap_ratio": ratio,
+                         "solid_1hop_maxd": maxd(sol),
+                         "solid_2hop_maxd": maxd(A2[0]),
+                         "edge_min_1hop": round(float(sol[:2 * s].min()), 4)})
+        print(f"   spacing={s} done")
+    return {"rows": rows, "L": L, "note": "ratio 0 = hard tiling control; "
+            "edge_min near 0 at ratio 0 must reproduce the deep-line "
+            "tile-edge deadness"}
+
+
+
+
+def b7_mscaling():
+    line("B7 M-SCALING — thousands of tiny heads vs data rank")
+    D, K = 64, 4
+    Ms = [16, 64, 256, 1024, 2048] if not QUICK else [16, 64, 256]
+    ranks = [8, 32, 64]              # 64 = full
+    n = 100_000 if not QUICK else 20_000
+    rows = []
+    for r in ranks:
+        x = gen("lowrank", n, D, SEED0 + 71 + r, r_lowrank=r)
+        n_tr = int(0.75 * x.shape[0])
+        for M in Ms:
+            alephs = _make_family("independent", M, K, D, SEED0 + 73 + M)
+            # HELD-OUT streaming linear probe: at large M the lstsq gauge
+            # both OOMs (100k x 65k fp32 = 26GB, measured crash) and
+            # degenerates (features > rows -> interpolation, trivial 1.0).
+            # Probe weights are O(M*K*D) only; reads computed per batch.
+            feat_dim = sum(a.K for a in alephs)
+            W = torch.zeros(feat_dim, D, device=DEV, requires_grad=True)
+            opt = torch.optim.Adam([W], lr=3e-3)
+            def reads_of(xb):
+                with torch.no_grad():
+                    return torch.cat([a.signed(xb) for a in alephs], -1)
+            for ep in range(3):
+                perm = torch.randperm(n_tr, device=DEV)
+                for i in range(0, n_tr, 8192):
+                    xb = x[perm[i:i + 8192]]
+                    pred = reads_of(xb) @ W
+                    loss = (1 - F.cosine_similarity(pred, xb, dim=-1)).mean()
+                    opt.zero_grad(); loss.backward(); opt.step()
+            with torch.no_grad():
+                rec_parts = []
+                for i in range(n_tr, x.shape[0], 8192):
+                    xb = x[i:i + 8192]
+                    rec_parts.append(F.cosine_similarity(
+                        reads_of(xb) @ W, xb, dim=-1))
+                rec = float(torch.cat(rec_parts).mean())
+                p1, n1 = alephs[0].oriented(x[:50000])
+                p2, n2 = alephs[1].oriented(x[:50000])
+                w1 = torch.cat([p1, n1], -1).argmax(-1)
+                w2 = torch.cat([p2, n2], -1).argmax(-1)
+            K2 = 2 * K
+            jc = torch.bincount(w1 * K2 + w2, minlength=K2 * K2).float()
+            pj = jc / jc.sum()
+            pa = pj.reshape(K2, K2).sum(1); pb = pj.reshape(K2, K2).sum(0)
+            eps = 1e-12
+            mi = float((pj * (pj + eps).log()).sum()
+                       - (pa * (pa + eps).log()).sum()
+                       - (pb * (pb + eps).log()).sum())
+            rows.append({"rank": r, "M": M, "half_axes": 2 * K * M,
+                         "readback_heldout": round(rec, 4),
+                         "pair_mi_nats": round(mi, 4)})
+            print(f"   rank={r} M={M}: readback {rec:.4f}")
+    return {"rows": rows, "K": K, "D": D, "n": n}
+
+
+def b8_headscale():
+    line("B8 HEAD-SCALE BLACKBOARD — context recall under splat sharding")
+    D, K = 64, 4
+    Ns = [2048, 8192] if not QUICK else [512]
+    configs = [("monolith", 1, 2048), ("M512", 512, None), ("M2048", 2048, None)]
+    rows = []
+    for N_ctx in Ns:
+        torch.manual_seed(SEED0 + 81 + N_ctx)
+        keys = F.normalize(torch.randn(N_ctx, D, device=DEV), dim=-1)
+        vals = F.normalize(torch.randn(N_ctx, D, device=DEV), dim=-1)
+        q = F.normalize(keys + 0.05 * torch.randn_like(keys), dim=-1)
+        for tag, M, Kmono in configs:
+            Ke = Kmono if Kmono else K
+            alephs = _make_family("independent", M, Ke, D, SEED0 + 83 + M)
+            t0 = time.time()
+            with torch.no_grad():
+                if M == 1:
+                    w = alephs[0].signed(keys); wq = alephs[0].signed(q)
+                    cells = w.T @ vals
+                    out = wq @ cells
+                else:
+                    # splat sharding: head m owns window centered at
+                    # m*N/M, width sigma = 1.5 * spacing (B6 band)
+                    pos = torch.arange(N_ctx, device=DEV).float()
+                    centers = torch.linspace(0, N_ctx, M, device=DEV)
+                    sig = 1.5 * (N_ctx / M)
+                    gm = torch.exp(-0.5 * ((pos.unsqueeze(0)
+                                            - centers.unsqueeze(1)) / sig) ** 2)
+                    gm = gm / gm.sum(0, keepdim=True).clamp(min=1e-9)
+                    out = torch.zeros_like(vals)
+                    for m, a in enumerate(alephs):
+                        g = gm[m].unsqueeze(-1)
+                        w = a.signed(keys) * g
+                        cells = w.T @ vals
+                        out = out + (a.signed(q) * g) @ cells
+                wall = time.time() - t0
+                rec = float(F.cosine_similarity(out, vals, dim=-1).mean())
+                # sharp-retrieval comparison: cosine top-1 accuracy
+                top1 = float((F.normalize(out, dim=-1) @ vals.T)
+                             .argmax(-1).eq(torch.arange(N_ctx, device=DEV))
+                             .float().mean())
+            rows.append({"N_ctx": N_ctx, "form": tag, "M": M,
+                         "cells_total": sum(a.K for a in alephs) * 2,
+                         "recall_cos": round(rec, 4),
+                         "top1_acc": round(top1, 4),
+                         "wall_s": round(wall, 3)})
+            print(f"   N={N_ctx} {tag}: recall {rec:.4f} top1 {top1:.4f} "
+                  f"({wall:.2f}s)")
+    return {"rows": rows, "note": "splat sharding keeps per-board load "
+            "~N/M*overlap; monolith board must hold all N"}
+
+
+
+
+def _rope(x, pos, base=10000.0):
+    """RoPE rotation applied to the ADDRESS QUERY: pairs (2i,2i+1) rotate
+    by pos*theta_i. Position enters the aleph through the addressing
+    itself — relative structure R(i-j) in every write/read affinity."""
+    D = x.shape[-1]
+    half = D // 2
+    freqs = base ** (-torch.arange(half, device=x.device,
+                                   dtype=torch.float32) / half)
+    ang = pos.unsqueeze(-1) * freqs                    # (..., half)
+    c, sn = torch.cos(ang), torch.sin(ang)
+    x1, x2 = x[..., :half], x[..., half:]
+    return torch.cat([x1 * c - x2 * sn, x1 * sn + x2 * c], dim=-1)
+
+
+def b9_rotary():
+    line("B9 CODEBOOK ROTARY — position in the address, accuracy probe")
+    D, K, M = 64, 8, 16
+    torch.manual_seed(SEED0 + 91)
+    alephs = _make_family("independent", M, K, D, SEED0 + 91)
+    def addr(x, pos):
+        xr = F.normalize(_rope(F.normalize(x, dim=-1), pos), dim=-1)
+        return torch.cat([a.signed(xr) for a in alephs], -1)
+    out = {}
+    # (a) relative-offset structure: same content, positions 0..256 —
+    # address cos vs delta (the interference curve; RoPE-like decay)
+    x0 = F.normalize(torch.randn(1, D, device=DEV), dim=-1).repeat(257, 1)
+    pos = torch.arange(257, device=DEV, dtype=torch.float32)
+    w = addr(x0, pos)
+    ref = w[0:1]
+    cosd = F.cosine_similarity(w, ref.expand_as(w), dim=-1)
+    out["addr_cos_vs_delta"] = {str(d): round(float(cosd[d]), 4)
+                                for d in (0, 1, 2, 4, 8, 16, 32, 64,
+                                          128, 256)}
+    # (b) position discriminability: 1000 contents x 2 positions 32 apart
+    xc = F.normalize(torch.randn(1000, D, device=DEV), dim=-1)
+    wa = addr(xc, torch.full((1000,), 10.0, device=DEV))
+    wb = addr(xc, torch.full((1000,), 42.0, device=DEV))
+    out["same_content_dpos32_addr_cos"] = round(
+        float(F.cosine_similarity(wa, wb, dim=-1).mean()), 4)
+    # (c) recall under position shift: store P pairs at their positions,
+    # query same content at shifted positions
+    P = 64
+    keys = F.normalize(torch.randn(P, D, device=DEV), dim=-1)
+    vals = F.normalize(torch.randn(P, D, device=DEV), dim=-1)
+    kpos = torch.arange(P, device=DEV, dtype=torch.float32) * 4
+    wk = addr(keys, kpos)
+    cells = wk.T @ vals
+    rec_by_shift = {}
+    for shift in (0, 1, 2, 4, 8, 16, 64):
+        wq = addr(keys, kpos + shift)
+        got = wq @ cells
+        rec_by_shift[str(shift)] = round(float(
+            F.cosine_similarity(got, vals, dim=-1).mean()), 4)
+    out["recall_vs_pos_shift"] = rec_by_shift
+    # (d) TRANSPORT at short L — the collapse-fix test: token at pos 0
+    # reads content written at pos p, GLOBAL rotary heads (no windows)
+    L = 128
+    toks = F.normalize(torch.randn(L, D, device=DEV), dim=-1)
+    tpos = torch.arange(L, device=DEV, dtype=torch.float32)
+    wt = addr(toks, tpos)
+    cellsT = wt.T @ toks                     # every token written globally
+    probe_reads = wt @ cellsT                # each reads the shared board
+    self_rec = float(F.cosine_similarity(probe_reads, toks, dim=-1).mean())
+    # cross-read: query content of token j FROM position 0's frame
+    w0 = addr(toks, torch.zeros(L, device=DEV))
+    cross = w0 @ cellsT
+    cross_rec = float(F.cosine_similarity(cross, toks, dim=-1).mean())
+    out["shortL_transport"] = {"self_recall": round(self_rec, 4),
+                               "cross_pos0_recall": round(cross_rec, 4),
+                               "note": "cross>0.3 = content reachable "
+                               "across positions (the a4 collapse cure)"}
+    # (e) sign-code stability under rotation
+    win = (F.normalize(_rope(F.normalize(xc, dim=-1),
+                             torch.full((1000,), 100.0, device=DEV)),
+                       dim=-1) @ F.normalize(alephs[0].codebook,
+                                             dim=-1).T).abs().amax(-1)
+    out["win_cos_after_rotation"] = round(float(win.mean()), 4)
+    print(f"   {json.dumps(out, indent=1)[:600]}")
+    return out
+
+
+def ship(results):
+    os.makedirs(OUT_DIR, exist_ok=True)
+    tag = "" if ARM == "ALL" else f"_{ARM}"
+    path = f"{OUT_DIR}/splat_battery{tag}.json"
+    json.dump(results, open(path, "w"), indent=1)
+    print(f"\n   wrote {path}")
+    tok = os.environ.get("HF_TOKEN")
+    if tok:
+        try:
+            from huggingface_hub import HfApi, create_repo
+            create_repo(HUB, token=tok, exist_ok=True, private=True)
+            HfApi(token=tok).upload_file(
+                path_or_fileobj=path, path_in_repo=f"battery/splat_battery{tag}.json",
+                repo_id=HUB, commit_message="B1-B6 math battery")
+            print(f"   shipped -> {HUB}/battery/")
+        except Exception as e:
+            print(f"   ship failed: {str(e)[:80]} (local copy kept)")
+
+
+def main():
+    print("=" * 78)
+    print(f"SPLAT MATH BATTERY — arm={ARM} quick={QUICK} dev={DEV} N={N}")
+    print("=" * 78)
+    t0 = time.time()
+    arms = {"B1": b1_capacity, "B2": b2_product, "B3": b3_dynamics,
+            "B4": b4_opinion, "B5": b5_blackboard, "B6": b6_boundary,
+            "B7": b7_mscaling, "B8": b8_headscale, "B9": b9_rotary}
+    todo = arms if ARM == "ALL" else {ARM: arms[ARM]}
+    results = {"config": {"quick": QUICK, "N": N, "seed": SEED0,
+                          "device": DEV}}
+    for k, fn in todo.items():
+        t = time.time()
+        results[k] = fn()
+        results[k]["wall_s"] = round(time.time() - t, 1)
+    print(f"\nTOTAL {time.time()-t0:.0f}s")
+    ship(results)
+    return results
+
+
+if __name__ == "__main__" or "get_ipython" in globals():
+    RESULTS = main()

trainers/trigram_bitspace_sweep.py

@@ -0,0 +1,194 @@
+# =========================================================================
+# trigram_bitspace_sweep.py — AbstractPhil's unverified hypothesis (2026-08-09):
+# "the bytemaps were forming inherently bit linked positioning causing
+# byte differentiated pooled accumulation rather than using the mechanism
+# ... the overlap bytes were causing anchored learning ... and in the
+# process the accumulation formed the very alephs we've been studying."
+#
+# THREE MEASURABLE CLAIMS, each with a shuffle null (CPU-only sweep):
+#  A) BIT-LINKAGE: byte-embedding cosine similarity correlates with byte
+#     BIT overlap (8 - Hamming). Null: byte-label shuffles (z-score).
+#  B) ALEPH EMERGENCE: the embedding table factors as a SIGN CODE over
+#     the 8 bit-planes — fraction of (centered) table variance explained
+#     by linear regression on the 8 bit sign-vectors (a bit-plane basis =
+#     an 8-half-axis codebook). Null: shuffled bit labels.
+#  C) POOLED ACCUMULATION vs MECHANISM: the three trigram tables converge
+#     toward one another (row-matched cosine + linear CKA). Pooled sum ->
+#     tables similar; positional mechanism -> differentiated.
+#  D) DATA-SIDE (current bed): V1b key bit-collision spectra per R_key —
+#     ties the overlap-space hypothesis to the measured mis-selections.
+# SPECIMENS: wikitext tri witness addr_mslh64_tri_s0_t2000.pt; unigram
+# sdpa_s0_t8000.pt comparator; fresh-init tri null. ASCII CONFOUND noted:
+# on wikitext, bit 0x20 IS the case bit — bit-structure is semantically
+# real in the data, which is itself part of AbstractPhil's "inherent" claim.
+# RUN: python tools\trigram_bitspace_sweep.py    (CPU, ~1 min)
+# =========================================================================
+
+import importlib
+import json
+import os
+import sys
+
+import torch
+import torch.nn.functional as F
+
+
+def _load(name):
+    if name in sys.modules:
+        return sys.modules[name]
+    try:
+        return importlib.import_module(name)
+    except ImportError:
+        here = globals().get("__file__")
+        if here is not None:
+            import pathlib
+            sys.path.insert(0, str(pathlib.Path(here).parent))
+            return importlib.import_module(name)
+        raise
+
+
+CKPT_DIR = "./data/ar_ckpts"
+OUT = "./data/v1_rank_army/trigram_bitspace_sweep.json"
+torch.manual_seed(0)
+
+BITS = torch.tensor([[(b >> i) & 1 for i in range(8)]
+                     for b in range(256)], dtype=torch.float64) * 2 - 1
+HAM = (BITS.unsqueeze(0) * BITS.unsqueeze(1)).sum(-1)   # (256,256) in [-8,8]
+OFF = ~torch.eye(256, dtype=torch.bool)
+
+
+def bit_linkage(W, n_null=500):
+    """A) corr(cos-sim, bit-overlap) + shuffle-null z."""
+    X = F.normalize(W.double(), dim=-1)
+    S = (X @ X.T)[OFF]
+    H = HAM[OFF]
+    r = float(torch.corrcoef(torch.stack([S, H]))[0, 1])
+    nulls = []
+    for _ in range(n_null):
+        p = torch.randperm(256)
+        nulls.append(float(torch.corrcoef(
+            torch.stack([S, HAM[p][:, p][OFF]]))[0, 1]))
+    nt = torch.tensor(nulls)
+    return {"r": round(r, 4),
+            "null_mean": round(float(nt.mean()), 4),
+            "z": round((r - float(nt.mean())) / max(float(nt.std()), 1e-9), 1)}
+
+
+def bitplane_variance(W, n_null=200):
+    """B) fraction of centered-table variance explained by the 8 bit
+    sign-vectors (linear regression, closed form)."""
+    Wc = W.double() - W.double().mean(0, keepdim=True)
+    B = BITS                                          # (256, 8)
+    coef = torch.linalg.lstsq(B, Wc).solution         # (8, d)
+    resid = Wc - B @ coef
+    ev = 1 - float((resid ** 2).sum() / (Wc ** 2).sum())
+    nulls = []
+    for _ in range(n_null):
+        Bp = BITS[torch.randperm(256)]
+        c = torch.linalg.lstsq(Bp, Wc).solution
+        nulls.append(1 - float(((Wc - Bp @ c) ** 2).sum()
+                               / (Wc ** 2).sum()))
+    nt = torch.tensor(nulls)
+    return {"explained_var": round(ev, 4),
+            "null_mean": round(float(nt.mean()), 4),
+            "z": round((ev - float(nt.mean())) / max(float(nt.std()), 1e-9),
+                       1)}
+
+
+def cka(A, B):
+    A = A.double() - A.double().mean(0, keepdim=True)
+    B = B.double() - B.double().mean(0, keepdim=True)
+    num = torch.norm(A.T @ B, "fro") ** 2
+    den = torch.norm(A.T @ A, "fro") * torch.norm(B.T @ B, "fro")
+    return round(float(num / den.clamp_min(1e-12)), 4)
+
+
+def pooled_vs_mechanism(sd):
+    """C) inter-table alignment for tri specimens."""
+    e0, e1, e2 = (sd["emb.weight"][:256], sd["emb1.weight"][:256],
+                  sd["emb2.weight"][:256])
+    rowcos = lambda A, B: round(float(F.cosine_similarity(
+        A.double(), B.double(), dim=-1).mean()), 4)
+    return {"rowcos_01": rowcos(e0, e1), "rowcos_02": rowcos(e0, e2),
+            "rowcos_12": rowcos(e1, e2),
+            "cka_01": cka(e0, e1), "cka_02": cka(e0, e2),
+            "cka_12": cka(e1, e2)}
+
+
+def analyze(name, sd):
+    out = {"specimen": name, "tables": {}}
+    for key in ("emb.weight", "emb1.weight", "emb2.weight"):
+        if key in sd:
+            W = sd[key][:256]
+            out["tables"][key] = {"bit_linkage": bit_linkage(W),
+                                  "bitplane": bitplane_variance(W)}
+    if "emb1.weight" in sd:
+        out["pooled_vs_mechanism"] = pooled_vs_mechanism(sd)
+    return out
+
+
+def keyspace_collisions():
+    """D) V1b key bit-collision spectra per R_key."""
+    v1b = _load("v1b_recall_army_battery")
+    res = {}
+    for R in (4, 16, 64):
+        sg = torch.Generator().manual_seed(40_000 + R)
+        U = torch.randn(16, R, generator=sg)
+        g = torch.Generator().manual_seed(99_000 + R)
+        z = torch.randn(4096, R, generator=g)
+        bits = ((z @ U.T) > 0).double() * 2 - 1        # (4096, 16)
+        ham16 = (bits @ bits.T)                        # agreement in [-16,16]
+        off = ~torch.eye(4096, dtype=torch.bool)
+        agree = (ham16[off] + 16) / 2                  # shared bits 0..16
+        res[f"R{R}"] = {
+            "mean_shared_bits": round(float(agree.mean()), 2),
+            "frac_ge14": round(float((agree >= 14).float().mean()), 5),
+            "frac_exact": round(float((agree >= 16).float().mean()), 6)}
+    return res
+
+
+def main():
+    print("=" * 74)
+    print("TRIGRAM BIT-SPACE SWEEP (CPU) — AbstractPhil's pooled-accumulation "
+          "hypothesis")
+    print("=" * 74)
+    results = {"claims": {}}
+    specs = []
+    p = os.path.join(CKPT_DIR, "addr_mslh64_tri_s0_t2000.pt")
+    if os.path.exists(p):
+        specs.append(("wikitext_tri_witness",
+                      torch.load(p, map_location="cpu",
+                                 weights_only=True)["state_dict"]))
+    p2 = os.path.join(CKPT_DIR, "sdpa_s0_t8000.pt")
+    if os.path.exists(p2):
+        specs.append(("wikitext_unigram_sdpa",
+                      torch.load(p2, map_location="cpu",
+                                 weights_only=True)["state_dict"]))
+    bed = _load("ar_differentiation_bed")
+    torch.manual_seed(0)
+    fresh = bed.ByteLM("sdpa_tri", block=256).state_dict()
+    specs.append(("fresh_init_null", fresh))
+    for name, sd in specs:
+        r = analyze(name, sd)
+        results[name] = r
+        print(f"\n== {name}")
+        for tk, tv in r["tables"].items():
+            print(f"  {tk}: bit-linkage r={tv['bit_linkage']['r']} "
+                  f"(z={tv['bit_linkage']['z']})  bitplane EV="
+                  f"{tv['bitplane']['explained_var']} "
+                  f"(null {tv['bitplane']['null_mean']}, "
+                  f"z={tv['bitplane']['z']})")
+        if "pooled_vs_mechanism" in r:
+            pm = r["pooled_vs_mechanism"]
+            print(f"  tables 0-1/0-2/1-2: rowcos {pm['rowcos_01']}/"
+                  f"{pm['rowcos_02']}/{pm['rowcos_12']}  CKA "
+                  f"{pm['cka_01']}/{pm['cka_02']}/{pm['cka_12']}")
+    results["keyspace_collisions"] = keyspace_collisions()
+    print("\n== V1b key bit-collision spectra:",
+          json.dumps(results["keyspace_collisions"]))
+    json.dump(results, open(OUT, "w"), indent=1)
+    print(f"\nsaved -> {OUT}")
+
+
+if __name__ == "__main__":
+    main()

trainers/v1_rank_army_battery.py

@@ -0,0 +1,241 @@
+# =========================================================================
+# v1_rank_army_battery.py — V1: rank-ladder x army-ladder under AR pressure
+# (plan 2026-08-08_data_shaped_army.md, validation V1 — THE arbiter for
+# Rule 1 "M = c*R"; overnight battery, AbstractPhil 2026-08-08: "set up a bunch of
+# small battery tests and feed them with synthetic data, run them on the
+# 4090 overnight").
+#
+# Question: does the army-size knee track the DATA'S latent rank under
+# causal/AR pressure, as B7 measured statically? Synthetic byte streams of
+# controlled rank R (hidden linear-dynamical state, emission logits confined
+# to an R-dim subspace) are fed to the AR bed's CausalHUB arm — the aleph
+# army under causal masks, army size = K oriented anchors (2K half-axes).
+#
+# GRID: R in {8, 32, 128} x K in {16, 64, 256} x seeds {0, 1} = 18 runs.
+# GAUGES: val bits-per-byte curve; final address census-lite (pos/neg mass
+# split, address erank). KNEE: smallest K within .01 bpb of that rank's
+# best. REGISTERED PREDICTION (Rule 1): knee(R=8) < knee(R=128); flat knee
+# across R demotes Rule 1 to static-battery scope.
+# HONESTY: matched steps and data, NOT matched FLOPs — HUB compute is
+# O(n*K*d), so K=256 spends ~16x K=16's attention FLOPs. The knee claim is
+# capability-vs-army-size at matched data; stated on every artifact.
+#
+# Resume-safe: per-run JSONs in OUT_DIR; existing runs skip. Ships each run
+# + the final knee table to AbstractPhil/aleph-splat-0 battery/v1_rank_army/.
+# RUN: python tools\v1_rank_army_battery.py   (HF_TOKEN in env; 4090)
+# Env: V1_STEPS (def 3000) V1_QUICK=1 (tiny smoke grid)
+# =========================================================================
+
+import importlib
+import json
+import math
+import os
+import sys
+
+import torch
+import torch.nn.functional as F
+
+
+def _load(name):
+    if name in sys.modules:
+        return sys.modules[name]
+    try:
+        return importlib.import_module(name)
+    except ImportError:
+        here = globals().get("__file__")
+        if here is not None:
+            import pathlib
+            sys.path.insert(0, str(pathlib.Path(here).parent))
+            return importlib.import_module(name)
+        raise
+
+
+bed = _load("ar_differentiation_bed")        # ByteLM + _batch + conventions
+class _cb:                          # public shim: token from env
+    @staticmethod
+    def hf_token():
+        import os as _os
+        return _os.environ.get("HF_TOKEN")
+cb = _cb()            # hf_token()
+
+from huggingface_hub import HfApi            # noqa: E402
+
+assert torch.cuda.is_available(), "GPU only (never CPU-train for accuracy)"
+DEV = "cuda"
+QUICK = os.environ.get("V1_QUICK") == "1"
+STEPS = int(os.environ.get("V1_STEPS", "200" if QUICK else "3000"))
+BATCH, BLOCK = 32, 256
+RANKS = [8, 32] if QUICK else [8, 32, 128]
+ARMIES = [16, 64] if QUICK else [16, 64, 256]
+SEEDS = [0] if QUICK else [0, 1]
+EVAL_EVERY = 100 if QUICK else 300
+DATA_DIR = os.environ.get("V1_DATA", "./data/v1_rank_army")
+OUT_DIR = os.path.join(DATA_DIR, "results")
+TRAIN_BYTES, VAL_BYTES = (400_000, 80_000) if QUICK else (2_000_000, 200_000)
+HUB_REPO = "AbstractPhil/aleph-splat-0"
+
+
+def make_stream(R, n_bytes, seed, device=DEV):
+    """Rank-R synthetic byte stream: hidden LDS state s (R-dim), emission
+    logits = W s confined to an R-dim subspace of R^256 by construction.
+    The model must FILTER the state from byte history — predictive
+    structure has latent rank exactly R. 64 parallel chains, concatenated."""
+    # STRUCTURAL seed depends on R only: train and val share the SAME
+    # system (A, W); the trajectory seed varies per split. (Smoke 2026-08-09
+    # caught the original bug: split-dependent A/W made val an unrelated
+    # stream — bpb pinned above uniform.)
+    sg = torch.Generator(device="cpu").manual_seed(10_000 + R)
+    A = torch.linalg.qr(torch.randn(R, R, generator=sg))[0] * 0.95
+    W = torch.randn(R, 256, generator=sg)
+    W = W / W.std() * 2.0                    # logit scale: peaked, not trivial
+    A, W = A.to(device), W.to(device)
+    chains = 64
+    steps = n_bytes // chains + 1
+    ig = torch.Generator().manual_seed(20_000 + R * 100 + seed)
+    s = torch.randn(chains, R, generator=ig).to(device)
+    gg = torch.Generator(device=device).manual_seed(30_000 + R * 100 + seed)
+    out = torch.empty(chains, steps, dtype=torch.uint8, device=device)
+    with torch.no_grad():
+        for t in range(steps):
+            probs = F.softmax(s @ W, dim=-1)
+            out[:, t] = torch.multinomial(probs, 1, generator=gg).squeeze(1)
+            s = torch.tanh(s @ A.T
+                           + 0.10 * torch.randn(chains, R, generator=gg,
+                                                device=device))
+    return out.reshape(-1)[:n_bytes].cpu()
+
+
+def get_streams(R):
+    os.makedirs(f"{DATA_DIR}/streams", exist_ok=True)
+    p = f"{DATA_DIR}/streams/R{R}_{TRAIN_BYTES}.pt"
+    if os.path.exists(p):
+        d = torch.load(p, weights_only=True)
+    else:
+        print(f"   generating rank-{R} stream ({TRAIN_BYTES:,}+{VAL_BYTES:,} bytes)",
+              flush=True)
+        d = {"train": make_stream(R, TRAIN_BYTES, seed=0),
+             "val": make_stream(R, VAL_BYTES, seed=1)}   # val = fresh chains
+        torch.save(d, p)
+    ent = -sum((c := torch.bincount(d['val'].long(), minlength=256).float()
+                / d['val'].numel())[c > 0]
+               * (c[c > 0]).log2()) if False else None   # (unigram, optional)
+    return d["train"], d["val"]
+
+
+def census_lite(model, va, g):
+    """Address census on one val batch: pos/neg half mass split + address
+    erank — the A1 instrument's AR-bed cousin."""
+    xv, _ = bed._batch(va, BATCH, BLOCK, DEV, g)
+    stats = []
+    with torch.no_grad():
+        x = model.emb(xv) + model.pos[:, : xv.shape[1]]
+        for blk in model.blocks:
+            h = blk.n1(x)
+            attn = blk.attn
+            qp, qn = attn.addr.oriented(attn.q(h))
+            mp, mn = float(qp.sum()), float(qn.sum())
+            flat = torch.cat([qp, qn], -1).reshape(-1, 2 * attn.addr.K)
+            sv = torch.linalg.svdvals(flat[:4096].float())
+            s2 = sv ** 2
+            stats.append({"neg_mass_frac": round(mn / (mp + mn + 1e-9), 4),
+                          "addr_erank": round(float(s2.sum() ** 2
+                                                    / (s2 ** 2).sum()), 2)})
+            x = blk(x)
+    return stats
+
+
+def run_cell(R, K, seed, tr, va):
+    tag = f"R{R}_K{K}_s{seed}"
+    out_p = f"{OUT_DIR}/{tag}.json"
+    if os.path.exists(out_p):
+        print(f"-- {tag}: exists, skip", flush=True)
+        return json.load(open(out_p))
+    torch.manual_seed(seed)
+    g = torch.Generator().manual_seed(seed)
+    model = bed.ByteLM("hub", block=BLOCK, K=K, D=4).to(DEV)
+    n_par = sum(p.numel() for p in model.parameters())
+    opt = torch.optim.Adam(model.parameters(), lr=3e-4, weight_decay=0.0)
+    curve = []
+    for step in range(1, STEPS + 1):
+        x, y = bed._batch(tr, BATCH, BLOCK, DEV, g)
+        loss = F.cross_entropy(model(x).reshape(-1, 256), 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():
+                ls = [F.cross_entropy(
+                    model(xv).reshape(-1, 256), yv.reshape(-1)).item()
+                    for xv, yv in (bed._batch(va, BATCH, BLOCK, DEV, g)
+                                   for _ in range(16))]
+            bpb = sum(ls) / len(ls) / math.log(2)
+            curve.append({"step": step, "val_bpb": round(bpb, 4)})
+            model.train()
+    model.eval()
+    res = {"R": R, "K": K, "seed": seed, "params": n_par,
+           "steps": STEPS, "batch": BATCH, "block": BLOCK,
+           "final_bpb": curve[-1]["val_bpb"], "curve": curve,
+           "census": census_lite(model, va, g),
+           "note": "matched steps+data, NOT matched FLOPs (HUB is O(nKd))"}
+    os.makedirs(OUT_DIR, exist_ok=True)
+    json.dump(res, open(out_p, "w"), indent=1)
+    print(f"-- {tag}: bpb {res['final_bpb']:.4f}  ({n_par:,} params)",
+          flush=True)
+    del model
+    torch.cuda.empty_cache()
+    return res
+
+
+def main():
+    print("=" * 78, flush=True)
+    print(f"V1 RANK x ARMY BATTERY — R{RANKS} x K{ARMIES} x s{SEEDS}, "
+          f"{STEPS} steps {'[QUICK]' if QUICK else ''}", flush=True)
+    print("=" * 78, flush=True)
+    api = HfApi(token=cb.hf_token())
+    results = []
+    for R in RANKS:
+        tr, va = get_streams(R)
+        for K in ARMIES:
+            for seed in SEEDS:
+                results.append(run_cell(R, K, seed, tr, va))
+                if not QUICK:
+                    tag = f"R{R}_K{K}_s{seed}"
+                    api.upload_file(
+                        path_or_fileobj=f"{OUT_DIR}/{tag}.json",
+                        path_in_repo=f"battery/v1_rank_army/{tag}.json",
+                        repo_id=HUB_REPO,
+                        commit_message=f"V1 cell {tag}")
+    # ---- knee analysis: smallest K within .01 bpb of the rank's best ----
+    verdict = {}
+    for R in RANKS:
+        by_k = {K: sum(r["final_bpb"] for r in results
+                       if r["R"] == R and r["K"] == K)
+                / len(SEEDS) for K in ARMIES}
+        best = min(by_k.values())
+        knee = min(K for K, b in by_k.items() if b <= best + 0.01)
+        verdict[R] = {"bpb_by_K": {str(k): round(v, 4)
+                                   for k, v in by_k.items()},
+                      "knee_K": knee}
+        print(f"R={R:>3}: " + "  ".join(f"K{k}={v:.4f}"
+                                        for k, v in by_k.items())
+              + f"  -> knee K={knee}", flush=True)
+    knees = [verdict[R]["knee_K"] for R in RANKS]
+    verdict["registered_prediction"] = (
+        "Rule 1 SUPPORTED (knee tracks rank)" if knees == sorted(knees)
+        and knees[0] < knees[-1] else
+        "Rule 1 NOT supported at this bed scale (knee flat or non-monotone)")
+    print("VERDICT:", verdict["registered_prediction"], flush=True)
+    out = f"{OUT_DIR}/v1_verdict.json"
+    json.dump(verdict, open(out, "w"), indent=1)
+    if not QUICK:
+        api.upload_file(path_or_fileobj=out,
+                        path_in_repo="battery/v1_rank_army/v1_verdict.json",
+                        repo_id=HUB_REPO,
+                        commit_message="V1 verdict: knee-vs-rank table "
+                        "(Rule 1 arbiter)")
+    print("DONE.", flush=True)
+
+
+if __name__ == "__main__":
+    main()

trainers/v1b_recall_army_battery.py

@@ -0,0 +1,323 @@
+# =========================================================================
+# v1b_recall_army_battery.py — V1b: ADDRESSING-DEMAND x army-ladder under AR
+# (overnight battery #2, 2026-08-09; the V1-LDS census showed filtering
+# demands ~no addressing — this battery applies the addressing-bound
+# pressure: in-context associative recall, B8's territory, key space
+# rank-controlled.)
+#
+# Episodes: P=8 (key 2 bytes, val 1 byte) pairs + SEP + query key -> the
+# model must emit the queried value at the answer position. Keys are sign
+# patterns of R_key-dim latents projected through 16 fixed directions —
+# key diversity (addressing demand) rises with R_key. Values fresh-random
+# per episode: binding is IN-CONTEXT, only the address machinery can do it.
+# Loss masked to ANSWER positions only.
+#
+# GRID: R_key {4,16,64} x K {16,64,256} x seeds {0,1} = 18 cells,
+# 2500 steps. GAUGES: answer accuracy + answer bpb + census-lite
+# (consumed addr erank = the demand gauge). REGISTERED PREDICTIONS:
+# (i) knee tracks R_key; (ii) consumed addr erank rises with R_key;
+# (iii) both => Rule 1 re-scoped to M = c * addressing-demand.
+# Same honesty stamp as V1: matched steps/data, NOT matched FLOPs.
+# RUN: python tools\v1b_recall_army_battery.py  (HF_TOKEN, 4090)
+# Env: V1B_STEPS (def 2500) V1B_QUICK=1
+# =========================================================================
+
+import importlib
+import json
+import math
+import os
+import sys
+
+import torch
+import torch.nn.functional as F
+
+
+def _load(name):
+    if name in sys.modules:
+        return sys.modules[name]
+    try:
+        return importlib.import_module(name)
+    except ImportError:
+        here = globals().get("__file__")
+        if here is not None:
+            import pathlib
+            sys.path.insert(0, str(pathlib.Path(here).parent))
+            return importlib.import_module(name)
+        raise
+
+
+bed = _load("ar_differentiation_bed")
+class _cb:                          # public shim: token from env
+    @staticmethod
+    def hf_token():
+        import os as _os
+        return _os.environ.get("HF_TOKEN")
+cb = _cb()
+from huggingface_hub import HfApi            # noqa: E402
+
+assert torch.cuda.is_available(), "GPU only"
+DEV = "cuda"
+QUICK = os.environ.get("V1B_QUICK") == "1"
+STEPS = int(os.environ.get("V1B_STEPS", "250" if QUICK else "8000"))
+# CONTROL FINDING (2026-08-09 pre-battery): on this task sdpa_tri reads
+# .9251 answer-acc at step 1500 while hub_tri reads .0561 — the harness is
+# sound and in-context BINDING is address-capacity-hard for the linear
+# aleph read (late-takeoff curve, the splat late-bloom signature). The
+# battery therefore runs hub long (8k steps) with an sdpa reference arm
+# per rank, and prediction (iii) becomes: K gates binding FORMATION.
+BATCH, BLOCK = 32, 256
+RKEYS = [4, 16] if QUICK else [4, 16, 64]
+ARMIES = [16, 64] if QUICK else [16, 64, 256]
+SEEDS = [0] if QUICK else [0, 1]
+EVAL_EVERY = 100 if QUICK else 250
+D_ADDR = int(os.environ.get("V1B_D", "4"))          # address dims (V1c axis)
+if os.environ.get("V1B_RKEYS"):
+    RKEYS = [int(x) for x in os.environ["V1B_RKEYS"].split(",")]
+if os.environ.get("V1B_ARMIES"):
+    ARMIES = [int(x) for x in os.environ["V1B_ARMIES"].split(",")]
+P = 8                                        # pairs per episode
+EPI = P * 3 + 3                              # 27 bytes: pairs + SEP + query(2)
+SEP = 255                                    # bytes 0..253 for keys/vals
+DATA_DIR = os.environ.get("V1B_DATA", "./data/v1_rank_army")
+OUT_DIR = os.path.join(DATA_DIR, "results_v1b")
+N_EPISODES = (3_000, 600) if QUICK else (60_000, 8_000)   # train, val
+HUB_REPO = "AbstractPhil/aleph-splat-0"
+
+
+def make_episodes(R, n_epi, seed):
+    """Concatenated recall episodes + answer-position mask.
+    Key = 2 bytes from sign bits of a fresh R-dim latent through 16 fixed
+    directions (structural, R-only seed); vals fresh-random per episode."""
+    sg = torch.Generator().manual_seed(40_000 + R)
+    U = torch.randn(16, R, generator=sg)                 # fixed directions
+    g = torch.Generator().manual_seed(50_000 + R * 100 + seed)
+    z = torch.randn(n_epi, P, R, generator=g)            # latents per pair
+    bits = (torch.einsum("epr,br->epb", z, U) > 0)       # (n_epi, P, 16)
+    w1 = (1 << torch.arange(8))
+    k1 = (bits[..., :8].long() * w1).sum(-1)             # 0..255
+    k2 = (bits[..., 8:].long() * w1).sum(-1)
+    k1, k2 = k1 % 254, k2 % 254                          # keep off SEP
+    vals = torch.randint(0, 254, (n_epi, P), generator=g)
+    qi = torch.randint(0, P, (n_epi,), generator=g)      # queried pair
+    seq = torch.zeros(n_epi, EPI, dtype=torch.uint8)
+    seq[:, 0:P * 3:3] = k1.to(torch.uint8)
+    seq[:, 1:P * 3:3] = k2.to(torch.uint8)
+    seq[:, 2:P * 3:3] = vals.to(torch.uint8)
+    seq[:, P * 3] = SEP
+    ar = torch.arange(n_epi)
+    seq[:, P * 3 + 1] = k1[ar, qi].to(torch.uint8)
+    seq[:, P * 3 + 2] = k2[ar, qi].to(torch.uint8)
+    answer = vals[ar, qi].to(torch.uint8)                # target AFTER query
+    # stream layout: [...episode..., answer] so predicting the byte at the
+    # answer slot from the preceding query is exactly next-byte loss there.
+    flat = torch.cat([seq, answer.unsqueeze(1)], dim=1).reshape(-1)
+    mask = torch.zeros_like(flat, dtype=torch.bool)
+    mask[(EPI + 1) * ar + EPI] = True                    # answer positions
+    return flat, mask
+
+
+def get_data(R):
+    os.makedirs(f"{DATA_DIR}/streams_v1b", exist_ok=True)
+    p = f"{DATA_DIR}/streams_v1b/R{R}_{N_EPISODES[0]}.pt"
+    if os.path.exists(p):
+        d = torch.load(p, weights_only=True)
+    else:
+        print(f"   generating R_key={R} episodes {N_EPISODES}", flush=True)
+        tr, trm = make_episodes(R, N_EPISODES[0], seed=0)
+        va, vam = make_episodes(R, N_EPISODES[1], seed=1)
+        d = {"tr": tr, "trm": trm, "va": va, "vam": vam}
+        torch.save(d, p)
+    return d
+
+
+def batch_masked(flat, mask, batch, block, device, g):
+    ix = torch.randint(0, flat.numel() - block - 1, (batch,), generator=g)
+    x = torch.stack([flat[i:i + block] for i in ix]).long().to(device)
+    y = torch.stack([flat[i + 1:i + block + 1] for i in ix]).long().to(device)
+    m = torch.stack([mask[i + 1:i + block + 1] for i in ix]).to(device)
+    if os.environ.get("V1B_CLEAN_MASK") == "1":
+        # 2026-08-10 corruption repair: drop answer positions whose episode
+        # is window-truncated (~6.05% unanswerable — 4x-weighted label
+        # noise otherwise; hunter-verified j>=26 = answerable frac 1.0000)
+        m[:, :26] = False
+    return x, y, m
+
+
+def masked_eval(model, d, g, iters=16):
+    accs, bits = [], []
+    with torch.no_grad():
+        for _ in range(iters):
+            xv, yv, mv = batch_masked(d["va"], d["vam"], BATCH, BLOCK, DEV, g)
+            if mv.sum() == 0:
+                continue
+            logits = model(xv)
+            la, ya = logits[mv], yv[mv]
+            bits.append(F.cross_entropy(la, ya).item() / math.log(2))
+            accs.append((la.argmax(-1) == ya).float().mean().item())
+    return (sum(accs) / len(accs), sum(bits) / len(bits)) if accs else (0.0, 8.0)
+
+
+def census_lite(model, d, g):
+    xv, _, _ = batch_masked(d["va"], d["vam"], BATCH, BLOCK, DEV, g)
+    stats = []
+    with torch.no_grad():
+        x = model.emb(xv)
+        if getattr(model, "trigram", False):   # 2026-08-09 audit fix: the
+            # census must see the SAME composed embedding the model runs
+            # on (was reading 1 of 3 tables — demand gauge underweighted)
+            pv = 256 if getattr(model, "pad_fix", False) else 0
+            x = x + model.emb1(F.pad(xv, (1, 0), value=pv)[:, :-1]) \
+                  + model.emb2(F.pad(xv, (2, 0), value=pv)[:, :-2])
+        x = x + model.pos[:, : xv.shape[1]]
+        for blk in model.blocks:
+            h = blk.n1(x)
+            attn = blk.attn
+            qp, qn = attn.addr.oriented(attn.q(h))
+            mp, mn = float(qp.sum()), float(qn.sum())
+            fl = torch.cat([qp, qn], -1).reshape(-1, 2 * attn.addr.K)
+            sv = torch.linalg.svdvals(fl[:4096].float())
+            s2 = sv ** 2
+            stats.append({"neg_mass_frac": round(mn / (mp + mn + 1e-9), 4),
+                          "addr_erank": round(float(s2.sum() ** 2
+                                                    / (s2 ** 2).sum()), 2)})
+            x = blk(x)
+    return stats
+
+
+def run_cell(R, K, seed, d):
+    tag = f"R{R}_K{K}_s{seed}" + (f"_D{D_ADDR}" if D_ADDR != 4 else "")
+    out_p = f"{OUT_DIR}/{tag}.json"
+    if os.path.exists(out_p):
+        print(f"-- {tag}: exists, skip", flush=True)
+        return json.load(open(out_p))
+    torch.manual_seed(seed)
+    g = torch.Generator().manual_seed(seed)
+    arm = "sdpa_tri" if K == 0 else "hub_tri"     # K=0 = the control arm
+    model = bed.ByteLM(arm, block=BLOCK, K=max(K, 4), D=D_ADDR).to(DEV)
+    opt = torch.optim.Adam(model.parameters(), lr=3e-4, weight_decay=0.0)
+    curve = []
+    for step in range(1, STEPS + 1):
+        x, y, m = batch_masked(d["tr"], d["trm"], BATCH, BLOCK, DEV, g)
+        logits = model(x)
+        if m.sum() == 0:
+            continue
+        # DENSE loss builds the sequence circuits (masked-only starves
+        # them — smoke 2026-08-09: chance acc, bpb>10); answers get 4x
+        # weight and remain the ONLY reported gauge.
+        loss = (F.cross_entropy(logits.reshape(-1, 256), y.reshape(-1))
+                + 4.0 * F.cross_entropy(logits[m], y[m]))
+        opt.zero_grad(set_to_none=True)
+        loss.backward()
+        opt.step()
+        if step % EVAL_EVERY == 0 or step == STEPS:
+            model.eval()
+            acc, bpb = masked_eval(model, d, g)
+            curve.append({"step": step, "ans_acc": round(acc, 4),
+                          "ans_bpb": round(bpb, 4)})
+            model.train()
+    model.eval()
+    acc, bpb = masked_eval(model, d, g, iters=32)
+    res = {"R_key": R, "K": K, "seed": seed, "steps": STEPS, "arm": arm,
+           "final_acc": round(acc, 4), "final_bpb": round(bpb, 4),
+           "curve": curve,
+           "census": census_lite(model, d, g) if K else None,
+           "note": "loss+gauges on answer positions only; matched steps, "
+                   "NOT matched FLOPs (HUB O(nKd))"}
+    os.makedirs(OUT_DIR, exist_ok=True)
+    json.dump(res, open(out_p, "w"), indent=1)
+    print(f"-- {tag}: acc {acc:.4f}  bpb {bpb:.4f}", flush=True)
+    del model
+    torch.cuda.empty_cache()
+    return res
+
+
+@torch.no_grad()
+def selection_eval(model, d, g, iters=32):
+    """Error decomposition (AbstractPhil lineage 2026-08-09): of WRONG answers, the
+    fraction that are OTHER IN-CONTEXT VALUES (mis-selection = retrieved
+    the wrong pair — the 'incorrect selections' fault class) vs bytes from
+    outside the episode's value set (no-retrieval). Only full-episode
+    windows (mask index >= 26) are scored."""
+    n_right = n_missel = n_noret = 0
+    for _ in range(iters):
+        xv, yv, mv = batch_masked(d["va"], d["vam"], BATCH, BLOCK, DEV, g)
+        pred = model(xv).argmax(-1)
+        for b, j in mv.nonzero(as_tuple=False).tolist():
+            if j < 26:
+                continue
+            vals = {int(xv[b, j - 24 + 3 * k]) for k in range(P)}
+            p, t = int(pred[b, j]), int(yv[b, j])
+            if p == t:
+                n_right += 1
+            elif p in vals:
+                n_missel += 1
+            else:
+                n_noret += 1
+    tot = n_right + n_missel + n_noret
+    wrong = n_missel + n_noret
+    return {"n": tot, "acc": round(n_right / max(tot, 1), 4),
+            "mis_sel_frac_of_errors": round(n_missel / max(wrong, 1), 4),
+            "no_retrieval_frac_of_errors": round(n_noret / max(wrong, 1), 4)}
+
+
+def main():
+    print("=" * 78, flush=True)
+    print(f"V1b RECALL x ARMY — R_key{RKEYS} x K{ARMIES} x s{SEEDS}, "
+          f"{STEPS} steps {'[QUICK]' if QUICK else ''}", flush=True)
+    print("=" * 78, flush=True)
+    api = HfApi(token=cb.hf_token())
+    results = []
+    for R in RKEYS:
+        d = get_data(R)
+        for K in ([0] + ARMIES if not QUICK else ARMIES):   # K=0 = sdpa ref
+            for seed in (SEEDS if K else [0]):
+                results.append(run_cell(R, K, seed, d))
+                if not QUICK:
+                    tag = f"R{R}_K{K}_s{seed}" + (f"_D{D_ADDR}" if D_ADDR != 4 else "")
+                    api.upload_file(
+                        path_or_fileobj=f"{OUT_DIR}/{tag}.json",
+                        path_in_repo=f"battery/v1b_recall_army/{tag}.json",
+                        repo_id=HUB_REPO, commit_message=f"V1b cell {tag}")
+    verdict = {}
+    for R in RKEYS:
+        by_k = {K: sum(r["final_acc"] for r in results
+                       if r["R_key"] == R and r["K"] == K) / len(SEEDS)
+                for K in ARMIES}
+        best = max(by_k.values())
+        knee = min(K for K, a in by_k.items() if a >= best - 0.02)
+        er = {K: sum(max(c["addr_erank"] for c in r["census"])
+                     for r in results if r["R_key"] == R and r["K"] == K)
+              / len(SEEDS) for K in ARMIES}
+        sdpa_ref = next((r["final_acc"] for r in results
+                         if r["R_key"] == R and r["K"] == 0), None)
+        verdict[R] = {"acc_by_K": {str(k): round(v, 4)
+                                   for k, v in by_k.items()},
+                      "knee_K": knee, "sdpa_ref_acc": sdpa_ref,
+                      "max_addr_erank_by_K": {str(k): round(v, 1)
+                                              for k, v in er.items()}}
+        print(f"R_key={R:>3}: "
+              + "  ".join(f"K{k}={v:.4f}" for k, v in by_k.items())
+              + f"  -> knee K={knee}  | consumed erank "
+              + " ".join(f"{v:.0f}" for v in er.values()), flush=True)
+    knees = [verdict[R]["knee_K"] for R in RKEYS]
+    verdict["prediction_i_knee_tracks_Rkey"] = (
+        knees == sorted(knees) and knees[0] < knees[-1])
+    ers = [max(verdict[R]["max_addr_erank_by_K"].values()) for R in RKEYS]
+    verdict["prediction_ii_demand_rises_with_Rkey"] = ers == sorted(ers)
+    print(f"VERDICT: (i) knee tracks R_key: "
+          f"{verdict['prediction_i_knee_tracks_Rkey']}  "
+          f"(ii) consumed demand rises: "
+          f"{verdict['prediction_ii_demand_rises_with_Rkey']}", flush=True)
+    out = f"{OUT_DIR}/v1b_verdict.json"
+    json.dump(verdict, open(out, "w"), indent=1)
+    if not QUICK:
+        api.upload_file(path_or_fileobj=out,
+                        path_in_repo="battery/v1b_recall_army/v1b_verdict.json",
+                        repo_id=HUB_REPO,
+                        commit_message="V1b verdict: recall knee + "
+                        "consumed-demand table")
+    print("DONE.", flush=True)
+
+
+if __name__ == "__main__":
+    main()

trainers/v1d_svae_graft.py

@@ -0,0 +1,230 @@
+# =========================================================================
+# v1d_svae_graft.py — V1d: SVAE-transformer pieces vs the binding gap
+# (2026-08-09; AbstractPhil: "try taking some pieces from the SVAE transformer
+# concept, see if we can shorten the gap, or if the svae-transformer
+# projection concept is simply obsolete at this point.")
+#
+# Bed point: R64 recall (v1b data), K=64, D=16 — baseline .599/.722
+# (mean .661), sdpa ref .936. Winner (if any) confirms at K=256/D=16
+# (baseline .678/.778). Grafts from canon/svae_h2_class.md (May 29 arc):
+#   sphere    — H2 chain "linear->sphere-norm->canon": per-token sphere
+#               normalization BEFORE the q/k projections (the address
+#               already cos-normalizes AFTER; this changes what the
+#               projection learns).
+#   lens      — fixed isometric lens (0-param orthogonal DxD between
+#               projection and address). PREDICTED NULL by inspection:
+#               with a LEARNABLE codebook, cos(Lx,a)=cos(x,L^T a) — the
+#               lens is absorbed into codebook learning. Runs 1 seed as
+#               the labeled math-check.
+#   boundgate — attenuator grammar lite: hub output enters the residual
+#               through a bounded learnable gate a<=0.2, init .024
+#               ("modulate never inject" + the C6 null-path lineage).
+#   modulate  — the literal H2 form: y = x * (1 + a*tanh(hub_out)),
+#               multiplicative, bounded, never additive injection.
+#   combo     — sphere + boundgate (the two live-hypothesis pieces).
+# OBSOLESCENCE GATE: any arm closing >= half the remaining gap
+# (mean acc >= .80 at K64/D16) = SVAE pieces LIVE; all arms within +.02
+# of baseline = the projection concept is OBSOLETE here (its function
+# absorbed by cos addressing + D-matching + K-provisioning).
+# RUN: python tools\v1d_svae_graft.py  (HF_TOKEN, 4090)
+# Env: V1D_ARMS, V1D_STEPS (def 8000), V1D_K (def 64)
+# =========================================================================
+
+import importlib
+import json
+import os
+import sys
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+def _load(name):
+    if name in sys.modules:
+        return sys.modules[name]
+    try:
+        return importlib.import_module(name)
+    except ImportError:
+        here = globals().get("__file__")
+        if here is not None:
+            import pathlib
+            sys.path.insert(0, str(pathlib.Path(here).parent))
+            return importlib.import_module(name)
+        raise
+
+
+bed = _load("ar_differentiation_bed")
+v1b = _load("v1b_recall_army_battery")
+class _cb:                          # public shim: token from env
+    @staticmethod
+    def hf_token():
+        import os as _os
+        return _os.environ.get("HF_TOKEN")
+cb = _cb()
+from huggingface_hub import HfApi            # noqa: E402
+
+assert torch.cuda.is_available(), "GPU only"
+DEV = "cuda"
+STEPS = int(os.environ.get("V1D_STEPS", "8000"))
+K_ARMY = int(os.environ.get("V1D_K", "64"))
+D_ADDR = 16                                   # matched (V1c law)
+R_KEY = 64
+ARMS = os.environ.get(
+    "V1D_ARMS", "sphere,lens,boundgate,modulate,combo").split(",")
+BATCH, BLOCK = v1b.BATCH, v1b.BLOCK
+OUT_DIR = os.path.join(v1b.DATA_DIR, "results_v1d")
+HUB_REPO = v1b.HUB_REPO
+
+
+class GraftHUB(bed.CausalHUB):
+    """CausalHUB + SVAE grafts. sphere: normalize x before q/k projections.
+    lens: fixed orthogonal DxD after projection (0 params, buffer)."""
+
+    def __init__(self, d, K, D, sphere=False, lens=False):
+        super().__init__(d, K, D)
+        self.sphere = sphere
+        if lens:
+            L = torch.linalg.qr(torch.randn(D, D))[0]
+            self.register_buffer("lens", L)
+        else:
+            self.lens = None
+
+    def forward(self, x):
+        xa = F.normalize(x, dim=-1) if self.sphere else x
+        q, k = self.q(xa), self.k(xa)
+        if self.lens is not None:
+            q, k = q @ self.lens, k @ self.lens
+        qp, qn = self.addr.oriented(q)
+        kp, kn = self.addr.oriented(k)
+        v = self.v(x)
+        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 GraftBlock(nn.Module):
+    """Block with the SVAE residual grammars. inject: y = x + attn (bed
+    default). boundgate: y = x + min(a,0.2)*attn, a learnable init .024.
+    modulate: y = x * (1 + a*tanh(attn)) — multiplicative, never additive."""
+
+    def __init__(self, d, attn, grammar="inject"):
+        super().__init__()
+        self.n1, self.n2 = nn.LayerNorm(d), nn.LayerNorm(d)
+        self.attn = attn
+        self.grammar = grammar
+        if grammar in ("boundgate", "modulate"):
+            self.alpha = nn.Parameter(torch.tensor(0.024))
+        self.mlp = nn.Sequential(nn.Linear(d, 4 * d), nn.GELU(),
+                                 nn.Linear(4 * d, d))
+
+    def forward(self, x):
+        a = self.attn(self.n1(x))
+        if self.grammar == "boundgate":
+            x = x + self.alpha.clamp(0, 0.2) * a
+        elif self.grammar == "modulate":
+            x = x * (1.0 + self.alpha.clamp(0, 0.2) * torch.tanh(a))
+        else:
+            x = x + a
+        return x + self.mlp(self.n2(x))
+
+
+def build_model(arm, d=192, layers=4):
+    sphere = arm in ("sphere", "combo")
+    lens = arm == "lens"
+    grammar = ("boundgate" if arm in ("boundgate", "combo")
+               else "modulate" if arm == "modulate" else "inject")
+    m = bed.ByteLM("hub_tri", block=BLOCK, K=K_ARMY, D=D_ADDR)
+    m.blocks = nn.ModuleList([
+        GraftBlock(d, GraftHUB(d, K_ARMY, D_ADDR, sphere, lens), grammar)
+        for _ in range(layers)])
+    return m
+
+
+def run_cell(arm, seed, d):
+    tag = f"{arm}_R{R_KEY}_K{K_ARMY}_D{D_ADDR}_s{seed}" + (f"_t{STEPS // 1000}k" if STEPS != 8000 else "")
+    out_p = f"{OUT_DIR}/{tag}.json"
+    if os.path.exists(out_p):
+        print(f"-- {tag}: exists, skip", flush=True)
+        return json.load(open(out_p))
+    torch.manual_seed(seed)
+    g = torch.Generator().manual_seed(seed)
+    model = build_model(arm).to(DEV)
+    opt = torch.optim.Adam(model.parameters(), lr=3e-4, weight_decay=0.0)
+    for step in range(1, STEPS + 1):
+        x, y, m = v1b.batch_masked(d["tr"], d["trm"], BATCH, BLOCK, DEV, g)
+        logits = model(x)
+        if m.sum() == 0:
+            continue
+        loss = (F.cross_entropy(logits.reshape(-1, 256), y.reshape(-1))
+                + 4.0 * F.cross_entropy(logits[m], y[m]))
+        opt.zero_grad(set_to_none=True)
+        loss.backward()
+        opt.step()
+    model.eval()
+    acc, bpb = v1b.masked_eval(model, d, g, iters=32)
+    alphas = [round(float(b.alpha.detach()), 4) for b in model.blocks
+              if hasattr(b, "alpha")]
+    res = {"arm": arm, "seed": seed, "R": R_KEY, "K": K_ARMY, "D": D_ADDR,
+           "steps": STEPS, "final_acc": round(acc, 4),
+           "final_bpb": round(bpb, 4), "alphas": alphas,
+           "baseline_ref": {"K64_D16": [0.5994, 0.7224],
+                            "K256_D16": [0.6783, 0.7776], "sdpa": 0.936}}
+    os.makedirs(OUT_DIR, exist_ok=True)
+    json.dump(res, open(out_p, "w"), indent=1)
+    print(f"-- {tag}: acc {acc:.4f}  bpb {bpb:.4f}"
+          + (f"  alphas {alphas}" if alphas else ""), flush=True)
+    del model
+    torch.cuda.empty_cache()
+    return res
+
+
+def main():
+    print("=" * 78, flush=True)
+    print(f"V1d SVAE GRAFTS — arms {ARMS} at R{R_KEY}/K{K_ARMY}/D{D_ADDR}, "
+          f"{STEPS} steps (baseline mean .661, sdpa .936)", flush=True)
+    print("=" * 78, flush=True)
+    api = HfApi(token=cb.hf_token())
+    d = v1b.get_data(R_KEY)
+    results = []
+    for arm in ARMS:
+        seeds = [0] if arm == "lens" else [0, 1]
+        for seed in seeds:
+            results.append(run_cell(arm, seed, d))
+            tag = f"{arm}_R{R_KEY}_K{K_ARMY}_D{D_ADDR}_s{seed}" + (f"_t{STEPS // 1000}k" if STEPS != 8000 else "")
+            api.upload_file(path_or_fileobj=f"{OUT_DIR}/{tag}.json",
+                            path_in_repo=f"battery/v1d_svae_graft/{tag}.json",
+                            repo_id=HUB_REPO, commit_message=f"V1d {tag}")
+    base = 0.6609
+    verdict = {}
+    for arm in ARMS:
+        accs = [r["final_acc"] for r in results if r["arm"] == arm]
+        verdict[arm] = {"acc": accs,
+                        "mean": round(sum(accs) / len(accs), 4),
+                        "delta_vs_base": round(sum(accs) / len(accs) - base, 4)}
+        print(f"{arm:>10}: {verdict[arm]['mean']:.4f} "
+              f"({verdict[arm]['delta_vs_base']:+.4f} vs baseline)", flush=True)
+    best = max(verdict, key=lambda a: verdict[a]["mean"])
+    live = verdict[best]["mean"] >= 0.80
+    obsolete = all(v["mean"] <= base + 0.02 for v in verdict.values())
+    verdict["gate"] = ("SVAE PIECES LIVE" if live else
+                       "OBSOLETE HERE (absorbed)" if obsolete else
+                       f"PARTIAL: best={best} {verdict[best]['mean']:.4f}")
+    print("GATE:", verdict["gate"], flush=True)
+    out = f"{OUT_DIR}/v1d_verdict.json"
+    json.dump(verdict, open(out, "w"), indent=1)
+    api.upload_file(path_or_fileobj=out,
+                    path_in_repo="battery/v1d_svae_graft/v1d_verdict.json",
+                    repo_id=HUB_REPO,
+                    commit_message="V1d verdict: SVAE grafts vs binding gap")
+    print("DONE.", flush=True)
+
+
+if __name__ == "__main__":
+    main()

trainers/v1e_knit_battery.py

@@ -0,0 +1,250 @@
+# =========================================================================
+# v1e_knit_battery.py — V1e: the conv-knit + patchwork grafts vs the gap
+# (2026-08-09; AbstractPhil: "Consult the alpha attention mixed with the SVAE
+# patchwork's edge solidification from the conv mechanism to knit, that
+# could be the answer we require.")
+#
+# Consult results (canon/constellation_forms.md universal rules +
+# canon/svae_h2_class.md): patchwork spec Linear->SquaredReLU->LN->Linear,
+# SquaredReLU NEVER GELU (anchor diversity 7.1 vs 4.6); conv solidifies
+# edges between patch codes; gate init -3.0 (theme D). Bed point: R64
+# recall, K=64, D=16 (baseline .661; V1c best K256 .728; sdpa .936).
+# ARMS:
+#   knitseq   — depthwise CAUSAL conv (kernel 8) over the HUB output,
+#               gated residual at -3.0: adjacent positions' read codes
+#               knit into a locally solid field (edge solidification in
+#               SEQUENCE).
+#   knitaddr  — grouped conv (kernel 3) over the K-axis of the oriented
+#               address (qp/qn/kp/kn): NEIGHBORING CELLS couple — B6's
+#               overlap made structural (edge solidification in ADDRESS).
+#   patchhead — the HUB o-projection replaced by the constellation
+#               patchwork generator (Linear d->2d -> SquaredReLU -> LN ->
+#               Linear 2d->d): the read GENERATES from the address per the
+#               patchwork grammar.
+#   alphaknit — knitseq + boundgate alpha residual (the literal "alpha
+#               attention mixed with the edge-knit" ask).
+# GATE (same as V1d): >= .80 mean = LIVE (half the remaining gap);
+# within +.02 of .661 = the knit adds nothing here.
+# Chained: waits for V1d's verdict file before starting (one GPU).
+# RUN: python tools\v1e_knit_battery.py  (HF_TOKEN, 4090)
+# =========================================================================
+
+import importlib
+import json
+import os
+import sys
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+def _load(name):
+    if name in sys.modules:
+        return sys.modules[name]
+    try:
+        return importlib.import_module(name)
+    except ImportError:
+        here = globals().get("__file__")
+        if here is not None:
+            import pathlib
+            sys.path.insert(0, str(pathlib.Path(here).parent))
+            return importlib.import_module(name)
+        raise
+
+
+bed = _load("ar_differentiation_bed")
+v1b = _load("v1b_recall_army_battery")
+v1d = _load("v1d_svae_graft")
+class _cb:                          # public shim: token from env
+    @staticmethod
+    def hf_token():
+        import os as _os
+        return _os.environ.get("HF_TOKEN")
+cb = _cb()
+from huggingface_hub import HfApi            # noqa: E402
+
+assert torch.cuda.is_available(), "GPU only"
+DEV = "cuda"
+STEPS = int(os.environ.get("V1E_STEPS", "8000"))
+K_ARMY, D_ADDR, R_KEY = 64, 16, 64
+ARMS = os.environ.get(
+    "V1E_ARMS", "knitseq,knitaddr,patchhead,alphaknit").split(",")
+BATCH, BLOCK = v1b.BATCH, v1b.BLOCK
+OUT_DIR = os.path.join(v1b.DATA_DIR, "results_v1e")
+HUB_REPO = v1b.HUB_REPO
+
+
+class SquaredReLU(nn.Module):
+    def forward(self, x):
+        return F.relu(x) ** 2
+
+
+class KnitHUB(bed.CausalHUB):
+    """CausalHUB + the knit grafts."""
+
+    def __init__(self, d, K, D, knitaddr=False, patchhead=False):
+        super().__init__(d, K, D)
+        self.ka = None
+        if knitaddr:
+            # grouped conv over the K axis; SAME padding, shared across
+            # the four oriented maps; identity-init (weight peak at center)
+            self.ka = nn.Conv1d(1, 1, kernel_size=3, padding=1, bias=False)
+            w = torch.zeros(1, 1, 3)
+            w[0, 0, 1] = 1.0                     # identity at birth
+            self.ka.weight = nn.Parameter(w)
+        if patchhead:
+            self.o = nn.Sequential(              # constellation patchwork
+                nn.Linear(d, 2 * d), SquaredReLU(), nn.LayerNorm(2 * d),
+                nn.Linear(2 * d, d))
+
+    def _knit(self, a):
+        if self.ka is None:
+            return a
+        B, n, K = a.shape
+        return self.ka(a.reshape(B * n, 1, K)).reshape(B, n, K)
+
+    def forward(self, x):
+        qp, qn = self.addr.oriented(self.q(x))
+        kp, kn = self.addr.oriented(self.k(x))
+        qp, qn, kp, kn = (self._knit(t) for t in (qp, qn, kp, kn))
+        v = self.v(x)
+        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 KnitBlock(nn.Module):
+    """Block with optional sequence-knit (depthwise causal conv over the
+    attn output, gated at -3.0) and optional bounded-alpha residual."""
+
+    def __init__(self, d, attn, knitseq=False, boundgate=False):
+        super().__init__()
+        self.n1, self.n2 = nn.LayerNorm(d), nn.LayerNorm(d)
+        self.attn = attn
+        self.ks = None
+        if knitseq:
+            self.ks = nn.Conv1d(d, d, kernel_size=8, groups=d, bias=False)
+            self.ks_gate = nn.Parameter(torch.tensor(-3.0))
+        self.alpha = nn.Parameter(torch.tensor(0.024)) if boundgate else None
+        self.mlp = nn.Sequential(nn.Linear(d, 4 * d), nn.GELU(),
+                                 nn.Linear(4 * d, d))
+
+    def forward(self, x):
+        a = self.attn(self.n1(x))
+        if self.ks is not None:
+            ap = F.pad(a.transpose(1, 2), (7, 0))        # causal left-pad
+            knit = self.ks(ap).transpose(1, 2)
+            a = a + torch.sigmoid(self.ks_gate) * knit
+        if self.alpha is not None:
+            x = x + self.alpha.clamp(0, 0.2) * a
+        else:
+            x = x + a
+        return x + self.mlp(self.n2(x))
+
+
+def build_model(arm, d=192, layers=4):
+    knitseq = arm in ("knitseq", "alphaknit")
+    knitaddr = arm == "knitaddr"
+    patchhead = arm == "patchhead"
+    boundgate = arm == "alphaknit"
+    m = bed.ByteLM("hub_tri", block=BLOCK, K=K_ARMY, D=D_ADDR)
+    m.blocks = nn.ModuleList([
+        KnitBlock(d, KnitHUB(d, K_ARMY, D_ADDR, knitaddr, patchhead),
+                  knitseq, boundgate)
+        for _ in range(layers)])
+    return m
+
+
+def run_cell(arm, seed, d):
+    tag = f"{arm}_R{R_KEY}_K{K_ARMY}_D{D_ADDR}_s{seed}" + (f"_t{STEPS // 1000}k" if STEPS != 8000 else "")
+    out_p = f"{OUT_DIR}/{tag}.json"
+    if os.path.exists(out_p):
+        print(f"-- {tag}: exists, skip", flush=True)
+        return json.load(open(out_p))
+    torch.manual_seed(seed)
+    g = torch.Generator().manual_seed(seed)
+    model = build_model(arm).to(DEV)
+    opt = torch.optim.Adam(model.parameters(), lr=3e-4, weight_decay=0.0)
+    for step in range(1, STEPS + 1):
+        x, y, m = v1b.batch_masked(d["tr"], d["trm"], BATCH, BLOCK, DEV, g)
+        logits = model(x)
+        if m.sum() == 0:
+            continue
+        loss = (F.cross_entropy(logits.reshape(-1, 256), y.reshape(-1))
+                + 4.0 * F.cross_entropy(logits[m], y[m]))
+        opt.zero_grad(set_to_none=True)
+        loss.backward()
+        opt.step()
+    model.eval()
+    acc, bpb = v1b.masked_eval(model, d, g, iters=32)
+    gates = {}
+    b0 = model.blocks[0]
+    if b0.ks is not None:
+        gates["ks_gate_sig"] = [round(float(torch.sigmoid(b.ks_gate)), 4)
+                                for b in model.blocks]
+    if b0.alpha is not None:
+        gates["alpha"] = [round(float(b.alpha), 4) for b in model.blocks]
+    res = {"arm": arm, "seed": seed, "R": R_KEY, "K": K_ARMY, "D": D_ADDR,
+           "steps": STEPS, "final_acc": round(acc, 4),
+           "final_bpb": round(bpb, 4), "gates": gates,
+           "baseline_ref": {"K64_D16_mean": 0.6609, "sdpa": 0.936}}
+    os.makedirs(OUT_DIR, exist_ok=True)
+    json.dump(res, open(out_p, "w"), indent=1)
+    print(f"-- {tag}: acc {acc:.4f}  bpb {bpb:.4f}  {gates}", flush=True)
+    del model
+    torch.cuda.empty_cache()
+    return res
+
+
+def main():
+    print("=" * 78, flush=True)
+    print(f"V1e KNIT BATTERY — arms {ARMS} at R{R_KEY}/K{K_ARMY}/D{D_ADDR}, "
+          f"{STEPS} steps (baseline .661, sdpa .936)", flush=True)
+    print("=" * 78, flush=True)
+    api = HfApi(token=cb.hf_token())
+    d = v1b.get_data(R_KEY)
+    results = []
+    for arm in ARMS:
+        for seed in (0, 1):
+            results.append(run_cell(arm, seed, d))
+            tag = f"{arm}_R{R_KEY}_K{K_ARMY}_D{D_ADDR}_s{seed}" + (f"_t{STEPS // 1000}k" if STEPS != 8000 else "")
+            api.upload_file(path_or_fileobj=f"{OUT_DIR}/{tag}.json",
+                            path_in_repo=f"battery/v1e_knit/{tag}.json",
+                            repo_id=HUB_REPO, commit_message=f"V1e {tag}")
+    base = 0.6609
+    verdict = {}
+    for arm in ARMS:
+        accs = [r["final_acc"] for r in results if r["arm"] == arm]
+        verdict[arm] = {"acc": accs,
+                        "mean": round(sum(accs) / len(accs), 4),
+                        "delta_vs_base": round(sum(accs) / len(accs) - base,
+                                               4)}
+        print(f"{arm:>10}: {verdict[arm]['mean']:.4f} "
+              f"({verdict[arm]['delta_vs_base']:+.4f})", flush=True)
+    best = max(verdict, key=lambda a: verdict[a]["mean"])
+    verdict["gate"] = ("KNIT LIVE" if verdict[best]["mean"] >= 0.80 else
+                       "KNIT NULL HERE" if all(
+                           v["mean"] <= base + 0.02
+                           for k, v in verdict.items() if k != "gate")
+                       else f"PARTIAL: best={best} "
+                            f"{verdict[best]['mean']:.4f}")
+    print("GATE:", verdict["gate"], flush=True)
+    out = f"{OUT_DIR}/v1e_verdict.json"
+    json.dump(verdict, open(out, "w"), indent=1)
+    api.upload_file(path_or_fileobj=out,
+                    path_in_repo="battery/v1e_knit/v1e_verdict.json",
+                    repo_id=HUB_REPO,
+                    commit_message="V1e verdict: conv-knit + patchwork "
+                    "grafts vs the binding gap")
+    print("DONE.", flush=True)
+
+
+if __name__ == "__main__":
+    main()

trainers/v1f_consult_tier.py

@@ -0,0 +1,280 @@
+# =========================================================================
+# v1f_consult_tier.py — V1f: the consult-informed corrector/control tier
+# (2026-08-09 evening; sources: fresnel/johanna/freckles + H2-era + trigram
+# consult, AbstractPhil's stabilizer-vs-corrector lineage, the boundgate crater.)
+#
+# Bed point: R64 recall, K=64, D=16 (baseline mean .661, sdpa .936).
+# ARMS:
+#   rownorm   — L-041 port (rated 9; the ONLY ablation that broke the
+#               233-run battery): row sphere-norm at the M-point = the
+#               HUB's VALUE rows normalized at the write (v = ||v||-unit
+#               * learned scale). Directions|magnitudes decoupled.
+#   auxalpha  — the graft-geometry CORRECTION of the boundgate crater
+#               (alphas pinned at cap, acc .036): bounded alpha on the
+#               AUXILIARY knit channel ONLY, base path unthrottled —
+#               the faithful SVAE whisper-channel geometry.
+#   strobe3   — the bed's own anti-selection refinement ported to the
+#               HUB: q/k oriented at 3 taus (.05/.1/.3) concatenated
+#               (3K channels) — neighborhood disambiguation vs the
+#               incorrect-selections class.
+#   unihub    — unigram control (plain hub, NO trigram): does binding
+#               late-bloom without the tri lineage? (tri caveat, exp020
+#               memorizer artifact channel.)
+#   unisdpa   — unigram sdpa reference, 1 seed.
+#   padfix    — hub_tri with ALEPH_TRI_PAD_FIX=1: prices the pad-
+#               conflation fault (discovery #16) against the tri baseline.
+# INSTRUMENTS ON EVERY CELL: CV@1000 (H2-era early-screening law: codebook
+# CV at step 1000 predicted the final band in 96% of 149 runs — ported
+# validation), selection_eval (mis-selection vs no-retrieval), final
+# census, alpha/gate trajectories where present.
+# RUN: python tools\v1f_consult_tier.py  (HF_TOKEN, 4090; chains after V1e)
+# Env: V1F_ARMS, V1F_STEPS (def 8000)
+# =========================================================================
+
+import importlib
+import json
+import os
+import sys
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+def _load(name):
+    if name in sys.modules:
+        return sys.modules[name]
+    try:
+        return importlib.import_module(name)
+    except ImportError:
+        here = globals().get("__file__")
+        if here is not None:
+            import pathlib
+            sys.path.insert(0, str(pathlib.Path(here).parent))
+            return importlib.import_module(name)
+        raise
+
+
+bed = _load("ar_differentiation_bed")
+v1b = _load("v1b_recall_army_battery")
+class _cb:                          # public shim: token from env
+    @staticmethod
+    def hf_token():
+        import os as _os
+        return _os.environ.get("HF_TOKEN")
+cb = _cb()
+from huggingface_hub import HfApi            # noqa: E402
+
+assert torch.cuda.is_available(), "GPU only"
+DEV = "cuda"
+STEPS = int(os.environ.get("V1F_STEPS", "8000"))
+K_ARMY, D_ADDR, R_KEY = 64, 16, 64
+ARMS = os.environ.get(
+    "V1F_ARMS", "rownorm,auxalpha,strobe3,unihub,unisdpa,padfix").split(",")
+BATCH, BLOCK = v1b.BATCH, v1b.BLOCK
+OUT_DIR = os.path.join(v1b.DATA_DIR, "results_v1f")
+HUB_REPO = v1b.HUB_REPO
+TAUS = (0.05, 0.1, 0.3)
+
+
+class RowNormHUB(bed.CausalHUB):
+    """L-041 at the M-point: value rows sphere-normalized at the write,
+    magnitude carried by a learned per-row scale (directions|magnitudes
+    decoupled, the H2 separation-of-concerns)."""
+
+    def __init__(self, d, K, D):
+        super().__init__(d, K, D)
+        self.vscale = nn.Parameter(torch.ones(()))
+
+    def forward(self, x):
+        qp, qn = self.addr.oriented(self.q(x))
+        kp, kn = self.addr.oriented(self.k(x))
+        v = F.normalize(self.v(x), dim=-1) * self.vscale
+        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 Strobe3HUB(bed.CausalHUB):
+    """3-tau stroboscope on the HUB address: oriented maps at three
+    temperatures concatenated along K (3K memory channels) — the bed's
+    v2 anti-selection refinement, ported to attention."""
+
+    def _strobe(self, x):
+        A = F.normalize(self.addr.codebook, dim=-1)
+        cos = F.normalize(x, dim=-1) @ A.transpose(-1, -2)
+        ps, ns = [], []
+        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)
+            Z = (ep + en).sum(dim=-1, keepdim=True)
+            ps.append(ep / Z)
+            ns.append(en / Z)
+        return torch.cat(ps, -1), torch.cat(ns, -1)
+
+    def forward(self, x):
+        qp, qn = self._strobe(self.q(x))
+        kp, kn = self._strobe(self.k(x))
+        v = self.v(x)
+        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 AuxAlphaBlock(nn.Module):
+    """The corrected graft geometry: base attn path UNTHROTTLED; the knit
+    conv rides an auxiliary bounded-alpha channel (init .024, cap .2) —
+    the SVAE whisper-channel form."""
+
+    def __init__(self, d, attn):
+        super().__init__()
+        self.n1, self.n2 = nn.LayerNorm(d), nn.LayerNorm(d)
+        self.attn = attn
+        self.ks = nn.Conv1d(d, d, kernel_size=8, groups=d, bias=False)
+        self.alpha = nn.Parameter(torch.tensor(0.024))
+        self.mlp = nn.Sequential(nn.Linear(d, 4 * d), nn.GELU(),
+                                 nn.Linear(4 * d, d))
+
+    def forward(self, x):
+        a = self.attn(self.n1(x))
+        knit = self.ks(F.pad(a.transpose(1, 2), (7, 0))).transpose(1, 2)
+        x = x + a + self.alpha.clamp(0, 0.2) * torch.tanh(knit)
+        return x + self.mlp(self.n2(x))
+
+
+def build_model(arm, d=192, layers=4):
+    base_arm = ("hub" if arm == "unihub"
+                else "sdpa" if arm == "unisdpa" else "hub_tri")
+    m = bed.ByteLM(base_arm, block=BLOCK, K=K_ARMY, D=D_ADDR)
+    if arm == "rownorm":
+        m.blocks = nn.ModuleList([
+            bed.Block(d, RowNormHUB(d, K_ARMY, D_ADDR)) for _ in range(layers)])
+    elif arm == "strobe3":
+        m.blocks = nn.ModuleList([
+            bed.Block(d, Strobe3HUB(d, K_ARMY, D_ADDR)) for _ in range(layers)])
+    elif arm == "auxalpha":
+        m.blocks = nn.ModuleList([
+            AuxAlphaBlock(d, bed.CausalHUB(d, K_ARMY, D_ADDR))
+            for _ in range(layers)])
+    return m
+
+
+def codebook_cv(model):
+    """H2-era CV gauge on the address codebooks (fp64, normalized rows):
+    coefficient of variation of pairwise cosine magnitudes."""
+    cvs = []
+    for blk in model.blocks:
+        addr = getattr(blk.attn, "addr", None)
+        if addr is None:
+            return None
+        A = F.normalize(addr.codebook.detach().double(), dim=-1)
+        G = (A @ A.T).abs()
+        off = G[~torch.eye(G.shape[0], dtype=torch.bool, device=G.device)]
+        cvs.append(float(off.std() / off.mean().clamp_min(1e-12)))
+    return round(sum(cvs) / len(cvs), 4)
+
+
+def run_cell(arm, seed, d):
+    tag = (f"{arm}_R{R_KEY}_K{K_ARMY}_D{D_ADDR}_s{seed}"
+           + (f"_t{STEPS // 1000}k" if STEPS != 8000 else ""))
+    out_p = f"{OUT_DIR}/{tag}.json"
+    if os.path.exists(out_p):
+        print(f"-- {tag}: exists, skip", flush=True)
+        return json.load(open(out_p))
+    if arm == "padfix":
+        os.environ["ALEPH_TRI_PAD_FIX"] = "1"
+    torch.manual_seed(seed)
+    g = torch.Generator().manual_seed(seed)
+    model = build_model(arm).to(DEV)
+    if arm == "padfix":
+        del os.environ["ALEPH_TRI_PAD_FIX"]
+    opt = torch.optim.Adam(model.parameters(), lr=3e-4, weight_decay=0.0)
+    cv1000 = None
+    for step in range(1, STEPS + 1):
+        x, y, m = v1b.batch_masked(d["tr"], d["trm"], BATCH, BLOCK, DEV, g)
+        logits = model(x)
+        if m.sum() == 0:
+            continue
+        loss = (F.cross_entropy(logits.reshape(-1, 256), y.reshape(-1))
+                + 4.0 * F.cross_entropy(logits[m], y[m]))
+        opt.zero_grad(set_to_none=True)
+        loss.backward()
+        opt.step()
+        if step == 1000:
+            cv1000 = codebook_cv(model)
+    model.eval()
+    acc, bpb = v1b.masked_eval(model, d, g, iters=32)
+    sel = v1b.selection_eval(model, d, g, iters=32)
+    alphas = [round(float(b.alpha.detach()), 4) for b in model.blocks
+              if hasattr(b, "alpha")]
+    res = {"arm": arm, "seed": seed, "R": R_KEY, "K": K_ARMY, "D": D_ADDR,
+           "steps": STEPS, "final_acc": round(acc, 4),
+           "final_bpb": round(bpb, 4), "cv_at_1000": cv1000,
+           "cv_final": codebook_cv(model), "selection": sel,
+           "alphas": alphas,
+           "baseline_ref": {"K64_D16_mean": 0.6609, "sdpa_tri": 0.936}}
+    os.makedirs(OUT_DIR, exist_ok=True)
+    json.dump(res, open(out_p, "w"), indent=1)
+    print(f"-- {tag}: acc {acc:.4f}  bpb {bpb:.4f}  missel "
+          f"{sel['mis_sel_frac_of_errors']:.3f}  cv1k {cv1000}"
+          + (f"  alphas {alphas}" if alphas else ""), flush=True)
+    del model
+    torch.cuda.empty_cache()
+    return res
+
+
+def main():
+    print("=" * 78, flush=True)
+    print(f"V1f CONSULT TIER — arms {ARMS} at R{R_KEY}/K{K_ARMY}/D{D_ADDR}, "
+          f"{STEPS} steps", flush=True)
+    print("=" * 78, flush=True)
+    api = HfApi(token=cb.hf_token())
+    d = v1b.get_data(R_KEY)
+    results = []
+    for arm in ARMS:
+        seeds = [0] if arm == "unisdpa" else [0, 1]
+        for seed in seeds:
+            results.append(run_cell(arm, seed, d))
+            tag = (f"{arm}_R{R_KEY}_K{K_ARMY}_D{D_ADDR}_s{seed}"
+                   + (f"_t{STEPS // 1000}k" if STEPS != 8000 else ""))
+            api.upload_file(path_or_fileobj=f"{OUT_DIR}/{tag}.json",
+                            path_in_repo=f"battery/v1f_consult/{tag}.json",
+                            repo_id=HUB_REPO, commit_message=f"V1f {tag}")
+    base = 0.6609
+    verdict = {}
+    for arm in ARMS:
+        rs = [r for r in results if r["arm"] == arm]
+        accs = [r["final_acc"] for r in rs]
+        ms = [r["selection"]["mis_sel_frac_of_errors"] for r in rs]
+        verdict[arm] = {"acc": accs,
+                        "mean": round(sum(accs) / len(accs), 4),
+                        "delta": round(sum(accs) / len(accs) - base, 4),
+                        "missel_frac": round(sum(ms) / len(ms), 4)}
+        print(f"{arm:>9}: {verdict[arm]['mean']:.4f} "
+              f"({verdict[arm]['delta']:+.4f})  missel "
+              f"{verdict[arm]['missel_frac']:.3f}", flush=True)
+    out = f"{OUT_DIR}/v1f_verdict.json"
+    json.dump(verdict, open(out, "w"), indent=1)
+    api.upload_file(path_or_fileobj=out,
+                    path_in_repo="battery/v1f_consult/v1f_verdict.json",
+                    repo_id=HUB_REPO,
+                    commit_message="V1f verdict: consult-tier arms + "
+                    "mis-selection decomposition")
+    print("DONE.", flush=True)
+
+
+if __name__ == "__main__":
+    main()

trainers/v1g_svae_overlap_sweep.py

@@ -0,0 +1,202 @@
+# =========================================================================
+# v1g_svae_overlap_sweep.py — the 16-noise-spectrum overlap sweep on the
+# NATIVE substrate (AbstractPhil, 2026-08-09: "you just need the correct noises
+# that we trained johanna and freckles with" — the wikitext sweep pointed
+# at the wrong beast). Also answers the STANDING open question
+# (history/open_questions.md:191): the 16-codebook similarity matrix.
+#
+# HYPOTHESIS UNDER TEST (AbstractPhil, never verified): overlapping input spectra
+# cause anchored/pooled accumulation — overlap-linked noise types should
+# produce SIMILAR model responses (the model anchors on shared structure),
+# and high-overlap types should converge slower / less differentiated.
+#
+# SUBSTRATE: OmegaNoiseDataset (16 types, verbatim from
+# AbstractPhil/geolip-svae-batteries battery_maker_proto.py) + trained
+# johanna-F-S32-V32-D4-h32-d1-p2 (PatchSVAE_F, all defense mechanisms).
+# MEASURES:
+#  O[i,j] data-side overlap: radial power-spectrum cosine + histogram
+#         Bhattacharyya (averaged).
+#  S[i,j] model-side response similarity: per-type mean sigma (omega)
+#         profile cosine + per-mode sigma-distribution overlap.
+#  LINKAGE: corr(O_off, S_off) — overlap-driven anchoring verdict.
+#  DIFFICULTY: per-type recon MSE vs overlap centrality (slow-convergence
+#         link, cross-checked against the canon difficulty ordering).
+#  ALEPH EMERGENCE (native): antipodal row pairing in the per-sample M
+#         codebooks (RP^D axis signature, cos < -0.9), per type.
+# RUN: python tools\v1g_svae_overlap_sweep.py   (CPU, ~3 min)
+# =========================================================================
+
+import importlib.util
+import json
+import math
+import os
+import sys
+
+import torch
+import torch.nn.functional as F
+
+sys.stdout.reconfigure(encoding="utf-8", errors="replace")
+from huggingface_hub import hf_hub_download, HfApi   # noqa: E402
+
+REPO = "AbstractPhil/geolip-svae-batteries"
+RUN = "johanna-F-S32-V32-D4-h32-d1-p2"
+N_PER_TYPE = 48
+IMG = 32
+OUT = "./data/v1_rank_army/v1g_svae_overlap.json"
+SHIP_REPO = "AbstractPhil/aleph-splat-0"
+
+TYPE_NAMES = ["gaussian", "uniform", "wide_uniform", "poisson", "pink",
+              "brown", "binary", "sparse_spikes", "block", "gradient",
+              "checker", "gauss_uniform_mix", "quadrant", "t13", "t14",
+              "t15"]
+
+
+def load_proto():
+    p = hf_hub_download(REPO, "battery_maker_proto.py")
+    spec = importlib.util.spec_from_file_location("battery_maker_proto", p)
+    mod = importlib.util.module_from_spec(spec)
+    sys.modules["battery_maker_proto"] = mod
+    spec.loader.exec_module(mod)
+    return mod
+
+
+def gen_type(mod, t, n):
+    torch.manual_seed(1234 + t)
+    ds = mod.OmegaNoiseDataset(size=n, img_size=IMG,
+                               seed_rotate_every=10**9, allowed_types=[t])
+    return torch.stack([ds[i] if isinstance(ds[i], torch.Tensor)
+                        else ds[i][0] for i in range(n)])
+
+
+def radial_spectrum(x):
+    """Mean radially-averaged power spectrum over a batch (B,3,H,W)."""
+    S = torch.fft.rfft2(x.double()).abs() ** 2
+    S = S.mean(dim=(0, 1))                            # (H, W//2+1)
+    h, w = S.shape
+    fy = torch.fft.fftfreq(h).abs().unsqueeze(-1).expand(-1, w)
+    fx = torch.fft.rfftfreq(IMG).unsqueeze(0).expand(h, -1)
+    r = torch.sqrt(fx ** 2 + fy ** 2)
+    nb = 16
+    bins = torch.linspace(0, float(r.max()) + 1e-6, nb + 1)
+    prof = torch.zeros(nb, dtype=torch.float64)
+    for b in range(nb):
+        m = (r >= bins[b]) & (r < bins[b + 1])
+        if m.any():
+            prof[b] = S[m].mean()
+    return (prof / prof.sum()).clamp_min(1e-12)
+
+
+def hist_overlap(a, b, nbins=64):
+    lo = float(min(a.min(), b.min()))
+    hi = float(max(a.max(), b.max()))
+    ha = torch.histc(a.double().flatten(), nbins, lo, hi)
+    hb = torch.histc(b.double().flatten(), nbins, lo, hi)
+    ha, hb = ha / ha.sum(), hb / hb.sum()
+    return float((ha * hb).sqrt().sum())              # Bhattacharyya
+
+
+def main():
+    print("=" * 74)
+    print("V1g SVAE 16-NOISE OVERLAP SWEEP (native substrate)")
+    print("=" * 74)
+    mod = load_proto()
+    cfgp = hf_hub_download(REPO, f"{RUN}/config.json")
+    cfg = json.load(open(cfgp))
+    model = mod.PatchSVAE_F(
+        matrix_v=cfg.get("matrix_v", 32), D=cfg.get("D", 4),
+        patch_size=cfg.get("patch_size", 2), hidden=cfg.get("hidden", 32),
+        depth=cfg.get("depth", 1),
+        n_cross_layers=cfg.get("n_cross_layers", 1),
+        n_heads=cfg.get("n_heads", 4))
+    ck = torch.load(hf_hub_download(REPO, f"{RUN}/checkpoints/best.pt"),
+                    map_location="cpu", weights_only=False)
+    sd = ck.get("model_state_dict", ck.get("state_dict", ck))
+    model.load_state_dict(sd, strict=True)
+    model.eval()
+    print(f"loaded {RUN}: {sum(p.numel() for p in model.parameters()):,} "
+          f"params")
+
+    batches, spectra, sig_profiles, mse, antipodal = {}, {}, {}, {}, {}
+    for t in range(16):
+        x = gen_type(mod, t, N_PER_TYPE)
+        batches[t] = x
+        spectra[t] = radial_spectrum(x)
+        with torch.no_grad():
+            out = model(x)
+        mse[t] = round(float(F.mse_loss(out["recon"], x)), 5)
+        svd = out["svd"]
+        S = svd["S"]                                   # (..., D) sigma
+        sig_profiles[t] = S.reshape(-1, S.shape[-1]).double()
+        M = svd.get("M", svd.get("M_norm"))
+        if M is not None:
+            Mn = F.normalize(M.reshape(-1, M.shape[-2], M.shape[-1])
+                             .double(), dim=-1)
+            G = torch.einsum("bvd,bwd->bvw", Mn, Mn)
+            V = G.shape[-1]
+            iu = torch.triu_indices(V, V, offset=1)
+            pairs = G[:, iu[0], iu[1]]
+            antipodal[t] = round(float((pairs < -0.9).double().mean()), 5)
+        print(f"  type {t:>2} {TYPE_NAMES[t]:>17}: mse {mse[t]:.5f}"
+              + (f"  antipodal {antipodal.get(t)}" if antipodal else ""),
+              flush=True)
+
+    # ---- data-side overlap O and model-side similarity S ----
+    Omat = torch.zeros(16, 16)
+    Smat = torch.zeros(16, 16)
+    for i in range(16):
+        for j in range(16):
+            if j < i:
+                Omat[i, j], Smat[i, j] = Omat[j, i], Smat[j, i]
+                continue
+            spec_cos = float(F.cosine_similarity(
+                spectra[i].unsqueeze(0), spectra[j].unsqueeze(0)))
+            hov = hist_overlap(batches[i], batches[j])
+            Omat[i, j] = (spec_cos + hov) / 2
+            mi = sig_profiles[i].mean(0)
+            mj = sig_profiles[j].mean(0)
+            prof_cos = float(F.cosine_similarity(mi.unsqueeze(0),
+                                                 mj.unsqueeze(0)))
+            dov = sum(hist_overlap(sig_profiles[i][:, d],
+                                   sig_profiles[j][:, d])
+                      for d in range(mi.shape[0])) / mi.shape[0]
+            Smat[i, j] = (prof_cos + dov) / 2
+    off = ~torch.eye(16, dtype=torch.bool)
+    Ov, Sv = Omat[off], Smat[off]
+    r_link = float(torch.corrcoef(torch.stack([Ov, Sv]))[0, 1])
+    centrality = Omat.sum(1) - 1
+    mset = torch.tensor([mse[t] for t in range(16)])
+    r_diff = float(torch.corrcoef(torch.stack(
+        [centrality.double(), mset.double()]))[0, 1])
+    ranks = lambda v: torch.argsort(torch.argsort(v)).double()
+    rho_link = float(torch.corrcoef(torch.stack(
+        [ranks(Ov), ranks(Sv)]))[0, 1])
+
+    print("\n== VERDICTS")
+    print(f"  overlap->response linkage: pearson r={r_link:.3f} "
+          f"spearman rho={rho_link:.3f} (n={int(off.sum())} pairs)")
+    print(f"  overlap-centrality vs difficulty (MSE): r={r_diff:.3f}")
+    if antipodal:
+        av = torch.tensor([antipodal[t] for t in range(16)])
+        print(f"  antipodal (RP axis) pairing: mean {float(av.mean()):.4f} "
+              f"range {float(av.min()):.4f}-{float(av.max()):.4f}")
+    res = {"run": RUN, "n_per_type": N_PER_TYPE, "img": IMG,
+           "type_names": TYPE_NAMES,
+           "O_overlap": [[round(float(v), 4) for v in row] for row in Omat],
+           "S_response": [[round(float(v), 4) for v in row] for row in Smat],
+           "mse_per_type": mse, "antipodal_per_type": antipodal,
+           "linkage_pearson": round(r_link, 4),
+           "linkage_spearman": round(rho_link, 4),
+           "centrality_vs_mse_r": round(r_diff, 4)}
+    json.dump(res, open(OUT, "w"), indent=1)
+    api = HfApi()
+    api.upload_file(path_or_fileobj=OUT,
+                    path_in_repo="battery/v1g_svae_overlap/v1g_sweep.json",
+                    repo_id=SHIP_REPO,
+                    commit_message="V1g: 16-noise overlap sweep on the "
+                    "native SVAE substrate (overlap->response linkage + "
+                    "16x16 matrices + antipodal census)")
+    print(f"saved -> {OUT} ; shipped -> {SHIP_REPO}")
+
+
+if __name__ == "__main__":
+    main()

trainers/v1i_validity_batteries.py

@@ -0,0 +1,400 @@
+# =========================================================================
+# v1i_validity_batteries.py — AbstractPhil's validity campaign (2026-08-10):
+# corruption/numerics/optimizer/schedule batteries against the four
+# possibilities: (1) Adam may not capture the necessary information;
+# (2) scheduling may be the solution or a no-op; (3) splat/aleph fragility
+# vs standard attention; (4) unaccounted corruption.
+#
+# Bed point: R64 recall, K=64, D=16, ALEPH_TRI_PAD_FIX=1 (the repaired
+# config; padfix baseline .696/.733 mean .714, sdpa_tri ref .936).
+# MODES (env V1I_MODE):
+#  dtype — fp32 control / bf16 autocast / fp16 AMP / fp8sim (address-path
+#          e4m3 roundtrip: codebook + q/k projections quantized each
+#          forward) / fp64probe (2k-step numeric-truth probe).
+#          AbstractPhil: "is the computable range of differentiation beyond fp32,
+#          can it be represented as less data (fp8), test middlegrounds."
+#  opt   — adam(control)/sgd_mom/lion/muon/adagrad x {hub, sdpa}.
+#          PHIL-AUTHORIZED DEVIATION from the pure-Adam rider (screens
+#          only, labeled; AdamW remains excluded per the hard law).
+#          Fair-comparison discipline: 300-step LR probe over
+#          {3e-4,1e-3,3e-3,1e-2} per optimizer/arm before the real run.
+#          Fragility gauge (possibility 3): cross-optimizer outcome
+#          variance per architecture.
+#  sched — on hub+adam: warmcos / geomfirst (addr-group fast->slow per
+#          A1 frame-lock, trunk-group slow->fast per A2 late-accrual —
+#          the math-aligned schedule) / inverse (labeled falsification
+#          control). Flat control = the padfix cells.
+# Gauges everywhere: answer acc, bpb, selection_eval decomposition,
+# den-clamp fraction (numeric-health), census.
+# RUN: V1I_MODE=dtype|opt|sched python tools\v1i_validity_batteries.py
+# =========================================================================
+
+import importlib
+import json
+import math
+import os
+import sys
+
+import torch
+import torch.nn.functional as F
+
+os.environ["ALEPH_TRI_PAD_FIX"] = "1"          # standing order (V1f)
+
+
+def _load(name):
+    if name in sys.modules:
+        return sys.modules[name]
+    try:
+        return importlib.import_module(name)
+    except ImportError:
+        here = globals().get("__file__")
+        if here is not None:
+            import pathlib
+            sys.path.insert(0, str(pathlib.Path(here).parent))
+            return importlib.import_module(name)
+        raise
+
+
+bed = _load("ar_differentiation_bed")
+v1b = _load("v1b_recall_army_battery")
+class _cb:                          # public shim: token from env
+    @staticmethod
+    def hf_token():
+        import os as _os
+        return _os.environ.get("HF_TOKEN")
+cb = _cb()
+from huggingface_hub import HfApi            # noqa: E402
+
+assert torch.cuda.is_available(), "GPU only"
+DEV = "cuda"
+MODE = os.environ.get("V1I_MODE", "dtype")
+STEPS = int(os.environ.get("V1I_STEPS", "8000"))
+K_ARMY, D_ADDR, R_KEY = 64, 16, 64
+BATCH, BLOCK = v1b.BATCH, v1b.BLOCK
+DATA_DIR = "./data/v1_rank_army_padfix"
+OUT_DIR = f"{DATA_DIR}/results_v1i_{MODE}"
+HUB_REPO = v1b.HUB_REPO
+BASELINE = 0.7143                              # padfix K64/D16 mean
+
+
+def get_data():
+    os.environ["V1B_DATA"] = DATA_DIR
+    v1b.DATA_DIR = DATA_DIR
+    return v1b.get_data(R_KEY)
+
+
+# ---------------------------------------------------------------- optimizers
+class Lion(torch.optim.Optimizer):
+    """Sign-momentum (pattern-aligned). lr ~3-10x smaller than Adam's."""
+
+    def __init__(self, params, lr=1e-4, betas=(0.9, 0.99)):
+        super().__init__(params, dict(lr=lr, betas=betas))
+
+    @torch.no_grad()
+    def step(self):
+        for g in self.param_groups:
+            b1, b2 = g["betas"]
+            for p in g["params"]:
+                if p.grad is None:
+                    continue
+                st = self.state.setdefault(p, {})
+                m = st.setdefault("m", torch.zeros_like(p))
+                p.add_(torch.sign(m.mul(b1).add(p.grad, alpha=1 - b1)),
+                       alpha=-g["lr"])
+                m.mul_(b2).add_(p.grad, alpha=1 - b2)
+
+
+def _ns_orth(G, steps=5):
+    """Newton-Schulz orthogonalization (Muon core), fp32."""
+    a, b, c = 3.4445, -4.7750, 2.0315
+    X = G.float()
+    X = X / (X.norm() + 1e-7)
+    tall = X.shape[0] > X.shape[1]
+    if tall:
+        X = X.T
+    for _ in range(steps):
+        A = X @ X.T
+        X = a * X + (b * A + c * A @ A) @ X
+    return (X.T if tall else X).to(G.dtype)
+
+
+class Muon(torch.optim.Optimizer):
+    """Orthogonalized momentum on 2D weights (geometrically aligned);
+    Adam fallback for non-2D params handled by the caller."""
+
+    def __init__(self, params, lr=2e-2, momentum=0.95):
+        super().__init__(params, dict(lr=lr, momentum=momentum))
+
+    @torch.no_grad()
+    def step(self):
+        for g in self.param_groups:
+            for p in g["params"]:
+                if p.grad is None or p.ndim != 2:
+                    continue
+                st = self.state.setdefault(p, {})
+                m = st.setdefault("m", torch.zeros_like(p))
+                m.mul_(g["momentum"]).add_(p.grad)
+                p.add_(_ns_orth(m), alpha=-g["lr"])
+
+
+def make_opt(name, model, lr):
+    ps = list(model.parameters())
+    if name == "adam":
+        return [torch.optim.Adam(ps, lr=lr, weight_decay=0.0)]
+    if name == "sgd_mom":
+        return [torch.optim.SGD(ps, lr=lr, momentum=0.9)]
+    if name == "adagrad":
+        return [torch.optim.Adagrad(ps, lr=lr)]
+    if name == "lion":
+        return [Lion(ps, lr=lr / 3)]
+    if name == "muon":
+        two = [p for p in ps if p.ndim == 2]
+        rest = [p for p in ps if p.ndim != 2]
+        return [Muon(two, lr=lr * 20),
+                torch.optim.Adam(rest, lr=lr, weight_decay=0.0)]
+    raise ValueError(name)
+
+
+def lr_probe(name, arm, d, cands=(3e-4, 1e-3, 3e-3, 1e-2)):
+    best, best_loss = cands[0], float("inf")
+    for lr in cands:
+        torch.manual_seed(0)
+        g = torch.Generator().manual_seed(0)
+        m = bed.ByteLM(arm, block=BLOCK, K=K_ARMY, D=D_ADDR).to(DEV)
+        opts = make_opt(name, m, lr)
+        tot = 0.0
+        ok = True
+        for step in range(300):
+            x, y, mk = v1b.batch_masked(d["tr"], d["trm"], BATCH, BLOCK,
+                                        DEV, g)
+            logits = m(x)
+            loss = (F.cross_entropy(logits.reshape(-1, 256), y.reshape(-1))
+                    + 4.0 * F.cross_entropy(logits[mk], y[mk]))
+            if not torch.isfinite(loss):
+                ok = False
+                break
+            for o in opts:
+                o.zero_grad(set_to_none=True)
+            loss.backward()
+            for o in opts:
+                o.step()
+            if step >= 200:
+                tot += float(loss)
+        del m
+        torch.cuda.empty_cache()
+        if ok and tot < best_loss:
+            best_loss, best = tot, lr
+    return best
+
+
+# ---------------------------------------------------------------- fp8 sim
+def fp8_roundtrip(t):
+    if hasattr(torch, "float8_e4m3fn"):
+        return t.to(torch.float8_e4m3fn).to(t.dtype)
+    scale = t.abs().amax().clamp_min(1e-8) / 448.0
+    return ((t / scale).clamp(-448, 448).round() * scale)
+
+
+class FP8AddrHUB(bed.CausalHUB):
+    """Address path through an e4m3 bottleneck each forward: does the
+    differentiation structure survive 8-bit representation?"""
+
+    def forward(self, x):
+        q8 = fp8_roundtrip(self.q(x))
+        k8 = fp8_roundtrip(self.k(x))
+        A = self.addr.codebook.data
+        self.addr.codebook.data = fp8_roundtrip(A)
+        try:
+            qp, qn = self.addr.oriented(q8)
+            kp, kn = self.addr.oriented(k8)
+        finally:
+            self.addr.codebook.data = A
+        v = self.v(x)
+        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))
+        self._den_min = float(den.abs().min())
+        return self.o(num / den.clamp_min(1e-12))
+
+
+def den_health(model, d, g):
+    """Fraction of read positions whose denominator sits near the clamp."""
+    xv, _, _ = v1b.batch_masked(d["va"], d["vam"], BATCH, BLOCK, DEV, g)
+    fracs = []
+    with torch.no_grad():
+        x = model.emb(xv)
+        if getattr(model, "trigram", False):
+            pv = 256 if getattr(model, "pad_fix", False) else 0
+            x = x + model.emb1(F.pad(xv, (1, 0), value=pv)[:, :-1]) \
+                  + model.emb2(F.pad(xv, (2, 0), value=pv)[:, :-2])
+        x = x + model.pos[:, : xv.shape[1]]
+        for blk in model.blocks:
+            h = blk.n1(x)
+            at = blk.attn
+            if not hasattr(at, "addr"):
+                return None
+            qp, qn = at.addr.oriented(at.q(h))
+            kp, kn = at.addr.oriented(at.k(h))
+            zp, zn = torch.cumsum(kp, 1), torch.cumsum(kn, 1)
+            den = ((qp * zp).sum(-1) + (qn * zn).sum(-1))
+            fracs.append(float((den.abs() < 1e-6).float().mean()))
+            x = blk(x)
+    return round(sum(fracs) / len(fracs), 6)
+
+
+# ---------------------------------------------------------------- schedules
+def sched_lr(kind, group, step, total, base=3e-4):
+    t = step / total
+    if kind == "warmcos":
+        if t < 0.05:
+            return base * t / 0.05
+        return base * 0.5 * (1 + math.cos(math.pi * (t - .05) / .95))
+    if kind == "geomfirst":                      # math-aligned (A1+A2)
+        if group == "addr":                      # frame locks early
+            return 3e-3 * math.exp(-6 * t) + 3e-5
+        return 1e-4 + (5e-4 - 1e-4) * t          # function accrues late
+    if kind == "inverse":                        # labeled falsification
+        if group == "addr":
+            return 3e-5 + (3e-3 - 3e-5) * t
+        return 5e-4 * math.exp(-6 * t) + 1e-4
+    return base
+
+
+def addr_params(model):
+    ids = set()
+    for blk in model.blocks:
+        at = blk.attn
+        for p in (list(at.addr.parameters()) + list(at.q.parameters())
+                  + list(at.k.parameters())):
+            ids.add(id(p))
+    return ids
+
+
+# ---------------------------------------------------------------- cells
+def run_cell(tag, build_fn, opt_fn, seed, d, autocast_dtype=None,
+             sched_kind=None):
+    out_p = f"{OUT_DIR}/{tag}_s{seed}.json"
+    if os.path.exists(out_p):
+        print(f"-- {tag}_s{seed}: exists, skip", flush=True)
+        return json.load(open(out_p))
+    torch.manual_seed(seed)
+    g = torch.Generator().manual_seed(seed)
+    model = build_fn().to(DEV)
+    opts = opt_fn(model)
+    aset = addr_params(model) if sched_kind else None
+    scaler = (torch.amp.GradScaler("cuda")
+              if autocast_dtype == torch.float16 else None)
+    for step in range(1, STEPS + 1):
+        x, y, mk = v1b.batch_masked(d["tr"], d["trm"], BATCH, BLOCK, DEV, g)
+        if autocast_dtype is not None:
+            with torch.autocast("cuda", dtype=autocast_dtype):
+                logits = model(x)
+                loss = (F.cross_entropy(logits.reshape(-1, 256).float(),
+                                        y.reshape(-1))
+                        + 4.0 * F.cross_entropy(logits[mk].float(), y[mk]))
+        else:
+            logits = model(x)
+            loss = (F.cross_entropy(logits.reshape(-1, 256), y.reshape(-1))
+                    + 4.0 * F.cross_entropy(logits[mk], y[mk]))
+        for o in opts:
+            o.zero_grad(set_to_none=True)
+        if scaler:
+            scaler.scale(loss).backward()
+            for o in opts:
+                scaler.step(o)
+            scaler.update()
+        else:
+            loss.backward()
+            for o in opts:
+                o.step()
+        if sched_kind:
+            for o in opts:
+                for grp in o.param_groups:
+                    is_addr = all(id(p) in aset for p in grp["params"]) \
+                        if grp["params"] else False
+                    grp["lr"] = sched_lr(sched_kind,
+                                         "addr" if is_addr else "trunk",
+                                         step, STEPS)
+    model.eval()
+    acc, bpb = v1b.masked_eval(model, d, g, iters=32)
+    sel = v1b.selection_eval(model, d, g, iters=32)
+    dh = den_health(model, d, g)
+    res = {"tag": tag, "seed": seed, "steps": STEPS, "mode": MODE,
+           "final_acc": round(acc, 4), "final_bpb": round(bpb, 4),
+           "selection": sel, "den_near_clamp_frac": dh,
+           "baseline_padfix": BASELINE}
+    os.makedirs(OUT_DIR, exist_ok=True)
+    json.dump(res, open(out_p, "w"), indent=1)
+    print(f"-- {tag}_s{seed}: acc {acc:.4f} bpb {bpb:.4f} "
+          f"missel {sel['mis_sel_frac_of_errors']:.3f} den {dh}", flush=True)
+    del model
+    torch.cuda.empty_cache()
+    return res
+
+
+def main():
+    print("=" * 78, flush=True)
+    print(f"V1i VALIDITY BATTERY mode={MODE} at R{R_KEY}/K{K_ARMY}/D{D_ADDR}"
+          f" padfix (baseline {BASELINE}, sdpa .936)", flush=True)
+    print("=" * 78, flush=True)
+    api = HfApi(token=cb.hf_token())
+    d = get_data()
+    results = []
+    mk_hub = lambda: bed.ByteLM("hub_tri", block=BLOCK, K=K_ARMY, D=D_ADDR)
+    mk_sdpa = lambda: bed.ByteLM("sdpa_tri", block=BLOCK, K=K_ARMY, D=D_ADDR)
+    adam = lambda m: make_opt("adam", m, 3e-4)
+
+    if MODE == "dtype":
+        def mk_fp8():
+            m = mk_hub()
+            m.blocks = torch.nn.ModuleList(
+                [bed.Block(192, FP8AddrHUB(192, K_ARMY, D_ADDR))
+                 for _ in range(4)])
+            return m
+        cells = [("fp32", mk_hub, None), ("bf16", mk_hub, torch.bfloat16),
+                 ("fp16", mk_hub, torch.float16), ("fp8addr", mk_fp8, None)]
+        for tag, fn, ac in cells:
+            for seed in (0, 1):
+                results.append(run_cell(tag, fn, adam, seed, d,
+                                        autocast_dtype=ac))
+    elif MODE == "opt":
+        for name in ("adam", "sgd_mom", "lion", "muon", "adagrad"):
+            for arm, mk, seeds in (("hub", mk_hub, (0, 1)),
+                                   ("sdpa", mk_sdpa, (0,))):
+                lr = 3e-4 if name == "adam" else lr_probe(name,
+                                                          f"{arm}_tri", d)
+                print(f"   [{name}/{arm}] lr={lr}", flush=True)
+                for seed in seeds:
+                    results.append(run_cell(
+                        f"{name}_{arm}", mk,
+                        lambda m, n=name, l=lr: make_opt(n, m, l),
+                        seed, d))
+    elif MODE == "sched":
+        for kind in ("warmcos", "geomfirst", "inverse"):
+            for seed in (0, 1):
+                results.append(run_cell(f"sched_{kind}", mk_hub, adam,
+                                        seed, d, sched_kind=kind))
+    # ---- summarize + ship ----
+    summary = {}
+    for r in results:
+        summary.setdefault(r["tag"], []).append(r["final_acc"])
+    for tag, accs in summary.items():
+        mean = sum(accs) / len(accs)
+        print(f"{tag:>14}: {mean:.4f} ({mean - BASELINE:+.4f})", flush=True)
+    out = f"{OUT_DIR}/v1i_{MODE}_verdict.json"
+    json.dump({t: {"acc": a, "mean": round(sum(a) / len(a), 4)}
+               for t, a in summary.items()}, open(out, "w"), indent=1)
+    api.upload_file(path_or_fileobj=out,
+                    path_in_repo=f"battery/v1i_validity/{MODE}_verdict.json",
+                    repo_id=HUB_REPO,
+                    commit_message=f"V1i {MODE} battery verdict")
+    print("DONE.", flush=True)
+
+
+if __name__ == "__main__":
+    main()