Upload jobs/g1fs16_probe.py with huggingface_hub

jobs/g1fs16_probe.py

@@ -0,0 +1,1005 @@
+#!/usr/bin/env python3
+# /// script
+# requires-python = ">=3.10"
+# dependencies = [
+#   "torch>=2.2",
+#   "numpy>=1.23",
+#   "huggingface_hub>=0.24",
+# ]
+# ///
+"""G1-FS16: the corrected emergence instrument (spec v4.3 prereg).
+
+Question, unchanged: does compression pressure ALONE bind an operator
+field, shown by compositional generalization no matched control reaches?
+
+What makes this instrument different from the falsified G1-DR probe:
+
+* MAP-FAMILY EXPLOSION.  Operators are two SHA256-derived random
+  permutations of all 256 byte values.  Training covers every word of
+  depth 0..10 -- 2,047 DISTINCT random permutations, ~4.2 Mbit of
+  incompressible map content.  A d=64 spine cannot store that, but it
+  can store two generators (~4 kbit) if the field binds them.  Binding
+  is not merely possible, it is the only affordable encoding.
+* GENUINELY JOINT EVENTS.  One latent word governs M records that share
+  a program, so the event marginal spans M*8 answer bytes.
+* ORDER-SENSITIVE COMPILER + TRUE M3 EXECUTION (trident/nucleus5m3.py),
+  repairing the two structural defects that made G1-DR's negative
+  uninformative.
+* CLOSURE EVALUATION.  Words of depth 11..16 are never trained; the
+  preregistered global cap is 16, the same frozen tensors execute, and
+  evaluation adds no weights and no routing.
+
+Oracle certificate runs FIRST and is a training-only diagnostic under
+the 9.3 control rules: if the executor cannot represent the maps under
+forced words, the apparatus is invalid and no G1 evidence exists.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import itertools
+import json
+import math
+import os
+import sys
+import time
+from typing import Dict, List, Optional, Tuple
+
+import numpy as np
+import torch
+from huggingface_hub import HfApi
+from torch import Tensor, nn
+
+SRC_REPO = os.environ.get("TRIDENT_SRC_REPO", "farguney/trident-src")
+try:
+    import trident  # noqa: F401
+except ModuleNotFoundError:
+    from huggingface_hub import snapshot_download
+
+    sys.path.insert(0, snapshot_download(
+        repo_id=SRC_REPO, repo_type="model",
+        revision=os.environ.get("TRIDENT_SRC_REVISION")))
+
+from trident.core5 import BOS_ID, Core5, Core5Config      # noqa: E402
+from trident.nucleus5m3 import M3Config, M3Field          # noqa: E402
+
+DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+ARM = os.environ.get("FS16_ARM", "field")
+SEEDS = [int(s) for s in os.environ.get("FS16_SEEDS", "0").split(",")]
+STEPS = int(os.environ.get("FS16_STEPS", "24000"))
+EVENTS = int(os.environ.get("FS16_EVENTS", "2"))      # logical events/step
+M_REC = int(os.environ.get("FS16_M", "16"))           # records per event
+LR = float(os.environ.get("FS16_LR", "1e-3"))
+COMP_LR = float(os.environ.get("FS16_COMP_LR", "1e-4"))
+D_MODEL = int(os.environ.get("FS16_D", "64"))
+N_LAYERS = int(os.environ.get("FS16_LAYERS", "3"))
+CARRIER = int(os.environ.get("FS16_CARRIER", "256"))
+D_COMPILE = int(os.environ.get("FS16_DC", "32"))
+TRAIN_DEPTH = int(os.environ.get("FS16_TRAIN_DEPTH", "10"))
+CLOSURE = int(os.environ.get("FS16_CLOSURE", "16"))
+N_SLOTS = int(os.environ.get("FS16_SLOTS", "16"))
+LAM_MID = float(os.environ.get("FS16_LAM_MID", "1.0"))
+LAM_CPU = float(os.environ.get("FS16_LAM_CPU", "0.02"))
+LAM_A = float(os.environ.get("FS16_LAM_A", "0.02"))
+# Cold-start schedules (training-only; the model never observes either
+# variable, and both end at the registered stationary objective).
+#   MID_WARMUP: fraction of training over which lam_mid ramps 0 -> LAM_MID.
+#     At init the intermediate distributions are near-uniform, so the full
+#     charge prices a depth-10 word at ~64*8*9 = 4608 bits against 0 for
+#     the empty word, an order of magnitude more than the ~512 bits of
+#     answer content any word could ever win.  That is an initialization
+#     artifact, not a description length: nothing is being transmitted yet.
+#   CURRIC: fraction over which the trained depth grows 1 -> TRAIN_DEPTH,
+#     with the alphabet tracking it.  Pure data ordering plus a schedule on
+#     a preregistered hypothesis-space cap; codes stay exchangeable.
+MID_WARMUP = float(os.environ.get("FS16_MID_WARMUP", "0.3"))
+CURRIC = float(os.environ.get("FS16_CURRIC", "0.5"))
+# ST: run the training forward pass through the EXACT deploy bottleneck (a
+# one-hot byte) with the softmax gradient, instead of a soft mixture.  The
+# entropy charge exists only because the soft relaxation re-seeds the
+# carrier from a convex combination of all 256 byte embeddings, which
+# carries far more than 8 bits and is a continuous scratchpad deploy cannot
+# use.  Straight-through removes that gap by construction, at which point
+# lam_mid has nothing left to buy and the honest remaining price of an
+# intermediate is CPU, which LAM_CPU already charges: at deploy the byte is
+# recomputed deterministically from weights the decoder already holds, so
+# no intermediate is ever transmitted and no codelength is owed for it.
+ST = os.environ.get("FS16_ST", "0") == "1"
+# ST_AFTER: fraction of training after which the forward pass switches from
+# the soft mixture to the exact one-hot.  Straight-through alone measured
+# WORSE than the soft path at matched step and depth (byte 0.253 vs 0.971 at
+# step 5000, depth 4): the one-hot forward is exact but its gradient is
+# biased, and early on the mixture's gradient is what breaks the code
+# symmetry.  Only the DEPLOYED model has to satisfy train == deploy; the
+# path there does not.  Annealing soft -> one-hot ends at the exact identity,
+# so the final claim is clean, no entropy charge is ever levied, and the
+# early gradient is unbiased.  0 = one-hot from the start, 1 = never.
+ST_AFTER = float(os.environ.get("FS16_ST_AFTER", "0"))
+# ACT_INIT: F_k = I + ACT_INIT * Q_k with Q_k Haar-orthogonal.  At the old
+# near-identity scale two codes' displacement logits differed by std 0.0001
+# against base logits of 0.16 -- 1600x too small for a gradient to tell the
+# codes apart, which is the real reason the field sat idle.  Measured
+# separations: 0.0001 (old) / 0.20 (2.0) / 0.40 (4.0), min singular value
+# 3.0 at 4.0 so every action is invertible at init.
+ACT_INIT = float(os.environ.get("FS16_ACT_INIT", "4.0"))
+# SAMPLED: send executor gradient through ONE posterior-sampled word per
+# event rather than the full q-weighted marginal.  Same expected gradient
+# (q is the posterior, so the envelope theorem applies) but the realized
+# update is a coherent program instead of the posterior-mean of 2047 words.
+SAMPLED = os.environ.get("FS16_SAMPLED", "1") == "1"
+NO_PUSH = os.environ.get("FS16_NO_PUSH", "0") == "1"
+# Optimizer schedule.  OFF by default: the registered 24k matrix ran with a
+# constant LR and its law must stay reproducible.  A schedule carries no task,
+# label, reward, or semantic signal and changes no tensor's provenance, so it
+# is A0-neutral -- it is an optimizer setting, not a training signal.
+COSINE = os.environ.get("FS16_COSINE", "0") == "1"
+# --- the board's repair set for FS16-UNSTABLE (all default ON; setting all
+# --- three to 0 with COSINE=0 reproduces the registered 24k matrix exactly)
+# Byte-local compiler: stationary symbol map, so concatenation is mechanical.
+BYTE_LOCAL = os.environ.get("FS16_BYTE_LOCAL", "1") == "1"
+# Rate barrier on the posterior. beta*log2(W/eps) = 61.3 bits at beta=4 must
+# be paid before an alternative word can displace the incumbent, which stops
+# hard EM from locking onto a random alias. A STRICTER R_A charge, never weaker.
+BETA_A = float(os.environ.get("FS16_BETA_A", "4.0"))
+# Per-group gradient clipping instead of one global norm.
+GROUP_CLIP = os.environ.get("FS16_GROUP_CLIP", "1") == "1"
+# Frozen, domain-separated evaluation panel; evaluation never touches train RNG.
+FROZEN_PANEL = os.environ.get("FS16_FROZEN_PANEL", "1") == "1"
+LR_WARMUP = int(os.environ.get("FS16_LR_WARMUP", "500"))
+LR_FLOOR = float(os.environ.get("FS16_LR_FLOOR", "0.02"))
+EPS = float(os.environ.get("FS16_EPS", "0.05"))
+EVAL_EVERY = int(os.environ.get("FS16_EVAL_EVERY", "1000"))
+# evaluation sample sizes; a reading must be able to carry a gate
+EVAL_WORDS = int(os.environ.get("FS16_EVAL_WORDS", "4"))
+EVAL_EVENTS_PER_WORD = int(os.environ.get("FS16_EVAL_EVENTS", "2"))
+EVAL_BIND = int(os.environ.get("FS16_EVAL_BIND", "16"))
+EVAL_PURITY = int(os.environ.get("FS16_EVAL_PURITY", "4"))
+ORACLE_STEPS = int(os.environ.get("FS16_ORACLE_STEPS", "3000"))
+ORACLE_ONLY = os.environ.get("FS16_ORACLE_ONLY", "0") == "1"
+# 0.02 bits for every registered run; env override exists ONLY so the
+# plumbing smoke can run at toy widths that cannot meet the certificate
+ORACLE_ENT_TOL = float(os.environ.get("FS16_ORACLE_ENT_TOL", "0.02"))
+RESULTS_REPO = os.environ.get("FS16_RESULTS_REPO", "deepadapt/trident-ec")
+
+# The registered G1-FS16 certification geometry (10.5.2).  Two independent
+# accidents made this a structural matter rather than a naming convention:
+# (i) every seed of an arm wrote to `g1fs16_{ARM}.json`, so three concurrent
+# seed jobs silently overwrote each other and a 3/3-seed verdict could not be
+# assembled from the artifacts at all; (ii) a toy-width CPU smoke published
+# over a registered field artifact, and it differed only in
+# m_records/carrier/closure/slots -- nothing a reader of the filename could
+# have noticed.  So the path now carries the seed, and any deviation from the
+# geometry below is diverted to `scratch/` at construction time.  Publishing
+# correctly is no longer something anyone has to remember to do.
+CERT_GEOMETRY = {"events": 2, "m_records": 16, "d": 64, "layers": 3,
+                 "carrier": 256, "train_depth": 10, "closure": 16,
+                 "slots": 16}
+
+
+def _geometry() -> Dict[str, int]:
+    return {"events": EVENTS, "m_records": M_REC, "d": D_MODEL,
+            "layers": N_LAYERS, "carrier": CARRIER,
+            "train_depth": TRAIN_DEPTH, "closure": CLOSURE, "slots": N_SLOTS}
+
+
+def _off_law() -> Dict[str, str]:
+    """Law-bearing dimensions in which this run departs from the registered
+    geometry.  Empty for a certification run."""
+    live = _geometry()
+    return {k: f"{live[k]} != {v}"
+            for k, v in CERT_GEOMETRY.items() if live[k] != v}
+
+
+OFF_LAW = _off_law()
+RESULT_FILE = os.environ.get("FS16_RESULT_FILE") or (
+    ("scratch/" if OFF_LAW else "")
+    + f"g1fs16_{ARM}_s{'-'.join(str(s) for s in SEEDS)}.json")
+NONCE_MAX = int(os.environ.get("FS16_NONCE_MAX", "32"))
+
+REC_LEN = 32
+N_PAIRS = 8
+PROG_BYTES = 16
+PAD = ord(".")
+K_CODES = 2
+
+torch.set_float32_matmul_precision("high")
+
+
+# ---------------------------------------------------------------------------
+# corpus: collision-free free semigroup of random byte permutations
+# ---------------------------------------------------------------------------
+
+def _stream(nonce: int, gen: int, counter: int) -> int:
+    h = hashlib.sha256(
+        b"TRIDENT-G1-FS16-v1" + nonce.to_bytes(4, "big")
+        + gen.to_bytes(1, "big") + counter.to_bytes(8, "big")).digest()
+    return int.from_bytes(h[:8], "big")
+
+
+def _permutation(nonce: int, gen: int) -> np.ndarray:
+    """Fisher-Yates with rejection sampling (never modulo-biased)."""
+    p = np.arange(256, dtype=np.uint8)
+    counter = 0
+    for i in range(255, 0, -1):
+        m = i + 1
+        limit = (1 << 64) - ((1 << 64) % m)
+        while True:
+            r = _stream(nonce, gen, counter)
+            counter += 1
+            if r < limit:
+                break
+        j = r % m
+        p[i], p[j] = p[j], p[i]
+    return p
+
+
+def _closure_is_collision_free(perms: List[np.ndarray],
+                               depth: int) -> bool:
+    """All words of depth 0..depth induce distinct permutations."""
+    seen = {np.arange(256, dtype=np.uint8).tobytes()}
+    frontier = [np.arange(256, dtype=np.uint8)]
+    for _ in range(depth):
+        nxt = []
+        for cur in frontier:
+            for p in perms:
+                comp = p[cur]                    # sigma_g o sigma_w
+                key = comp.tobytes()
+                if key in seen:
+                    return False
+                seen.add(key)
+                nxt.append(comp)
+        frontier = nxt
+    return True
+
+
+def find_nonce(depth: int) -> Tuple[int, List[np.ndarray]]:
+    for nonce in range(NONCE_MAX):
+        perms = [_permutation(nonce, g) for g in range(K_CODES)]
+        if _closure_is_collision_free(perms, depth):
+            return nonce, perms
+    raise RuntimeError("no collision-free nonce found")
+
+
+def word_perm(perms: List[np.ndarray], w: Tuple[int, ...]) -> np.ndarray:
+    out = np.arange(256, dtype=np.uint8)
+    for g in w:
+        out = perms[g][out]
+    return out
+
+
+def enumerate_words(depth_lo: int, depth_hi: int) -> List[Tuple[int, ...]]:
+    out: List[Tuple[int, ...]] = []
+    for d in range(depth_lo, depth_hi + 1):
+        if d == 0:
+            out.append(())
+        else:
+            out.extend(itertools.product(range(K_CODES), repeat=d))
+    return out
+
+
+def make_event(word: Tuple[int, ...], perm: np.ndarray,
+               rng: np.random.Generator) -> np.ndarray:
+    """M records, 32 bytes each, sharing one program."""
+    prog = np.full(PROG_BYTES, PAD, dtype=np.uint8)
+    for j, g in enumerate(word):
+        prog[j] = ord("P") + g
+    xs = rng.integers(0, 256, size=(M_REC, N_PAIRS)).astype(np.uint8)
+    rec = np.empty((M_REC, REC_LEN), dtype=np.uint8)
+    rec[:, :PROG_BYTES] = prog
+    rec[:, PROG_BYTES::2] = xs
+    rec[:, PROG_BYTES + 1::2] = perm[xs]
+    return rec
+
+
+# ---------------------------------------------------------------------------
+# model
+# ---------------------------------------------------------------------------
+
+class FS16Probe(nn.Module):
+    def __init__(self, arm: str):
+        super().__init__()
+        self.arm = arm
+        self.spine = Core5(Core5Config(d_model=D_MODEL, n_layers=N_LAYERS))
+        self.field: Optional[M3Field] = None
+        if arm != "no_opfield":
+            self.field = M3Field(M3Config(
+                d_model=D_MODEL, n_codes=K_CODES, carrier=CARRIER,
+                d_compile=D_COMPILE, n_slots=N_SLOTS,
+                train_depth=TRAIN_DEPTH, closure_depth=CLOSURE,
+                tie_actions=(arm == "dense_shared"), act_init=ACT_INIT,
+                byte_local=BYTE_LOCAL))
+            if arm == "random_frozen":
+                self.field.F_raw.requires_grad_(False)
+                self.field.S.requires_grad_(False)
+
+    def base_decode(self, xb: Tensor) -> Tensor:
+        """The model's OWN context-free byte decode (shared tensors)."""
+        if xb.dtype == torch.long:
+            e = self.spine.embed(xb)
+        else:
+            e = xb @ self.spine.embed.weight[:256]
+        return self.spine.head(self.spine.norm_f(e))
+
+    def spine_pass(self, rec: Tensor) -> Tuple[Tensor, Tensor]:
+        """(B,32) records -> (logits (B,32,256), states (B,32,d))."""
+        B = rec.shape[0]
+        bos = torch.full((B, 1), BOS_ID, dtype=torch.long,
+                         device=rec.device)
+        ids = torch.cat([bos, rec[:, :-1]], dim=1)
+        x = self.spine.embed(ids)
+        for n1, mix, n2, mlp in self.spine.blocks:
+            y, _ = mix(n1(x), None)
+            x = x + y
+            x = x + mlp(n2(x))
+        h = self.spine.norm_f(x)
+        return self.spine.head(h), h
+
+
+def target_positions() -> Tuple[List[int], List[int]]:
+    xpos = [PROG_BYTES + 2 * j for j in range(N_PAIRS)]
+    ypos = [PROG_BYTES + 2 * j + 1 for j in range(N_PAIRS)]
+    return xpos, ypos
+
+
+# ---------------------------------------------------------------------------
+# oracle capacity certificate (training-only diagnostic, never deployed)
+# ---------------------------------------------------------------------------
+
+def oracle_certificate(model: FS16Probe, perms: List[np.ndarray],
+                       seed: int) -> Dict[str, object]:
+    """Force singleton words; require exact composition to depth CLOSURE."""
+    field = model.field
+    params = [field.F_raw, field.S, model.spine.embed.weight,
+              model.spine.head.weight, model.spine.norm_f.g]
+    opt = torch.optim.AdamW([p for p in params if p.requires_grad],
+                            lr=3e-3, weight_decay=0.0)
+    rng = np.random.default_rng(7000 + seed)
+    P = torch.from_numpy(np.stack(perms)).long().to(DEVICE)
+    for step in range(ORACLE_STEPS):
+        x = torch.from_numpy(
+            rng.integers(0, 256, size=256).astype(np.int64)).to(DEVICE)
+        loss = 0.0
+        for g in range(K_CODES):
+            logits, _ = field.chain(x, (g,), model.base_decode, hard=False)
+            loss = loss + torch.nn.functional.cross_entropy(
+                logits, P[g][x])
+        opt.zero_grad(set_to_none=True)
+        loss.backward()
+        opt.step()
+        if step % 500 == 0:
+            print(f"[oracle-s{seed}] step {step} loss {float(loss):.5f}",
+                  flush=True)
+    allx = torch.arange(256, device=DEVICE)
+    worst_acc, worst_depth, max_ent = 1.0, -1, 0.0
+    with torch.no_grad():
+        for d in range(1, CLOSURE + 1):
+            probe = [tuple(rng.integers(0, K_CODES, size=d).tolist())
+                     for _ in range(4)] if d > 3 else \
+                list(itertools.product(range(K_CODES), repeat=d))
+            for w in probe:
+                logits, ent = field.chain(allx, w, model.base_decode,
+                                          hard=True)
+                tgt = torch.from_numpy(
+                    word_perm(perms, w).astype(np.int64)).to(DEVICE)
+                acc = float(logits.argmax(-1).eq(tgt).float().mean())
+                if acc < worst_acc:
+                    worst_acc, worst_depth = acc, d
+                max_ent = max(max_ent, float(ent.max()) / max(1, d - 1))
+    ok = worst_acc >= 1.0 - 1e-9 and max_ent < ORACLE_ENT_TOL
+    print(f"[oracle-s{seed}] worst_acc={worst_acc:.4f} at depth "
+          f"{worst_depth}, max_mid_entropy={max_ent:.4f} -> "
+          f"{'PASS' if ok else 'FAIL'}", flush=True)
+    return {"worst_acc": worst_acc, "worst_depth": worst_depth,
+            "max_mid_entropy": max_ent, "pass": ok}
+
+
+# ---------------------------------------------------------------------------
+# primary training: exact event codelength
+# ---------------------------------------------------------------------------
+
+def _slot_logits(field, rec: Tensor, states: Tensor) -> Tensor:
+    """Compiler read, contextual or byte-local.
+
+    The contextual path reads causal spine state, so the same program byte can
+    map to different codes after different prefixes and w(uv) = w(u)w(v) is
+    not enforced -- the mechanism behind the purity failure in the registered
+    24k matrix. The byte-local path makes the symbol map stationary by
+    construction. Default is byte-local; BYTE_LOCAL=0 reproduces the
+    registered matrix exactly."""
+    if BYTE_LOCAL:
+        return field.slot_logits_bytes(rec[:1, :N_SLOTS])
+    return field.slot_logits(states[:1, 1:1 + N_SLOTS])
+
+
+def event_codelength(model: FS16Probe, rec: Tensor, words, onehot,
+                     wlen: Tensor, salt: int, lam_mid: float = LAM_MID,
+                     st: bool = ST) -> Tuple[Tensor, Tensor, Tensor]:
+    """Returns (prefix_bits scalar, per-word event bits (W,), prior (W,))."""
+    logits, states = model.spine_pass(rec)
+    logp = torch.log_softmax(logits.float(), -1)
+    nll = -logp.gather(2, rec.unsqueeze(2)).squeeze(2) / math.log(2.0)
+    xpos, ypos = target_positions()
+    prefix_bits = nll.sum() - nll[:, ypos].sum()
+
+    if model.field is None:
+        return prefix_bits, nll[:, ypos].sum().unsqueeze(0), \
+            torch.zeros(1, device=rec.device)
+
+    field = model.field
+    if model.arm == "shuffled":
+        g = torch.Generator().manual_seed(salt)
+        perm = torch.randperm(K_CODES, generator=g).tolist()
+        words_exec = [tuple(perm[c] for c in w) for w in words]
+    else:
+        words_exec = words
+
+    x = rec[:, xpos].reshape(-1)                       # (M*8,)
+    y = rec[:, ypos].reshape(-1)
+    # FULL M3 logits, exactly the executor the oracle certifies.  The spine's
+    # contextual answer logits are deliberately NOT the base here: the law's
+    # own b(z_{L-1}) term is what the certificate covers, and substituting a
+    # contextual base made latent execution differ from the certified
+    # executor.  It also makes the field's task strictly harder than the
+    # no-field control's, which keeps its contextual spine readout.
+    word_logits, ent = field.tree_execute(
+        x, words_exec, model.base_decode, hard=False, st=st)
+    lp = torch.log_softmax(word_logits.float(), -1)
+    ans_bits = -lp.gather(2, y.view(1, -1, 1).expand(lp.shape[0], -1, 1)
+                          ).squeeze(2) / math.log(2.0)  # (W,N)
+    per_word = (ans_bits.sum(1) + lam_mid * ent.sum(1)
+                + LAM_CPU * x.shape[0] * wlen
+                + LAM_A * wlen * math.log2(K_CODES))
+    prior = field.word_scores_indexed(_slot_logits(field, rec, states),
+                                      onehot).squeeze(0)
+    return prefix_bits, per_word, prior
+
+
+PREFIX_R = float(os.environ.get("FS16_PREFIX_R", "0.5"))
+STRATIFIED = os.environ.get("FS16_STRATIFIED", "1") == "1"
+
+
+def _strata(words):
+    """Partition the enumerated support by length class: empty / 1 / >=2.
+
+    The strata are a property of the word lattice only -- lengths, nothing
+    else -- so stratifying carries no task signal and leaves the estimator
+    permutation-equivariant in the codes."""
+    lens = [len(w) for w in words]
+    masks = []
+    for pred in (lambda n: n == 0, lambda n: n == 1, lambda n: n >= 2):
+        m = torch.tensor([pred(n) for n in lens], device=DEVICE)
+        if bool(m.any()):
+            masks.append(m)
+    return masks
+
+
+def _prefix_floor(words, depth):
+    """Exchangeable prefix-process floor rho_r over the enumerated words.
+
+    The uniform eps/W floor spreads exploration mass evenly over every word,
+    and because words of depth d outnumber shorter ones geometrically, almost
+    all of that mass lands on LONG random aliases while each single primitive
+    gets eps/W.  At eps=0.05 over 2047 words a singleton floor is 2.4e-05, so
+    displacing a collapsed blank incumbent costs beta*log2(0.95/2.4e-05) = 61.3
+    bits -- and that is the same barrier that (correctly) stops random aliases.
+    Raising it protects against aliases and imprisons the first REAL code;
+    lowering it frees the code and reopens alias lock-in.  Tuning beta cannot
+    separate them because it scales both.
+
+    Length can.  Generate a word by stopping with probability (1-r), else
+    emitting one of K exchangeable codes, with forced termination at the cap:
+
+        rho_r(w) = (1-r) (r/K)^|w|      |w| < D
+                 = (r/K)^D              |w| = D
+
+    which is normalized by construction.  At r=1/2, K=2 a singleton floor is
+    eps/8 while a depth-10 alias floor is eps*(1/4)^10, so the singleton
+    barrier falls to 29.14 bits -- comfortably above the 15.9-bit largest
+    accidental advantage measured at init by scripts/beta_barrier.py -- while
+    the depth-10 alias barrier RISES to 97.14 bits.  Escape and stability stop
+    competing.
+
+    A0: rho_r reads only K, D and |w|.  It never sees a byte, a task id, a
+    label, an operator meaning or a verifier, and it is invariant under
+    relabelling of the codes, so it is an admissible R_A coding measure rather
+    than a task-shaped prior.
+    """
+    r, K = PREFIX_R, K_CODES
+    out = torch.empty(len(words), device=DEVICE)
+    for i, w in enumerate(words):
+        n = len(w)
+        if n >= depth:
+            lp = n * math.log(r / K)
+        else:
+            lp = math.log1p(-r) + n * math.log(r / K)
+        out[i] = lp
+    # renormalize over the ENUMERATED support: the cap means the tail beyond
+    # `depth` is unreachable here, and an unnormalized floor would silently
+    # change the total rate charge rather than only its shape.
+    out = out - torch.logsumexp(out, dim=0)
+    return out + math.log(EPS)
+
+
+def train_one(seed: int, perms: List[np.ndarray],
+              out: Dict[str, object], on_progress=None
+              ) -> Dict[str, object]:
+    torch.manual_seed(seed)
+    model = FS16Probe(ARM).to(DEVICE)
+    out["seed"] = seed
+
+    if model.field is not None:
+        out["oracle"] = oracle_certificate(model, perms, seed)
+        # The certificate is a validity gate for the PRIMARY arm only: it
+        # asks whether the executor could represent the maps at all, so a
+        # failure there means the instrument is broken and no G1 evidence
+        # exists.  For a control it asks nothing of the sort.  RANDOM-FROZEN
+        # freezes the actions and DENSE-SHARED ties them to one, so both
+        # MUST fail a capacity certificate -- that failure IS the crippling
+        # the control exists to impose.  Aborting them as invalid apparatus
+        # (which is what happened, silently, to both arms) would leave the
+        # purity comparison with no controls at all.
+        if ARM == "field" and not out["oracle"]["pass"]:
+            out["verdict"] = "INVALID-APPARATUS"
+            return out
+        if ORACLE_ONLY:
+            out["verdict"] = "ORACLE-ONLY"
+            return out
+        torch.manual_seed(seed)              # discard oracle weights
+        model = FS16Probe(ARM).to(DEVICE)
+
+    # one alphabet per curriculum depth; each is prefix-closed, so the
+    # level-batched executor consumes it directly
+    alpha: Dict[int, Tuple] = {}
+    for dd in range(1, TRAIN_DEPTH + 1):
+        ws = enumerate_words(0, dd)
+        alpha[dd] = (
+            ws,
+            (model.field.alphabet_onehot(ws).to(DEVICE)
+             if model.field is not None else None),
+            torch.tensor([float(len(w)) for w in ws], device=DEVICE),
+            math.log(EPS / len(ws)),
+            _prefix_floor(ws, dd),
+            _strata(ws))
+
+    # EXHAUSTIVE OWNERSHIP, not suffix guessing.
+    #
+    # The previous partition looked for {"W_c.weight", "e_code", "e_blank"} --
+    # but under byte_local=True there IS no W_c, so the "compiler" group held
+    # only the two symbol vectors while `E_byte` and `W_b.weight` -- the exact
+    # parameters that let P, Q and PAD acquire DISTINCT representations -- fell
+    # into the spine group and were clipped against its ~3915 norm.  `field.S`
+    # went with them.  So the 2260x throttle was only half repaired: the symbol
+    # vectors were freed and the byte READER was not, which is why the seed born
+    # with a distinct map held while the blank-born seeds could never repair
+    # theirs.  A missing name silently degraded to "spine", which is the failure
+    # mode that has now cost this line two matrices.
+    #
+    # Ownership is therefore explicit and total: every trainable parameter must
+    # belong to exactly one group, and an unowned parameter ABORTS rather than
+    # being absorbed by whichever group happens to catch it.
+    groups: dict[str, list] = {
+        "compiler_symbols": [],   # e_code, e_blank      -- the symbol map
+        "compiler_reader": [],    # E_byte, W_b, W_c     -- byte -> symbol
+        "actions": [],            # F_raw                -- the semigroup
+        "carrier": [],            # S                    -- readout carrier
+        "spine": [],
+    }
+    OWNERS = (
+        ("compiler_symbols", ("e_code", "e_blank")),
+        ("compiler_reader", ("E_byte", "W_b.weight", "W_c.weight")),
+        ("actions", ("F_raw",)),
+        ("carrier", ("field.S",)),
+    )
+    unowned = []
+    for n, p in model.named_parameters():
+        if not p.requires_grad:
+            continue
+        for group, suffixes in OWNERS:
+            if any(n == s or n.endswith("." + s) or n.endswith(s)
+                   for s in suffixes):
+                groups[group].append((n, p))
+                break
+        else:
+            if n.startswith("spine."):
+                groups["spine"].append((n, p))
+            else:
+                unowned.append(n)
+    if unowned:
+        raise SystemExit(
+            "optimizer ownership is not exhaustive; these trainable tensors "
+            "belong to no declared group and would be clipped against "
+            f"whichever group caught them: {unowned}")
+    seen: dict[int, str] = {}
+    for gname, items in groups.items():
+        for n, p in items:
+            if id(p) in seen:
+                raise SystemExit(
+                    f"parameter {n} is owned by both {seen[id(p)]} and {gname}")
+            seen[id(p)] = gname
+    if model.field is not None:
+        for gname in ("compiler_symbols", "compiler_reader", "actions",
+                      "carrier"):
+            if not groups[gname]:
+                raise SystemExit(
+                    f"group {gname} is empty while a field is present; the "
+                    f"partition no longer matches the nucleus")
+    print("[opt] " + "  ".join(
+        f"{g}={[n for n, _ in items]}" for g, items in groups.items()
+        if g != "spine"), flush=True)
+
+    comp = [p for _, p in groups["compiler_symbols"]]
+    reader = [p for _, p in groups["compiler_reader"]]
+    actions = [p for _, p in groups["actions"]]
+    carrier = [p for _, p in groups["carrier"]]
+    rest = [p for _, p in groups["spine"]]
+    # The code actions get NO weight decay.  They are initialized at
+    # I + noise, and 0.01 decay over 24k updates at lr 1e-3 multiplies that
+    # identity component by exp(-0.24) = 0.787 -- the optimizer was quietly
+    # dismantling the very structure the oracle certifies, and the oracle
+    # itself runs decay-free, so the two were not even the same executor.
+    opt = torch.optim.AdamW(
+        [{"params": rest, "lr": LR},
+         {"params": comp, "lr": COMP_LR},
+         # the reader keeps the nominal LR: it was never meant to be slowed,
+         # only to be clipped on its own norm instead of the spine's
+         {"params": reader, "lr": LR},
+         {"params": carrier, "lr": LR},
+         {"params": actions, "lr": LR, "weight_decay": 0.0}],
+        weight_decay=0.01)
+    for g in opt.param_groups:
+        g["base_lr"] = g["lr"]
+    # Every declared group clips on its OWN norm.  The reader and carrier were
+    # previously inside `spine` and therefore inside its ~3915 norm.
+    clip_groups = {"compiler_symbols": comp, "compiler_reader": reader,
+                   "actions": actions, "carrier": carrier, "spine": rest}
+    clip_norms: Dict[str, float] = {}
+
+    rng = np.random.default_rng(3000 + seed)
+    # Evaluation must not share the training stream.  It did: `evaluate` drew
+    # from `rng`, and a field arm draws extra binding and purity samples that
+    # NO-OPFIELD never draws, so the training bytes AFTER the first evaluation
+    # were not identical across arms -- a control-validity defect, and a
+    # confound for every mid-run swing, since a resampled panel makes
+    # evaluation noise look like training instability.  The panel is now
+    # frozen once, domain-separated, and shared by every checkpoint and every
+    # matched control.
+    eval_rng = np.random.default_rng(0xE7A1_0000 + seed)
+    train_words = enumerate_words(0, TRAIN_DEPTH)
+    by_depth = {d: [w for w in train_words if len(w) == d]
+                for d in range(TRAIN_DEPTH + 1)}
+    cursor = {d: 0 for d in by_depth}
+    hist, t0 = [], time.time()
+
+    for step in range(STEPS):
+        frac = step / max(1, STEPS - 1)
+        lam_mid = (LAM_MID if MID_WARMUP <= 0
+                   else LAM_MID * min(1.0, frac / MID_WARMUP))
+        cur_depth = (TRAIN_DEPTH if CURRIC <= 0 else
+                     1 + int((TRAIN_DEPTH - 1) * min(1.0, frac / CURRIC)))
+        st_now = ST or (ST_AFTER > 0 and frac >= ST_AFTER)
+        words, onehot, wlen, log_eps, log_floor, strata = alpha[cur_depth]
+        total = 0.0
+        bits = 0.0
+        for _ in range(EVENTS):
+            d = step % (cur_depth + 1)
+            pool = by_depth[d]
+            w = pool[cursor[d] % len(pool)]
+            cursor[d] += 1
+            rec = torch.from_numpy(
+                make_event(w, word_perm(perms, w), rng).astype(np.int64)
+            ).to(DEVICE)
+            pre, per_word, prior = event_codelength(
+                model, rec, words, onehot, wlen, salt=step, lam_mid=lam_mid,
+                st=st_now)
+            if model.field is None:
+                total = total + pre + per_word.sum()
+                bits = bits + float(pre) + float(per_word.sum())
+                continue
+            logpi = torch.log_softmax(prior, dim=-1)
+            mixed = torch.logaddexp(
+                logpi + math.log(1 - EPS),
+                log_floor if log_floor is not None
+                else torch.full_like(logpi, log_eps))
+            with torch.no_grad():
+                # beta-tempered posterior and the matching free energy.
+                #
+                #   F_b = min_q [ E_q C_w + b * KL_2(q || pi_eps) ]
+                #       = -b * log2 sum_w pi_eps(w) 2^(-C_w / b)
+                #
+                # Why this is needed: C_w sums 128 answer bytes, so an
+                # accidental advantage of 0.1 bit/byte is posterior odds of
+                # 2^12.8 ~ 7100.  Over 2047 words the posterior is essentially
+                # one-hot on a RANDOM alias before any action has acquired
+                # meaning, and the run is then doing hard EM over aliases.
+                # Raising the rate price to b bits makes an alternative pay
+                # b*log2(W/eps) = 61.3 bits at b=4 before it can displace the
+                # incumbent, which random advantages should not clear while a
+                # correct action (saving ~998 bits) clears it easily.
+                #
+                # A0: C_w is L_post and the KL is R_A, both listed terms.
+                # b > 1 is a STRICTER rate charge than the minimum, never a
+                # weaker one, and the posterior stays training-only and
+                # equivariant under permutation of the codes.
+                q = torch.softmax(mixed - per_word * math.log(2.0) / BETA_A, -1)
+                # the honest codelength, always the exact marginal
+                code_bits = -torch.logsumexp(
+                    mixed - per_word * math.log(2.0), dim=-1) / math.log(2.0)
+            if SAMPLED:
+                # EM M-step, sampled: E_q[C_w] has the same executor gradient
+                # as the marginal (q IS the posterior, so the envelope
+                # theorem applies) but the realized gradient runs through ONE
+                # word, so all M*8 answers in the event push a single coherent
+                # program.  The full marginal instead pulls every action
+                # toward the posterior-mean word, which is not a word.
+                if STRATIFIED:
+                    # STRATIFIED EM M-step.  One draw from q almost always
+                    # returns blank or a long word, so a primitive action can
+                    # go thousands of steps with no coherent credit at all --
+                    # and when the posterior sits on blank, the drawn word is
+                    # the EMPTY one, which by a pinned nucleus invariant touches
+                    # no action parameter, so the actions receive exactly zero
+                    # gradient and the deadlock is permanent.  Splitting the
+                    # exact posterior by length and drawing one word per stratum
+                    # guarantees a primitive gets a coherent update every event,
+                    # while the composite stratum still contributes ONE coherent
+                    # program rather than a posterior mean that is not a word.
+                    #
+                    #   E[grad] = sum_j Q_j E_{w~q(.|S_j)}[grad C_w]
+                    #           = sum_w q(w) grad C_w
+                    #
+                    # i.e. the SAME L_post gradient, since q is detached.  This
+                    # is a variance-reduction of a listed term, not a new one.
+                    exec_term = per_word.new_zeros(())
+                    for mask in strata:
+                        mass = float(q[mask].sum())
+                        if mass <= 0.0:
+                            continue
+                        sub = q[mask] / mass
+                        pick = int(torch.multinomial(sub, 1))
+                        idx = int(mask.nonzero()[pick])
+                        exec_term = exec_term + mass * per_word[idx]
+                else:
+                    exec_term = per_word[int(torch.multinomial(q, 1))]
+            else:
+                # The compiler is trained ONLY by the mirror step below.
+                # Leaving the marginal attached to `prior` sent it a second,
+                # undeclared gradient on top of the mirror step.
+                exec_term = -torch.logsumexp(
+                    mixed.detach() - per_word * math.log(2.0),
+                    dim=-1) / math.log(2.0)
+            # base 2: the rest of this objective is bits, and log_softmax is
+            # natural log, so the mirror step was silently weighted by 1/ln2.
+            # Scaled by BETA_A so the mirror surrogate is the gradient of the
+            # same beta free energy the posterior above is drawn from, rather
+            # than of a different objective.
+            comp_loss = -BETA_A * (
+                q * torch.log_softmax(prior, -1)).sum() / math.log(2.0)
+            total = total + pre + exec_term + comp_loss
+            bits = bits + float(pre) + float(code_bits)
+        loss = total / max(1, EVENTS)
+        opt.zero_grad(set_to_none=True)
+        loss.backward()
+        if GROUP_CLIP:
+            # One global norm over compiler + actions + spine is positive
+            # feedback: the answer gradient sums 128 bytes through up to ten
+            # actions while the compiler gets a single mirror term, so the
+            # seed with the largest executor gradient receives the SMALLEST
+            # effective compiler update -- exactly the seed that needs the
+            # compiler to move.  Seed 1 never left its initial basin.
+            # Clipping each group against its own norm removes the coupling.
+            # A0: a block-diagonal preconditioner carries no signal.
+            for gname, plist in clip_groups.items():
+                gs = [p for p in plist if p.grad is not None]
+                if gs:
+                    n = torch.nn.utils.clip_grad_norm_(gs, 1.0)
+                    clip_norms[gname] = float(n)
+        else:
+            clip_norms["global"] = float(torch.nn.utils.clip_grad_norm_(
+                [p for p in model.parameters() if p.requires_grad], 1.0))
+        # Linear warmup then cosine decay, applied to each group's own base LR.
+        # The completed 24k matrix ran with NO schedule at all -- a constant
+        # 1e-3 for the whole run -- and every field seed random-walked rather
+        # than converged: seed 0 reached 0.875 record-exact at 18k and fell to
+        # 0.625 by 24k.  A constant step against a sharpening discrete
+        # posterior, with credit routed through one sampled word, cannot settle
+        # into a basin it has already found.  Default is OFF so the registered
+        # matrix's law is reproduced exactly; COSINE=1 selects the new arm.
+        if COSINE:
+            if step < LR_WARMUP:
+                scale = (step + 1) / max(1, LR_WARMUP)
+            else:
+                p = (step - LR_WARMUP) / max(1, STEPS - LR_WARMUP)
+                scale = LR_FLOOR + (1 - LR_FLOOR) * 0.5 * (
+                    1 + math.cos(math.pi * min(1.0, p)))
+            for g in opt.param_groups:
+                g["lr"] = g["base_lr"] * scale
+        opt.step()
+
+        if step % EVAL_EVERY == 0 or step == STEPS - 1:
+            # a FRESH generator from the frozen seed every time, so each
+            # checkpoint is scored on the identical panel and the training
+            # stream is untouched
+            row = evaluate(model, perms,
+                           np.random.default_rng(0xE7A1_0000 + seed)
+                           if FROZEN_PANEL else rng)
+            row.update({f"clip_{k}": round(v, 3)
+                        for k, v in clip_norms.items()})
+            row.update({"step": step, "loss": float(loss),
+                        "train_bits": round(bits / max(1, EVENTS), 2),
+                        "lam_mid": round(lam_mid, 4),
+                        "cur_depth": cur_depth, "st": int(st_now),
+                        "s_per_step": round(
+                            (time.time() - t0) / max(1, step), 4),
+                        "wall_s": round(time.time() - t0, 1)})
+            hist.append(row)
+            print(f"[{ARM}-s{seed}] {row}", flush=True)
+            out["history"] = hist
+            out["final"] = row
+            if on_progress is not None:
+                on_progress()
+
+    out["history"] = hist
+    out["final"] = hist[-1] if hist else {}
+    return out
+
+
+@torch.no_grad()
+def _run_event(model: FS16Probe, w: Tuple[int, ...], perm: np.ndarray,
+               rng: np.random.Generator
+               ) -> Tuple[float, float, float, Optional[Tuple[int, ...]]]:
+    """One event under the hard deploy law -> (byte acc, record exact,
+    answer bits/byte, the compiler's hard word)."""
+    xpos, ypos = target_positions()
+    rec = torch.from_numpy(
+        make_event(w, perm, rng).astype(np.int64)).to(DEVICE)
+    logits, states = model.spine_pass(rec)
+    x = rec[:, xpos].reshape(-1)
+    y = rec[:, ypos].reshape(-1)
+    ans = logits[:, ypos].reshape(-1, 256)
+    hard_w: Optional[Tuple[int, ...]] = None
+    if model.field is not None:
+        hard_w = model.field.argmax_word(
+            _slot_logits(model.field, rec, states))[0]
+        wl, _ = model.field.tree_execute(
+            x, sorted({hard_w[:i] for i in range(len(hard_w) + 1)},
+                      key=len), model.base_decode, hard=True)
+        # the certified law's own logits REPLACE the spine readout; the
+        # no-field control keeps its contextual spine logits, so the control
+        # is scored on the strictly easier readout of the two
+        ans = wl[-1]
+    lp = torch.log_softmax(ans.float(), -1)
+    bits = float(-lp.gather(1, y.view(-1, 1)).mean() / math.log(2.0))
+    pred = ans.argmax(-1)
+    return (float(pred.eq(y).float().mean()),
+            float(pred.view(M_REC, N_PAIRS).eq(
+                y.view(M_REC, N_PAIRS)).all(1).float().mean()),
+            bits, hard_w)
+
+
+@torch.no_grad()
+def evaluate(model: FS16Probe, perms: List[np.ndarray],
+             rng: np.random.Generator) -> Dict[str, float]:
+    """The preregistered gate quantities, under the hard deploy law.
+
+    Held-out closure depths 11..16 are never trained.  Each reading scores
+    EVAL_WORDS fresh words x EVAL_EVENTS events per depth, so it rests on
+    EVAL_WORDS*EVAL_EVENTS*M_REC*N_PAIRS answer bytes.  The first cut used
+    ONE word and ONE event per depth — 384 bytes total — whose sampling
+    noise was large enough to swing the pilot's held-out accuracy between
+    0.35 and 0.10 on consecutive readings.  No gate can be scored off that.
+    """
+    row: Dict[str, float] = {}
+    accs, exact, bits = [], [], []
+    for d in range(TRAIN_DEPTH + 1, CLOSURE + 1):
+        da, de, db = [], [], []
+        for _ in range(EVAL_WORDS):
+            w = tuple(rng.integers(0, K_CODES, size=d).tolist())
+            perm = word_perm(perms, w)
+            for _ in range(EVAL_EVENTS_PER_WORD):
+                a, e, b, _ = _run_event(model, w, perm, rng)
+                da.append(a); de.append(e); db.append(b)
+        row[f"acc_d{d}"] = round(float(np.mean(da)), 4)
+        row[f"exact_d{d}"] = round(float(np.mean(de)), 4)
+        accs += da; exact += de; bits += db
+    row["heldout_byte_acc"] = float(np.mean(accs))
+    row["heldout_record_exact"] = float(np.mean(exact))
+    row["heldout_answer_bpb"] = float(np.mean(bits))
+    row["heldout_min_exact"] = min(row[f"exact_d{d}"] for d in
+                                   range(TRAIN_DEPTH + 1, CLOSURE + 1))
+    if model.field is None:
+        return row
+
+    # ---- binding gates: does the compiler read programs to codes? ----
+    votes: List[Dict[int, int]] = [{} for _ in range(K_CODES)]
+    len1: List[bool] = []
+    for g in range(K_CODES):
+        for _ in range(EVAL_BIND):
+            _, _, _, hw = _run_event(model, (g,), perms[g], rng)
+            len1.append(len(hw) == 1)
+            if len(hw) == 1:
+                votes[g][hw[0]] = votes[g].get(hw[0], 0) + 1
+    code_map = [max(v, key=v.get) if v else None for v in votes]
+    row["singleton_len1"] = float(np.mean(len1))
+    row["distinct_codes"] = float(
+        len({c for c in code_map if c is not None}) == K_CODES)
+    row["code_map"] = str(code_map)
+
+    ident = np.arange(256, dtype=np.uint8)
+    row["empty_word_rate"] = float(np.mean(
+        [len(_run_event(model, (), ident, rng)[3]) == 0
+         for _ in range(EVAL_BIND)]))
+
+    # word purity: the hard word must be the singleton mapping applied to
+    # the true program, at EVERY depth including the untrained closure
+    if all(c is not None for c in code_map):
+        pure, plen, per_depth = [], [], []
+        for d in range(0, CLOSURE + 1):
+            dp = []
+            for _ in range(EVAL_PURITY):
+                w = tuple(rng.integers(0, K_CODES, size=d).tolist())
+                _, _, _, hw = _run_event(model, w, word_perm(perms, w), rng)
+                dp.append(hw == tuple(code_map[g] for g in w))
+                plen.append(len(hw) == d)
+            pure += dp
+            per_depth.append(round(float(np.mean(dp)), 2))
+        row["word_purity"] = float(np.mean(pure))
+        row["word_len_match"] = float(np.mean(plen))
+        # aggregate purity cannot tell "perfect on the trained depths and
+        # failing on the untrained closure" apart from "uniformly mediocre",
+        # and those two call for different interventions
+        row["purity_by_depth"] = str(per_depth)
+        row["purity_trained"] = round(float(np.mean(
+            per_depth[:TRAIN_DEPTH + 1])), 3)
+        row["purity_closure"] = round(float(np.mean(
+            per_depth[TRAIN_DEPTH + 1:])), 3)
+    else:
+        row["word_purity"] = 0.0
+        row["word_len_match"] = 0.0
+    return row
+
+
+def main() -> None:
+    nonce, perms = find_nonce(CLOSURE)
+    print(f"nonce={nonce} collision-free to depth {CLOSURE}", flush=True)
+    payload: Dict[str, object] = {
+        "screen": "G1-FS16", "arm": ARM, "seeds": SEEDS, "nonce": nonce,
+        "steps": STEPS, "events": EVENTS, "m_records": M_REC,
+        "d": D_MODEL, "layers": N_LAYERS, "carrier": CARRIER,
+        "train_depth": TRAIN_DEPTH, "closure": CLOSURE,
+        "lam_mid": LAM_MID, "lam_cpu": LAM_CPU, "lam_a": LAM_A,
+        "mid_warmup": MID_WARMUP, "curriculum": CURRIC, "straight_through": ST,
+        "st_after": ST_AFTER, "act_init": ACT_INIT, "sampled": SAMPLED,
+        "eps": EPS, "device": str(DEVICE), "runs": [], "partial": True,
+        "result_file": RESULT_FILE, "off_law": OFF_LAW,
+        "certification_geometry": not OFF_LAW,
+    }
+
+    def push() -> None:
+        # A local smoke run inherits HF_TOKEN from the shell, so without an
+        # explicit opt-out it publishes toy-width numbers over a registered
+        # result file under the DEFAULT name.  That already happened once.
+        if not os.environ.get("HF_TOKEN") or NO_PUSH:
+            return
+        api = HfApi()
+        api.create_repo(RESULTS_REPO, repo_type="model", exist_ok=True)
+        api.upload_file(
+            path_or_fileobj=json.dumps(payload, indent=1).encode(),
+            path_in_repo=RESULT_FILE, repo_id=RESULTS_REPO,
+            repo_type="model")
+        print(f"pushed {RESULTS_REPO}/{RESULT_FILE}", flush=True)
+
+    for seed in SEEDS:
+        run: Dict[str, object] = {}
+        payload["runs"].append(run)
+        train_one(seed, perms, run, on_progress=push)
+        push()
+    payload["partial"] = False
+    push()
+    print(json.dumps({"arm": ARM,
+                      "runs": [r.get("final", r) for r in payload["runs"]]},
+                     indent=1), flush=True)
+
+
+if __name__ == "__main__":
+    main()