loss-manifest companion: article + 155-entry rated registry + sidecar + loss library + gates/battery + campaign beds + raw run ledgers

LOSS_MANIFEST.md

@@ -0,0 +1,612 @@
+# LOSS MANIFEST - every objective this program has back-propagated, rated
+#TAG:loss_manifest #TAG:accumulation #TAG:losses #TAG:rubric
+[CENSUS-VERIFIED 2026-07-25 - three independent censuses: canon+MANIFEST, history+sessions, full code tree]
+Living registry (SCALE_MANIFEST discipline): entries are NEVER deleted - demoted with a
+reason and a date. Rubric v1; every rating below is RECOMPUTABLE from its six sub-score
+digits and the lookup table in THE RUBRIC. Machine-readable sidecar:
+inventory/loss_manifest.json. Views + lint: `python skill/loss_view.py card|ladder|lint`.
+Taxonomy and format laws: canon/loss_accumulation_forms.md.
+
+THE RATING ANSWERS: **"how much would I stake on this term in a NEW bed"** - NOT effect
+size. InfoNCE is the most potent term in the census and rates 2.
+
+## THE STRUCTURAL FINDING (read before any row)
+
+Only **three primitives ever receive a backward pass** in this program: `F.cross_entropy`,
+squared error, and `F.kl_div` (plus fp64 Cayley-Menger determinants in gauges). No margin,
+triplet, hinge, contrastive-margin, or load-balancing loss has ever existed in the tree.
+
+The four objectives that look composed are those same primitives under different
+**accumulation formats**: InfoNCE is CE over an N x N grid; blob-LP-x0 is squared error
+dose-coupled and band-routed; HP/LP band roles are squared error under a cosine crossfade;
+CV is a determinant statistic accumulated in fp64.
+
+**So the loss surface is three primitives wide and eleven accumulation formats deep, and
+every loss discovery this program has made lives on the second axis.** Two receipts:
+
+- **The addr_head cure changed accumulation only, primitive held fixed.** 5.6650 bpb with
+  usage perplexity 1.88/64 (collapsed) -> 2.47 by going slot-parallel. Same `F.cross_entropy`
+  on both sides. (L-112 -> L-012)
+- **Chunked CE and plain CE are identical mathematics and a 5x memory law.** 22.8GB
+  dedicated + 42.8GB silently spilled to shared memory -> 8.8GB peak at 1.03 s/step. The
+  law lives entirely in the reduction schedule. (L-004)
+
+A third receipt sits in the forbidden class. `A10` - accumulation that carries state across
+steps (EMA codebooks, commitment counters, k-means centroids) - contains **exactly two
+entries, and both are prohibitions** (L-105 VQ/commitment/EMA, L-134 load-balancing). Not
+one working objective in the program's history has ever used that format. It is precisely
+where a newcomer would naturally write code, and the empirical warrant for not doing so is
+L-083: the codebook stays 125+/128 axes alive at `div_weight = 0`, with no diversity term
+at all.
+
+`A9` (raw sum, no denominator) is empty for a duller reason: the scale rides on batch and
+sequence length, so the learning rate stops transferring between beds.
+
+## THE RUBRIC (how every number below was produced)
+
+Six sub-scores, summed to `S_raw` (0-13), then a **lookup table** - not arithmetic, so
+anyone can re-derive a rating without trusting a float:
+
+| sub-score | 0 | 1 | 2 | 3 |
+|---|---|---|---|---|
+| **R** replication | designed, never run | one seed, one bed | >=2 seeds OR >=2 beds | >=2 seeds AND >=2 beds/substrates |
+| **P** potency vs its own gauge's noise | null / within noise / wrong direction | directional but <1% or below seed spread | 1-10%, or an ordinal win above seed spread | >10%, categorical enable, or 50-200x separation |
+| **D** doctrinal fit | violates a MANIFEST law | permitted but antagonistic | aligned/reconstructive, or a gated exception with a written statute | - |
+| **C** cost | recorded catastrophic-cost event | material but budgeted | free or near-free | - |
+| **I** instrument risk | headline rests on a DISTRUSTED gauge, or the term can silently become zero with no assert | aggregate-only; gauge-blindness plausible | dedicated non-blind gauge AND a silent-zero assert | - |
+| **+L** law bonus | - | encoded as a MANIFEST law **and** enforced in code (assert, refusal, or guard) | - | - |
+
+```
+S_raw:  0  1  2  3  4  5  6  7  8  9 10 11 12 13
+rating: 1  1  2  3  3  4  5  6  7  8  8  9 10 10
+```
+
+**The nine traceability rules** (applied in this order, after the lookup):
+
+1. **UNRUN CEILING** - `R=0` => rating <= 3. A beautiful design does not score on paper.
+2. **BLIND-GAUGE DEMOTION** - headline from a DISTRUSTED gauge, not re-measured => **-2**.
+3. **SINGLE-SEED CAP** - `R<=1` => rating <= 6.
+4. **SUB-1% CAP** - `P<=1` => rating <= 5. Four-for-four directional at 0.05-0.2% cannot
+   outrank a measured 5.9%.
+5. **DOCTRINE-ZERO CEILING** - `D=0` => rating <= 2.
+6. **RETRACTION FLOOR-BREAKER** - a dated retraction, demotion, or REFUTED verdict anywhere
+   in the record => **rating = 1, unconditional.** Sub-scores are still printed so you can
+   see why it once looked good. Retracted entries never compete on the ladder.
+7. **CONTRADICTION** - unreconciled records get a RANGE or a marked sub-claim, never an
+   average.
+8. **PROVENANCE** - every sub-score digit is backed by the row's citations. An uncited digit
+   forces the unrun ceiling.
+9. **SCOPE / GAUGE SPLIT** - a term whose standing differs by scope or by judging instrument
+   gets TWO adjacent rows, never one averaged row.
+
+### Calibration - three pairs that prove the rubric works
+
+- **L-048 rates 8 and L-123 rates 4. Same objective, same seeds, same data.** The only
+  difference is which gauge judged it: the role-aligned in-bed gauge, or aggregate eps-MSE.
+  This pair is the concrete price of gauge blindness.
+- **L-047 rates 6 and L-111 rates 1. Same operator - Procrustes.** As a regularizer it
+  tightens CV to .19; as a training force it produced R@1 = 0.000 and P_cos stuck at .094
+  for thirty epochs. Campaign law 2 restated in loss terms: placement decides
+  load-bearingness.
+- **L-113 rates 2 and L-001 rates 10.** The most potent measured objective in the census
+  against the plainest one. If that ordering is surprising, the rubric is working: potency
+  and standing are different axes.
+
+## THE GRID - PRIMITIVE x ACCUMULATION FORMAT
+
+| accumulation | CE | SQ | KL | DET | BREG | - | row |
+|---|---|---|---|---|---|---|---|
+| `A0` uniform-mean | 26 | 27 | 2 | 3 | 4 | 22 | **84** |
+| `A1` chunk-sum-renormalize | 1 | . | . | . | . | . | **1** |
+| `A2` per-sample-then-weighted | 4 | 2 | . | 1 | . | 2 | **9** |
+| `A3` band-crossfade | . | 3 | . | . | . | 6 | **9** |
+| `A4` masked-denominator | 5 | . | 1 | . | . | . | **6** |
+| `A5` dose-coupled | . | 2 | . | . | . | 1 | **3** |
+| `A6` paired-difference | . | . | . | . | . | 3 | **3** |
+| `A7` grid-pairwise | 5 | . | . | . | . | . | **5** |
+| `A8` fp64-accumulate | . | . | . | 3 | . | 4 | **7** |
+| `A9` sum-no-norm | 1 | . | . | . | . | . | **1** |
+| `A10` EMA / external cross-step state | 1 | 1 | . | . | . | . | **2**  **PROHIBITIONS ONLY** |
+| `NA` not an accumulation | . | . | . | . | . | 25 | **25** |
+
+**Rating distribution** (n=155, mean 5.84): `1`x30 `2`x2 `3`x4 `4`x3 `5`x29 `6`x23 `7`x7 `8`x15 `9`x25 `10`x17
+
+Glyphs: `†` retraction floor-breaker | `✖` doctrine ceiling | `⟂` split sibling (scope or gauge) | `⚠` unreconciled contradiction
+
+## THE FORMULA MAP - every entry's mathematics and where it runs
+
+Extracted 2026-07-25 (operator directive: the process is the ROSTER). 'NOT RECORDED' is itself information - those formulas were never written down anywhere and their numbers cannot be reproduced without re-derivation. Machine copy in the sidecar.
+
+| ID | FORMULA | IMPLEMENTATION |
+|---|---|---|
+| L-001 | `L = mean((dec(z) - x)^2); convergence endpoint = bitwise-exact recon` | geolip_svae (installed pkg) . loss_forms::prim_sq+a0_mean |
+| L-002 | `M_hat = sum_k sinh(u_k)A_k / sum_k cosh(u_k), u = cos(x,A)/tau; L = mean((dec(M_hat)-x)^2); codebook grad ONLY via num@A and cos=M@A^T` | amoe.core.address::m_hat + geolip_svae aleph_model.py . loss_forms::prim_sq |
+| L-003 | `L = mean(-log softmax(W h)[y])` | pod/v35_exp001_placement.py:170 . loss_forms::prim_ce+a0_mean |
+| L-004 | `L = sum_chunks CE_sum(h[i:i+512]) / n_live_tokens (ONE global denominator)` | loss_forms::a1_chunked_ce . pod/v35_exp003_termination.py:128-138 |
+| L-005 | `CE(logits[:,:-1], y[:,1:], ignore_index=-100)` | pod/v35_exp006_math.py:180 . loss_forms::prim_ce+a4_masked |
+| L-006 | `model(**batch, labels=y).loss (masked shift-CE inside HF; vision tower fires)` | pod/v35_exp004_caption.py:175 (chunking unavailable on this path) |
+| L-007 | `same CE; trainable set = per-block dispatch key matrices ONLY` | closeout amoe/train/aligner.py:41-67 |
+| L-008 | `CE(logits, y) on CIFAR-10` | tools/addressed_distillation_v1.py:301 |
+| L-009 | `x_t = sqrt(abar_t)x0 + sqrt(1-abar_t)eps, t~U{0..999}; L = mse(unet(x_t,t,c), eps); CFG drop p=.1` | pod2/dexp006_sd15core_relay.py:132-146 . amoe.diffusion.train.objectives |
+| L-010 | `s = warp(u; shift=2.5); x_t = (1-s)x0 + s*eps; L = mse(pred, eps - x0); x0 = x_t - s*v EXACT/LINEAR` | pod2/dexp001_sd15_relay.py:151-164 . amoe objectives.py:51-58 |
+| L-011 | `M_hard = sign(cos[argmax|cos|])*A[argmax]; forward discrete, backward soft (M_hard + M_soft - sg[M_soft]); CE on head(M_hard)` | tools/ar_differentiation_bed.py (addr_mslh64 arm) |
+| L-012 | `feats = concat_p M_hat^(p)(slots); logits = W feats; CE. P=4/16/32/64 dose` | tools/ar_differentiation_bed.py (addr_msl* arms) |
+| L-013 | `reads at multiple tau; concat -> logits; CE (stroboscope)` | tools/ar_differentiation_bed.py (addr_3tau arm) |
+| L-014 | `logits = head(M_hat) directly (reconstructive read consumed in AR); CE` | tools/ar_differentiation_bed.py (addr_mhat arm) |
+| L-015 | `shift-CE(-100) on stepwise-CoT target sequences vs direct-answer targets` | pod/v35_exp013_experts.py:211 |
+| L-016 | `L = mean_B[ mse_vec + lam*w_HIGH(s01)*blob_lp ]; blob_lp = sum(blob*(LP(x0h)-LP(x0))^2)/(sum(blob)*C); x0h = x_t - s*v_hat` | closeout amoe/diffusion/train/objectives.py:63-69 [REFUSES on eps] |
+| L-017 | `sym CE over sims = za@zb^T/0.07 with in-batch labels` | loss_forms::a7_grid_infonce . tools/qwen_exp011_newanchors.py:445-453 |
+| L-018 | `InfoNCE*1.0 + Procrustes_SVD*0.3 + |CV(bank)-0.20|*0.05` | external (blueprint line; pieces: a7 + procrustes_sq + cv_band_loss) |
+| L-019 | `InfoNCE + MSE + BCE + Procrustes + CV + spread (6-term, never ablated)` | external (Expert Soup, Form 2) |
+| L-020 | `mse(norm(pred), norm(tgt)) + (1 - cos(pred, tgt)) on (B,77,768)` | external (Form 4) . pieces in loss_forms |
+| L-021 | `w = min(SNR,5)/(SNR+1) velocity-adjusted; L = mean(w * mse_vec)` | external (KSimplex trainer) . loss_forms::a2_weighted |
+| L-022 | `L = CE + a*KL(log_softmax(student), mean_k softmax(teacher_k).detach()), a<=0.25, never founders` | tools/exp014_genetic_distillation.py:249-255 . loss_forms::prim_kl+kd_guard |
+| L-023 | `fact rows: KL(teacher) ONLY (CE masked off); clean rows: CE - row-routed channels` | tools/exp019_content_retention.py:158-176 |
+| L-024 | `GPA: mean shape after per-teacher Procrustes to consensus (delta<1e-8); student anchors init from it` | tools/exp014-016 (dif line) |
+| L-025 | `projective ICP: iterate sign-aligned Procrustes on RP; lineage-core overwrite` | tools/exp015_content_inheritance.py (dif line) |
+| L-026 | `prox = exp(-(cv-target)^2/2sig^2); L = (1+boost*prox)*mse + pen*(1-prox)` | geolip_core.core.distinguish (installed pkg) . loss_forms::soft_hand_weights |
+| L-027 | `conv := fold(m_hat(unfold(x))); no plain filter, no ReLU; CE on head` | geolip-aleph-classification (external repo, cls line) |
+| L-028 | `score(v) = logP(x_i=v | x_masked) - logP(x_i=WT | x_masked) (masked marginal)` | external (ryan protein line) |
+| L-029 | `CE; trainable = aleph MslRelay adapters on frozen GPT-2 (<1%)` | tools/exp013_augmentation_bed.py track C |
+| L-030 | `CE on frozen CLIP-L token-AR (matched transforms + shared vocab proj)` | tools/exp013_augmentation_bed.py track A |
+| L-031 | `SOURCE RECOVERED 2026-07-25: attraction (1-s_y)^2 + 0.5*repulsion sum_{c!=y}(s_c^2) + 0.5*margin relu(max_{c!=y}s_c - s_y + .3) + 0.1*range clamp; siblings: prototype (cos-to-learned-prototypes + diversity) and hierarchical (coarse+fine+consistency)` | geofractal.losses.pure_geometric (installed pkg, VERBATIM) . tools/geobasin_bed.py |
+| L-032 | `SOURCE RECOVERED 2026-07-25 (GBC head, geofractal/model/experiment_geometric_basin.py:118): compat = triadic (resonance-weighted cos to class signatures) x self-similarity (level-pair pattern match) x Cantor coherence exp(-(m - proto_c)^2/.1) x hierarchical early/late check - the 4-factor product` | geofractal.model.experiment_geometric_basin::GeometricBasinCompatibility (installed pkg) |
+| L-033 | `mask patches; L = mse(recon_from_antipode_read(masked), x) (law 2 ORIGINAL form)` | built-unrun in geolip-aleph-classification (cls line) |
+| L-034 | `w=.05 entropy-balanced alignment (exact form NOT fully recorded); endpoint M = +/-ref EXACT` | external (SVAE H2 arc) |
+| L-035 | `rectified-flow velocity mse + Min-SNR gamma=5 + CM terms (L-045/L-046)` | external (KSimplex 4.8M prior) |
+| L-036 | `ArcFace cos(th+m) | CosFace cos(th)-m | SphereFace cos(m*th); s=30 m=.30; L1-then-L2 dual-norm` | loss_forms::margin_head (NEW) . external ViT-ZANA |
+| L-037 | `CE on x0 tokens from noise-level-t corrupted tokens, iterative` | q25-e008 bed (pod archive) |
+| L-038 | `L = mse(ea, norm(frozen_h @ fixed_proj)) + mse(eb, ...) (absolute target regression)` | tools/qwen_exp011_newanchors.py:449-453 |
+| L-039 | `standard contrastive; measured as a CV-compression force` | external (cv_band_origin sweep) |
+| L-040 | `V = sqrt(clamp(-det(CM(A[idx5]))/9216)); L += 1e-3 * std(V)/mean(V); fp64, fixed seed-0 subsets, S15 bank ONLY` | tools/exp017_aleph_constellation.py:154-186 . loss_forms::cv_band_loss (NEW, arm-gated) |
+| L-041 | `M = F.normalize(M, dim=-1) (||M||_F^2 = V pins sum sigma^2) - ONE line, not a loss` | structural; everywhere |
+| L-042 | `per tower: g <- g * target/||g|| (equal gradient norms; outputs stay free)` | external (geofractal) |
+| L-043 | `Sp = S * (1 + a*tanh(f)), a <= 0.2, init .024 - modulate never inject` | external (omega line) |
+| L-044 | `p = softmax(-(y-[.5,1.5,2.5])^2/.25); bit_k = p_R + 0.5*p_M; C = sum bit_k 2^-k` | tools/compartment_smoke.py::exact_cantor + soft_cantor_ungated |
+| L-045 | `L_CM = .01 * relu(eps - vol2(CM)) on first k+1 tokens (validity hinge)` | loss_forms::cm_validity_hinge (NEW) . external KSimplex |
+| L-046 | `L_vol = -.005 * std(log|vol^2| across layers) (spread REWARD, anti-collapse)` | loss_forms::cm_volume_spread (NEW) . external KSimplex |
+| L-047 | `L = ||A R* - B||^2, R* = Procrustes(A,B) via SVD - as x0.3 REGULARIZER beside a force` | loss_forms::procrustes_sq (NEW) . external blueprint |
+| L-048 | `low = base + .5*mse(HP3(pred),HP3(tgt)); high = base + .5*mse(LP7,..); composed by band windows [role-aligned gauge]` | closeout amoe/diffusion/train/objectives.py:74-80 |
+| L-049 | `dropout(anchors, p=.3) during alignment` | external (constellation) |
+| L-050 | `clip_grad_norm .5 on cross-attn ONLY; NEVER inside an LBFGS closure` | protocol |
+| L-051 | `Adam(params, lr, weight_decay=0.0) - the ONLY constructor` | closeout amoe/laws.py:26-28 |
+| L-052 | `zeros_(head.weight); zeros_(head.bias); gates = -3.0` | closeout amoe relay.py:49-52 |
+| L-053 | `g_tang pass; g_radial *= (1-.01); g_collapse *= 1.0 (gradient gating)` | external (GM3 Form 12; ALEPH-OMITTED) |
+| L-054 | `q_comp = R (Hamilton) q_expert over 4 FiLM arms` | external (protein line) |
+| L-055 | `Q = (I-A)(I+A)^-1, A skew - det=1 by construction` | external (protein line) |
+| L-056 | `k-step MLP cascade in place of one dimensional jump` | structural, external |
+| L-057 | `w_route = f(phase-0 triangulation distances), softmax-free, geometry-derived` | external (Form 6) |
+| L-058 | `exact softmax within sorted equal-width same-bucket block; codebook grad via address-agreement bias` | design (Tree 3b pending) |
+| L-059 | `M_hard + (M_soft - sg[M_soft]) (STE over an ABSOLUTE reconstructive read)` | amoe.core.address / geolip_svae |
+| L-060 | `n_i_new = min(ceil(norm * n_i^0.5), 8, 1.25*top) (sqrt-damped repeats)` | external (anima bucketing) |
+| L-061 | `assert |question_space| >= 3*draws; train-eval overlap <= .05` | closeout amoe/train/guards.py:19-45 |
+| L-062 | `on starvation strike: sampling_weight[starved] *= 2; 3 strikes abort - DATA, never a loss` | closeout amoe/train/aligner.py:68-84 |
+| L-063 | `with p=.1: cond <- 0 (zeroed, not empty-prompt)` | pod2/dexp006:132-146 |
+| L-064 | `NOT RECORDED (role-weighted pentachoron regularization; rose_w=1e-4, temp .07)` | external (David classifier) |
+| L-065 | `ramp(x)=.5-.5cos(pi*(clamp(x/XF,-1,1)+1)/2); low=1-up1; mid=up1(1-up2); high=up1*up2; edges(.35,.75) XF=.06` | closeout amoe/diffusion/core/multiband.py:23-35 . compartment_smoke::compartment_windows |
+| L-066 | `L = base + lam * w_route * aux, lam~1 (3-pt dose curve)` | loss_forms::a5_dose_coupled |
+| L-067 | `reduce in float64, autocast off (gauges)` | loss_forms::a8_fp64_gauge . geolip_vitals |
+| L-068 | `acc = mean_fp64(res_arm(row,noise,t) - res_ref(row,noise,t)), triples FIXED per row` | loss_forms::a6_paired . dexp001:167-185 |
+| L-069 | `w = f(pi_frozen_ref); L = sum(w*ce_tok)/sum(w)` | loss_forms::pwa_weights+a2_weighted [gate: 0.014-0.083] |
+| L-070 | `v = norm(feats)@R^T/t; L = mean(cosh(clamp(v - c_y*mu, -4, 4)) - 1)` | loss_forms::fac_loss . tools/fac_bed.py |
+| L-071 | `CV = std(V)/mean(V), V = CM 4-volumes over 200 random 5-subsets, fp64 - READOUT` | tools/geolip_vitals.py::pentachoron_cv |
+| L-072 | `drift = arccos(<norm(a), norm(a_init)>); binding_frac = mean(|drift-.29154|<=.05)` | tools/geolip_vitals.py::anchor_drift |
+| L-073 | `bpb = mean CE / ln(2) per byte` | beds (ar_differentiation, fac_bed) |
+| L-074 | `tax = exp(mean CE_512)|adapted - exp(mean CE_512)|frozen on wikitext` | pod beds (v35) |
+| L-075 | `F1 = 2PR/(P+R) over token multisets vs GT captions` | pod v35 judges |
+| L-076 | `precision = |pred inter GT|/|pred|; invented = |pred minus GT_vocab|/|pred|` | pod halluc judge (exp004_caption/halluc) |
+| L-077 | `sep_L = mean_ij inter-register Ham(code_i,code_j) - mean intra (diagonal KEPT, +4% bias, comparability)` | pod2/aleph_diffusion_core.py:257-290 . canon/register_probe_gauge.md |
+| L-078 | `Spearman(Hamming(c_i,c_j), arccos|<a_i,a_j>|) over random pairs` | tools/fac_bed.py (reimpl) . exp015 |
+| L-079 | `HIGH-band foreground-masked LP-x0 error (fp32 judged)` | closeout amoe/diagnostics/diffusion.py::foreground_gauge |
+| L-080 | `assert torch.equal(logits_all_off, logits_base)` | closeout amoe/testing/invariants.py:76-97 |
+| L-081 | `ratio = damage(own band lesion) / damage(cross band lesion) per gauge` | closeout amoe/diagnostics/diffusion.py::lesion_report |
+| L-082 | `excess = metric(real keys) - metric(SAME key repeated); + matched-vs-mismatched delta` | pod2/dexp015_router_v2.py:159-191 |
+| L-083 | `usage = mean oriented-softmax row; ppl = exp(H(usage)); alive = usage > eps/2K` | tools/geolip_vitals.py::axis_aliveness |
+| L-084 | `read ppl = exp(H(mean read weights)); commitment = |cos(read, nearest atom)|` | geolip-aleph-classification gauges (cls line) |
+| L-085 | `ratio = mean|delta|_domain / mean|delta|_neutral; escape <= 1.5; damped >= 3.0` | closeout amoe/diagnostics/__init__.py:58-71 |
+| L-086 | `exact-match on two-step composite prompts vs single-step controls` | pod v35 composite judges |
+| L-087 | `effect = mean|loss_off - loss_on|; report VACUOUS if < eps instead of a ratio` | colab/anima_closeout.ipynb (v14 guard) |
+| L-088 | `orders = log10(max group ||g||) - log10(min); dead = groups with 0` | tools/geolip_vitals.py::grad_norm_spread |
+| L-089 | `CV at step 1000 -> band {<.30 LOW / .35-.50 MID / >.80 HIGH} + stability + freeze-survival` | tools/geolip_vitals.py::CVScreen |
+| L-090 | `ripser H2 on d(a,b)=arccos|<a,b>| (RP metric), thresh 20deg; beta2/axis` | ripser+persim (installed); canon/void_topology.md:27-63 |
+| L-091 | `S0/S_D spectral ratio; erank = exp(-sum p ln p), p = sigma/sum sigma` | external (structural attractors) |
+| L-092 | `var(recon MSE) across patch grids 81..4096 - flatness IS the pass` | external (omega line) |
+| L-093 | `guarded subprocess: restricted builtins, len cap, timeout, no net; exact-match out` | pod v35 exec judge (protocol) |
+| L-094 | `json.parse validity + IoU(xywh) + pair-order + termination-within-window` | pod v35 judges |
+| L-095 | `torch.cuda.max_memory_allocated + s/step at an early step (WDDM spill tell)` | telemetry; pod/run_g6b_rider.py:34-48 |
+| L-096 | `drift_g = arccos(<consensus_g, consensus_prev>); stationarity = no acceleration` | tools (dif line) |
+| L-097 | `held-out byte acc under substitution cipher; variant-format recall` | tools/exp019/exp020 |
+| L-098 | `NN symbol-Hamming between stored and recomputed keys; match@theta=.25` | tools/exp021_persistent_store.py |
+| L-099 | `mean cos(book_epoch, book_init) across the bank sweep` | external (192-bank sweep) |
+| L-100 | `|V_fast - V_geovocab2| / |V| at fp64 == 0 required` | tools/geolip_vitals.py::cv_reference_check |
+| L-101 | `gate_mean = mean sigmoid(g); band [.012,.03] ADVISORY` | tools/geolip_vitals.py::gate_stats |
+| L-102 | `mean mse over all sigma - BLIND to band structure (distrusted for bands)` | prim_sq+a0 (the point is what it hides) |
+| L-103 | `cos(recon, x) - WRONG instrument for addressed systems (address = lookup key)` | distrusted; do not implement as a judge |
+| L-104 | `recall@k under Hamming(code_query, code_bank)` | tools/qwen_exp011 (q25 line) |
+| L-105 | `||sg[z_e] - e||^2 + beta*||z_e - sg[e]||^2 (+ EMA codebook update)` | loss_forms::forbidden_vq_commitment (NEW, force-gated control) |
+| L-106 | `selection event = argmax/softmax-over-roster in the compute path` | prohibited class (the EVENT is the violation, not one formula) |
+| L-107 | `alphabet learned by task gradient (vs fitted-frozen)` | prohibited class (dif line evidence) |
+| L-108 | `direct task-gradient descent on pentachoron vertices` | prohibited (geovocab evidence) |
+| L-109 | `gap = x.mean(dim=spatial) in a geometric encoder` | loss_forms::forbidden_gap (NEW, force-gated control) |
+| L-110 | `CV term injected in backward, or weight > 1e-3` | prohibited placement of L-040 |
+| L-111 | `same as L-047 - AS THE TRAINING FORCE (placement retracted)` | loss_forms::procrustes_sq [placement warning] |
+| L-112 | `logits = W u, u = single-slot coefficients at hard tau (K=32)` | tools/ar_differentiation_bed.py (addr_head) . fac_bed p4 cells |
+| L-113 | `a7_grid_infonce INTO an address path` | loss_forms::a7 [placement ban in docstring] |
+| L-114 | `prim_kl at alpha=1.0 from near-parity teachers in a selection loop` | loss_forms::prim_kl+kd_guard [guard warns] |
+| L-115 | `L-016 with x0h = (x_t - sqrt(1-abar)eps_hat)/sqrt(abar) - divides by vanishing sqrt(abar)` | closeout amoe trainer [REFUSES unless force_blob_on_eps] |
+| L-116 | `keep-or-kill on 1-epoch MSE rank` | retracted protocol; replaced by L-089 |
+| L-117 | `logits = tied(M_hat) with U=M_hat, S=Omega, Vt=I` | dif-e018 bed (tools) |
+| L-118 | `route experts by frozen text keys (raw/pooled/M-hat-slot) vs repeated-key null` | pod2/dexp014/dexp015 beds |
+| L-119 | `a trainable anchor trained to orchestrate others (composite prereg >= +.15)` | pod v35_exp010/exp020 beds (refuted) |
+| L-120 | `solo specialist stack attached always-on` | configuration class (v35 e018 evidence) |
+| L-121 | `frozen solo-trained experts composed under dispatch` | pod v35_exp014 beds (demoted) |
+| L-122 | `transplant proj+codebook onto a fresh trunk` | NA protocol (dif line, demoted) |
+| L-123 | `L-048 judged by aggregate eps-MSE` | same impl; the GAUGE is the difference |
+| L-124 | `append frozen byte-trigram address beside full text cond` | pod2/dexp002 bed |
+| L-125 | `null = shuffle keys across rows (measures diversity, not correctness)` | retracted instrument; use L-082 |
+| L-126 | `CE on generated question sets with space < 3x draws` | retracted claim; guard = L-061 |
+| L-127 | `cross-seed comparison across DIFFERENT instruments` | NA (claim-level error) |
+| L-128 | `bands nested within bands on a Cantor axis` | prohibited configuration |
+| L-129 | `re-enter measure space per layer/step` | prohibited configuration |
+| L-130 | `soft_cantor_ungated(x) used as a band COORDINATE (non-monotone)` | tools/compartment_smoke.py::soft_cantor_ungated (as the regression) |
+| L-131 | `repeat count = ceil(max_bucket / n_i) (alpha=0 equalize-to-largest)` | NA data policy (prohibited) |
+| L-132 | `conv re-weighted by convex sum a_k=1 over a filter bank (hull-bounded mean)` | geolip-aleph-classification (cautionary control, cls line) |
+| L-133 | `argmax decoding in an iterative denoiser` | NA decoding policy |
+| L-134 | `aux = alpha * N * sum_i f_i * P_i (switch-style balance)` | loss_forms::forbidden_load_balancing (NEW, force-gated control) |
+| L-135 | `CE on the big-JSON composite format` | dropped by operator ruling (never built) |
+| L-136 | `learned SVD rotation transform in the dual-penta head` | retracted (convergence failure) |
+| L-137 | `coefficients->logits at ONE hard tau, any dim` | class of L-112; cure = L-012/L-013 |
+| L-138 | `L-070 on the addr_head collapse configuration` | tools/fac_bed.py (p4_addr_head_fac) |
+| L-139 | `sparsemax_loss on addr_head logits (K=32, hard tau) - only the loss differs from the certified collapse cell` | tools/deviant_bed.py (p4_sparsemax) . loss_forms::sparsemax_loss |
+| L-140 | `L = -z_y + 0.5*sum_{j in S}(z_j^2 - tau^2) + 0.5 (sparse support S)` | loss_forms::sparsemax_loss . tools/deviant_bed.py |
+| L-141 | `L = T*logsumexp(ce_tok/T) - T*log(N), T=0.5` | loss_forms::dev_softmax_accum . tools/deviant_bed.py |
+| L-142 | `L = mean(log(ce_tok + 1e-3))` | loss_forms::dev_geomean_accum . tools/deviant_bed.py |
+| L-143 | `CE to (1-eps) smoothed targets == (1-eps)CE + eps*uniform-KL` | F.cross_entropy(label_smoothing=.1) . tools/deviant_bed.py |
+| L-144 | `L = sum((1-p_y)^2 * ce_tok) / sum((1-p_y)^2), p_y detached from the live model` | tools/deviant_bed.py (focal) |
+| L-145 | `L = sum(ce_tok * [pi_ref > .6]) / count, pi_ref from the frozen ce_s0 checkpoint` | tools/deviant_bed.py (anti_curr) |
+| L-146 | `L = mean(1 - tanh(v) * c)` | loss_forms::fac_loss_link(link='tanh') . tools/deviant_bed.py |
+| L-147 | `L = mean(log(1 + (v - c*mu)^2))` | loss_forms::fac_loss_link(link='cauchy') . tools/deviant_bed.py |
+| L-148 | `L = CE - 0.1*H(p)` | tools/deviant_bed.py (conf_penalty_CONTROL) |
+| L-149 | `CE over logits = cos(normalize(feats), normalize(A_c)) * 10` | tools/geobasin_bed.py (geo_ce_scores) |
+| L-150 | `attraction (1-s_y)^2 + 0.5*sum_{c!=y}s_c^2 + 0.5*relu(max_{c!=y}s_c - s_y + .3) + 0.1*range` | geofractal.losses.pure_geometric (VERBATIM) . tools/geobasin_bed.py |
+| L-151 | `same loss; A registered as a frozen buffer` | tools/geobasin_bed.py (geo_pure_frozen) |
+| L-152 | `L = (1 - s_y)^2 + 0.1*(relu(s-1)^2 + relu(-s)^2) - no other-class terms at all` | tools/geobasin_bed.py (geo_pure_norep) |
+| L-153 | `cos(proj(scores), prototypes) pulled/pushed + prototype-diversity term` | geofractal.losses.pure_geometric::GeometricPrototypeLoss (VERBATIM) |
+| L-154 | `coarse (superclass sums to target) + fine + consistency, sigmoid-weighted` | geofractal.losses.pure_geometric::HierarchicalGeometricLoss (VERBATIM, FastHierarchical parity wrapper) |
+| L-155 | `0.5*CE(cos*10) + 0.5*PureGeometricLoss(scores)` | tools/geobasin_bed.py (geo_hybrid) |
+
+## PRIMARY OBJECTIVES
+
+Terms that were the training signal, not an addition to one.
+
+| ID | RATE | RPDCI+L | CELL / SUBSTRATE | NAME | HEADLINE NUMBER | CITE |
+|---|---|---|---|---|---|---|
+| L-001 | **10** | 33222+1 | `SQ.A0`/bytes | MSE -> bitwise reconstruction (SVAE H2, 16 noise types) | 16 noise types converge simultaneously; bitwise text recon; the two-year survivor | MANIFEST.md:133-139; MANIFEST.md:144-145 |
+| L-002 | **10** | 33222+1 | `SQ.A0`/codebook | recon gradient through M-hat (the aleph's ONLY codebook pressure) | cos .992-.997 hard-mode, 125-126/128 axes alive, ZERO collapse, div_weight=0 | canon/aleph_core.md:16-18; canon/discovery_catalog.md:40-44 |
+| L-012 | **9** | 33212+0 | `CE.A2`/coefficients | addr_msl slot-parallel read (P parallel D=4 slots, shared K=64) | THE ACCUMULATION CURE: 5.6650 (collapsed) -> 2.47 with the primitive held FIXED | history/timeline.md:124-138; history/timeline.md:1098-1104 |
+| L-015 | **9** | 33212+0 | `CE.A4`/logits | derived-steps expert supervision (stepwise-CoT target vs direct target) | +0.79 vs direct +0.63; held-out ceiling 1.00/1.00; seeds matched to 4 decimals (+0.7917 / +0.7916) | inventory/SCALE_MANIFEST.md:144-154; history/timeline.md:1640 |
+| L-004 | **9** | 23122+1 | `CE.A1`/logits | chunked masked CE (512-token slices, sum-then-renormalize) | 22.8GB dedicated + 42.8GB SILENTLY SHARED -> 8.8GB peak @ 1.03 s/step | MANIFEST.md:50-59; pod/v35_exp003_termination.py:128-138 |
+| L-138 | **9⟂** | 23222+0 | `BREG.A0`/coefficients | FAC on the partition-collapse configuration (the P4 loss-swap cell) | the certified addr_head collapse DECOMPRESSES under a loss swap alone, 3/3 seeds: usage ppl 1.0-2.7 -> 60.6-61.1 of 64; decoded acc 0.05-0.20 -> 0.45-0.47; the win|cos| saturation DISSOLVES (0.9995+ -> 0.13) | tools/fac_runs/p4_addr_head_fac_s0_t2000.jsonl; history/timeline.md:1105-1118 |
+| L-139 | **9** | 23222+0 | `CE.A0`/logits | sparsemax on the collapse configuration (the coupling-axis probe) | THE DOSE-RESPONSE: usage 1.85 (CE, full coupling) -> 23.5 (sparsemax, partial) -> 60.9 (FAC, none); win|cos| .9997 -> .562 -> .132; acc .11 -> .417 -> .456 - MONOTONE on every gauge, 3 seeds/point | tools/deviant_runs/; history/timeline.md 2026-07-25 deviant-matrix block |
+| L-152 | **9** | 23222+0 | `SQ.A0`/basin-scores | PureGeometric ABSOLUTE-ONLY (attraction + range; comparative terms dropped) | MORE THAN DOUBLES the full set: acc 0.349 vs 0.157, bpb 3.75 vs 7.52, 3/3 seeds - the comparative terms are the poison | tools/geobasin_runs/; history/timeline.md 2026-07-25 geobasin block |
+| L-010 | **9** | 32212+1 | `SQ.A0`/x0-linear | flow v-MSE (rectified flow, SHIFT-warped sigma) | x0 = x_t - sigma*v is EXACT and LINEAR at every sigma - asserted, not assumed | pod2/dexp001_sd15_relay.py:151-164; closeout_2026-07-19/amoe/src/amoe/diffusion/train/objectives.py:51-58 |
+| L-003 | **8⚠** | 33121+0 | `CE.A0`/logits | plain full-sequence cross-entropy (packed labels) | the workhorse; also the documented geometry antagonist - CE drove the Oct '25 geometric collapse | pod/v35_exp001_placement.py:170; tools/ar_differentiation_bed.py:423 |
+| L-017 | **8⟂** | 33111+0 | `CE.A7`/similarity-grid | InfoNCE as an alignment force (OFF address paths) | NECESSARY + SUFFICIENT for alignment: swap it in -> R@1 .999 | canon/geometric_memory_blueprint.md:7-8; canon/geometric_memory_blueprint.md:20 |
+| L-005 | **8** | 32121+0 | `CE.A4`/logits | shift-CE with ignore_index=-100 (prefix-masked instruction rows) | the standard instruction-tuning form across the v35 and q25 lines | pod/v35_exp006_math.py:180; pod/v35_exp013_experts.py:211 |
+| L-009 | **8** | 32211+0 | `SQ.A0`/eps | eps-MSE (epsilon prediction, stock schedule) | relay -2.5% over frozen, 2 seeds; relay >= matched LoRA 2-for-2 across substrates | pod2/dexp006_sd15core_relay.py:132-146; history/timeline.md:1337-1350 |
+| L-011 | **8** | 32122+0 | `CE.A0`/logits | sign-code head addr_mslh64 (fully discrete forward, STE backward) | bpb 2.4711 vs soft 2.4685 - parity certified 3 seeds; a ~2.8% gap opens at 4x budget | history/timeline.md:249-283; inventory/SCALE_MANIFEST.md:64-71 |
+| L-149 | **8** | 22222+0 | `CE.A0`/basin-scores | CE on the cosine-anchor basin head (the geobasin control) | the head itself costs +0.13 bpb under CE (2.607 vs 2.477 linear, 3 seeds; acc .498 vs .505) - small, so every geometric-arm deficit is THE LOSS, isolated | tools/geobasin_runs/; history/timeline.md 2026-07-25 geobasin block |
+| L-028 | **7** | 23111+0 | `CE.A4`/logits | masked-marginal variant scoring (protein VEP) | WT unmasked marginal rho 0.10 -> masked marginal ESSENTIAL; final rho .993 / .309 unseen | canon/ryan_spearman_protein.md:41-42; canon/ryan_spearman_protein.md:6-8 |
+| L-006 | **7** | 32111+0 | `CE.A4`/logits+pixels | HuggingFace out.loss (VLM labels= path, vision tower fires) | required wherever the vision tower must fire - chunking bypasses it | pod/v35_exp004_caption.py:175; pod/v35_exp004_caption.py:17-19 |
+| L-029 | **7** | 22211+0 | `CE.A0`/logits | GPT-2 frozen-trunk relay objective (dif-e013 Track C) | frozen 38.648 -> aleph 26.53 vs param-matched zero-init MLP 27.26; beats matched 2/2 seeds | history/timeline.md:349-363 |
+| L-013 | **6** | 13212+0 | `CE.A2`/coefficients | addr_3tau multi-tau stroboscope | 4.2884 no collapse (usage ppl 7.9, 117/128 alive) against addr_d4's 5.3698 | history/timeline.md:1093-1095 |
+| L-027 | **6** | 13212+0 | `CE.A0`/logits | antipode-conv objective (the address AS the convolution operator) | CIFAR-10 87.23% @ 861,450 params with NO ReLU/GELU anywhere; none -> mag +21.8 | inventory/SCALE_MANIFEST.md:8-30; canon/discovery_catalog.md:49-61 |
+| L-037 | **6** | 13111+0 | `CE.A0`/logits | denoiser objective (tokendiff iterative image-token denoise) | beats identity at every level; t=1.0 gives 0.378 vs 0.002 (189x) | sessions/2026-07-13.md:35-43 |
+| L-018 | **6** | 22111+0 | `CE.A7`/mixed | blueprint composite (InfoNCE 1.0 + Procrustes_SVD 0.3 + |CV-0.20| 0.05) | BERT-8192 m_acc .927 at CV exactly 0.200; CLIP-ctx576 m_acc .945 | canon/geometric_memory_blueprint.md:9-20 |
+| L-014 | **6** | 12212+0 | `CE.A0`/coefficients | addr_mhat reconstructive read consumed in AR | 5.1300 bpb but the HEALTHIEST cultivation on the bed (ppl 11.0, binding_frac .234) | history/timeline.md:1095-1097 |
+| L-035 | **6** | 12211+0 | `SQ.A0`/x0-linear | rectified-flow velocity objective (KSimplex / Form 7 bottleneck) | loss .1749 beat the 268M skip's .1757; the model routed 88% through the 768 dims | canon/ksimplex_diffusion_prior.md:26-28; canon/constellation_forms.md:59-63 |
+| L-038 | **6** | 12211+0 | `SQ.A0`/embeddings | recon_target (absolute MSE to a fixed frozen-trunk projection) | recall@1 0.264 - real (5x frozen) but HALF of InfoNCE's 0.494 at matched budget | sessions/2026-07-13.md:122-126; tools/qwen_exp011_newanchors.py:445-453 |
+| L-019 | **5** | 12111+0 | `CE.A7`/mixed | Expert Soup composite (InfoNCE + MSE + BCE + Procrustes + CV + spread) | mAP .84 (data-limited), 1000/1000 positive volumes, eff-dim 76.9 for COCO-80 | canon/constellation_forms.md:35-39 |
+| L-020 | **5⚠** | 12111+0 | `SQ.A0`/sequence-embeddings | SequenceReconstructor loss: MSE(normed) + (1 - cos) | CLIP-L ep5 m_acc .957 / s_cos .734; Meridian bigG s_cos PLATEAUS at .425 | canon/geometric_memory_blueprint.md:56-63; canon/constellation_forms.md:44-48 |
+| L-146 | **5** | 21222+0 | `BREG.A0`/address-code | FAC tanh-Hamming link (bounded tails) | cosh beats tanh 3/3: 4.349 vs 4.1285 (+0.22) - the bounded link loses within the family | tools/deviant_runs/; history/timeline.md 2026-07-25 deviant-matrix block |
+| L-147 | **5** | 21222+0 | `BREG.A0`/address-code | FAC Cauchy link (sub-quadratic tails) | cosh beats Cauchy 3/3: 4.360 vs 4.1285 (+0.23) - robust-statistics tails lose within the family | tools/deviant_runs/; history/timeline.md 2026-07-25 deviant-matrix block |
+| L-007 | **5** | 11221+0 | `CE.A0`/logits | dispatch-keys-only CE (aligner; adapters frozen as anchors) | trainable set is ONLY the per-block key matrices; reference-grade, never seed-replicated | closeout_2026-07-19/amoe/src/amoe/train/aligner.py:41-67 |
+| L-030 | **5** | 20211+0 | `CE.A0`/logits | val_ce on a frozen semantic substrate (CLIP-L token-AR) | MLP WINS frozen-substrate token-AR (penult 5.245 best); aleph tax ~ +0.09 | history/timeline.md:335-348 |
+| L-031 | **5** | 20122+0 | `SQ.A0`/geometry | pure geometric-basin loss set (coherence/separation/discretization/geometry) | the program's ONE attempted CE replacement - NOW PROPERLY TESTED: refuted on the byte bed (acc 0.157 vs control 0.498, 3 seeds); the absolute-only variant doubles it (L-152) | canon/cantor_empirics.md:20-22 |
+| L-070 | **5⟂** | 20221+0 | `BREG.A0`/address-code | FAC as a PRIMARY sequential objective (cosh-Bregman, replace CE) | REFUTED AS PREREGISTERED, 3/3 seeds: fac_lsh 4.13 bpb vs ce 2.48; ce_fixedcode 3.81 beats it; fac_none 3.95 beats it | tools/fac_runs/; history/timeline.md 2026-07-25 pass-3 block |
+| L-140 | **5** | 20221+0 | `CE.A0`/logits | sparsemax as a full-bed objective | REFUTED as a general objective: bpb 7.43 / acc 0.331 vs ce 2.4769 / 0.505 (3 seeds) | tools/deviant_runs/; history/timeline.md 2026-07-25 deviant-matrix block |
+| L-141 | **5** | 20222+0 | `CE.A9`/logits | soft-max / worst-position accumulation (trained) | REFUTED: bpb 4.24 / acc 0.276, 3 seeds - the 0.911-novelty champion chases irreducible entropy exactly as flagged | tools/deviant_runs/; history/timeline.md 2026-07-25 deviant-matrix block |
+| L-142 | **5** | 20222+0 | `CE.A2`/logits | geometric-mean accumulation (trained) | REFUTED decisively: bpb 9.03 - the anti-focal starves hard positions and the distribution never forms (3 seeds) | tools/deviant_runs/; history/timeline.md 2026-07-25 deviant-matrix block |
+| L-143 | **5** | 20122+0 | `CE.A0`/logits | label smoothing eps=.1 (trained on the byte bed) | bpb 2.587 vs ce 2.4769 (+0.11, 3 seeds) - payer-class novelty (0.479), mildly WORSE outcome | tools/deviant_runs/; history/timeline.md 2026-07-25 deviant-matrix block |
+| L-144 | **5** | 20122+0 | `CE.A2`/logits | focal gamma=2 (trained, live-model weights) | bpb 2.597 (+0.12 vs ce, 3 seeds) - payer-class trained novelty (0.337), mildly worse outcome | tools/deviant_runs/; history/timeline.md 2026-07-25 deviant-matrix block |
+| L-145 | **5** | 20222+0 | `CE.A4`/logits | anti-curriculum (train only where the frozen reference is confident) | REFUTED as an objective: bpb 6.74 (3 seeds) - abandoning 72% of the distribution buys nothing on the rest | tools/deviant_runs/; history/timeline.md 2026-07-25 deviant-matrix block |
+| L-148 | **5** | 20122+0 | `CE.A0`/logits | confidence penalty (trained as the GATE-VALIDATION CONTROL) | CLOSEST TO CE OF ALL DEVIANTS: bpb 2.520 (+0.043, 3 seeds) - the gate's refusal correctly predicted 'CE plus nothing' | tools/deviant_runs/; history/timeline.md 2026-07-25 deviant-matrix block |
+| L-150 | **5** | 20122+0 | `SQ.A0`/basin-scores | PureGeometricLoss, learned anchors (the Oct '25 arm, properly tested) | REFUTED on this substrate: acc 0.157 vs control 0.498 (-68% relative, 3 seeds) - far below the historical -12% trade | tools/geobasin_runs/; history/timeline.md 2026-07-25 geobasin block |
+| L-151 | **5** | 20222+0 | `SQ.A0`/basin-scores | PureGeometricLoss, FROZEN anchors (the L-108 cell) | learned BEATS frozen by +8 acc points (0.157 vs 0.076, 3 seeds) - the L-108 falsifier FIRED for cosine anchors | tools/geobasin_runs/; history/timeline.md 2026-07-25 geobasin block |
+| L-153 | **5** | 20112+0 | `SQ.A0`/basin-scores | GeometricPrototypeLoss (verbatim, own projector) | WORST of the family: bpb 8.12, acc 0.008 (3 seeds) - the extra indirection buys total failure | tools/geobasin_runs/; history/timeline.md 2026-07-25 geobasin block |
+| L-154 | **5** | 20122+0 | `SQ.A0`/basin-scores | HierarchicalGeometricLoss on the nibble hierarchy (16x16) | CATASTROPHIC: acc 0.0003 - below chance (1/256) - hierarchy-in-class-space destroyed fine structure entirely (3 seeds) | tools/geobasin_runs/; history/timeline.md 2026-07-25 geobasin block |
+| L-155 | **5** | 20222+0 | `SQ.A0`/basin-scores | CE + PureGeometric hybrid (0.5/0.5) | the geometric set POISONS CE rather than riding it: bpb 4.53 vs control 2.61 (+1.9, 3 seeds) - P4 bar (within 0.15) missed by 12x | tools/geobasin_runs/; history/timeline.md 2026-07-25 geobasin block |
+| L-036 | **4** | 11111+0 | `CE.A0`/logits | margin losses ArcFace / CosFace / SphereFace (RoseFace dual-norm) | the ZANA innovation - and it hit a 60% single-stream ceiling | canon/vit_lineage_beatrix_zana.md:17-28 |
+| L-008 | **4** | 10121+0 | `CE.A0`/logits | image-classification CE (CIFAR-10, aleph-dispatched MoE vs dense) | MoE 58.52% TIES param-matched dense 58.52% exactly; 6x params bought nothing | history/timeline.md:1127-1138; tools/addressed_distillation_v1.py:301 |
+| L-032 | **3** | 00220+0 | `-.NA`/geometry | GBC - 'cross-entropy can be replaced entirely' (roadmap claim) | classification via triadic compatibility, self-similarity, Cantor coherence, hierarchical basin checks | canon/geovocab_chunking.md:21-22 |
+| L-033 | **3** | 00212+0 | `SQ.A0`/pixels | masked-recon / generative arm (campaign law 2 in its ORIGINAL form) | BUILT, NEVER RUN - predicted to be where the SIGNED read finally beats magnitude | inventory/SCALE_MANIFEST.md:19-21; history/open_questions.md:144-145 |
+
+## AUXILIARY TERMS, REGULARIZERS, AND STRUCTURAL SUBSTITUTES
+
+Includes the structural devices that REPLACED a loss term - sphere normalization, gradient
+equalization, bounded alpha. Their presence here is the point: this program's strongest
+results come from making geometry structural rather than penalized.
+
+| ID | RATE | RPDCI+L | CELL / SUBSTRATE | NAME | HEADLINE NUMBER | CITE |
+|---|---|---|---|---|---|---|
+| L-052 | **10** | 33221+1 | `-.NA`/adapters | zero-init output heads (WEIGHT and bias) - the inertness contract | makes the toggle law bit-exact (max|dlogit| = 0.0); the bias leak alone is a standing +0.5 ppl offset | MANIFEST.md:171-172; closeout_2026-07-19/amoe/src/amoe/diffusion/core/relay.py:49-52 |
+| L-065 | **10** | 33212+1 | `-.A3`/sigma-axis | band crossfade windows as STRUCTURAL positional gating | own-band damage 50-200x cross-band, 3/3 both seeds - specialists manufactured with NO routing loss | MANIFEST.md:90-96; plans/2026-07-17_multiband_stage_plan.md:18-35 |
+| L-044 | **10** | 23222+1 | `-.NA`/cantor-measure | Devil's Staircase alpha-normalization (bit_k = p[RIGHT] + alpha*p[MIDDLE], alpha=0.5) | WITHOUT the alpha term the measure COLLAPSES to {0, .333, .667} - the FractalDavid bug | MANIFEST.md:30-31; canon/vit_lineage_beatrix_zana.md:40-49 |
+| L-061 | **10** | 23222+1 | `-.NA`/data | question-space guard (training-question space >= 3x draws) | caught TWO memorized experts that had PASSED the answer-diversity guard (spaces 480 and 248 vs 800 draws) | MANIFEST.md:169-170; inventory/SCALE_MANIFEST.md:152-154 |
+| L-051 | **10** | 32222+1 | `-.NA`/optimizer | pure Adam, weight_decay = 0 (the anti-regularizer law) | Adam+gates .731 vs AdamW(3e-4, wd .01) .667 - 'weight decay is uniform damping that destroys the geometric harmonic' | MANIFEST.md:15; canon/discovery_catalog.md:18 |
+| L-068 | **9** | 33212+0 | `-.A6`/any | paired (row, noise, t) triples - the variance-killing accumulation | the noise-pair floor is ~0.988 - without pairing the effects this program measures are invisible | history/timeline.md:1220-1227; pod2/dexp001_sd15_relay.py:167-185 |
+| L-042 | **9** | 23212+1 | `-.NA`/gradients | gradient equalization across heterogeneous geometric towers | without it spreads hit 20 ORDERS of magnitude (fibonacci dead at 2.25e-21 under helix) | MANIFEST.md:43-45; canon/fibonacci_systems.md:14-20 |
+| L-016 | **9** | 32212+1 | `SQ.A5`/x0-linear | blob-LP-x0 structural supervision on FLOW (lambda ~ 1) | -5.9% / -3.7% two seeds on flow vs +0.03% / -1.0% on eps: a ~125-200x effect ratio | MANIFEST.md:65-69; history/timeline.md:1481-1491 |
+| L-041 | **9** | 32222+0 | `-.NA`/activations | sphere normalization (M = F.normalize(M); ||M||_F^2 = V pins sum sigma^2) | zero collapses in 400 epochs; V=1024 went from 48 s/ep crashing to 2.0 s/ep stable | canon/structural_attractors.md:32-37; canon/discovery_catalog.md:8 |
+| L-043 | **9** | 32221+1 | `-.NA`/spectra | bounded multiplicative alpha (S*(1 + alpha*tanh), alpha <= 0.2, init .024) | unbounded alpha POISONS the spectrum; bounded modulation costs 2,272 of 16.9M params (0.013%) | MANIFEST.md:40; canon/omega_tokens_fresnel_johanna.md:5-9 |
+| L-050 | **9** | 22222+1 | `-.NA`/gradients | gradient clipping discipline (0.5 on cross-attn ONLY; NEVER inside an LBFGS closure) | unclipped LBFGS closure DIVERGED to G-MSE 7.4e26; safety is line_search_fn='strong_wolfe' | MANIFEST.md:46-47; canon/tri_band_omega_arc.md:55-57 |
+| L-048 | **8⟂** | 32212+0 | `SQ.A3`/band-routed | HP/LP band-role objectives [judged by the ROLE-ALIGNED gauge] | multiband beats the matched monolith ~10% on HIGH-band foreground, BOTH seeds | history/timeline.md:1465-1479 |
+| L-059 | **8** | 32122+0 | `-.NA`/codebook | straight-through estimator on the aleph HARD read | forward fully DISCRETE oriented code, backward soft: hosted books hold cos .992-.997, 112-122/128 hard axes, zero collapse | canon/aleph_core.md:20-23; MANIFEST.md:135-138 |
+| L-040 | **8** | 22221+0 | `DET.A2`/S15-bank | 1e-3 CV bank loss (arm-gated, S^15 bank ONLY, never the aleph codebook) | holds CV .295-.305 at zero-to-positive task cost where bare CE drifts it to .31-.34 | tools/exp017_aleph_constellation.py:154-186; history/timeline.md:692-696 |
+| L-066 | **8** | 22212+1 | `-.A5`/x0-linear | lambda dose coupling (3-point curve on the blob term) | 0.5 -> -5.9% | 1.0 -> -8.3% (in bound) | 2.0 -> -8.4% (OUT of the 0.5% common-gauge bound) | history/timeline.md:1584-1589; closeout_2026-07-19/amoe/src/amoe/diffusion/laws.py:41 |
+| L-067 | **8** | 22212+1 | `-.A8`/gauges | fp64 gauge accumulation (autocast disabled in the reduction) | fp32 determinants lose up to ~4% on near-degenerate pentachora - 'fp32 det only' now means fp32 MINIMUM | MANIFEST.md:32-39; tools/geolip_vitals.py:60-103 |
+| L-023 | **7** | 23111+0 | `KL.A4`/logits | kd_facts (fact rows supervised ONLY by teacher logits, alpha=1.0 legal here) | recall 0.953 vs direct 0.871; held-out RULE induction 0.264/0.279 >= the teacher itself | history/timeline.md:758-767; history/timeline.md:783-806 |
+| L-024 | **7** | 23111+0 | `SQ.A0`/shape-mean | dual-teacher Procrustes consensus distillation | teachers .699/.649 -> student .761 EXCEEDS BOTH, still accelerating at E30 | canon/geometric_memory_blueprint.md:90-98; canon/gm3_parity/03_teachers_and_distillation.md:7-13 |
+| L-055 | **7** | 22211+0 | `-.NA`/rotations | Cayley orthogonality constraint + Newton-Schulz whitening | Q = (I-A)(I+A)^-1 guarantees pure rotation: det = 1.000 throughout, wins 76/84 unseen assays | canon/ryan_spearman_protein.md:19-23 |
+| L-026 | **6** | 13211+0 | `SQ.A2`/recon | soft-hand loss (proximity REWARD, not penalty) | V256 D24: MSE 0.034 at 400ep - 37% better than the best unconstrained run (.054) | canon/structural_attractors.md:38-56 |
+| L-054 | **6** | 13211+0 | `-.NA`/arms | quaternion composition as a structural regularizer (Hamilton product) | GeoQuat 0.916 -> 0.993 over 100 epochs vs best baseline 0.903 | canon/ryan_spearman_protein.md:12-18; canon/ryan_spearman_protein.md:26-29 |
+| L-056 | **6** | 13221+0 | `-.NA`/architecture | cascade as a regularizer (multi-step MLP instead of a direct dimensional jump) | 9-step 256->64 gives 84.6% vs a direct jump's 29.6%; a 27-step r=.95 cascade EXCEEDS the root | canon/geometric_memory_blueprint.md:38-40 |
+| L-057 | **6** | 13201+0 | `-.A3`/routing | Cantor router (soft weights derived FROM triangulation distances) | cos .9818 at 8 layers vs relay-alone .6533; geometry IMPROVES with more tokens | canon/constellation_forms.md:53-58 |
+| L-022 | **6** | 22111+0 | `KL.A0`/logits | logit-KD at alpha <= 0.25 with founder exemption | mlp_kd lineage 2.4106 -> 2.3707 -> 2.3662 -> 2.3594 monotone ascent; replicates at s1 | history/timeline.md:396-410; history/timeline.md:570-583 |
+| L-034 | **6** | 12221+0 | `SQ.A0`/codebook | entropy-balanced alignment cultivation (w = .05) | produced the emergent basin M = +/- ref EXACTLY - the sign-code convergence endpoint | canon/svae_h2_class.md:23 |
+| L-045 | **6** | 12212+0 | `DET.A0`/simplices | L_CM - Cayley-Menger validity hinge (lambda = .01) | CM validity 100% across the lineage table | canon/ksimplex_diffusion_prior.md:18-23 |
+| L-046 | **6** | 12211+0 | `DET.A0`/simplices | L_vol - volume-spread REWARD (-std(log|vol^2|), lambda = .005) | fragmented anatomy -> coherent composition; base fully preserved (purely additive) | canon/ksimplex_diffusion_prior.md:21-23 |
+| L-047 | **6⟂** | 12211+0 | `SQ.A0`/shape-mean | Procrustes_SVD as a REGULARIZER (x 0.3 alongside a real force) | tightens CV (.19 vs .25) when it rides alongside InfoNCE | canon/geometric_memory_blueprint.md:22-24; canon/constellation_forms.md:26 |
+| L-049 | **6** | 12221+0 | `-.NA`/anchors | anchor dropout (30%) | prevents collapse: 508/512 anchors active | canon/constellation_forms.md:27 |
+| L-060 | **6** | 12221+0 | `-.NA`/data | data-level dampening (sqrt damping alpha=0.5, max_repeats=8, cap 1.25x) | NEVER equalize-to-largest: alpha=0 repeats 5 images ~50x/epoch | canon/subject_bucketing_anima.md:17-19 |
+| L-064 | **6** | 12221+0 | `SQ.A0`/crystals | rose loss (role-weighted pentachoron regularization, rose_w = 1e-4) | 74.87% CIFAR-100 @ 393,216 params vs ~65% zero-shot and ~70-72% linear probe | canon/fibonacci_systems.md:29-33; canon/geovocab_chunking.md:24 |
+| L-039 | **5** | 12111+0 | `CE.A7`/similarity-grid | contrastive dynamics as a CV-compression force | 100 clusters / 200 steps at d=128 -> CV .2451 (in band); 10 clusters -> .94 | canon/cv_band_origin.md:14-17 |
+| L-053 | **5** | 12111+0 | `-.NA`/gradients | geometric autograd / gradient gating (Form 12 tangential-radial split) | gradients split tangential (pass) / radial (attenuate) / collapse-direction (attenuate) | canon/constellation_forms.md:83-86; canon/gm3_parity/02_optimizer_and_cv.md:7-18 |
+| L-025 | **5** | 21212+0 | `SQ.A0`/shape-mean | projective-ICP / GPA consensus operator (lineage-core overwrite) | recovers planted truth |cos|=1.000 in 5 iterations; TASK-NEUTRAL on bpb, 2 seeds | history/timeline.md:417-437; history/timeline.md:570-595 |
+| L-062 | **5** | 21222+1 | `-.A2`/data | usage / starvation reweighting (drives DATA sampling, NEVER a loss term) | the program's ONLY answer to load balancing: x2 upweight the starved anchor's DATA, 3-strike abort | closeout_2026-07-19/amoe/src/amoe/train/aligner.py:68-84; pod/v35_exp007_collective.py:248-262 |
+| L-063 | **5** | 21221+0 | `-.NA`/conditioning | CFG dropout 0.1 (conditioning zeroed, not empty-prompt) | standard in every diffusion bed; never ablated in this program | pod2/dexp006_sd15core_relay.py:132-146 |
+| L-021 | **5** | 11221+0 | `SQ.A2`/eps | Min-SNR gamma=5 weighting + velocity adjustment | part of a working recipe (1 ep, 10k synthetic, ~7 min on an L4); never ablated | canon/ksimplex_diffusion_prior.md:28 |
+| L-058 | **3** | 01211+0 | `-.NA`/codebook | address-agreement bias (BUCKET - making a hard address differentiable) | exact softmax within sorted equal-width blocks masked to the same bucket; argmax alone is gradient-dead | canon/mother_threads.md:35-37; canon/constellation_forms.md:118-120 |
+| L-069 | **3** | 00221+0 | `-.A2`/sequence-axis | predictability-weighted accumulation (PWA) | DESIGNED 2026-07-25: make the PREDICTABILITY PRINCIPLE a loss geometry instead of a discovered side effect | history/timeline.md:1062-1066; inventory/SCALE_MANIFEST.md:144-154 |
+
+## GAUGES - measure only, never in the gradient path
+
+| ID | RATE | RPDCI+L | CELL / SUBSTRATE | NAME | HEADLINE NUMBER | CITE |
+|---|---|---|---|---|---|---|
+| L-071 | **10** | 33212+1 | `DET.A8`/anchors | CV as a READOUT (never a force) | the historical CV 'loss' was GRADIENT-FREE all along - .item() stripped the graph | canon/discovery_catalog.md:9-10; canon/aleph_core.md:40-41 |
+| L-073 | **10** | 33222+0 | `-.A0`/bytes | bpb (bits per byte) - the AR line's verdict currency | certified band 2.469-2.499; addr_msl64 beats the unrestricted head 7/7 across seeds and budgets | inventory/SCALE_MANIFEST.md:53-58; history/timeline.md:139-147 |
+| L-074 | **10** | 33222+0 | `-.A0`/logits | perplexity tax ladder (wikitext ppl delta, one shared gauge) | one always-on stack +9.23/+9.87 | monolith +3.66 | 5-anchor collective +11.0/+12.6 | UNGATED +91.6 | inventory/SCALE_MANIFEST.md:240-248; history/timeline.md:1156-1171 |
+| L-075 | **10** | 33222+0 | `-.A0`/text | token-F1 (caption distribution-match delta) | 0.408 -> 0.706/0.704 (+0.30, |s0-s1| = 0.0019); the hub checkpoint reproduces 0.706 EXACTLY | inventory/SCALE_MANIFEST.md:155-166; history/timeline.md:1656 |
+| L-080 | **10** | 33222+1 | `-.NA`/logits | toggle law - all anchors off is BIT-EXACT to the base model | max|dlogit| = 0.0 exactly at 0.8B on a hybrid DeltaNet/full-attention trunk; library-enforced | MANIFEST.md:171-172; closeout_2026-07-19/amoe/src/amoe/testing/invariants.py:76-97 |
+| L-083 | **10** | 33222+0 | `-.A0`/codebook | usage perplexity / axis aliveness (read-only) | 125+/128 axes alive WITHOUT regularization - the standing refutation of load-balancing auxiliaries | canon/discovery_catalog.md:41-42; tools/geolip_vitals.py:108 |
+| L-085 | **10** | 33222+1 | `-.A0`/anchors | blend-escape ratio (threshold 1.5) and damping ratio (target >= 3x) | specialists damped 5-11x but caption ESCAPES undamped at 0.1004 - the corollary that became the regime law | closeout_2026-07-19/amoe/src/amoe/laws.py:37-39; history/timeline.md:1961-1964 |
+| L-089 | **10** | 33222+0 | `DET.A8`/anchors | CV@1000-batches early screen + the 3-tier filter | CV at 1000 batches PREDICTS the final band; turnaround ~2h -> ~7 min per config | canon/tri_band_omega_arc.md:21-27; canon/discovery_catalog.md:11-13 |
+| L-092 | **10** | 33222+0 | `-.A0`/patches | resolution-invariance flatness (the debugging canary) | 4.5% MSE variance from 81 to 4096 patches; ~1% across a 36-config sweep - ANY shift means an upstream break | canon/discovery_catalog.md:20-22; canon/tri_band_omega_arc.md:67-70 |
+| L-095 | **10** | 23222+1 | `-.NA`/hardware | peak_mem + s/step (the WDDM sysmem-spill tell) | the tell is ~100W/450W at '100% util' with no step prints - 42.8GB observed spilled to shared memory | MANIFEST.md:50-59; pod/run_g6b_rider.py:34-48 |
+| L-077 | **9** | 33221+0 | `-.A0`/codes | register probe (sign-code inter-minus-intra Hamming separation) | THE PREDICTOR of the two-regime law: registers ~0.2-0.3 blend, domains ~0.35-0.5 specialize | canon/register_probe_gauge.md; inventory/SCALE_MANIFEST.md:38-42 |
+| L-081 | **9** | 33212+0 | `-.A3`/bands | band-lesion surgical test (own vs cross damage) | surgical 3/3 both seeds at 50-200x; on a DiT edge bands hit cross-damage EXACTLY 0.0 | MANIFEST.md:70-76; history/timeline.md:1851-1864 |
+| L-091 | **9** | 33212+0 | `-.A8`/spectra | spectral gauges: S0/S_D ratio, effective rank, the universal attractor | critical ratio ~6.5 triggers DISCHARGE; universal attractor S0 ~5.1, erank 15.88 +/- 0.04 across 48+ measurements | canon/structural_attractors.md:24-30; canon/discovery_catalog.md:5-7 |
+| L-094 | **9** | 33221+0 | `-.A0`/structured-text | structured-task validity judges (JSON validity, IoU, pair-order, termination) | bbox 0 -> 0.6875 valid (0.894 IoU); the FORMAT TRAMPLING signature: 9/12 truncated_no_json | inventory/SCALE_MANIFEST.md:253-255; sessions/2026-07-14_pod.md:378-394 |
+| L-076 | **9** | 23222+0 | `-.A0`/text | precision + invented-attribute rate (the hallucination decomposition) | precision 0.356 -> 0.694/0.705 and invented-attribute rate 0.200 -> 0.136/0.101, BOTH seeds | inventory/SCALE_MANIFEST.md:233-238; history/timeline.md:1679 |
+| L-078 | **9** | 23222+0 | `-.A8`/codes | sign_fidelity (Spearman of code-Hamming vs true angular distance) | PROMOTED: separates inheritance from lottery where bpb CANNOT - successors lock at .9555-.9558, spread < .001 | history/timeline.md:476-521; inventory/SCALE_MANIFEST.md:67-69 |
+| L-086 | **9** | 23222+0 | `-.A0`/text | composition score (the controller prereg gauge) | the chaining wall: components >= 0.96 solo, composite 0.0 for EVERY config | inventory/SCALE_MANIFEST.md:261-270; history/timeline.md:1657-1660 |
+| L-088 | **9** | 23222+0 | `-.A0`/gradients | grad_norm_spread (gradient democracy monitor) | reference failure it exists to catch: 20 orders of magnitude across unequalized towers | tools/geolip_vitals.py:160-173; canon/fibonacci_systems.md:14-20 |
+| L-097 | **9** | 23222+0 | `-.A0`/text | held-out byte accuracy (rule induction) and variant-format recall (the format lock) | teachers memorize at 1.000 train but induce at 0.270/0.245 held-out; memorized content is BOUND to surface form | history/timeline.md:783-806; history/timeline.md:794-800 |
+| L-098 | **9** | 23222+0 | `-.A0`/codes | key-durability gauge (nearest-neighbour symbol Hamming + key drift) | sign-code keys disagree on ~91% of symbols; match rate at theta=0.25 is 0.000 EVERYWHERE | history/timeline.md:868-894 |
+| L-099 | **9** | 23222+0 | `-.A0`/codebook | basin mean_cos (BASIN SET AT INIT) | 192-bank sweep: epoch_1 .8632 / best .8635 / final .8615 - delta 0.0017 BELOW the within-phase std | MANIFEST.md:124-127; canon/tri_band_omega_arc.md:71-75 |
+| L-100 | **9** | 22222+1 | `DET.A8`/simplices | cv_reference_check (fp64 parity against the source of truth) | exact parity (relative 0.0) at fp64 against geovocab2, at ~260x the speed | MANIFEST.md:32-39; tools/geolip_vitals.py:78-103 |
+| L-079 | **8** | 23212+0 | `SQ.A3`/band-routed | role-aligned in-bed gauge (HIGH-band foreground-masked LP-x0) | PROMOTED: found a ~10% multiband win that EVERY aggregate comparison hid | history/timeline.md:1465-1479 |
+| L-082 | **8** | 23212+0 | `-.A6`/routing | repeated-key null + matched-vs-mismatched deltas | the instrument that falsified address-as-key: routing excess 2.5e-06 over the null | inventory/SCALE_MANIFEST.md:203-208; history/timeline.md:1611-1629 |
+| L-096 | **8** | 22222+0 | `-.A0`/anchors | consensus drift / stationarity gauge | ROBUST for structured configurations (0.003 drift by g2, both seeds) but SEED-DEPENDENT for a lone flat book | inventory/SCALE_MANIFEST.md:79-86; canon/gm3_parity/01_inherited_object.md:77-85 |
+| L-090 | **7** | 22211+0 | `-.A8`/codebook | void topology beta_2/axis (persistent homology on RP^(D-1)) | within the D=4 cohort every GEOMETRIC signal collapses while VOIDS rise; beta_2 vs recon MSE |rho| = 0.471 | canon/void_topology.md:27-63; canon/discovery_catalog.md:37-38 |
+| L-084 | **6** | 13222+0 | `-.A0`/codebook | read perplexity + |cos to nearest atom| (the quantizer gauge) | read perplexity 14/64 atoms, |cos to nearest atom| 0.964, 64/64 alive - the representation LIES ON the codebook | inventory/SCALE_MANIFEST.md:14-16; canon/discovery_catalog.md:54-58 |
+| L-087 | **6** | 13222+0 | `-.A0`/any | adapter_effect_mean - the VACUOUS guard | returns VACUOUS instead of a false PASS when the stack barely moves the loss | sessions/2026-07-21_comfyui_amoe_packaging.md:363-371 |
+| L-093 | **6** | 12222+0 | `-.NA`/code | exec judge (guarded subprocess: restricted builtins, length cap, hard timeout, no network) | the write-0.0 floor was verified GENUINE off-pod, not a judge artifact | history/timeline.md:1634-1635; plans/2026-07-16_math_night_plan.md:46-51 |
+| L-104 | **6** | 12222+0 | `-.A0`/codes | sign-code Hamming retrieval | 0.359 @1 against the continuous head's 0.494 - ~73% of its power from raw 64-symbol Hamming | sessions/2026-07-13.md:116-121 |
+
+### DISTRUSTED GAUGES - do not rate anything on these alone
+
+Each was load-bearing until it was caught. Any entry whose headline rests on one takes the
+-2 blind-gauge demotion (rule 2) until it is re-measured on a promoted gauge.
+
+| ID | RATE | RPDCI+L | CELL / SUBSTRATE | NAME | HEADLINE NUMBER | CITE |
+|---|---|---|---|---|---|---|
+| L-072 | **8** | 32221+0 | `-.A0`/anchors | anchor drift -> 0.29154 rad + binding_fraction | the binding constant recurs across 5 architectures and 3 paradigms - but the drift-based fraction is a STAGE statistic | MANIFEST.md:115-116; history/timeline.md:231-241 |
+| L-101 | **5** | 31221+0 | `-.A0`/gates | gate-mean band 0.012-0.03 (advisory, NOT universal) | held across 6 architectures and 2 optimizers - then MISSED on a 7th at 0.051-0.061 | MANIFEST.md:121; history/open_questions.md:31-33 |
+| L-102 | **5** | 30220+0 | `SQ.A0`/eps | aggregate eps-MSE as a band-behaviour gauge | DISTRUSTED: moved 0.2% against +0.089 grounding effects in image space, and HID a ~10% multiband win | history/timeline.md:1402-1422; history/timeline.md:1465-1479 |
+| L-103 | **2✖** | 20020+0 | `-.A0`/addresses | recon cosine as a judge for ADDRESSED systems | DISTRUSTED: an address is a LOOKUP KEY, not a compressor - judge drift and crushed CV instead | MANIFEST.md:115-116; history/open_questions.md:198-204 |
+
+## RETRACTED / DEMOTED / FORBIDDEN - the doctrine's proof set
+
+**Each row below is the EVIDENCE for a standing law. This is not a graveyard and not an
+appendix - these are the controls that turned results into laws. Cite them.**
+
+Grouped by the law each row proves, not by entry.
+
+### absolute-beats-relative
+
+| ID | RATE | RPDCI+L | CELL / SUBSTRATE | NAME | HEADLINE NUMBER | CITE |
+|---|---|---|---|---|---|---|
+| L-105 | **1†** | 30012+1 | `SQ.A10`/codebook | VQ / commitment / EMA codebook losses | THE NAMED PROHIBITION - and unnecessary: the codebook stays 125+/128 alive at div_weight = 0 | canon/aleph_core.md:16-18; MANIFEST.md:132-134 |
+| L-106 | **1†** | 30012+1 | `CE.A0`/roster | comparative / relative selectors (argmax anchors, softmax-over-roster, STE one-hots, k-means alphabets) | roster-dependent; the gradient HOMOGENIZES - 14x path collapse, width attenuation, BN-on-padding, same disease | MANIFEST.md:135-138; canon/aleph_core.md:53-58 |
+| L-107 | **1†** | 20011+1 | `CE.A0`/alphabet | gradient-learned alphabets (CAMPAIGN LAW 3) | fitted-frozen alphabets differentiate (1,594 unique paths); gradient-learned alphabets COLLAPSE (116) | MANIFEST.md:157-158; canon/acd_campaign.md:18-20 |
+| L-108 | **1†** | 10011+0 | `SQ.A0`/crystals | direct gradient descent on pentachora | collapses them to zero - as FROZEN anchors the same crystals retain full cohesion and stay backtrackable | canon/geovocab_chunking.md:16-18 |
+| L-118 | **1†** | 30012+1 | `SQ.A0`/routing | comparative routing on diffusion (state+sigma, raw address, M-hat address-as-key) | FALSIFIED THREE WAYS, 2 seeds: routing excess 2.5e-06 over the repeated-key null; match advantage -0.0 | MANIFEST.md:70-76; inventory/SCALE_MANIFEST.md:203-208 |
+
+### regime-law
+
+| ID | RATE | RPDCI+L | CELL / SUBSTRATE | NAME | HEADLINE NUMBER | CITE |
+|---|---|---|---|---|---|---|
+| L-119 | **1†** | 20212+0 | `CE.A0`/logits | the controller hypothesis (a trainable anchor that orchestrates the others) | prereg required >= +0.15; measured -0.417 / -0.167. The passenger role is an ATTRACTOR | inventory/SCALE_MANIFEST.md:261-270; sessions/2026-07-14_pod.md:610-646 |
+| L-120 | **1†** | 30112+1 | `CE.A0`/logits | always-on solo specialist stacks | MUTUALLY DESTRUCTIVE at n=48: the depth stack drives caption F1 to 0.0014 with termination 0.0 | MANIFEST.md:160-166; inventory/SCALE_MANIFEST.md:216-232 |
+| L-121 | **1†** | 20212+0 | `CE.A0`/logits | frozen solo-trained expert collectives under aleph dispatch | no surgical independence (own-drop 0.04/0.00), NO damping (all five blend-regime, 0.86-1.6), composite 0.0 | inventory/SCALE_MANIFEST.md:169-178 |
+
+### instrument-design
+
+| ID | RATE | RPDCI+L | CELL / SUBSTRATE | NAME | HEADLINE NUMBER | CITE |
+|---|---|---|---|---|---|---|
+| L-125 | **1†** | 10222+0 | `-.A6`/routing | shuffled-key null | CONFESSED INSTRUMENT FAILURE: it measures diversity, not correctness - the null scored like the real thing | history/timeline.md:1539-1548 |
+| L-127 | **1†** | 20221+0 | `-.NA`/anchors | the exp021 seed-inversion claim for the trainable anchor | RETRACTED WITHIN HOURS: the claim compared DIFFERENT INSTRUMENTS across seeds | history/timeline.md:1697; hfstage/exp021_s1battery/README.md |
+| L-133 | **1†** | 10222+0 | `-.NA`/sampling | deterministic (greedy) decoding in an iterative denoiser | collapses to the global mode: diversity 0.0, conditional == shuffled EXACTLY | sessions/2026-07-13.md:35-43 |
+
+### coordinate-law
+
+| ID | RATE | RPDCI+L | CELL / SUBSTRATE | NAME | HEADLINE NUMBER | CITE |
+|---|---|---|---|---|---|---|
+| L-128 | **1†** | 10021+1 | `-.A3`/cantor-measure | hierarchical refinement in Cantor space | HARMFUL (-10%); parallel ADJACENT NON-OVERLAPPING bands are +3% | canon/cantor_empirics.md:5-18; MANIFEST.md:122-123 |
+| L-129 | **1†** | 10021+1 | `-.A3`/cantor-measure | repeated boundary crossing in a measure space | KILLS gradients (catastrophic -> random). Enter and exit the measure space ONCE | canon/cantor_empirics.md:5-7; MANIFEST.md:122-123 |
+| L-130 | **1†** | 20022+0 | `-.A3`/cantor-measure | the SOFT devil's staircase used as a BAND COORDINATE | NEW 2026-07-25: measured NON-MONOTONE - min slope -0.13 to -0.49 at EVERY level count on EVERY grid tested | .venv/Lib/site-packages/geofractal/model/positional/staircase.py:49-67; MANIFEST.md:90-96 |
+
+### aggregation-destroys
+
+| ID | RATE | RPDCI+L | CELL / SUBSTRATE | NAME | HEADLINE NUMBER | CITE |
+|---|---|---|---|---|---|---|
+| L-109 | **1†** | 30022+1 | `-.A0`/patches | global average pooling in geometric encoders | 70% -> 29% collapse, REPLICATED independently in the protein line | MANIFEST.md:24; canon/discovery_catalog.md:17 |
+| L-131 | **1†** | 10021+0 | `-.NA`/data | equalize-to-largest data balancing (alpha = 0) | repeats the 5-image bucket ~50x per epoch - 'the textbook way to overfit the long tail you were trying to protect' | canon/subject_bucketing_anima.md:17-21 |
+
+### consumption-law
+
+| ID | RATE | RPDCI+L | CELL / SUBSTRATE | NAME | HEADLINE NUMBER | CITE |
+|---|---|---|---|---|---|---|
+| L-112 | **1†** | 20022+0 | `CE.A0`/coefficients | addr_head - coefficients to logits at a single hard tau | 5.6650 bpb COLLAPSED: usage ppl 1.88/64, TWO unique winners, win|cos| .9992 | history/timeline.md:1105-1118; history/timeline.md:1092-1104 |
+| L-137 | **1†** | 20022+0 | `CE.A0`/coefficients | single hard-tau coefficient heads at ANY dimension | DEMOTED on the standing registry: collapse, and low-D was falsified as the fix | inventory/SCALE_MANIFEST.md:137-139 |
+
+### inheritance
+
+| ID | RATE | RPDCI+L | CELL / SUBSTRATE | NAME | HEADLINE NUMBER | CITE |
+|---|---|---|---|---|---|---|
+| L-114 | **1†** | 20112+0 | `KL.A0`/logits | logit-KD at alpha = 1.0 from near-parity teachers | INVERSE EVOLUTION, compounding downward: 2.4301 -> 2.5046 -> 2.5603 | history/timeline.md:383-395; canon/gm3_parity/03_teachers_and_distillation.md:14-24 |
+| L-122 | **1†** | 20222+0 | `-.NA`/weights | organ-only inheritance (projection + book transplanted onto fresh trunks) | BELOW random init, 2/2 lineages - sixteen random draws beat component inheritance | inventory/SCALE_MANIFEST.md:132-134; history/timeline.md:396-437 |
+
+### regime-transfer
+
+| ID | RATE | RPDCI+L | CELL / SUBSTRATE | NAME | HEADLINE NUMBER | CITE |
+|---|---|---|---|---|---|---|
+| L-117 | **1†** | 20222+0 | `CE.A0`/coefficients | tied M-hat readout (U=M_hat, S=Omega-token, Vt=I) in an AR head | +1.0 bpb BOTH seeds and it STARVES the codebook (drift 0.02, binding 0) | history/timeline.md:715-736; canon/gm3_parity/01_inherited_object.md:77-85 |
+| L-136 | **1†** | 10211+0 | `SQ.A0`/rotations | SVD-rotation transform in the dual-pentachoron head | DROPPED for convergence failure; reduced to scale + shift | canon/cayley_menger_foundations.md:36-38 |
+
+### cv-pressure
+
+| ID | RATE | RPDCI+L | CELL / SUBSTRATE | NAME | HEADLINE NUMBER | CITE |
+|---|---|---|---|---|---|---|
+| L-110 | **1†** | 20011+0 | `DET.A0`/anchors | CV loss as backward injection / above the 1e-3 ceiling | MUST be a forward loss; above ~.001 the CV term dominates CE and trades discrimination for regularity | canon/constellation_forms.md:85-86; canon/geometric_memory_blueprint.md:87 |
+
+### force-vs-regularizer
+
+| ID | RATE | RPDCI+L | CELL / SUBSTRATE | NAME | HEADLINE NUMBER | CITE |
+|---|---|---|---|---|---|---|
+| L-111 | **1†⟂** | 10112+0 | `SQ.A0`/shape-mean | Procrustes as a training FORCE | as a training loss: R@1 = 0.000, P_cos stuck at .094 for THIRTY EPOCHS | canon/geometric_memory_blueprint.md:22-24 |
+
+### infonce-placement
+
+| ID | RATE | RPDCI+L | CELL / SUBSTRATE | NAME | HEADLINE NUMBER | CITE |
+|---|---|---|---|---|---|---|
+| L-113 | **2✖⟂** | 33011+0 | `CE.A7`/similarity-grid | InfoNCE into ADDRESS paths | BANNED despite R@1 .999 - it is the LOUDEST gradient and the bank learns IT instead of the useful signal | MANIFEST.md:135-137; tools/exp013_augmentation_bed.py:18 |
+
+### conditioning-law
+
+| ID | RATE | RPDCI+L | CELL / SUBSTRATE | NAME | HEADLINE NUMBER | CITE |
+|---|---|---|---|---|---|---|
+| L-115 | **1†** | 30012+1 | `SQ.A5`/eps | blob structural supervision on the EPS objective | +0.03% / -1.0%, two seeds - the x0 recovery divides by a vanishing sqrt(alpha_bar) EXACTLY in the supervised band | MANIFEST.md:65-69; history/timeline.md:1465-1500 |
+
+### screening
+
+| ID | RATE | RPDCI+L | CELL / SUBSTRATE | NAME | HEADLINE NUMBER | CITE |
+|---|---|---|---|---|---|---|
+| L-116 | **1†** | 20220+0 | `SQ.A0`/recon | MSE-first single-epoch keep-or-kill screening | DEAD: the lowest-MSE config was a HIGH-band false candidate | canon/tri_band_omega_arc.md:23-27 |
+
+### band-roles
+
+| ID | RATE | RPDCI+L | CELL / SUBSTRATE | NAME | HEADLINE NUMBER | CITE |
+|---|---|---|---|---|---|---|
+| L-123 | **4⟂** | 31210+0 | `SQ.A3`/band-routed | HP/LP band-role objectives [judged by AGGREGATE eps-MSE] | 4/4 directional both seeds at 0.05-0.2% margins - 'nearly collinear with the base objective' | history/timeline.md:1394-1435 |
+
+### redundant-in-context
+
+| ID | RATE | RPDCI+L | CELL / SUBSTRATE | NAME | HEADLINE NUMBER | CITE |
+|---|---|---|---|---|---|---|
+| L-124 | **5** | 21222+0 | `SQ.A0`/conditioning | frozen-address conditioning injected beside full text | real vs deranged -0.0009 beside full text; but ALONE the address steers at +0.0287 | inventory/SCALE_MANIFEST.md:209-210; history/timeline.md:1305-1318 |
+
+### question-space
+
+| ID | RATE | RPDCI+L | CELL / SUBSTRATE | NAME | HEADLINE NUMBER | CITE |
+|---|---|---|---|---|---|---|
+| L-126 | **1†** | 10222+0 | `CE.A0`/logits | the sequences / baseconv expert gains | SELF-RETRACTED: question space 480 and 248 against 800 training draws per tier = MEMORIZED | history/timeline.md:1640 |
+
+### law2-placement
+
+| ID | RATE | RPDCI+L | CELL / SUBSTRATE | NAME | HEADLINE NUMBER | CITE |
+|---|---|---|---|---|---|---|
+| L-132 | **1†** | 10122+0 | `CE.A0`/conv-filters | addr_conv - the decorative address (convex re-weighting of a filter bank) | DECORATIVE: a convex sum a_k = 1 is a hull-bounded perturbation of a MEAN; the 1x1 address is CONSTANT on grayscale (variance 4e-16) | history/timeline.md:1890-1896; sessions/2026-07-24_antipode_conv_decouple.md:24-30 |
+
+### no-balancing
+
+| ID | RATE | RPDCI+L | CELL / SUBSTRATE | NAME | HEADLINE NUMBER | CITE |
+|---|---|---|---|---|---|---|
+| L-134 | **1†** | 30022+1 | `CE.A10`/routing | load-balancing / auxiliary router losses | BANNED and replaced by architectural equality; ZERO instances exist in the tree | history/progression_plan_2026-07-08.md:126-137; closeout_2026-07-19/amoe/src/amoe/core/dispatch.py:1-12 |
+
+### operator-ruling
+
+| ID | RATE | RPDCI+L | CELL / SUBSTRATE | NAME | HEADLINE NUMBER | CITE |
+|---|---|---|---|---|---|---|
+| L-135 | **1†** | 00201+0 | `CE.A0`/logits | the big-JSON objective | FORMALLY DROPPED by operator ruling - too costly; 3-5 task adapters deliver more per GPU hour | history/timeline.md:1977-1981; sessions/2026-07-14_pod.md:813-817 |
+
+## MECHANISM NOTES
+
+Keyed by ID so `grep L-115` finds both the row and its reasoning. Full notes live in
+`inventory/loss_manifest.json`; `python skill/loss_view.py show L-115` prints one.
+
+## OPEN CONTRADICTIONS (never averaged, per rule 7)
+
+1. **CE vs the CV band.** One record has Form-1 CORE holding CV .2045 under cross-entropy;
+   the repo results table shows CV drifting **.238 -> .124 by ep50** against CE at weight
+   .01. Bears on L-003's doctrinal standing. **Settled by:** a same-config re-run, or a
+   provenance split showing the two runs are not the same configuration.
+2. **The Meridian s_cos plateau at .425.** Two recorded explanations - a 1280->1024
+   dimensional mismatch, or pooled-bank gradient loudness. Bears on L-020. **Settled by:**
+   re-running the bank at matched dimension.
+3. **soft-vs-mag is depth-scoped.** Magnitude leads +10.3 at 3 layers; soft ran AHEAD at 6
+   layers with cosine schedule. SCALE_MANIFEST already forbids stating the modulus finding
+   as a law. **Settled by:** both arms run to completion at depth.
+
+## CROSS-REFERENCES
+
+- `canon/loss_accumulation_forms.md` - the taxonomy, the eleven format laws, the binning
+  procedure, the A10 statute.
+- `inventory/SCALE_MANIFEST.md` - answers "what scales". This file answers "what is allowed
+  to pull, and on what evidence". A mechanism in both carries the other's ID.
+- `canon/discovery_catalog.md` entry 26 - the three-primitive finding as a program-wide law.
+- `inventory/EXPERIMENT_LINES.md` - resolves the line-qualified IDs used in citations.
+
+## AMENDMENTS (append-only, dated)
+
+- **2026-07-25 - created.** Rubric v1, 137 entries, from three independent censuses.
+  Two findings NEW to the program are folded in as rows: the soft devil's staircase is
+  non-monotone and therefore inadmissible as a band coordinate (L-130), and alpha=0.5 is
+  the unique expectation-matching value for the staircase (L-044).
+- **2026-07-25 - A0 AUDIT (the operator: "is A0 correct?").** Partially no, three ways: (1) two
+  PRIMARY misbins fixed - L-006 (HF labels= path is masked CE inside) and L-015
+  (derived-steps trains shift-CE with ignore_index=-100) both move A0 -> A4 per binning
+  rule 4; (2) the fallback bucket had swallowed 25 rows with NO residual-reduction
+  semantics (structural devices, optimizer/data disciplines, assertion protocols,
+  decoding policies, claims) - a category error, now an explicit **NA** class; (3) what
+  remains at A0 (71 of 138) is honestly dominant: plain means ARE the program default,
+  and the aleph's only pressure lives there. GAP stays at A0 deliberately - it IS a
+  uniform-mean accumulation, the format's cautionary instance.
+- **2026-07-25 - pass 3 measured (same day).** L-070 (FAC) moved from UNRUN to a
+  scope-split pair: as a PRIMARY objective it is REFUTED as preregistered, 3/3 seeds
+  (loses to ce, to ce_fixedcode, and to fac_none on the bpb-of-record); on the
+  partition-collapse configuration (new L-138) a loss swap alone decompresses the
+  certified addr_head catastrophe (usage ppl 1.0-2.7 -> 60.6-61.1 of 64, decoded acc 0.05-0.20 -> 0.45-0.47,
+  3/3 SEEDS, spread < 0.5) and dissolves the win|cos| saturation (0.9995+ -> 0.13) -
+  amending L-112's recorded geometry attribution. The collapse follows the loss.

README.md

@@ -0,0 +1,66 @@
+---
+license: mit
+tags:
+- loss-functions
+- research-record
+- geometric-deep-learning
+---
+
+# The Loss Manifest — companion repository
+
+Companion to the article **"The Loss Manifest: A Field History of Objective
+Functions, and What a Machine Can Actually Be Asked to Compute"**
+(`article_loss_manifest.md` in this repo; also published on the author's blog).
+
+155 objective functions, regularizers, gauges, and prohibitions from a
+multi-year geometric deep learning program — each rated 1-10 under a fixed,
+recomputable rubric, each carrying its mathematics, its implementation home,
+and its verdict with receipts. Failures ship alongside successes: the
+retractions and prohibitions are first-class rows, because each is the
+evidence for a standing law.
+
+## Contents
+- `article_loss_manifest.md` — the article (canonical copy).
+- `LOSS_MANIFEST.md` — the full rated registry, human-readable.
+- `loss_manifest.json` — the machine-readable sidecar; every rating is
+  recomputable from its six sub-scores + the lookup table + the nine rules.
+- `code/loss_forms.py` — the composable loss library (4 differencing
+  primitives, accumulation formats A0-A8, the campaign candidates, the
+  force-gated forbidden controls, self-smoke).
+- `code/compartment_smoke.py` — the 22-test formula-smoke battery, including
+  the two calibrated pre-spend gates (conditioning + collinearity).
+- `code/fac_bed.py`, `code/deviant_bed.py`, `code/geobasin_bed.py` — the
+  campaign beds (cosh-Bregman/FAC matrix; the deviant roster matrix; the
+  recovered CE-replacement geometric arm under full controls).
+- `code/ar_differentiation_bed.py`, `code/geolip_vitals.py`,
+  `code/loss_view.py` — the certified byte bed, the shared read-only gauge
+  harness, and the registry viewer/linter.
+- `runs/` — the raw run ledgers (JSONL) behind every trained verdict in the
+  article's era-six tables.
+
+## Quick start
+```bash
+pip install torch  # cu-enabled build recommended
+python code/loss_forms.py          # library self-smoke
+python code/compartment_smoke.py   # the 22-test battery + gates
+python code/loss_view.py card --json loss_manifest.json
+```
+Beds default their data root to `$GEOLIP_DATA` (or `./data`) and download
+wikitext bytes on first use.
+
+## The program's lines (evidence trails)
+[Qwen3.5 adapter line](https://huggingface.co/AbstractPhil/geolip-aleph-qwen-3.5-0.8b-instruct) ·
+[Qwen2.5 line](https://huggingface.co/AbstractPhil/geolip-aleph-qwen) ·
+[diffusion line](https://huggingface.co/AbstractPhil/aleph-diffusion-adapters) ·
+[differentiation line](https://huggingface.co/AbstractPhil/geolip-aleph-differentiation) ·
+[amoe-lora](https://github.com/AbstractEyes/amoe-lora) ·
+[classification line](https://github.com/AbstractEyes/geolip-aleph-classification) ·
+[geolip-svae](https://github.com/AbstractEyes/geolip-svae) ·
+[geofractal](https://github.com/AbstractEyes/geofractal)
+
+Field reports: [ft1](https://huggingface.co/blog/AbstractPhil/aleph-autoregressive-differentiation-ft1) ·
+[ft2](https://huggingface.co/AbstractPhil/geolip-aleph-qwen/blob/main/article_ft2.md) ·
+[ft3](https://huggingface.co/AbstractPhil/geolip-aleph-qwen-3.5-0.8b-instruct/blob/main/article_ft3.md)
+
+Internal citations in the registry (file:line anchors into the program's
+research record) are preserved verbatim for provenance integrity.

article_loss_manifest.md

@@ -0,0 +1,612 @@
+# The Loss Manifest: A Field History of Objective Functions, and What a Machine Can Actually Be Asked to Compute
+
+*One hundred and fifty-five objective functions, regularizers, gauges, and
+prohibitions from a multi-year geometric deep learning program — each rated,
+each with its receipts, failures shipped alongside successes. Read it as a
+blueprint of a long experiment in computable mathematics: years of drilling
+machines to find out which structures gradient descent can cultivate in a
+reasonable amount of time, and which it cannot.*
+
+---
+
+## Why keep a manifest of losses
+
+Every result in a deep learning paper is downstream of a decision the paper
+rarely examines: what, exactly, was the machine asked to compute? The loss is
+the entire interface between mathematics and learning. It decides what is
+expressible, what is reachable, and what silently cannot happen no matter how
+long you train.
+
+This program has been probing that interface for years, across byte-level
+autoregressive models, CLIP-family alignment systems, diffusion U-Nets and
+DiTs, vision classifiers, and adapter mixtures on frozen language-model
+trunks. The through-line was never any single task. It was a single question
+asked over and over in different geometries: **is this structure computable by
+differential generation — can the gradient path itself cultivate it — or does
+it only look computable on paper?**
+
+Mathematics is generous; optimization is not. A structure can be perfectly
+well-defined, provably expressive, and still be unreachable in practice —
+because its gradient homogenizes, because its partition function couples every
+axis to every other, because its measure collapses without a normalization
+term, because its worst case is irreducible noise. If everything well-defined
+were also cheaply computable, this manifest would be short and boring. It is
+neither, because the universe of trainable mathematics is much smaller than
+the universe of mathematics, and finding its boundary is empirical work.
+
+So we kept the ledger. All of it: the objectives that carried entire product
+lines, the regularizers that turned out to be gradient-free the whole time,
+the elegant formulations that collapsed on contact, the
+retractions, the prohibitions with their evidence attached. The result is a
+manifest of successes **and failures** for a large family of structures —
+which we would argue is more useful experimental substrate than another
+benchmark table, precisely because the failures are load-bearing: each one
+marks a place where the computability boundary was located by direct contact.
+
+Everything below is traceable. The campaign evidence lives in public
+repositories ([the Qwen3.5 adapter line](https://huggingface.co/AbstractPhil/geolip-aleph-qwen-3.5-0.8b-instruct),
+[the Qwen2.5 predecessor line](https://huggingface.co/AbstractPhil/geolip-aleph-qwen),
+[the diffusion adapter line](https://huggingface.co/AbstractPhil/aleph-diffusion-adapters),
+[the amoe-lora framework](https://github.com/AbstractEyes/amoe-lora),
+[the classification line](https://github.com/AbstractEyes/geolip-aleph-classification),
+[geolip-svae](https://github.com/AbstractEyes/geolip-svae),
+[geofractal](https://github.com/AbstractEyes/geofractal),
+[the differentiation line](https://huggingface.co/AbstractPhil/geolip-aleph-differentiation)), and the story so
+far is told in three prior field reports:
+[part 1](https://huggingface.co/blog/AbstractPhil/aleph-autoregressive-differentiation-ft1),
+[part 2](https://huggingface.co/AbstractPhil/geolip-aleph-qwen/blob/main/article_ft2.md),
+and [part 3](https://huggingface.co/AbstractPhil/geolip-aleph-qwen-3.5-0.8b-instruct/blob/main/article_ft3.md).
+
+---
+
+## The structural finding: three primitives wide, eleven formats deep
+
+The manifest began with a census: three independent sweeps over the program's
+record — its canon of verdicts, its history layer, and its full code tree, looking for every term that ever received a backward
+pass. The census found something we did not expect and now consider the
+organizing fact of the whole record:
+
+> **Until this week's campaign deliberately built its challengers, only three
+> differencing primitives had ever been back-propagated in this program:
+> cross-entropy, squared error, and KL divergence** (plus float64 determinants
+> on the gauge side, and one arm-gated exception). No margin loss, no triplet,
+> no hinge, no load-balancing auxiliary existed anywhere in the historical
+> tree. Everything that looked like a distinct objective was one of those
+> three primitives under a different **accumulation format**: InfoNCE is
+> cross-entropy accumulated over an N×N similarity grid; structural blob
+> supervision is squared error, dose-coupled and routed to one noise band;
+> frequency-role objectives are squared error under a cosine crossfade. (The
+> campaign then widened the space on purpose — a fourth, Bregman-class
+> primitive and a sparse partition were built precisely to test the boundary,
+> and the margin family was retested under controls. Their verdicts are in
+> era six and in the roster.)
+
+So the program's loss surface is **three primitives wide and eleven
+accumulation formats deep**, and nearly every discovery in this manifest lives
+on the second axis. Two receipts make the point sharply:
+
+- The worst training collapse in the byte-level line (a coefficients-to-logits
+  head at a single hard temperature: 5.67 bits per byte, address usage
+  perplexity 1.88 of 64 — two winners starve sixty-two axes) was **cured by
+  changing accumulation only**: split the read into parallel slots and the
+  same cross-entropy lands at 2.47. Identical primitive, different
+  aggregation, night and day.
+- Chunked cross-entropy — sum per chunk, divide once by the global token count
+  — is *mathematically identical* to plain cross-entropy and operationally a
+  five-fold memory law: on one recorded configuration, 22.8 GB of dedicated
+  VRAM plus 42.8 GB silently spilled to shared memory became 8.8 GB at 1.03
+  seconds per step. A law of practice that lives entirely in the reduction
+  schedule.
+
+The eleven formats range from the uniform mean (honestly dominant: 84 of 155
+entries — plain means are the program's default, and its founding objective
+lives there) through chunk-renormalized, per-sample-then-weighted,
+band-crossfaded, masked-denominator, dose-coupled, paired-difference,
+grid-pairwise, and float64-accumulated forms, down to two cells empty of working
+objectives. One (raw sum, no denominator) held nothing for the program's
+entire history — the scale rides on batch and sequence length, so learning
+rates stop transferring — until this campaign trained its first member, a
+worst-position accumulation, and refuted it on schedule. The other holds only
+prohibitions, by statute, and is the single most informative cell in the
+grid: **accumulation that carries state across steps** — EMA codebooks,
+commitment counters, k-means centroids, the entire VQ-VAE bookkeeping family
+([van den Oord et al., 2017](https://arxiv.org/abs/1711.00937)) — contains
+exactly two entries, and both are prohibitions. Not one working objective in
+the program's history has ever needed it. The empirical warrant: the program's
+learned codebooks stay 125+ of 128 axes alive with the diversity weight set to
+zero. Where the standard literature reaches for a balancing term, this record
+says the geometry, correctly constructed, balances itself.
+
+---
+
+## How the ratings work, and what a 10 means
+
+Every entry carries a 1–10 rating, and the rating deliberately does **not**
+answer "how big is the effect." It answers: **how much would we stake on this
+term in a new, unseen experiment?** Six sub-scores (replication across seeds
+and substrates; measured potency against the term's own gauge noise; doctrinal
+fit; cost; instrument risk; and a bonus for findings that are enforced in
+code, not just prose) feed a fixed lookup table, and then nine hard rules
+bind, in order. The ones that do the most work:
+
+- anything never run caps at 3 — a beautiful design does not score on paper;
+- a headline resting on an instrument later shown blind takes a penalty until
+  re-measured;
+- single-seed evidence caps at 6; sub-1% margins cap at 5;
+- **any formal retraction floors the entry at 1, unconditionally** — retracted
+  entries never compete, they testify;
+- contradictory records get a range, never an average; and every sub-score
+  digit must carry a citation or the entry caps as if unrun.
+
+Three calibration pairs prove the rubric measures what it claims:
+
+1. **The same objective rates 8 and 4 in adjacent rows** — frequency-band role
+   objectives judged by a role-aligned gauge versus the same objective judged
+   by an aggregate error that was later shown blind to band structure. The
+   only difference is the instrument. That pair is the price of gauge
+   blindness, made explicit.
+2. **The same operator rates 6 and 1** — Procrustes alignment as a mild
+   regularizer beside a real training force (it tightens geometric regularity)
+   versus Procrustes as the training force itself (retrieval 0.000, stuck for
+   thirty epochs). Placement decides load-bearingness.
+3. **The most potent term in the census rates 2.** InfoNCE
+   ([van den Oord et al., 2018](https://arxiv.org/abs/1807.03748)) is, by
+   measured effect, the strongest alignment force in the record — swap it in
+   and retrieval goes to 0.999. It is also the loudest gradient in the
+   program: representation banks learn *it* instead of the signal you wanted,
+   and it is banned from address pathways outright. Potency and
+   trustworthiness are different axes. The plainest entry in the record —
+   mean-squared reconstruction driven to bitwise exactness — rates 10.
+
+---
+
+## A short history, told as computability results
+
+### Era one: reconstruction, and the discovery that codes are free
+
+The founding result of the program is that **reconstruction pressure alone —
+squared error, uniform mean, nothing else — will cultivate discrete structure
+that most of the literature builds special machinery to obtain.** A small
+spherical autoencoder driven by plain MSE converged sixteen noise types
+simultaneously and ended at bitwise-exact text reconstruction; its learned
+codebook converged to a *sign code* — rows equal to ± reference vectors at
+floating-point precision — with no vector-quantization loss, no commitment
+term, no EMA, no straight-through trick at the objective level. Read the
+signs, not the probabilities.
+
+That pair of entries sits at the top of the manifest because everything else
+in the program leans on it: the addressing mechanism at the center of these
+lines (a signed softmax over oriented half-axes, with sinh in the numerator
+and cosh in the denominator) receives its **only** training pressure through
+reconstruction gradients. In computability terms: discrete codes are
+computable by differential generation, cheaply and stably — *if* the pressure
+is absolute (match this target) rather than comparative (beat those rivals).
+That distinction became the program's oldest law, and this week it received
+its sharpest confirmation yet (see era six).
+
+### Era two: geometry as force versus geometry as readout
+
+The program spent a long time learning where geometric structure may be
+*pushed* and where it may only be *watched*. The pivotal discovery is almost
+embarrassing and we publish it anyway: the historical "volume-regularity loss"
+— a coefficient-of-variation statistic over Cayley–Menger simplex volumes,
+believed for months to be shaping representations — turned out to be
+**gradient-free the whole time** (a `.item()` call had severed it from the
+graph). The geometry it was credited with had emerged on its own. That
+accident became a law: *geometric statistics are readouts, never forces*, with
+exactly one sanctioned exception — a micro-weighted (1e-3, hard ceiling)
+forward CV term on a specific anchor bank, arm-gated, where bare cross-entropy
+measurably drifts the regularity band and the micro-force holds it at zero
+task cost.
+
+The rest of the era's entries chart the same boundary from different sides.
+Sphere normalization — one line of code, no loss term — ended a family of
+spectral collapses outright and is the founding case for "geometry is
+regularization: build it in, don't penalize toward it." Direct gradient
+descent on pentachoron crystals collapses them to zero; the same crystals held
+frozen retain full cohesion — placement by construction beats placement by
+hope. Margin-family heads (SphereFace, CosFace, ArcFace —
+[Liu et al., 2017](https://arxiv.org/abs/1704.08063);
+[Wang et al., 2018](https://arxiv.org/abs/1801.09414);
+[Deng et al., 2019](https://arxiv.org/abs/1801.07698)) were explored in a
+vision-transformer lineage and hit a ceiling attributable to the architecture
+around them rather than the margins themselves. A "soft hand" objective — a
+*reward* that boosts the reconstruction gradient near a geometric target
+rather than penalizing distance from it — produced the best run of its sweep
+and one adverse finding worth more than the win: sustained moderate boost
+teaches the model to optimize for staying in the boost zone. Pressure toward a
+zone is computable; residence in the zone as a goal corrupts.
+
+### Era three: alignment, and the loudest gradient
+
+The multi-system alignment era established two placement laws that the rubric
+now encodes as calibration pairs. InfoNCE is *necessary and sufficient* as the
+alignment force — and catastrophic anywhere near an addressing pathway,
+because grid-pairwise accumulation makes every off-diagonal element a
+gradient contributor and the bank learns the loss instead of the sequence
+signal. Procrustes analysis measures alignability and cannot create it.
+Knowledge distillation ([Hinton et al., 2015](https://arxiv.org/abs/1503.02531))
+earned a statute with teeth after a genetic-selection experiment: distilling
+at full weight from near-parity teachers produces *inverse evolution* —
+best-of-round degrading monotonically across three generations — because
+children anchor to teacher level and selection feeds the degradation back.
+Tamed (weight ≤ 0.25, never on founders, never inside a selection loop without
+a quality gap), the same primitive is a clean positive, and in its
+row-routed form it demonstrated genuine dark-knowledge transfer: students
+matching or exceeding teachers on *held-out rule induction* while the teachers
+themselves had merely memorized.
+
+### Era four: diffusion, and the conditioning law
+
+The diffusion line contributed the manifest's most transferable single result.
+Identical auxiliary structural supervision — foreground-masked, low-passed
+squared error on the recovered clean image, dose-coupled at λ≈1 — **pays
+−5.9%/−3.7% on a rectified-flow trunk and is inert (+0.03%/−1.0%) on an
+epsilon-prediction trunk, a 125–200× effect ratio at two seeds each.** The
+mechanism is exact: flow recovery of the clean image is linear at every noise
+level, while epsilon recovery divides by a vanishing signal coefficient
+precisely in the supervised band
+(cf. [Liu et al., 2022](https://arxiv.org/abs/2209.03003);
+[Lipman et al., 2022](https://arxiv.org/abs/2210.02747)). Generalized, this is
+the **conditioning law**: *an auxiliary term pays only where the supervised
+quantity is recoverable from the prediction through an exact, well-conditioned
+map* — a computability criterion you can evaluate before spending a GPU-hour,
+and now the first of two pre-spend gates the program runs on every new loss
+design.
+
+The same era produced the manifest's best accumulation success and its
+cleanest inertness. Cosine-crossfade band windows over the noise axis — a
+partition of unity entering both the forward pass and the loss — manufacture
+surgically decoupled specialists with **no routing loss at all** (own-band
+lesion damage 50–200× cross-band; on a diffusion transformer the edge bands
+reached cross-damage of exactly 0.0). Meanwhile frequency-reweighted "role"
+objectives moved nothing (0.05–0.2% margins), and the diagnosis became the
+second pre-spend gate: their gradients were 99.2–99.7% collinear with the
+base objective. **A reweighting of the same residual is still the same
+pressure.** The payers differ in supervised *quantity* and *mask*, not in
+weight — measured at 0.715 gradient novelty for the paying term against
+0.003–0.008 for the inert ones.
+
+### Era five: the adapter campaigns, and what cross-entropy actually teaches
+
+Two full adapter campaigns on frozen language-model trunks (a 0.5B and then a
+0.8B hybrid vision-language model) supplied the workhorse rows: plain,
+shift-masked, and chunked cross-entropy; the HuggingFace labels path; and the
+best-evidenced positive supervision result in the record — **derived-steps
+supervision**, where training targets carry worked derivations instead of bare
+answers. It beat direct-answer supervision on held-out generalization at
+ceiling (1.00/1.00), replicated across seeds to four decimal places, and
+produced the campaign's first positive off-domain spillover. The same
+campaigns minted the laws that guard every later row: the *question-space
+law* (training-question space must exceed draws threefold, or the loss teaches
+memorization — discovered by self-retraction when two "experts" passed an
+answer-diversity guard while memorizing); the *toggle law* (all adapters off
+must be bit-exact to the base model — max logit delta 0.0, enforced in code);
+and the *blend-escape* diagnostics that grew into a two-regime dispatch law.
+
+The era also filled the proof set. A "controller" anchor hypothesis was
+refuted at preregistration bars and its failure mechanism classified. Solo
+always-on specialist stacks proved mutually destructive at n=48. And the
+consumption-pattern law localized collapse precisely: it is a property of
+*how coefficients are consumed* — a single hard-temperature softmax starves
+non-winners at any dimensionality — not of the address, and slot-parallel
+accumulation cures it with the primitive untouched.
+
+### Era six: the loss campaign — the boundary, measured directly
+
+Everything above set up the question this week finally asked head-on: is
+cross-entropy itself the right thing to ask a machine to compute, and if not
+where, exactly, does it fail? Five results — every trained one preregistered at three seeds on a
+certified byte-level bed:
+
+**1. Cross-entropy's failure mode is its partition function, and the failure
+is graded.** The Hessian of CE in logit space has an exact null direction and
+a spectrum that collapses precisely as the model commits — the same shape as
+the conditioning law's vanishing coefficient, now inside the loss itself. We
+built the substrate-native alternative: since CE is the Bregman divergence of
+log-sum-exp ([Bregman, 1967](https://doi.org/10.1016/0041-5553%2867%2990040-7);
+[Banerjee et al., 2005](https://jmlr.org/papers/v6/banerjee05b.html)), and the
+addressing mechanism's own potential is a sum of hyperbolic cosines, the
+matching loss is the Bregman divergence of Σcosh — curvature bounded below by
+one everywhere, no null direction, no partition function, antipodally
+symmetric by construction.
+
+**2. In open field, cross-entropy won — as preregistered bars, 3/3 seeds.**
+The cosh-Bregman code loss lost to CE, lost to CE-through-a-frozen-readout,
+and lost even to its own no-geometry control. Where CE is healthy, nothing we
+built beats it, and we publish that plainly.
+
+**3. Where CE's coupling is the disease, decoupling is the cure — and it's a
+dose-response.** On the certified collapse configuration, with parameters and
+compute identical and only the loss swapped: full coupling (CE) leaves address
+usage at 1.85 of 64 axes with saturation 0.9997; a *partially* coupled
+partition (sparsemax — [Martins & Astudillo, 2016](https://arxiv.org/abs/1602.02068))
+decompresses to 23.5 of 64; zero coupling (the cosh-Bregman form) reaches 60.9
+of 64, with decoded accuracy climbing 0.11 → 0.417 → 0.456. **Monotone on
+every gauge, three seeds per point.** A two-year-old diagnosis blaming the
+geometry was amended: the collapse follows the loss.
+
+**4. The deviant sweep calibrated the instruments as much as the losses.** A
+roster of strange forms — focal ([Lin et al., 2017](https://arxiv.org/abs/1708.02002)),
+label smoothing ([Szegedy et al., 2016](https://arxiv.org/abs/1512.00567);
+[Müller et al., 2019](https://arxiv.org/abs/1906.02629)), a confidence
+penalty ([Pereyra et al., 2017](https://arxiv.org/abs/1701.06548)),
+worst-position and geometric-mean accumulations, an anti-curriculum — was
+gate-measured and then trained without exception. Nothing beat CE. The
+gate-refused confidence penalty landed closest to CE of all arms, validating
+the gate's refusal mode against training reality; the two highest-novelty
+accumulations failed exactly as flagged (one chases irreducible entropy — the
+worst positions of natural text are not computable structure, they are noise;
+the other starves the hard positions and the distribution never forms). The
+protocol finding: **novelty is state-dependent** — commitment-dependent forms
+are invisible to gates run at initialization and must be gated at a trained
+state as well. And novelty is necessary, never sufficient: it screens out
+inertness; only the bed decides benefit.
+
+**5. The oldest law held its hardest test.** The program's one previous
+attempt at replacing cross-entropy entirely — a pure geometric basin loss set
+(attraction, repulsion, margin, range) from an earlier classification line —
+was recovered *verbatim* from its original source and retested under full
+controls, including CE run on the identical score head. The full set was
+refuted decisively (−68% relative accuracy — its historical −12% showing was
+flattered by its original substrate). But the arm that dropped the two
+roster-comparative terms and kept only the absolute ones **more than doubled
+the full set** (0.349 vs 0.157 accuracy, 3/3 seeds). *Absolute beats
+relative*, confirmed inside the CE-replacement family itself: the comparative
+terms are the poison. The bed's loss landscape now shows two clean clusters —
+absolute-target objectives at 3.75–4.13 bits per byte, partition-coupled
+cross-entropy at 2.48–2.61 — with the space between them mapped by the coupling
+dial.
+
+---
+
+## What is computable, then?
+
+Collapsing the manifest to its computability verdicts:
+
+**Computable by differential generation, certified here:** discrete sign codes
+via pure reconstruction; surgical specialist structure via positional
+crossfade windows (no router, no balancing term); structural supervision
+wherever the supervised quantity is linearly recoverable; derived-steps
+reasoning supervision; decoupled per-axis code supervision *at coupling-driven
+collapse sites*; and near-uniform codebook aliveness with no diversity
+pressure at all.
+
+**Not computable in reasonable time, located by direct contact:**
+gradient-learned alphabets (they collapse; fitted-frozen ones differentiate);
+pentachora under direct descent; selection events in the compute path
+(comparative selectors homogenize their own gradient); hierarchy imposed in
+class space (below-chance, not merely taxed); worst-position training on
+natural text (the worst positions are irreducible); target-zone residence as
+an objective; and balancing-by-loss of things that balance themselves.
+
+**Conditional, with the condition now measurable:** every auxiliary term,
+via the conditioning gate (is the supervised quantity recoverable through a
+well-conditioned map?) and the collinearity gate (is the added pressure a
+genuinely different direction, novelty ≥ 0.3, or a reweighting in costume?).
+Both gates are calibrated against known outcomes (refusal fires below 0.05
+novelty; the payer class begins near 0.3). One refused a design this week
+that training then confirmed was inert; the other reproduces, retroactively
+and exactly, the split that cost the record a wasted arm before the gate
+existed.
+
+That is the blueprint this manifest offers: not a leaderboard, but a mapped
+boundary — with instruments for extending it that cost seconds, not
+GPU-days.
+
+## Using the roster
+
+The tables below address every entry in the record: what it is
+mathematically, what it was for, what became of it, where it can be run
+today, and why it holds its rank. Ratings answer "how much would we stake on
+this in a new bed." The daggers mark the proof set — retractions and
+prohibitions kept as first-class citizens, because each is the evidence for a
+standing law, and because a manifest of failures with receipts is the part of
+the record you cannot get from papers that publish only what worked.
+
+The open cells are marked too, and they are the invitation: the untested
+program-native forms (a hyperbolic-distance objective for a sinh/cosh-native
+substrate; rotor-decode reconstruction; simplex-closure sequence losses), the
+gauge-to-force promotions each pinned to the lesson of the force that was
+never a force, and the coupling dial between the two measured clusters. We
+will be working from this list in the coming days; it is published so that
+anyone can.
+
+---
+
+## THE ROSTER — all 155 entries
+
+### Rated 10 — certified bedrock (17 entries)
+
+| ID | R | entry | the mathematics | verdict on record | lives at |
+|---|---|---|---|---|---|
+| L-001 | 10 | MSE -> bitwise reconstruction (SVAE H2, 16 noise types) | `L = mean((dec(z) - x)^2); convergence endpoint = bitwise-exact recon` | 16 noise types converge simultaneously; bitwise text recon; the two-year survivor | [geolip-svae](https://github.com/AbstractEyes/geolip-svae) |
+| L-002 | 10 | recon gradient through M-hat (the aleph's ONLY codebook pressure) | `M_hat = sum_k sinh(u_k)A_k / sum_k cosh(u_k), u = cos(x,A)/tau; L = mean((dec(M_hat)-x)^2); codebook grad ONLY…` | cos .992-.997 hard-mode, 125-126/128 axes alive, ZERO collapse, div_weight=0 | [amoe-lora](https://github.com/AbstractEyes/amoe-lora) |
+| L-044 | 10 | Devil's Staircase alpha-normalization (bit_k = p[RIGHT] + alpha*p[MIDDLE], alpha=0.5) | `p = softmax(-(y-[.5,1.5,2.5])^2/.25); bit_k = p_R + 0.5*p_M; C = sum bit_k 2^-k` | WITHOUT the alpha term the measure COLLAPSES to {0, .333, .667} - the FractalDavid bug | [campaign loss library](https://huggingface.co/AbstractPhil/loss-manifest) |
+| L-051 | 10 | pure Adam, weight_decay = 0 (the anti-regularizer law) | `Adam(params, lr, weight_decay=0.0) - the ONLY constructor` | Adam+gates .731 vs AdamW(3e-4, wd .01) .667 - 'weight decay is uniform damping that destroys the geometric harmonic' | [amoe-lora](https://github.com/AbstractEyes/amoe-lora) |
+| L-052 | 10 | zero-init output heads (WEIGHT and bias) - the inertness contract | `zeros_(head.weight); zeros_(head.bias); gates = -3.0` | makes the toggle law bit-exact (max\|dlogit\| = 0.0); the bias leak alone is a standing +0.5 ppl offset | [amoe-lora](https://github.com/AbstractEyes/amoe-lora) |
+| L-061 | 10 | question-space guard (training-question space >= 3x draws) | `assert \|question_space\| >= 3*draws; train-eval overlap <= .05` | caught TWO memorized experts that had PASSED the answer-diversity guard (spaces 480 and 248 vs 800 draws) | [amoe-lora](https://github.com/AbstractEyes/amoe-lora) |
+| L-065 | 10 | band crossfade windows as STRUCTURAL positional gating | `ramp(x)=.5-.5cos(pi*(clamp(x/XF,-1,1)+1)/2); low=1-up1; mid=up1(1-up2); high=up1*up2; edges(.35,.75) XF=.06` | own-band damage 50-200x cross-band, 3/3 both seeds - specialists manufactured with NO routing loss | [amoe-lora](https://github.com/AbstractEyes/amoe-lora) |
+| L-071 | 10 | CV as a READOUT (never a force) | `CV = std(V)/mean(V), V = CM 4-volumes over 200 random 5-subsets, fp64 - READOUT` | the historical CV 'loss' was GRADIENT-FREE all along - .item() stripped the graph | [campaign loss library](https://huggingface.co/AbstractPhil/loss-manifest) |
+| L-073 | 10 | bpb (bits per byte) - the AR line's verdict currency | `bpb = mean CE / ln(2) per byte` | certified band 2.469-2.499; addr_msl64 beats the unrestricted head 7/7 across seeds and budgets | [campaign loss library](https://huggingface.co/AbstractPhil/loss-manifest) |
+| L-074 | 10 | perplexity tax ladder (wikitext ppl delta, one shared gauge) | `tax = exp(mean CE_512)\|adapted - exp(mean CE_512)\|frozen on wikitext` | one always-on stack +9.23/+9.87 · monolith +3.66 · 5-anchor collective +11.0/+12.6 · UNGATED +91.6 | [Qwen3.5 line](https://huggingface.co/AbstractPhil/geolip-aleph-qwen-3.5-0.8b-instruct) |
+| L-075 | 10 | token-F1 (caption distribution-match delta) | `F1 = 2PR/(P+R) over token multisets vs GT captions` | 0.408 -> 0.706/0.704 (+0.30, \|s0-s1\| = 0.0019); the hub checkpoint reproduces 0.706 EXACTLY | [Qwen3.5 line](https://huggingface.co/AbstractPhil/geolip-aleph-qwen-3.5-0.8b-instruct) |
+| L-080 | 10 | toggle law - all anchors off is BIT-EXACT to the base model | `assert torch.equal(logits_all_off, logits_base)` | max\|dlogit\| = 0.0 exactly at 0.8B on a hybrid DeltaNet/full-attention trunk; library-enforced | [amoe-lora](https://github.com/AbstractEyes/amoe-lora) |
+| L-083 | 10 | usage perplexity / axis aliveness (read-only) | `usage = mean oriented-softmax row; ppl = exp(H(usage)); alive = usage > eps/2K` | 125+/128 axes alive WITHOUT regularization - the standing refutation of load-balancing auxiliaries | [campaign loss library](https://huggingface.co/AbstractPhil/loss-manifest) |
+| L-085 | 10 | blend-escape ratio (threshold 1.5) and damping ratio (target >= 3x) | `ratio = mean\|delta\|_domain / mean\|delta\|_neutral; escape <= 1.5; damped >= 3.0` | specialists damped 5-11x but caption ESCAPES undamped at 0.1004 - the corollary that became the regime law | [amoe-lora](https://github.com/AbstractEyes/amoe-lora) |
+| L-089 | 10 | CV@1000-batches early screen + the 3-tier filter | `CV at step 1000 -> band {<.30 LOW / .35-.50 MID / >.80 HIGH} + stability + freeze-survival` | CV at 1000 batches PREDICTS the final band; turnaround ~2h -> ~7 min per config | [campaign loss library](https://huggingface.co/AbstractPhil/loss-manifest) |
+| L-092 | 10 | resolution-invariance flatness (the debugging canary) | `var(recon MSE) across patch grids 81..4096 - flatness IS the pass` | 4.5% MSE variance from 81 to 4096 patches; ~1% across a 36-config sweep - ANY shift means an upstream break | record only |
+| L-095 | 10 | peak_mem + s/step (the WDDM sysmem-spill tell) | `torch.cuda.max_memory_allocated + s/step at an early step (WDDM spill tell)` | the tell is ~100W/450W at '100% util' with no step prints - 42.8GB observed spilled to shared memory | [Qwen3.5 line](https://huggingface.co/AbstractPhil/geolip-aleph-qwen-3.5-0.8b-instruct) |
+
+### Rated 9 — replicated and load-bearing (25 entries)
+
+| ID | R | entry | the mathematics | verdict on record | lives at |
+|---|---|---|---|---|---|
+| L-004 | 9 | chunked masked CE (512-token slices, sum-then-renormalize) | `L = sum_chunks CE_sum(h[i:i+512]) / n_live_tokens (ONE global denominator)` | 22.8GB dedicated + 42.8GB SILENTLY SHARED -> 8.8GB peak @ 1.03 s/step | [Qwen3.5 line](https://huggingface.co/AbstractPhil/geolip-aleph-qwen-3.5-0.8b-instruct) |
+| L-010 | 9 | flow v-MSE (rectified flow, SHIFT-warped sigma) | `s = warp(u; shift=2.5); x_t = (1-s)x0 + s*eps; L = mse(pred, eps - x0); x0 = x_t - s*v EXACT/LINEAR` | x0 = x_t - sigma*v is EXACT and LINEAR at every sigma - asserted, not assumed | [amoe-lora](https://github.com/AbstractEyes/amoe-lora) |
+| L-012 | 9 | addr_msl slot-parallel read (P parallel D=4 slots, shared K=64) | `feats = concat_p M_hat^(p)(slots); logits = W feats; CE. P=4/16/32/64 dose` | THE ACCUMULATION CURE: 5.6650 (collapsed) -> 2.47 with the primitive held FIXED | [campaign loss library](https://huggingface.co/AbstractPhil/loss-manifest) |
+| L-015 | 9 | derived-steps expert supervision (stepwise-CoT target vs direct target) | `shift-CE(-100) on stepwise-CoT target sequences vs direct-answer targets` | +0.79 vs direct +0.63; held-out ceiling 1.00/1.00; seeds matched to 4 decimals (+0.7917 / +0.7916) | [Qwen3.5 line](https://huggingface.co/AbstractPhil/geolip-aleph-qwen-3.5-0.8b-instruct) |
+| L-016 | 9 | blob-LP-x0 structural supervision on FLOW (lambda ~ 1) | `L = mean_B[ mse_vec + lam*w_HIGH(s01)*blob_lp ]; blob_lp = sum(blob*(LP(x0h)-LP(x0))^2)/(sum(blob)*C); x0h = x…` | -5.9% / -3.7% two seeds on flow vs +0.03% / -1.0% on eps: a ~125-200x effect ratio | [amoe-lora](https://github.com/AbstractEyes/amoe-lora) |
+| L-041 | 9 | sphere normalization (M = F.normalize(M); \|\|M\|\|_F^2 = V pins sum sigma^2) | `M = F.normalize(M, dim=-1) (\|\|M\|\|_F^2 = V pins sum sigma^2) - ONE line, not a loss` | zero collapses in 400 epochs; V=1024 went from 48 s/ep crashing to 2.0 s/ep stable | record only |
+| L-042 | 9 | gradient equalization across heterogeneous geometric towers | `per tower: g <- g * target/\|\|g\|\| (equal gradient norms; outputs stay free)` | without it spreads hit 20 ORDERS of magnitude (fibonacci dead at 2.25e-21 under helix) | [geofractal](https://github.com/AbstractEyes/geofractal) |
+| L-043 | 9 | bounded multiplicative alpha (S*(1 + alpha*tanh), alpha <= 0.2, init .024) | `Sp = S * (1 + a*tanh(f)), a <= 0.2, init .024 - modulate never inject` | unbounded alpha POISONS the spectrum; bounded modulation costs 2,272 of 16.9M params (0.013%) | record only |
+| L-050 | 9 | gradient clipping discipline (0.5 on cross-attn ONLY; NEVER inside an LBFGS closure) | `clip_grad_norm .5 on cross-attn ONLY; NEVER inside an LBFGS closure` | unclipped LBFGS closure DIVERGED to G-MSE 7.4e26; safety is line_search_fn='strong_wolfe' | record only |
+| L-068 | 9 | paired (row, noise, t) triples - the variance-killing accumulation | `acc = mean_fp64(res_arm(row,noise,t) - res_ref(row,noise,t)), triples FIXED per row` | the noise-pair floor is ~0.988 - without pairing the effects this program measures are invisible | [amoe-lora](https://github.com/AbstractEyes/amoe-lora) |
+| L-076 | 9 | precision + invented-attribute rate (the hallucination decomposition) | `precision = \|pred inter GT\|/\|pred\|; invented = \|pred minus GT_vocab\|/\|pred\|` | precision 0.356 -> 0.694/0.705 and invented-attribute rate 0.200 -> 0.136/0.101, BOTH seeds | [campaign loss library](https://huggingface.co/AbstractPhil/loss-manifest) |
+| L-077 | 9 | register probe (sign-code inter-minus-intra Hamming separation) | `sep_L = mean_ij inter-register Ham(code_i,code_j) - mean intra (diagonal KEPT, +4% bias, comparability)` | THE PREDICTOR of the two-regime law: registers ~0.2-0.3 blend, domains ~0.35-0.5 specialize | [diffusion line](https://huggingface.co/AbstractPhil/aleph-diffusion-adapters) |
+| L-078 | 9 | sign_fidelity (Spearman of code-Hamming vs true angular distance) | `Spearman(Hamming(c_i,c_j), arccos\|<a_i,a_j>\|) over random pairs` | PROMOTED: separates inheritance from lottery where bpb CANNOT - successors lock at .9555-.9558, spread < .001 | [campaign loss library](https://huggingface.co/AbstractPhil/loss-manifest) |
+| L-081 | 9 | band-lesion surgical test (own vs cross damage) | `ratio = damage(own band lesion) / damage(cross band lesion) per gauge` | surgical 3/3 both seeds at 50-200x; on a DiT edge bands hit cross-damage EXACTLY 0.0 | [amoe-lora](https://github.com/AbstractEyes/amoe-lora) |
+| L-086 | 9 | composition score (the controller prereg gauge) | `exact-match on two-step composite prompts vs single-step controls` | the chaining wall: components >= 0.96 solo, composite 0.0 for EVERY config | [Qwen3.5 line](https://huggingface.co/AbstractPhil/geolip-aleph-qwen-3.5-0.8b-instruct) |
+| L-088 | 9 | grad_norm_spread (gradient democracy monitor) | `orders = log10(max group \|\|g\|\|) - log10(min); dead = groups with 0` | reference failure it exists to catch: 20 orders of magnitude across unequalized towers | [campaign loss library](https://huggingface.co/AbstractPhil/loss-manifest) |
+| L-091 | 9 | spectral gauges: S0/S_D ratio, effective rank, the universal attractor | `S0/S_D spectral ratio; erank = exp(-sum p ln p), p = sigma/sum sigma` | critical ratio ~6.5 triggers DISCHARGE; universal attractor S0 ~5.1, erank 15.88 +/- 0.04 across 48+ measurements | record only |
+| L-094 | 9 | structured-task validity judges (JSON validity, IoU, pair-order, termination) | `json.parse validity + IoU(xywh) + pair-order + termination-within-window` | bbox 0 -> 0.6875 valid (0.894 IoU); the FORMAT TRAMPLING signature: 9/12 truncated_no_json | [Qwen3.5 line](https://huggingface.co/AbstractPhil/geolip-aleph-qwen-3.5-0.8b-instruct) |
+| L-097 | 9 | held-out byte accuracy (rule induction) and variant-format recall (the format lock) | `held-out byte acc under substitution cipher; variant-format recall` | teachers memorize at 1.000 train but induce at 0.270/0.245 held-out; memorized content is BOUND to surface form | [campaign loss library](https://huggingface.co/AbstractPhil/loss-manifest) |
+| L-098 | 9 | key-durability gauge (nearest-neighbour symbol Hamming + key drift) | `NN symbol-Hamming between stored and recomputed keys; match@theta=.25` | sign-code keys disagree on ~91% of symbols; match rate at theta=0.25 is 0.000 EVERYWHERE | [campaign loss library](https://huggingface.co/AbstractPhil/loss-manifest) |
+| L-099 | 9 | basin mean_cos (BASIN SET AT INIT) | `mean cos(book_epoch, book_init) across the bank sweep` | 192-bank sweep: epoch_1 .8632 / best .8635 / final .8615 - delta 0.0017 BELOW the within-phase std | record only |
+| L-100 | 9 | cv_reference_check (fp64 parity against the source of truth) | `\|V_fast - V_geovocab2\| / \|V\| at fp64 == 0 required` | exact parity (relative 0.0) at fp64 against geovocab2, at ~260x the speed | [campaign loss library](https://huggingface.co/AbstractPhil/loss-manifest) |
+| L-138 | 9⟂ | FAC on the partition-collapse configuration (the P4 loss-swap cell) | `L-070 on the addr_head collapse configuration` | the certified addr_head collapse DECOMPRESSES under a loss swap alone, 3/3 seeds: usage ppl 1.0-2.7 -> 60.6-61.1 of 64; decoded acc 0.05-0.20 -> 0.45-… | [campaign loss library](https://huggingface.co/AbstractPhil/loss-manifest) |
+| L-139 | 9 | sparsemax on the collapse configuration (the coupling-axis probe) | `sparsemax_loss on addr_head logits (K=32, hard tau) - only the loss differs from the certified collapse cell` | THE DOSE-RESPONSE: usage 1.85 (CE, full coupling) -> 23.5 (sparsemax, partial) -> 60.9 (FAC, none); win\|cos\| .9997 -> .562 -> .132; acc .11 -> .417 … | [campaign loss library](https://huggingface.co/AbstractPhil/loss-manifest) |
+| L-152 | 9 | PureGeometric ABSOLUTE-ONLY (attraction + range; comparative terms dropped) | `L = (1 - s_y)^2 + 0.1*(relu(s-1)^2 + relu(-s)^2) - no other-class terms at all` | MORE THAN DOUBLES the full set: acc 0.349 vs 0.157, bpb 3.75 vs 7.52, 3/3 seeds - the comparative terms are the poison | [campaign loss library](https://huggingface.co/AbstractPhil/loss-manifest) |
+
+### Rated 8 — solid, one caveat from bedrock (15 entries)
+
+| ID | R | entry | the mathematics | verdict on record | lives at |
+|---|---|---|---|---|---|
+| L-003 | 8⚠ | plain full-sequence cross-entropy (packed labels) | `L = mean(-log softmax(W h)[y])` | the workhorse; also the documented geometry antagonist - CE drove the Oct '25 geometric collapse | [Qwen3.5 line](https://huggingface.co/AbstractPhil/geolip-aleph-qwen-3.5-0.8b-instruct) |
+| L-005 | 8 | shift-CE with ignore_index=-100 (prefix-masked instruction rows) | `CE(logits[:,:-1], y[:,1:], ignore_index=-100)` | the standard instruction-tuning form across the v35 and q25 lines | [Qwen3.5 line](https://huggingface.co/AbstractPhil/geolip-aleph-qwen-3.5-0.8b-instruct) |
+| L-009 | 8 | eps-MSE (epsilon prediction, stock schedule) | `x_t = sqrt(abar_t)x0 + sqrt(1-abar_t)eps, t~U{0..999}; L = mse(unet(x_t,t,c), eps); CFG drop p=.1` | relay -2.5% over frozen, 2 seeds; relay >= matched LoRA 2-for-2 across substrates | [amoe-lora](https://github.com/AbstractEyes/amoe-lora) |
+| L-011 | 8 | sign-code head addr_mslh64 (fully discrete forward, STE backward) | `M_hard = sign(cos[argmax\|cos\|])*A[argmax]; forward discrete, backward soft (M_hard + M_soft - sg[M_soft]); C…` | bpb 2.4711 vs soft 2.4685 - parity certified 3 seeds; a ~2.8% gap opens at 4x budget | [campaign loss library](https://huggingface.co/AbstractPhil/loss-manifest) |
+| L-017 | 8⟂ | InfoNCE as an alignment force (OFF address paths) | `sym CE over sims = za@zb^T/0.07 with in-batch labels` | NECESSARY + SUFFICIENT for alignment: swap it in -> R@1 .999 | [Qwen2.5 line](https://huggingface.co/AbstractPhil/geolip-aleph-qwen) |
+| L-040 | 8 | 1e-3 CV bank loss (arm-gated, S^15 bank ONLY, never the aleph codebook) | `V = sqrt(clamp(-det(CM(A[idx5]))/9216)); L += 1e-3 * std(V)/mean(V); fp64, fixed seed-0 subsets, S15 bank ONLY` | holds CV .295-.305 at zero-to-positive task cost where bare CE drifts it to .31-.34 | [campaign loss library](https://huggingface.co/AbstractPhil/loss-manifest) |
+| L-048 | 8⟂ | HP/LP band-role objectives [judged by the ROLE-ALIGNED gauge] | `low = base + .5*mse(HP3(pred),HP3(tgt)); high = base + .5*mse(LP7,..); composed by band windows [role-aligned …` | multiband beats the matched monolith ~10% on HIGH-band foreground, BOTH seeds | [amoe-lora](https://github.com/AbstractEyes/amoe-lora) |
+| L-059 | 8 | straight-through estimator on the aleph HARD read | `M_hard + (M_soft - sg[M_soft]) (STE over an ABSOLUTE reconstructive read)` | forward fully DISCRETE oriented code, backward soft: hosted books hold cos .992-.997, 112-122/128 hard axes, zero collapse | [amoe-lora](https://github.com/AbstractEyes/amoe-lora) |
+| L-066 | 8 | lambda dose coupling (3-point curve on the blob term) | `L = base + lam * w_route * aux, lam~1 (3-pt dose curve)` | 0.5 -> -5.9% · 1.0 -> -8.3% (in bound) · 2.0 -> -8.4% (OUT of the 0.5% common-gauge bound) | [amoe-lora](https://github.com/AbstractEyes/amoe-lora) |
+| L-067 | 8 | fp64 gauge accumulation (autocast disabled in the reduction) | `reduce in float64, autocast off (gauges)` | fp32 determinants lose up to ~4% on near-degenerate pentachora - 'fp32 det only' now means fp32 MINIMUM | [campaign loss library](https://huggingface.co/AbstractPhil/loss-manifest) |
+| L-072 | 8 | anchor drift -> 0.29154 rad + binding_fraction | `drift = arccos(<norm(a), norm(a_init)>); binding_frac = mean(\|drift-.29154\|<=.05)` | the binding constant recurs across 5 architectures and 3 paradigms - but the drift-based fraction is a STAGE statistic | [campaign loss library](https://huggingface.co/AbstractPhil/loss-manifest) |
+| L-079 | 8 | role-aligned in-bed gauge (HIGH-band foreground-masked LP-x0) | `HIGH-band foreground-masked LP-x0 error (fp32 judged)` | PROMOTED: found a ~10% multiband win that EVERY aggregate comparison hid | [amoe-lora](https://github.com/AbstractEyes/amoe-lora) |
+| L-082 | 8 | repeated-key null + matched-vs-mismatched deltas | `excess = metric(real keys) - metric(SAME key repeated); + matched-vs-mismatched delta` | the instrument that falsified address-as-key: routing excess 2.5e-06 over the null | [diffusion line](https://huggingface.co/AbstractPhil/aleph-diffusion-adapters) |
+| L-096 | 8 | consensus drift / stationarity gauge | `drift_g = arccos(<consensus_g, consensus_prev>); stationarity = no acceleration` | ROBUST for structured configurations (0.003 drift by g2, both seeds) but SEED-DEPENDENT for a lone flat book | record only |
+| L-149 | 8 | CE on the cosine-anchor basin head (the geobasin control) | `CE over logits = cos(normalize(feats), normalize(A_c)) * 10` | the head itself costs +0.13 bpb under CE (2.607 vs 2.477 linear, 3 seeds; acc .498 vs .505) - small, so every geometric-arm deficit is THE LOSS, isola… | [campaign loss library](https://huggingface.co/AbstractPhil/loss-manifest) |
+
+### Rated 6–7 — measured, capped by replication or instrument (30 entries)
+
+| ID | R | entry | the mathematics | verdict on record | lives at |
+|---|---|---|---|---|---|
+| L-006 | 7 | HuggingFace out.loss (VLM labels= path, vision tower fires) | `model(**batch, labels=y).loss (masked shift-CE inside HF; vision tower fires)` | required wherever the vision tower must fire - chunking bypasses it | [Qwen3.5 line](https://huggingface.co/AbstractPhil/geolip-aleph-qwen-3.5-0.8b-instruct) |
+| L-023 | 7 | kd_facts (fact rows supervised ONLY by teacher logits, alpha=1.0 legal here) | `fact rows: KL(teacher) ONLY (CE masked off); clean rows: CE - row-routed channels` | recall 0.953 vs direct 0.871; held-out RULE induction 0.264/0.279 >= the teacher itself | [campaign loss library](https://huggingface.co/AbstractPhil/loss-manifest) |
+| L-024 | 7 | dual-teacher Procrustes consensus distillation | `GPA: mean shape after per-teacher Procrustes to consensus (delta<1e-8); student anchors init from it` | teachers .699/.649 -> student .761 EXCEEDS BOTH, still accelerating at E30 | [campaign loss library](https://huggingface.co/AbstractPhil/loss-manifest) |
+| L-028 | 7 | masked-marginal variant scoring (protein VEP) | `score(v) = logP(x_i=v · x_masked) - logP(x_i=WT · x_masked) (masked marginal)` | WT unmasked marginal rho 0.10 -> masked marginal ESSENTIAL; final rho .993 / .309 unseen | collaboration (pending release) |
+| L-029 | 7 | GPT-2 frozen-trunk relay objective (dif-e013 Track C) | `CE; trainable = aleph MslRelay adapters on frozen GPT-2 (<1%)` | frozen 38.648 -> aleph 26.53 vs param-matched zero-init MLP 27.26; beats matched 2/2 seeds | [campaign loss library](https://huggingface.co/AbstractPhil/loss-manifest) |
+| L-055 | 7 | Cayley orthogonality constraint + Newton-Schulz whitening | `Q = (I-A)(I+A)^-1, A skew - det=1 by construction` | Q = (I-A)(I+A)^-1 guarantees pure rotation: det = 1.000 throughout, wins 76/84 unseen assays | collaboration (pending release) |
+| L-090 | 7 | void topology beta_2/axis (persistent homology on RP^(D-1)) | `ripser H2 on d(a,b)=arccos\|<a,b>\| (RP metric), thresh 20deg; beta2/axis` | within the D=4 cohort every GEOMETRIC signal collapses while VOIDS rise; beta_2 vs recon MSE \|rho\| = 0.471 | record only |
+| L-013 | 6 | addr_3tau multi-tau stroboscope | `reads at multiple tau; concat -> logits; CE (stroboscope)` | 4.2884 no collapse (usage ppl 7.9, 117/128 alive) against addr_d4's 5.3698 | [campaign loss library](https://huggingface.co/AbstractPhil/loss-manifest) |
+| L-014 | 6 | addr_mhat reconstructive read consumed in AR | `logits = head(M_hat) directly (reconstructive read consumed in AR); CE` | 5.1300 bpb but the HEALTHIEST cultivation on the bed (ppl 11.0, binding_frac .234) | [campaign loss library](https://huggingface.co/AbstractPhil/loss-manifest) |
+| L-018 | 6 | blueprint composite (InfoNCE 1.0 + Procrustes_SVD 0.3 + \|CV-0.20\| 0.05) | `InfoNCE*1.0 + Procrustes_SVD*0.3 + \|CV(bank)-0.20\|*0.05` | BERT-8192 m_acc .927 at CV exactly 0.200; CLIP-ctx576 m_acc .945 | record only |
+| L-022 | 6 | logit-KD at alpha <= 0.25 with founder exemption | `L = CE + a*KL(log_softmax(student), mean_k softmax(teacher_k).detach()), a<=0.25, never founders` | mlp_kd lineage 2.4106 -> 2.3707 -> 2.3662 -> 2.3594 monotone ascent; replicates at s1 | [campaign loss library](https://huggingface.co/AbstractPhil/loss-manifest) |
+| L-026 | 6 | soft-hand loss (proximity REWARD, not penalty) | `prox = exp(-(cv-target)^2/2sig^2); L = (1+boost*prox)*mse + pen*(1-prox)` | V256 D24: MSE 0.034 at 400ep - 37% better than the best unconstrained run (.054) | [campaign loss library](https://huggingface.co/AbstractPhil/loss-manifest) |
+| L-027 | 6 | antipode-conv objective (the address AS the convolution operator) | `conv := fold(m_hat(unfold(x))); no plain filter, no ReLU; CE on head` | CIFAR-10 87.23% @ 861,450 params with NO ReLU/GELU anywhere; none -> mag +21.8 | [classification line](https://github.com/AbstractEyes/geolip-aleph-classification) |
+| L-034 | 6 | entropy-balanced alignment cultivation (w = .05) | `w=.05 entropy-balanced alignment (exact form NOT fully recorded); endpoint M = +/-ref EXACT` | produced the emergent basin M = +/- ref EXACTLY - the sign-code convergence endpoint | record only |
+| L-035 | 6 | rectified-flow velocity objective (KSimplex / Form 7 bottleneck) | `rectified-flow velocity mse + Min-SNR gamma=5 + CM terms (L-045/L-046)` | loss .1749 beat the 268M skip's .1757; the model routed 88% through the 768 dims | [diffusion line](https://huggingface.co/AbstractPhil/aleph-diffusion-adapters) |
+| L-037 | 6 | denoiser objective (tokendiff iterative image-token denoise) | `CE on x0 tokens from noise-level-t corrupted tokens, iterative` | beats identity at every level; t=1.0 gives 0.378 vs 0.002 (189x) | [Qwen2.5 line](https://huggingface.co/AbstractPhil/geolip-aleph-qwen) |
+| L-038 | 6 | recon_target (absolute MSE to a fixed frozen-trunk projection) | `L = mse(ea, norm(frozen_h @ fixed_proj)) + mse(eb, ...) (absolute target regression)` | recall@1 0.264 - real (5x frozen) but HALF of InfoNCE's 0.494 at matched budget | [Qwen2.5 line](https://huggingface.co/AbstractPhil/geolip-aleph-qwen) |
+| L-045 | 6 | L_CM - Cayley-Menger validity hinge (lambda = .01) | `L_CM = .01 * relu(eps - vol2(CM)) on first k+1 tokens (validity hinge)` | CM validity 100% across the lineage table | [diffusion line](https://huggingface.co/AbstractPhil/aleph-diffusion-adapters) |
+| L-046 | 6 | L_vol - volume-spread REWARD (-std(log\|vol^2\|), lambda = .005) | `L_vol = -.005 * std(log\|vol^2\| across layers) (spread REWARD, anti-collapse)` | fragmented anatomy -> coherent composition; base fully preserved (purely additive) | [diffusion line](https://huggingface.co/AbstractPhil/aleph-diffusion-adapters) |
+| L-047 | 6⟂ | Procrustes_SVD as a REGULARIZER (x 0.3 alongside a real force) | `L = \|\|A R* - B\|\|^2, R* = Procrustes(A,B) via SVD - as x0.3 REGULARIZER beside a force` | tightens CV (.19 vs .25) when it rides alongside InfoNCE | [campaign loss library](https://huggingface.co/AbstractPhil/loss-manifest) |
+| L-049 | 6 | anchor dropout (30%) | `dropout(anchors, p=.3) during alignment` | prevents collapse: 508/512 anchors active | record only |
+| L-054 | 6 | quaternion composition as a structural regularizer (Hamilton product) | `q_comp = R (Hamilton) q_expert over 4 FiLM arms` | GeoQuat 0.916 -> 0.993 over 100 epochs vs best baseline 0.903 | collaboration (pending release) |
+| L-056 | 6 | cascade as a regularizer (multi-step MLP instead of a direct dimensional jump) | `k-step MLP cascade in place of one dimensional jump` | 9-step 256->64 gives 84.6% vs a direct jump's 29.6%; a 27-step r=.95 cascade EXCEEDS the root | record only |
+| L-057 | 6 | Cantor router (soft weights derived FROM triangulation distances) | `w_route = f(phase-0 triangulation distances), softmax-free, geometry-derived` | cos .9818 at 8 layers vs relay-alone .6533; geometry IMPROVES with more tokens | record only |
+| L-060 | 6 | data-level dampening (sqrt damping alpha=0.5, max_repeats=8, cap 1.25x) | `n_i_new = min(ceil(norm * n_i^0.5), 8, 1.25*top) (sqrt-damped repeats)` | NEVER equalize-to-largest: alpha=0 repeats 5 images ~50x/epoch | record only |
+| L-064 | 6 | rose loss (role-weighted pentachoron regularization, rose_w = 1e-4) | `NOT RECORDED (role-weighted pentachoron regularization; rose_w=1e-4, temp .07)` | 74.87% CIFAR-100 @ 393,216 params vs ~65% zero-shot and ~70-72% linear probe | record only |
+| L-084 | 6 | read perplexity + \|cos to nearest atom\| (the quantizer gauge) | `read ppl = exp(H(mean read weights)); commitment = \|cos(read, nearest atom)\|` | read perplexity 14/64 atoms, \|cos to nearest atom\| 0.964, 64/64 alive - the representation LIES ON the codebook | [classification line](https://github.com/AbstractEyes/geolip-aleph-classification) |
+| L-087 | 6 | adapter_effect_mean - the VACUOUS guard | `effect = mean\|loss_off - loss_on\|; report VACUOUS if < eps instead of a ratio` | returns VACUOUS instead of a false PASS when the stack barely moves the loss | [amoe-lora](https://github.com/AbstractEyes/amoe-lora) |
+| L-093 | 6 | exec judge (guarded subprocess: restricted builtins, length cap, hard timeout, no network) | `guarded subprocess: restricted builtins, len cap, timeout, no net; exact-match out` | the write-0.0 floor was verified GENUINE off-pod, not a judge artifact | [Qwen3.5 line](https://huggingface.co/AbstractPhil/geolip-aleph-qwen-3.5-0.8b-instruct) |
+| L-104 | 6 | sign-code Hamming retrieval | `recall@k under Hamming(code_query, code_bank)` | 0.359 @1 against the continuous head's 0.494 - ~73% of its power from raw 64-symbol Hamming | [Qwen2.5 line](https://huggingface.co/AbstractPhil/geolip-aleph-qwen) |
+
+### Rated 2–5 — conditional, refuted-as-candidates, or unrun (38 entries)
+
+| ID | R | entry | the mathematics | verdict on record | lives at |
+|---|---|---|---|---|---|
+| L-007 | 5 | dispatch-keys-only CE (aligner; adapters frozen as anchors) | `same CE; trainable set = per-block dispatch key matrices ONLY` | trainable set is ONLY the per-block key matrices; reference-grade, never seed-replicated | [amoe-lora](https://github.com/AbstractEyes/amoe-lora) |
+| L-019 | 5 | Expert Soup composite (InfoNCE + MSE + BCE + Procrustes + CV + spread) | `InfoNCE + MSE + BCE + Procrustes + CV + spread (6-term, never ablated)` | mAP .84 (data-limited), 1000/1000 positive volumes, eff-dim 76.9 for COCO-80 | record only |
+| L-020 | 5⚠ | SequenceReconstructor loss: MSE(normed) + (1 - cos) | `mse(norm(pred), norm(tgt)) + (1 - cos(pred, tgt)) on (B,77,768)` | CLIP-L ep5 m_acc .957 / s_cos .734; Meridian bigG s_cos PLATEAUS at .425 | [campaign loss library](https://huggingface.co/AbstractPhil/loss-manifest) |
+| L-021 | 5 | Min-SNR gamma=5 weighting + velocity adjustment | `w = min(SNR,5)/(SNR+1) velocity-adjusted; L = mean(w * mse_vec)` | part of a working recipe (1 ep, 10k synthetic, ~7 min on an L4); never ablated | [diffusion line](https://huggingface.co/AbstractPhil/aleph-diffusion-adapters) |
+| L-025 | 5 | projective-ICP / GPA consensus operator (lineage-core overwrite) | `projective ICP: iterate sign-aligned Procrustes on RP; lineage-core overwrite` | recovers planted truth \|cos\|=1.000 in 5 iterations; TASK-NEUTRAL on bpb, 2 seeds | [campaign loss library](https://huggingface.co/AbstractPhil/loss-manifest) |
+| L-030 | 5 | val_ce on a frozen semantic substrate (CLIP-L token-AR) | `CE on frozen CLIP-L token-AR (matched transforms + shared vocab proj)` | MLP WINS frozen-substrate token-AR (penult 5.245 best); aleph tax ~ +0.09 | [campaign loss library](https://huggingface.co/AbstractPhil/loss-manifest) |
+| L-031 | 5 | pure geometric-basin loss set (coherence/separation/discretization/geometry) | `SOURCE RECOVERED 2026-07-25: attraction (1-s_y)^2 + 0.5*repulsion sum_{c!=y}(s_c^2) + 0.5*margin relu(max_{c!=…` | the program's ONE attempted CE replacement - NOW PROPERLY TESTED: refuted on the byte bed (acc 0.157 vs control 0.498, 3 seeds); the absolute-only var… | [geofractal](https://github.com/AbstractEyes/geofractal) |
+| L-039 | 5 | contrastive dynamics as a CV-compression force | `standard contrastive; measured as a CV-compression force` | 100 clusters / 200 steps at d=128 -> CV .2451 (in band); 10 clusters -> .94 | record only |
+| L-053 | 5 | geometric autograd / gradient gating (Form 12 tangential-radial split) | `g_tang pass; g_radial *= (1-.01); g_collapse *= 1.0 (gradient gating)` | gradients split tangential (pass) / radial (attenuate) / collapse-direction (attenuate) | record only |
+| L-062 | 5 | usage / starvation reweighting (drives DATA sampling, NEVER a loss term) | `on starvation strike: sampling_weight[starved] *= 2; 3 strikes abort - DATA, never a loss` | the program's ONLY answer to load balancing: x2 upweight the starved anchor's DATA, 3-strike abort | [amoe-lora](https://github.com/AbstractEyes/amoe-lora) |
+| L-063 | 5 | CFG dropout 0.1 (conditioning zeroed, not empty-prompt) | `with p=.1: cond <- 0 (zeroed, not empty-prompt)` | standard in every diffusion bed; never ablated in this program | [diffusion line](https://huggingface.co/AbstractPhil/aleph-diffusion-adapters) |
+| L-070 | 5⟂ | FAC as a PRIMARY sequential objective (cosh-Bregman, replace CE) | `v = norm(feats)@R^T/t; L = mean(cosh(clamp(v - c_y*mu, -4, 4)) - 1)` | REFUTED AS PREREGISTERED, 3/3 seeds: fac_lsh 4.13 bpb vs ce 2.48; ce_fixedcode 3.81 beats it; fac_none 3.95 beats it | [campaign loss library](https://huggingface.co/AbstractPhil/loss-manifest) |
+| L-101 | 5 | gate-mean band 0.012-0.03 (advisory, NOT universal) | `gate_mean = mean sigmoid(g); band [.012,.03] ADVISORY` | held across 6 architectures and 2 optimizers - then MISSED on a 7th at 0.051-0.061 | [campaign loss library](https://huggingface.co/AbstractPhil/loss-manifest) |
+| L-102 | 5 | aggregate eps-MSE as a band-behaviour gauge | `mean mse over all sigma - BLIND to band structure (distrusted for bands)` | DISTRUSTED: moved 0.2% against +0.089 grounding effects in image space, and HID a ~10% multiband win | record only |
+| L-124 | 5 | frozen-address conditioning injected beside full text | `append frozen byte-trigram address beside full text cond` | real vs deranged -0.0009 beside full text; but ALONE the address steers at +0.0287 | [diffusion line](https://huggingface.co/AbstractPhil/aleph-diffusion-adapters) |
+| L-140 | 5 | sparsemax as a full-bed objective | `L = -z_y + 0.5*sum_{j in S}(z_j^2 - tau^2) + 0.5 (sparse support S)` | REFUTED as a general objective: bpb 7.43 / acc 0.331 vs ce 2.4769 / 0.505 (3 seeds) | [campaign loss library](https://huggingface.co/AbstractPhil/loss-manifest) |
+| L-141 | 5 | soft-max / worst-position accumulation (trained) | `L = T*logsumexp(ce_tok/T) - T*log(N), T=0.5` | REFUTED: bpb 4.24 / acc 0.276, 3 seeds - the 0.911-novelty champion chases irreducible entropy exactly as flagged | [campaign loss library](https://huggingface.co/AbstractPhil/loss-manifest) |
+| L-142 | 5 | geometric-mean accumulation (trained) | `L = mean(log(ce_tok + 1e-3))` | REFUTED decisively: bpb 9.03 - the anti-focal starves hard positions and the distribution never forms (3 seeds) | [campaign loss library](https://huggingface.co/AbstractPhil/loss-manifest) |
+| L-143 | 5 | label smoothing eps=.1 (trained on the byte bed) | `CE to (1-eps) smoothed targets == (1-eps)CE + eps*uniform-KL` | bpb 2.587 vs ce 2.4769 (+0.11, 3 seeds) - payer-class novelty (0.479), mildly WORSE outcome | [campaign loss library](https://huggingface.co/AbstractPhil/loss-manifest) |
+| L-144 | 5 | focal gamma=2 (trained, live-model weights) | `L = sum((1-p_y)^2 * ce_tok) / sum((1-p_y)^2), p_y detached from the live model` | bpb 2.597 (+0.12 vs ce, 3 seeds) - payer-class trained novelty (0.337), mildly worse outcome | [campaign loss library](https://huggingface.co/AbstractPhil/loss-manifest) |
+| L-145 | 5 | anti-curriculum (train only where the frozen reference is confident) | `L = sum(ce_tok * [pi_ref > .6]) / count, pi_ref from the frozen ce_s0 checkpoint` | REFUTED as an objective: bpb 6.74 (3 seeds) - abandoning 72% of the distribution buys nothing on the rest | [campaign loss library](https://huggingface.co/AbstractPhil/loss-manifest) |
+| L-146 | 5 | FAC tanh-Hamming link (bounded tails) | `L = mean(1 - tanh(v) * c)` | cosh beats tanh 3/3: 4.349 vs 4.1285 (+0.22) - the bounded link loses within the family | [campaign loss library](https://huggingface.co/AbstractPhil/loss-manifest) |
+| L-147 | 5 | FAC Cauchy link (sub-quadratic tails) | `L = mean(log(1 + (v - c*mu)^2))` | cosh beats Cauchy 3/3: 4.360 vs 4.1285 (+0.23) - robust-statistics tails lose within the family | [campaign loss library](https://huggingface.co/AbstractPhil/loss-manifest) |
+| L-148 | 5 | confidence penalty (trained as the GATE-VALIDATION CONTROL) | `L = CE - 0.1*H(p)` | CLOSEST TO CE OF ALL DEVIANTS: bpb 2.520 (+0.043, 3 seeds) - the gate's refusal correctly predicted 'CE plus nothing' | [campaign loss library](https://huggingface.co/AbstractPhil/loss-manifest) |
+| L-150 | 5 | PureGeometricLoss, learned anchors (the Oct '25 arm, properly tested) | `attraction (1-s_y)^2 + 0.5*sum_{c!=y}s_c^2 + 0.5*relu(max_{c!=y}s_c - s_y + .3) + 0.1*range` | REFUTED on this substrate: acc 0.157 vs control 0.498 (-68% relative, 3 seeds) - far below the historical -12% trade | [geofractal](https://github.com/AbstractEyes/geofractal) |
+| L-151 | 5 | PureGeometricLoss, FROZEN anchors (the L-108 cell) | `same loss; A registered as a frozen buffer` | learned BEATS frozen by +8 acc points (0.157 vs 0.076, 3 seeds) - the L-108 falsifier FIRED for cosine anchors | [campaign loss library](https://huggingface.co/AbstractPhil/loss-manifest) |
+| L-153 | 5 | GeometricPrototypeLoss (verbatim, own projector) | `cos(proj(scores), prototypes) pulled/pushed + prototype-diversity term` | WORST of the family: bpb 8.12, acc 0.008 (3 seeds) - the extra indirection buys total failure | [geofractal](https://github.com/AbstractEyes/geofractal) |
+| L-154 | 5 | HierarchicalGeometricLoss on the nibble hierarchy (16x16) | `coarse (superclass sums to target) + fine + consistency, sigmoid-weighted` | CATASTROPHIC: acc 0.0003 - below chance (1/256) - hierarchy-in-class-space destroyed fine structure entirely (3 seeds) | [geofractal](https://github.com/AbstractEyes/geofractal) |
+| L-155 | 5 | CE + PureGeometric hybrid (0.5/0.5) | `0.5*CE(cos*10) + 0.5*PureGeometricLoss(scores)` | the geometric set POISONS CE rather than riding it: bpb 4.53 vs control 2.61 (+1.9, 3 seeds) - P4 bar (within 0.15) missed by 12x | [campaign loss library](https://huggingface.co/AbstractPhil/loss-manifest) |
+| L-008 | 4 | image-classification CE (CIFAR-10, aleph-dispatched MoE vs dense) | `CE(logits, y) on CIFAR-10` | MoE 58.52% TIES param-matched dense 58.52% exactly; 6x params bought nothing | [campaign loss library](https://huggingface.co/AbstractPhil/loss-manifest) |
+| L-036 | 4 | margin losses ArcFace / CosFace / SphereFace (RoseFace dual-norm) | `ArcFace cos(th+m) · CosFace cos(th)-m · SphereFace cos(m*th); s=30 m=.30; L1-then-L2 dual-norm` | the ZANA innovation - and it hit a 60% single-stream ceiling | [campaign loss library](https://huggingface.co/AbstractPhil/loss-manifest) |
+| L-123 | 4⟂ | HP/LP band-role objectives [judged by AGGREGATE eps-MSE] | `L-048 judged by aggregate eps-MSE` | 4/4 directional both seeds at 0.05-0.2% margins - 'nearly collinear with the base objective' | record only |
+| L-032 | 3 | GBC - 'cross-entropy can be replaced entirely' (roadmap claim) | `SOURCE RECOVERED 2026-07-25 (GBC head, geofractal/model/experiment_geometric_basin.py:118): compat = triadic (…` | classification via triadic compatibility, self-similarity, Cantor coherence, hierarchical basin checks | [geofractal](https://github.com/AbstractEyes/geofractal) |
+| L-033 | 3 | masked-recon / generative arm (campaign law 2 in its ORIGINAL form) | `mask patches; L = mse(recon_from_antipode_read(masked), x) (law 2 ORIGINAL form)` | BUILT, NEVER RUN - predicted to be where the SIGNED read finally beats magnitude | [classification line](https://github.com/AbstractEyes/geolip-aleph-classification) |
+| L-058 | 3 | address-agreement bias (BUCKET - making a hard address differentiable) | `exact softmax within sorted equal-width same-bucket block; codebook grad via address-agreement bias` | exact softmax within sorted equal-width blocks masked to the same bucket; argmax alone is gradient-dead | record only |
+| L-069 | 3 | predictability-weighted accumulation (PWA) | `w = f(pi_frozen_ref); L = sum(w*ce_tok)/sum(w)` | DESIGNED 2026-07-25: make the PREDICTABILITY PRINCIPLE a loss geometry instead of a discovered side effect | [campaign loss library](https://huggingface.co/AbstractPhil/loss-manifest) |
+| L-103 | 2✖ | recon cosine as a judge for ADDRESSED systems | `cos(recon, x) - WRONG instrument for addressed systems (address = lookup key)` | DISTRUSTED: an address is a LOOKUP KEY, not a compressor - judge drift and crushed CV instead | record only |
+| L-113 | 2✖⟂ | InfoNCE into ADDRESS paths | `a7_grid_infonce INTO an address path` | BANNED despite R@1 .999 - it is the LOUDEST gradient and the bank learns IT instead of the useful signal | [campaign loss library](https://huggingface.co/AbstractPhil/loss-manifest) |
+
+### Rated 1 — the proof set (retractions and prohibitions) (30 entries)
+
+| ID | R | entry | the mathematics | verdict on record | lives at |
+|---|---|---|---|---|---|
+| L-105 | 1✖† | VQ / commitment / EMA codebook losses | `\|\|sg[z_e] - e\|\|^2 + beta*\|\|z_e - sg[e]\|\|^2 (+ EMA codebook update)` | THE NAMED PROHIBITION - and unnecessary: the codebook stays 125+/128 alive at div_weight = 0 | [campaign loss library](https://huggingface.co/AbstractPhil/loss-manifest) |
+| L-106 | 1✖† | comparative / relative selectors (argmax anchors, softmax-over-roster, STE one-hots, k-means alphabets) | `selection event = argmax/softmax-over-roster in the compute path` | roster-dependent; the gradient HOMOGENIZES - 14x path collapse, width attenuation, BN-on-padding, same disease | record only |
+| L-107 | 1✖† | gradient-learned alphabets (CAMPAIGN LAW 3) | `alphabet learned by task gradient (vs fitted-frozen)` | fitted-frozen alphabets differentiate (1,594 unique paths); gradient-learned alphabets COLLAPSE (116) | record only |
+| L-108 | 1✖† | direct gradient descent on pentachora | `direct task-gradient descent on pentachoron vertices` | collapses them to zero - as FROZEN anchors the same crystals retain full cohesion and stay backtrackable | record only |
+| L-109 | 1✖† | global average pooling in geometric encoders | `gap = x.mean(dim=spatial) in a geometric encoder` | 70% -> 29% collapse, REPLICATED independently in the protein line | [campaign loss library](https://huggingface.co/AbstractPhil/loss-manifest) |
+| L-110 | 1✖† | CV loss as backward injection / above the 1e-3 ceiling | `CV term injected in backward, or weight > 1e-3` | MUST be a forward loss; above ~.001 the CV term dominates CE and trades discrimination for regularity | record only |
+| L-111 | 1†⟂ | Procrustes as a training FORCE | `same as L-047 - AS THE TRAINING FORCE (placement retracted)` | as a training loss: R@1 = 0.000, P_cos stuck at .094 for THIRTY EPOCHS | [campaign loss library](https://huggingface.co/AbstractPhil/loss-manifest) |
+| L-112 | 1✖† | addr_head - coefficients to logits at a single hard tau | `logits = W u, u = single-slot coefficients at hard tau (K=32)` | 5.6650 bpb COLLAPSED: usage ppl 1.88/64, TWO unique winners, win\|cos\| .9992 | [campaign loss library](https://huggingface.co/AbstractPhil/loss-manifest) |
+| L-114 | 1† | logit-KD at alpha = 1.0 from near-parity teachers | `prim_kl at alpha=1.0 from near-parity teachers in a selection loop` | INVERSE EVOLUTION, compounding downward: 2.4301 -> 2.5046 -> 2.5603 | [campaign loss library](https://huggingface.co/AbstractPhil/loss-manifest) |
+| L-115 | 1✖† | blob structural supervision on the EPS objective | `L-016 with x0h = (x_t - sqrt(1-abar)eps_hat)/sqrt(abar) - divides by vanishing sqrt(abar)` | +0.03% / -1.0%, two seeds - the x0 recovery divides by a vanishing sqrt(alpha_bar) EXACTLY in the supervised band | [amoe-lora](https://github.com/AbstractEyes/amoe-lora) |
+| L-116 | 1† | MSE-first single-epoch keep-or-kill screening | `keep-or-kill on 1-epoch MSE rank` | DEAD: the lowest-MSE config was a HIGH-band false candidate | record only |
+| L-117 | 1† | tied M-hat readout (U=M_hat, S=Omega-token, Vt=I) in an AR head | `logits = tied(M_hat) with U=M_hat, S=Omega, Vt=I` | +1.0 bpb BOTH seeds and it STARVES the codebook (drift 0.02, binding 0) | record only |
+| L-118 | 1✖† | comparative routing on diffusion (state+sigma, raw address, M-hat address-as-key) | `route experts by frozen text keys (raw/pooled/M-hat-slot) vs repeated-key null` | FALSIFIED THREE WAYS, 2 seeds: routing excess 2.5e-06 over the repeated-key null; match advantage -0.0 | [diffusion line](https://huggingface.co/AbstractPhil/aleph-diffusion-adapters) |
+| L-119 | 1† | the controller hypothesis (a trainable anchor that orchestrates the others) | `a trainable anchor trained to orchestrate others (composite prereg >= +.15)` | prereg required >= +0.15; measured -0.417 / -0.167. The passenger role is an ATTRACTOR | [Qwen3.5 line](https://huggingface.co/AbstractPhil/geolip-aleph-qwen-3.5-0.8b-instruct) |
+| L-120 | 1† | always-on solo specialist stacks | `solo specialist stack attached always-on` | MUTUALLY DESTRUCTIVE at n=48: the depth stack drives caption F1 to 0.0014 with termination 0.0 | [Qwen3.5 line](https://huggingface.co/AbstractPhil/geolip-aleph-qwen-3.5-0.8b-instruct) |
+| L-121 | 1† | frozen solo-trained expert collectives under aleph dispatch | `frozen solo-trained experts composed under dispatch` | no surgical independence (own-drop 0.04/0.00), NO damping (all five blend-regime, 0.86-1.6), composite 0.0 | [Qwen3.5 line](https://huggingface.co/AbstractPhil/geolip-aleph-qwen-3.5-0.8b-instruct) |
+| L-122 | 1† | organ-only inheritance (projection + book transplanted onto fresh trunks) | `transplant proj+codebook onto a fresh trunk` | BELOW random init, 2/2 lineages - sixteen random draws beat component inheritance | record only |
+| L-125 | 1† | shuffled-key null | `null = shuffle keys across rows (measures diversity, not correctness)` | CONFESSED INSTRUMENT FAILURE: it measures diversity, not correctness - the null scored like the real thing | record only |
+| L-126 | 1† | the sequences / baseconv expert gains | `CE on generated question sets with space < 3x draws` | SELF-RETRACTED: question space 480 and 248 against 800 training draws per tier = MEMORIZED | record only |
+| L-127 | 1† | the exp021 seed-inversion claim for the trainable anchor | `cross-seed comparison across DIFFERENT instruments` | RETRACTED WITHIN HOURS: the claim compared DIFFERENT INSTRUMENTS across seeds | [campaign loss library](https://huggingface.co/AbstractPhil/loss-manifest) |
+| L-128 | 1✖† | hierarchical refinement in Cantor space | `bands nested within bands on a Cantor axis` | HARMFUL (-10%); parallel ADJACENT NON-OVERLAPPING bands are +3% | record only |
+| L-129 | 1✖† | repeated boundary crossing in a measure space | `re-enter measure space per layer/step` | KILLS gradients (catastrophic -> random). Enter and exit the measure space ONCE | record only |
+| L-130 | 1✖† | the SOFT devil's staircase used as a BAND COORDINATE | `soft_cantor_ungated(x) used as a band COORDINATE (non-monotone)` | NEW 2026-07-25: measured NON-MONOTONE - min slope -0.13 to -0.49 at EVERY level count on EVERY grid tested | [geofractal](https://github.com/AbstractEyes/geofractal) |
+| L-131 | 1✖† | equalize-to-largest data balancing (alpha = 0) | `repeat count = ceil(max_bucket / n_i) (alpha=0 equalize-to-largest)` | repeats the 5-image bucket ~50x per epoch - 'the textbook way to overfit the long tail you were trying to protect' | record only |
+| L-132 | 1† | addr_conv - the decorative address (convex re-weighting of a filter bank) | `conv re-weighted by convex sum a_k=1 over a filter bank (hull-bounded mean)` | DECORATIVE: a convex sum a_k = 1 is a hull-bounded perturbation of a MEAN; the 1x1 address is CONSTANT on grayscale (variance 4e-16) | [classification line](https://github.com/AbstractEyes/geolip-aleph-classification) |
+| L-133 | 1† | deterministic (greedy) decoding in an iterative denoiser | `argmax decoding in an iterative denoiser` | collapses to the global mode: diversity 0.0, conditional == shuffled EXACTLY | record only |
+| L-134 | 1✖† | load-balancing / auxiliary router losses | `aux = alpha * N * sum_i f_i * P_i (switch-style balance)` | BANNED and replaced by architectural equality; ZERO instances exist in the tree | [amoe-lora](https://github.com/AbstractEyes/amoe-lora) |
+| L-135 | 1† | the big-JSON objective | `CE on the big-JSON composite format` | FORMALLY DROPPED by operator ruling - too costly; 3-5 task adapters deliver more per GPU hour | record only |
+| L-136 | 1† | SVD-rotation transform in the dual-pentachoron head | `learned SVD rotation transform in the dual-penta head` | DROPPED for convergence failure; reduced to scale + shift | record only |
+| L-137 | 1✖† | single hard-tau coefficient heads at ANY dimension | `coefficients->logits at ONE hard tau, any dim` | DEMOTED on the standing registry: collapse, and low-D was falsified as the fix | record only |
+
+---
+
+*The rated manifest, its machine-readable sidecar, the rubric, the campaign
+code, and the raw run ledgers accompany this article at
+[the companion repository](https://huggingface.co/AbstractPhil/loss-manifest). Evidence trails for every historical claim
+live in the linked line repositories; the three prior field reports carry the
+campaign narratives in full. Written by the program's operator (AbstractPhil)
+with Claude (Anthropic) as the research engineer of record for the loss
+campaign.*

code/ar_differentiation_bed.py

@@ -0,0 +1,488 @@
+"""ar_differentiation_bed.py — THE FOCUS (2026-07-09 redirect, the operator 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 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 repo).")
+
+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)
+        return self.o(num / den.clamp_min(1e-12))
+
+
+class MslRelay(nn.Module):
+    """Depth-composition unit (chain-rule probe): multi-slot M_hat read entering
+    the trunk as a NEAR-ZERO gated residual (gate init -3.0, sigma~0.047 — theme D:
+    geometry enters as a nudge and grows only if it earns gradient)."""
+
+    def __init__(self, d: int, n_slots: int = 16, K: int = 64):
+        super().__init__()
+        self.n_slots = n_slots
+        self.proj = nn.Linear(d, n_slots * 4, bias=False)
+        self.out = nn.Linear(n_slots * 4, d, bias=False)
+        nn.init.orthogonal_(self.proj.weight)
+        nn.init.orthogonal_(self.out.weight)
+        self.addr = AlephAddress(K, 4)
+        self.gate = nn.Parameter(torch.tensor(-3.0))
+
+    def forward(self, x):
+        B, n, _ = x.shape
+        slots = self.proj(x).view(B, n, self.n_slots, 4)
+        m = self.addr.m_hat(slots).reshape(B, n, -1)
+        return x + self.gate.sigmoid() * self.out(m)
+
+
+class Block(nn.Module):
+    def __init__(self, d: int, attn: nn.Module):
+        super().__init__()
+        self.n1, self.n2 = nn.LayerNorm(d), nn.LayerNorm(d)
+        self.attn = attn
+        self.mlp = nn.Sequential(nn.Linear(d, 4 * d), nn.GELU(), nn.Linear(4 * d, d))
+
+    def forward(self, x):
+        x = x + self.attn(self.n1(x))
+        return x + self.mlp(self.n2(x))
+
+
+class ByteLM(nn.Module):
+    def __init__(self, arm: str, d: int = 192, layers: int = 4, block: int = 256,
+                 K: int = 32, D: int = 4):
+        super().__init__()
+        # "<arm>_tri" suffix = trigram byte embedding (AlephLM byte_emb x3 lineage):
+        # token embedding is the sum of embeddings of bytes t, t-1, t-2.
+        self.trigram = arm.endswith("_tri")
+        if self.trigram:
+            arm = arm[:-4]
+        # "_fib" = super-Fibonacci S^3 codebook init (basin test: starts INSIDE
+        # the RP^3 attractor; primary observable is init->final geodesic drift).
+        self.fib = arm.endswith("_fib")
+        if self.fib:
+            arm = arm[:-4]
+        # "relay*" = stacked addresses in depth: MslRelay after every block.
+        # relay -> sdpa trunk + standard head; relay_msl64 -> + addressed head.
+        self.use_relay = arm.startswith("relay")
+        if arm == "relay":
+            arm = "sdpa"
+        elif arm == "relay_msl64":
+            arm = "addr_msl64"
+        self.arm, self.block = arm, block
+        self.emb = nn.Embedding(VOCAB, d)
+        if self.trigram:
+            self.emb1 = nn.Embedding(VOCAB, d)
+            self.emb2 = nn.Embedding(VOCAB, d)
+        self.pos = nn.Parameter(torch.zeros(1, block, d) + 0.01 * torch.randn(1, block, d))
+        mk_attn = (lambda: CausalHUB(d, K, D)) if arm == "hub" else (lambda: CausalSDPA(d))
+        self.blocks = nn.ModuleList([Block(d, mk_attn()) for _ in range(layers)])
+        if self.use_relay:
+            self.relays = nn.ModuleList([MslRelay(d) for _ in range(layers)])
+        self.nf = nn.LayerNorm(d)
+        if arm == "addr_head":
+            self.head_addr = AlephAddress(K, d)  # v1: codebook in model dim — COLLAPSED
+            self.head = nn.Linear(K, VOCAB, bias=True)
+        elif arm in ("addr_d4", "addr_3tau", "addr_mhat"):
+            # v2 refinements: LOW-D HOME — learned projection to the 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
+            x = x + self.emb1(F.pad(idx, (1, 0), value=0)[:, :-1]) \
+                  + self.emb2(F.pad(idx, (2, 0), value=0)[:, :-2])
+        x = x + self.pos[:, : idx.shape[1]]
+        if self.use_relay:
+            for b, r in zip(self.blocks, self.relays):
+                x = r(b(x))
+        else:
+            for b in self.blocks:
+                x = b(x)
+        h = self.nf(x)
+        self._last_h = h.detach()
+        if self.arm == "addr_head":
+            return self.head(self.head_addr.signed(h))
+        if self.arm == "addr_d4":
+            return self.head(self.head_addr.signed(self.head_proj(h)))
+        if self.arm == "addr_3tau":
+            return self.head(self.head_addr.signed_at(self.head_proj(h), self.taus))
+        if self.arm == "addr_mhat":
+            return self.head(self.head_addr.m_hat(self.head_proj(h)))
+        if self.arm.startswith("addr_msl"):
+            B, n, _ = h.shape
+            slots = self.head_proj(h).view(B, n, self.n_slots, 4)
+            if self.arm == "addr_msl_w":
+                feats = self.head_addr.signed(slots).reshape(B, n, -1)
+            elif getattr(self, "hard", False):
+                feats = self.head_addr.m_hard_ste(slots).reshape(B, n, -1)
+            else:
+                feats = self.head_addr.m_hat(slots).reshape(B, n, -1)
+            return self.head(feats)
+        if self.arm == "addr_3tau_mhat":
+            p = self.head_proj(h)
+            feats = torch.cat([self.head_addr.signed_at(p, self.taus),
+                               self.head_addr.m_hat(p)], dim=-1)
+            return self.head(feats)
+        return self.head(h)
+
+    @torch.no_grad()
+    def vitals(self) -> dict:
+        out = {}
+        if self.arm == "hub":
+            for i, b in enumerate(self.blocks):
+                if self._last_h is not None:
+                    out[f"L{i}"] = b.attn.addr.vitals(b.attn.q(self._last_h[:2]))
+        elif self.arm == "addr_head" and self._last_h is not None:
+            out["head"] = self.head_addr.vitals(self._last_h[:2])
+        elif self.arm in ("addr_d4", "addr_3tau", "addr_mhat",
+                          "addr_3tau_mhat") and self._last_h is not None:
+            out["head"] = self.head_addr.vitals(self.head_proj(self._last_h[:2]))
+        elif self.arm.startswith("addr_msl") and self._last_h is not None:
+            slots = self.head_proj(self._last_h[:2])
+            out["head"] = self.head_addr.vitals(
+                slots.reshape(*slots.shape[:-1], self.n_slots, 4))
+        if self.use_relay and self._last_h is not None:
+            for i, r in enumerate(self.relays):
+                s = r.proj(self._last_h[:2])
+                v = r.addr.vitals(s.reshape(*s.shape[:-1], r.n_slots, 4))
+                out[f"relay{i}"] = {"gate": round(r.gate.sigmoid().item(), 4),
+                                    "drift": v["drift"],
+                                    "binding_frac": v["binding_frac"],
+                                    "ppl": round(v["aliveness"]["usage_ppl"], 1)}
+        return out
+
+
+# --------------------------------------------------------------------------- data
+def _wikitext_bytes(data_root: str):
+    """wikitext-2-raw as flat uint8 tensors via the HF parquet CDN."""
+    from huggingface_hub import hf_hub_download
+    import pyarrow.parquet as pq
+
+    def load(split):
+        p = hf_hub_download("Salesforce/wikitext",
+                            f"wikitext-2-raw-v1/{split}-00000-of-00001.parquet",
+                            repo_type="dataset", local_dir=data_root)
+        text = "".join(pq.read_table(p).column("text").to_pylist())
+        return torch.frombuffer(bytearray(text.encode("utf-8")), dtype=torch.uint8).clone()
+
+    return load("train"), load("validation")
+
+
+def _batch(data: torch.Tensor, batch: int, block: int, device, g: torch.Generator):
+    ix = torch.randint(0, data.numel() - block - 1, (batch,), generator=g)
+    x = torch.stack([data[i:i + block] for i in ix]).long().to(device)
+    y = torch.stack([data[i + 1:i + block + 1] for i in ix]).long().to(device)
+    return x, y
+
+
+# -------------------------------------------------------------------- train/smoke
+def train(arms=("sdpa", "hub", "addr_head"), steps: int = 2000, batch: int = 32,
+          block: int = 256, device: str = "cuda", data_root: str = "./data",
+          seed: int = 0, eval_every: int = 500, save: bool = True):
+    """Verdict run — GPU only. Pure Adam wd=0. Reports val bits-per-byte + vitals.
+    save=True writes {data_root}/ar_ckpts/{arm}_s{seed}_t{steps}.pt per arm —
+    the cultivated codebooks are SPECIMENS for the projective reading instruments."""
+    import os
+    if device == "cuda" and not torch.cuda.is_available():
+        raise RuntimeError("Verdict runs are GPU-only (never CPU-train for accuracy).")
+    ckpt_dir = os.path.join(data_root, "ar_ckpts")
+    os.makedirs(ckpt_dir, exist_ok=True)
+    tr, va = _wikitext_bytes(data_root)
+    print(f"data ready: train {tr.numel():,} bytes, val {va.numel():,} bytes", flush=True)
+    results = {}
+    for arm in arms:
+        torch.manual_seed(seed)
+        g = torch.Generator().manual_seed(seed)
+        model = ByteLM(arm, block=block).to(device)
+        n_params = sum(p.numel() for p in model.parameters())
+        opt = torch.optim.Adam(model.parameters(), lr=3e-4, weight_decay=0.0)
+        for step in range(1, steps + 1):
+            x, y = _batch(tr, batch, block, device, g)
+            logits = model(x)
+            loss = F.cross_entropy(logits.reshape(-1, VOCAB), y.reshape(-1))
+            opt.zero_grad(set_to_none=True)
+            loss.backward()
+            opt.step()
+            if step % eval_every == 0 or step == steps:
+                model.eval()
+                with torch.no_grad():
+                    losses = []
+                    for _ in range(20):
+                        xv, yv = _batch(va, batch, block, device, g)
+                        lv = F.cross_entropy(model(xv).reshape(-1, VOCAB),
+                                             yv.reshape(-1))
+                        losses.append(lv.item())
+                bpb = sum(losses) / len(losses) / math.log(2)
+                print(f"[{arm}] step {step} val_bpb={bpb:.4f} vitals={model.vitals()}",
+                      flush=True)
+                model.train()
+        results[arm] = {"val_bpb": bpb, "params": n_params, "vitals": model.vitals()}
+        if save:
+            path = os.path.join(ckpt_dir, f"{arm}_s{seed}_t{steps}.pt")
+            torch.save({"arm": arm, "seed": seed, "steps": steps, "val_bpb": bpb,
+                        "state_dict": {k: v.cpu() for k, v in
+                                       model.state_dict().items()}}, path)
+            print(f"saved specimen: {path}", flush=True)
+    print(results, flush=True)
+    return results
+
+
+def smoke():
+    """Shapes/parse only — no accuracy claims."""
+    x = torch.randint(0, VOCAB, (2, 64))
+    for arm in ("sdpa", "hub", "addr_head"):
+        m = ByteLM(arm, d=96, layers=2, block=64, K=16)
+        logits = m(x)
+        assert logits.shape == (2, 64, VOCAB)
+        logits.sum().backward()
+        # causality check: future byte must not affect past logits
+        with torch.no_grad():
+            a = m(x)[0, 10]
+            x2 = x.clone(); x2[0, 40] = (x2[0, 40] + 7) % 256
+            b = m(x2)[0, 10]
+        assert torch.allclose(a, b, atol=1e-4), f"{arm} leaks future context"
+        print(f"{arm}: OK params={sum(p.numel() for p in m.parameters()):,} "
+              f"vitals={m.vitals()}", flush=True)
+    print("OK — AR bed smoke passed (verdict run: train() on GPU)", flush=True)
+
+
+def _in_notebook() -> bool:
+    try:
+        get_ipython()  # type: ignore[name-defined]  # noqa: F821
+        return True
+    except NameError:
+        return False
+
+
+if __name__ == "__main__":
+    if _in_notebook():
+        smoke()
+        print("Notebook mode: call  train(steps=2000)  in the next cell (GPU).")
+    else:
+        import argparse
+        ap = argparse.ArgumentParser()
+        ap.add_argument("--train", action="store_true")
+        ap.add_argument("--steps", type=int, default=2000)
+        a, _ = ap.parse_known_args()
+        train(steps=a.steps) if a.train else smoke()

code/compartment_smoke.py

@@ -0,0 +1,641 @@
+"""compartment_smoke.py — the loss-campaign formula-smoke battery. #TAG:loss_smoke #TAG:compartments #TAG:conditioning_gate #TAG:collinearity_gate
+Tree: loss campaign pass 2 (plan 2026-07-25). ONE file, Colab-cell-safe, <~60s
+on a 4090. Formula smoke ONLY — shapes, gradients, identities, conditioning,
+memory. NO training, ever (MANIFEST rider). Accuracy verdicts are real runs.
+
+Carries the REFERENCE implementations of:
+  - compartment_windows(): the certified cosine-crossfade ramp, parameterized
+    (parity-asserted bit-exact against amoe.diffusion band_weights at its
+    native constants — the "reuse verbatim" proof is a test, not a promise);
+  - CompartmentMap / CompartmentDelta: rigid channel->slot partition x smooth
+    slot->band crossfade, with the MASKED WRITE-BACK that is the entire
+    isolation mechanism on a feature axis;
+  - the CONDITIONING GATE (kappa^2 energy ratio; refuses predicted-inert
+    auxiliary couplings — calibrated on the eps/flow 125-200x receipt);
+  - the COLLINEARITY GATE (novelty = 1-|cos(grad_arm, grad_base)|; refuses
+    role objectives that cannot pay — calibrated on dexp009 vs dexp012);
+  - the exact fp64 Cantor warp (the ADMISSIBLE band coordinate) and the
+    soft-staircase non-monotonicity regression (the INADMISSIBLE one).
+
+Run:  python tools/compartment_smoke.py          (or paste as one Colab cell)
+"""
+import inspect
+import math
+import os
+import sys
+import time
+import zlib
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+# ---------------------------------------------------------------- environment
+def _repo_root():
+    d = os.path.abspath(os.getcwd())
+    while True:
+        if os.path.exists(os.path.join(d, "MANIFEST.md")):
+            return d
+        p = os.path.dirname(d)
+        if p == d:
+            return os.getcwd()
+        d = p
+
+ROOT = _repo_root()
+for _p in (os.path.join(ROOT, "tools"),
+           os.path.join(ROOT, "closeout_2026-07-19", "amoe", "src")):
+    if os.path.isdir(_p) and _p not in sys.path:
+        sys.path.insert(0, _p)
+
+torch.backends.cuda.matmul.allow_tf32 = False        # pin_precision (law)
+torch.backends.cudnn.allow_tf32 = False
+DEV = "cuda" if torch.cuda.is_available() else "cpu"
+if DEV == "cuda":
+    torch.cuda.set_per_process_memory_fraction(0.73)  # WDDM standing cap
+
+def seed_for(name: str) -> int:
+    """crc32, never hash() — PYTHONHASHSEED nondeterminism is a recorded law."""
+    return zlib.crc32(name.encode("utf-8")) & 0x7FFFFFFF
+
+try:
+    from geolip_vitals import (_pentachoron_volumes, axis_aliveness,
+                               pentachoron_cv)
+    HAVE_VITALS = True
+except Exception:
+    HAVE_VITALS = False
+try:
+    from amoe.diffusion.core.multiband import band_weights as amoe_band_weights
+    HAVE_AMOE = True
+except Exception:
+    HAVE_AMOE = False
+
+
+# --------------------------------------------------- windows (the smooth layer)
+def compartment_windows(coord: torch.Tensor, edges=(1/3, 2/3),
+                        xfade: float = 0.06) -> torch.Tensor:
+    """The certified cosine-crossfade windows, parameterized. Identical math to
+    amoe.diffusion.core.multiband.band_weights (parity test T01b); `coord` is a
+    monotone band coordinate in [0,1] — a FUNCTION OF INDEX ONLY on the feature
+    axis (T04). Rows sum to 1 everywhere; max step pi/(4*xfade) per unit."""
+    def ramp(x):
+        t = ((x / xfade).clamp(-1, 1) + 1) / 2
+        return 0.5 - 0.5 * torch.cos(t * math.pi)
+    e1, e2 = edges
+    up1, up2 = ramp(coord - e1), ramp(coord - e2)
+    low = 1 - up1
+    mid = up1 * (1 - up2)
+    high = up1 * up2
+    return torch.stack([low, mid, high], dim=-1)
+
+
+# ------------------------------------------------ Cantor coordinate (the warp)
+def exact_cantor(x: torch.Tensor, L: int = 12) -> torch.Tensor:
+    """Exact floor-based Cantor function, fp64, MONOTONE by construction. The
+    ADMISSIBLE static warp: built once, frozen, no gradient path — measure
+    space is entered exactly once (cantor law)."""
+    r = x.double().clone()
+    out = torch.zeros_like(r)
+    alive = torch.ones_like(r)
+    for k in range(1, L + 1):
+        d = torch.floor(3.0 * r).clamp(max=2.0)   # endpoint: 3*1.0 -> digit 2
+        r = 3.0 * r - d
+        out = out + alive * (2.0 ** -k) * (d >= 1).double()
+        alive = alive * (d != 1).double()
+    return out
+
+def soft_cantor_ungated(x: torch.Tensor, L: int = 12, tau: float = 0.25,
+                        alpha: float = 0.5) -> torch.Tensor:
+    """The soft alpha-form staircase (centers .5/1.5/2.5, soft trit, no stop
+    gate) — reimplemented from the recorded formula for the NON-MONOTONICITY
+    REGRESSION (timeline 2026-07-25): it keeps accumulating digits past the
+    first 1, so it is INADMISSIBLE as a band coordinate. Feature use is fine."""
+    centers = torch.tensor([0.5, 1.5, 2.5], dtype=torch.float64)
+    xx = x.double()
+    out = torch.zeros_like(xx)
+    for k in range(1, L + 1):
+        y = (xx * (3.0 ** (k - 1))) % 1.0 * 3.0
+        p = torch.softmax(-(y.unsqueeze(-1) - centers) ** 2 / tau, dim=-1)
+        out = out + (p[..., 2] + alpha * p[..., 1]) * (2.0 ** -k)
+    return out
+
+def exact_cantor_ungated(x: torch.Tensor, L: int = 12,
+                         alpha: float = 0.5) -> torch.Tensor:
+    """Exact-arithmetic UNGATED accumulation (digit-2 full bit, digit-1
+    alpha-bit, never stops) — the alpha-law regression pair for T06."""
+    r = x.double().clone()
+    out = torch.zeros_like(r)
+    for k in range(1, L + 1):
+        d = torch.floor(3.0 * r).clamp(max=2.0)
+        r = 3.0 * r - d
+        out = out + (2.0 ** -k) * ((d == 2).double() + alpha * (d == 1).double())
+    return out
+
+
+# ------------------------------------------------------- the compartment map
+def build_compartment_map(P: int = 32, Ds: int = 4, d: int = 128, B: int = 3,
+                          xfade_slots: float = 1.92, warp: str = "identity"):
+    """RIGID channel->slot partition (static int64) x SMOOTH slot->band
+    crossfade. The coordinate is a function of INDEX ONLY (torch.arange) —
+    never of activations; no argmax/topk/softmax selection appears in this
+    path (source-inspected by T04). Built ONCE, fp64 warp, frozen buffers."""
+    assert d % P == 0, "rigid partition must tile exactly"
+    member = torch.arange(d, dtype=torch.int64) // (d // P)
+    c = (torch.arange(P, dtype=torch.float64) + 0.5) / P
+    if warp == "cantor_exact":
+        c = exact_cantor(c)
+        c = (c - c.min()) / (c.max() - c.min()).clamp_min(1e-12)
+    W_slot = compartment_windows(c, edges=(1/3, 2/3),
+                                 xfade=xfade_slots / P).float()
+    W_chan = W_slot[member]
+    fp = zlib.crc32(member.numpy().tobytes()
+                    + W_slot.numpy().tobytes() + W_chan.numpy().tobytes())
+    return {"member": member, "coord": c.float(), "W_slot_band": W_slot,
+            "W_chan_band": W_chan, "P": P, "Ds": Ds, "B": B, "d": d,
+            "fingerprint": fp}
+
+
+class SquaredReLU(nn.Module):
+    def forward(self, x):
+        return F.relu(x) ** 2
+
+
+class MiniAleph(nn.Module):
+    """Minimal aleph read: M_hat = sum_k sinh(u_k) A_k / sum_k cosh(u_k),
+    stabilized by max-|u| factor-out. Codebook is the only parameter; `home`
+    is the frozen init snapshot (drift gauge). No argmax, no roster."""
+    def __init__(self, K=64, D=4, tau=0.1, gen=None):
+        super().__init__()
+        cb = F.normalize(torch.randn(K, D, generator=gen), dim=-1)
+        self.codebook = nn.Parameter(cb.clone())
+        self.register_buffer("home", cb.clone())
+        self.tau = tau
+
+    def m_hat(self, x):                       # x: (..., D) rows on the sphere
+        A = F.normalize(self.codebook, dim=-1)
+        u = (F.normalize(x, dim=-1) @ A.t()) / self.tau
+        m = u.abs().amax(dim=-1, keepdim=True)
+        ep, en = torch.exp(u - m), torch.exp(-u - m)
+        num = (ep - en) @ A
+        den = (ep + en).sum(dim=-1, keepdim=True)
+        return num / den
+
+
+class CompartmentDelta(nn.Module):
+    """One site: proj -> shared aleph read per slot -> B band consumers with
+    WINDOWED READ and MASKED WRITE. The masked write is load-bearing: on a
+    feature axis every band is active on every sample, so without masking the
+    write-back by the same window, isolation is exactly zero (measured
+    own/cross 1.04x). Zero-init heads (weight AND bias) => P-INIT bit-exact;
+    enabled=False is a code-path skip => toggle law bit-exact."""
+    def __init__(self, cmap, hidden=64, gen=None, head_scale=0.0):
+        super().__init__()
+        self.cm = cmap
+        P, Ds, B, d = cmap["P"], cmap["Ds"], cmap["B"], cmap["d"]
+        self.proj = nn.Linear(d, P * Ds, bias=False)
+        nn.init.orthogonal_(self.proj.weight, generator=gen)
+        self.addr = MiniAleph(K=64, D=Ds, gen=gen)
+        self.cons = nn.ModuleList()
+        for _ in range(B):
+            head = nn.Linear(hidden, d)
+            if head_scale == 0.0:
+                nn.init.zeros_(head.weight)
+                nn.init.zeros_(head.bias)          # bias too — the exp006 law
+            else:
+                with torch.no_grad():
+                    head.weight.normal_(0, head_scale, generator=gen)
+                    head.bias.zero_()
+            self.cons.append(nn.Sequential(nn.Linear(P * Ds, hidden),
+                                           SquaredReLU(),
+                                           nn.LayerNorm(hidden), head))
+        self.gates = nn.Parameter(torch.full((B,), -3.0))
+        self.register_buffer("W_slot", cmap["W_slot_band"])
+        self.register_buffer("W_chan", cmap["W_chan_band"])
+        self.enabled = True
+        self.band_enabled = [True] * B
+
+    def forward(self, x):                                # x: (B?, T, d)
+        if not self.enabled:
+            return x
+        P, Ds, B = self.cm["P"], self.cm["Ds"], self.cm["B"]
+        f = self.addr.m_hat(self.proj(x).view(*x.shape[:-1], P, Ds))
+        delta = None
+        for b in range(B):
+            if not self.band_enabled[b]:
+                continue
+            f_b = (f * self.W_slot[:, b].view(P, 1)).reshape(*x.shape[:-1], P * Ds)
+            piece = torch.sigmoid(self.gates[b]) * (self.W_chan[:, b]
+                                                    * self.cons[b](f_b))
+            delta = piece if delta is None else delta + piece
+        return x if delta is None else x + delta
+
+
+# ------------------------------------------------------------- the two gates
+def conditioning_gate(w_bands: torch.Tensor, amp: torch.Tensor,
+                      amp_ref: torch.Tensor, refuse_at: float = 25.0):
+    """kappa^2_b = band-weighted ENERGY of the prediction->quantity map's gain,
+    relative to a reference map — the conditioning law as a pre-spend check.
+    NEVER the pointwise mean ratio (it diverges as the reference gain -> 0).
+    kappa^2 >= refuse_at => REFUSE, predicted inert."""
+    w = w_bands.double()
+    e = (w * amp.double().unsqueeze(-1) ** 2).sum(0) / w.sum(0)
+    er = (w * amp_ref.double().unsqueeze(-1) ** 2).sum(0) / w.sum(0)
+    k2 = (e / er.clamp_min(1e-30))
+    return k2, [bool(v >= refuse_at) for v in k2]
+
+def collinearity_gate(loss_arm, loss_base, params, refuse_below: float = 0.05):
+    """novelty = 1 - |cos(grad_arm, grad_base)| over shared params. Calibrated:
+    HP/LP role arms 0.0026-0.0083 (WAS inert at 0.05-0.2%) vs the blob payer
+    0.715 (~10% win). novelty < refuse_below => REFUSE."""
+    def flat_grad(loss):
+        gs = torch.autograd.grad(loss, params, retain_graph=True,
+                                 allow_unused=True)
+        return torch.cat([g.reshape(-1) for g in gs if g is not None])
+    ga, gb = flat_grad(loss_arm), flat_grad(loss_base)
+    cos = F.cosine_similarity(ga.unsqueeze(0), gb.unsqueeze(0)).item()
+    nov = 1.0 - abs(cos)
+    return nov, nov < refuse_below
+
+
+def half_ulp_bf16(w: float) -> float:
+    """Half a bf16 ULP at magnitude |w| (7 explicit mantissa bits). At 3.0 this
+    is 0.0078125 — the exp004 sub-ULP freeze constant."""
+    if w == 0.0:
+        return 2.0 ** -133
+    return 2.0 ** (math.floor(math.log2(abs(w))) - 7) / 2.0
+
+
+# -------------------------------------------------------------------- battery
+RESULTS = []
+def record(tid, name, ok, detail=""):
+    RESULTS.append((tid, name, "PASS" if ok else "FAIL", detail))
+    return ok
+
+def skip(tid, name, why):
+    RESULTS.append((tid, name, "SKIP", why))
+
+
+def run_battery():
+    t0 = time.time()
+    g = torch.Generator().manual_seed(seed_for("compartment_smoke"))
+    cmap = build_compartment_map()
+    P, B, d = cmap["P"], cmap["B"], cmap["d"]
+    W = cmap["W_slot_band"]
+
+    # T01 partition of unity (fp32 grid + fp64 dense) + T01b amoe parity
+    dense = torch.linspace(0, 1, 4096, dtype=torch.float64)
+    Wd = compartment_windows(dense, (1/3, 2/3), 0.06)
+    ok = (W.sum(-1) - 1).abs().max().item() <= 1e-6 \
+        and (Wd.sum(-1) - 1).abs().max().item() <= 1e-12 \
+        and float(W.min()) >= 0 and float(W.max()) <= 1
+    record("T01", "window partition-of-unity",
+           ok, "fp32 err %.1e fp64 err %.1e" % (
+               (W.sum(-1) - 1).abs().max(), (Wd.sum(-1) - 1).abs().max()))
+    if HAVE_AMOE:
+        s = torch.linspace(0, 1, 2048)
+        mine = compartment_windows(s, (0.35, 0.75), 0.06)
+        record("T01b", "verbatim parity vs amoe band_weights",
+               torch.equal(mine, amoe_band_weights(s)),
+               "bit-exact at amoe's native constants")
+    else:
+        skip("T01b", "verbatim parity vs amoe band_weights", "amoe not importable")
+
+    # T02 max-step analytic bound (per-slot step; bound pi/(4*m_slots))
+    step = (W[1:] - W[:-1]).abs().max().item()
+    bound = math.pi / (4 * 1.92)
+    record("T02", "max-step analytic bound",
+           step <= bound and step >= 0.5 * bound,
+           "step %.4f bound %.4f (tight %.2f)" % (step, bound, step / bound))
+
+    # T03 rigid partition integrity
+    bc = torch.bincount(cmap["member"], minlength=P)
+    record("T03", "rigid partition integrity",
+           bool((bc == d // P).all()) and int(cmap["member"].max()) + 1 == P
+           and d % P == 0, "%d channels / %d slots, uniform" % (d, P))
+
+    # T04 coordinate law — source inspection (the band-coordinate idiom).
+    # Scan the CODE only (part after the docstring close) — the docstring
+    # names the forbidden ops, which is not the same as using them.
+    code = inspect.getsource(build_compartment_map).split('"""')[2]
+    ok = ("arange" in code and "argmax" not in code and "topk" not in code
+          and "softmax" not in code and ".grad" not in code)
+    record("T04", "coordinate is INDEX-ONLY (source-inspected)", ok,
+           "no argmax/topk/softmax in the coordinate path")
+
+    # T05 Cantor admissibility: exact monotone; soft form DETECTED non-monotone
+    # (interior grid — the x=1.0 mod-wrap is an endpoint artifact, not the
+    # finding; the recorded interior dips are slope -0.13..-0.49 per level)
+    xs = torch.linspace(0, 1, 2048, dtype=torch.float64)
+    ce_ = exact_cantor(xs)
+    mono = float((ce_[1:] - ce_[:-1]).min())
+    xin = xs[:-1]
+    worst = 0.0
+    for L in (3, 5, 12):
+        sc = soft_cantor_ungated(xin, L=L)
+        worst = min(worst, float(((sc[1:] - sc[:-1]) * (len(xin) - 1)).min()))
+    record("T05", "Cantor coordinate admissibility",
+           mono >= -1e-12 and worst < -0.05,
+           "exact min-diff %.1e; soft interior min-slope %.2f (non-monotone)"
+           % (mono, worst))
+
+    # T06 alpha-law: alpha=0.5 expectation-matches the gated form; alpha=0 collapses
+    # alpha=0.5 is the UNIQUE expectation-matching value: a digit-1 contributes
+    # 2^-N and stops (gated), while an unstopped continuation contributes
+    # alpha*2^-N plus a tail averaging 0.5*2^-N — so alpha=0.5 is unbiased and
+    # alpha=0 is systematically biased low. Distinct values must survive.
+    cent = (torch.arange(32, dtype=torch.float64) + 0.5) / 32   # slot centroids
+    gt5 = ce_ - exact_cantor_ungated(xs, alpha=0.5)
+    gt0 = ce_ - exact_cantor_ungated(xs, alpha=0.0)
+    slots32 = exact_cantor_ungated(cent, alpha=0.5)
+    record("T06", "alpha=0.5 expectation-matching law",
+           abs(float(gt5.mean())) < 1e-3 and float(gt5.abs().mean()) > 0.01
+           and float(gt0.mean()) > 0.01
+           and len(torch.unique(slots32)) == 32,
+           "bias a=.5 %.1e (unbiased) vs a=0 %.3f (low); gradation %.3f; "
+           "distinct 32/32" % (gt5.mean(), gt0.mean(), gt5.abs().mean()))
+
+    # T07 map staticity across optimizer steps
+    mod = CompartmentDelta(cmap, gen=g).to(DEV)
+    opt = torch.optim.Adam(mod.parameters(), lr=1e-3, weight_decay=0.0)
+    x = torch.randn(4, 16, d, generator=g).to(DEV)
+    for _ in range(3):
+        opt.zero_grad(set_to_none=True)
+        ((mod(x) - x) ** 2).mean().backward()
+        opt.step()
+    fp2 = zlib.crc32(mod.cm["member"].numpy().tobytes()
+                     + mod.cm["W_slot_band"].numpy().tobytes()
+                     + mod.cm["W_chan_band"].numpy().tobytes())
+    record("T07", "map staticity (crc32 across steps)",
+           fp2 == cmap["fingerprint"]
+           and not mod.W_slot.requires_grad and not mod.W_chan.requires_grad,
+           "fingerprint %08x stable" % fp2)
+
+    # T08 lesion does not renormalize
+    Wl = W.clone(); Wl[:, 1] = 0.0
+    record("T08", "lesion no-renormalization",
+           float(Wl.sum(-1).max()) < 1.0 + 1e-6
+           and bool((Wl.sum(-1) < 1 - 1e-6).any())
+           and torch.equal(Wl[:, 0], W[:, 0]) and torch.equal(Wl[:, 2], W[:, 2]),
+           "lesioned rows sum<1; other columns bit-identical")
+
+    # T09 toggle / P-INIT bit-exactness
+    fresh = CompartmentDelta(cmap, gen=g).to(DEV)
+    xb = torch.randn(2, 8, d, generator=g).to(DEV)
+    fresh.enabled = False
+    off = fresh(xb)
+    fresh.enabled = True
+    on0 = fresh(xb)                                     # zero-init => inert
+    fresh.band_enabled = [False] * B
+    les = fresh(xb)
+    record("T09", "toggle + P-INIT + full-lesion bit-exact",
+           torch.equal(off, xb) and torch.equal(on0, xb)
+           and torch.equal(les, xb), "all three torch.equal")
+
+    # T10/T11 gradient flow to intended / zero to unintended
+    live = CompartmentDelta(cmap, gen=g, head_scale=0.02).to(DEV)
+    live.band_enabled = [True, True, False]             # band 2 disabled
+    y = live(xb)
+    loss = ((y - xb) ** 2).mean()
+    loss.backward()
+    flow_ok = all(p.grad is not None and float(p.grad.abs().sum()) > 0
+                  for p in [live.proj.weight, live.addr.codebook,
+                            live.gates]
+                  ) and all(
+        any(p.grad is not None and float(p.grad.abs().sum()) > 0
+            for p in live.cons[b].parameters()) for b in (0, 1))
+    zero_ok = (live.addr.home.grad is None and live.W_slot.grad is None
+               and all(p.grad is None or float(p.grad.abs().sum()) == 0
+                       for p in live.cons[2].parameters()))
+    record("T10", "gradient FLOW to every intended parameter", flow_ok,
+           "proj+codebook+gates+cons[0,1] all nonzero")
+    record("T11", "gradient ZERO to every unintended parameter", zero_ok,
+           "buffers + disabled band grad-free")
+
+    # T12 cross-talk matrix (the isolation mechanism, measured)
+    ct = CompartmentDelta(cmap, gen=torch.Generator().manual_seed(
+        seed_for("crosstalk")), head_scale=0.02).to(DEV)
+    xc = torch.randn(4, 16, d,
+                     generator=torch.Generator().manual_seed(
+                         seed_for("crosstalk-x"))).to(DEV)
+    M = torch.zeros(B, B)
+    for b in range(B):
+        for p_ in ct.parameters():
+            p_.grad = None
+        delta = ct(xc) - xc
+        Lb = ((delta * ct.W_chan[:, b]) ** 2).mean()
+        Lb.backward()
+        for b2 in range(B):
+            M[b, b2] = math.sqrt(sum(float((p.grad ** 2).sum())
+                                     for p in ct.cons[b2].parameters()
+                                     if p.grad is not None))
+    Mn = M / M.diag().clamp_min(1e-12).unsqueeze(1)
+    edge_zero = float(Mn[0, 2]) == 0.0 and float(Mn[2, 0]) == 0.0
+    own_cross = min((1.0 / Mn[b][torch.arange(B) != b].max()).item()
+                    for b in range(B))
+    bleed = torch.tensor([[float((W[:, a] * W[:, c]).sum() / W[:, a].sum())
+                           for c in range(B)] for a in range(B)])
+    off_mask = ~torch.eye(B, dtype=torch.bool)
+    r = torch.corrcoef(torch.stack([Mn[off_mask], bleed[off_mask]]))[0, 1]
+    record("T12", "cross-talk: edges exactly 0, own/cross >= 10x, bleed-correlated",
+           edge_zero and own_cross >= 10.0 and float(r) > 0.8,
+           "LOW<->HIGH %.1e/%.1e; worst own/cross %.1fx; corr(bleed) %.2f"
+           % (Mn[0, 2], Mn[2, 0], own_cross, r))
+
+    # T13 CONDITIONING GATE — must reproduce the eps/flow calibration
+    betas = torch.linspace(0.00085 ** 0.5, 0.012 ** 0.5, 1000,
+                           dtype=torch.float64) ** 2
+    abar = torch.cumprod(1 - betas, dim=0)
+    s01 = torch.arange(1000, dtype=torch.float64) / 1000.0   # t/1000 — the LAW
+    wb = compartment_windows(s01, (0.35, 0.75), 0.06)         # sigma-axis bands
+    amp_eps = ((1 - abar).sqrt() / abar.sqrt()).float()       # d x0 / d eps_hat
+    amp_flow = s01.float()                                    # d x0 / d v_hat
+    k2, refuse = conditioning_gate(wb, amp_eps, amp_flow)
+    k2f, refuse_f = conditioning_gate(wb, amp_flow, amp_flow)
+    record("T13", "conditioning gate reproduces the eps/flow split",
+           bool(k2[0] < k2[1] < k2[2]) and refuse[2] and not any(refuse_f)
+           and 25.0 <= float(k2[2]) <= 400.0,
+           "kappa^2 LOW %.1f MID %.1f HIGH %.1f (refuse@25: HIGH fires; "
+           "flow self-ratio clean)" % (k2[0], k2[1], k2[2]))
+
+    # T14 COLLINEARITY GATE — must reproduce HP/LP-inert vs blob-payer
+    gc = torch.Generator().manual_seed(seed_for("collinearity"))
+    conv = nn.Conv2d(4, 4, 3, padding=1)
+    with torch.no_grad():
+        conv.weight.normal_(0, 0.1, generator=gc); conv.bias.zero_()
+    conv = conv.to(DEV)
+    xt = torch.randn(8, 4, 32, 32, generator=gc).to(DEV)
+    tgt = torch.randn(8, 4, 32, 32, generator=gc).to(DEV)
+    sig = torch.rand(8, 1, 1, 1, generator=gc).to(DEV) * 0.9 + 0.05
+    blob = (torch.rand(8, 1, 32, 32, generator=gc).to(DEV) > 0.7).float()
+    def hp(z): return z - F.avg_pool2d(z, 3, stride=1, padding=1)
+    def lp(z): return F.avg_pool2d(z, 7, stride=1, padding=3)
+    pred = conv(xt)
+    base = ((pred - tgt) ** 2).mean()
+    lam = 0.5
+    arm_low = base + lam * ((hp(pred) - hp(tgt)) ** 2).mean()
+    arm_high = base + lam * ((lp(pred) - lp(tgt)) ** 2).mean()
+    x0h, x0 = xt - sig * pred, xt - sig * tgt
+    den = blob.sum().clamp_min(1.0) * 4
+    blob_term = (blob * (lp(x0h) - lp(x0)) ** 2).sum() / den
+    ps = [conv.weight, conv.bias]
+    # Gate semantics: a COMPOSED role arm (base + filtered residual, exp009's
+    # actual objective) is judged whole; an ADDITIVE auxiliary is judged as
+    # THE TERM BEING ADDED — that is the new pressure whose direction matters.
+    n_low, ref_low = collinearity_gate(arm_low, base, ps)
+    n_high, ref_high = collinearity_gate(arm_high, base, ps)
+    n_blob, ref_blob = collinearity_gate(lam * blob_term, base, ps)
+    record("T14", "collinearity gate reproduces inert-vs-payer",
+           ref_low and ref_high and not ref_blob
+           and max(n_low, n_high) < 0.02 and n_blob > 0.3,
+           "novelty HP %.4f LP %.4f (REFUSED) vs blob %.3f (passes)"
+           % (n_low, n_high, n_blob))
+
+    # T15 fp32-vs-fp64 CM parity + geovocab2 reference
+    if HAVE_VITALS:
+        gp = torch.Generator().manual_seed(seed_for("cm-parity"))
+        pts = F.normalize(torch.randn(200, 5, 4, generator=gp), dim=-1)
+        v64 = _pentachoron_volumes(pts)
+        d2 = torch.cdist(pts, pts).pow(2)                    # fp32 clone
+        cm32 = torch.ones(200, 6, 6); cm32[:, 0, 0] = 0.0
+        cm32[:, 1:, 1:] = d2
+        v32 = (-torch.linalg.det(cm32) / 9216.0).clamp_min(0).sqrt()
+        rel = ((v32 - v64).abs() / v64.abs().clamp_min(1e-12)).max().item()
+        try:
+            from geolip_vitals import cv_reference_check
+            ref = "geovocab2 parity %.1e" % cv_reference_check()
+        except Exception as e:
+            ref = "geovocab2 skipped (%s)" % type(e).__name__
+        record("T15", "fp64-for-gauges precision law",
+               rel < 0.05, "fp32 max rel err %.2e (<4%% recorded); %s"
+               % (rel, ref))
+    else:
+        skip("T15", "fp64-for-gauges precision law", "geolip_vitals not importable")
+
+    # T16 memory + time: full CE vs chunked CE vs a K=64 code loss @ V=248,320
+    if DEV == "cuda":
+        V, dd, T = 248_320, 1024, 2048
+        E = torch.randn(V, dd, device=DEV) * 0.02
+        R = torch.randn(64, dd, device=DEV) / math.sqrt(dd)
+        yid = torch.randint(0, V, (1, T), device=DEV)
+        code = (torch.randn(V, 64, device=DEV) > 0).float() * 2 - 1
+        def one(name, fn):
+            h = torch.randn(1, T, dd, device=DEV, requires_grad=True)
+            fn(h).backward(); torch.cuda.synchronize()       # warm
+            torch.cuda.reset_peak_memory_stats()
+            h = torch.randn(1, T, dd, device=DEV, requires_grad=True)
+            t1 = time.time(); fn(h).backward()
+            torch.cuda.synchronize()
+            return torch.cuda.max_memory_allocated() / 2**30, time.time() - t1
+        def full(h):
+            return F.cross_entropy((h @ E.t()).reshape(-1, V), yid.reshape(-1))
+        def chunked(h):
+            s, n = 0.0, 0
+            for i in range(0, T, 512):
+                lg = h[:, i:i + 512] @ E.t()
+                s = s + F.cross_entropy(lg.reshape(-1, V),
+                                        yid[:, i:i + 512].reshape(-1),
+                                        reduction="sum")
+                n += lg.shape[1]
+            return s / n
+        def fac(h):
+            v = (F.normalize(h, dim=-1) @ R.t()) / 0.3
+            return (torch.cosh((v - code[yid] * 1.0).clamp(-4, 4)) - 1).mean()
+        m_full, s_full = one("full", full)
+        m_chunk, s_chunk = one("chunked", chunked)
+        m_fac, s_fac = one("fac", fac)
+        record("T16", "memory law: candidate <= 1.5x chunked CE",
+               m_fac <= 1.5 * m_chunk and m_chunk < m_full,
+               "full %.2fGB/%.3fs | chunked-512 %.2fGB/%.3fs | "
+               "FAC-K64 %.2fGB/%.3fs (%.0fx less than chunked)"
+               % (m_full, s_full, m_chunk, s_chunk, m_fac, s_fac,
+                  m_chunk / max(m_fac, 1e-9)))
+        del E, R, code
+        torch.cuda.empty_cache()
+    else:
+        skip("T16", "memory law vs chunked CE", "no CUDA")
+
+    # T17 sub-ULP safety
+    guard = half_ulp_bf16(3.0)
+    record("T17", "sub-ULP freeze guard",
+           guard == 0.0078125 and 4.5e-4 < guard          # bf16 step FREEZES
+           and 4.5e-4 > 2.0 ** (1 - 23) / 2,              # fp32 master moves
+           "half-ULP(bf16, 3.0)=%.7f; 4.5e-4 step frozen in bf16, live in fp32"
+           % guard)
+
+    # T18 anti-collapse smoke (rich-get-richer detector on the read)
+    if HAVE_VITALS:
+        ga = torch.Generator().manual_seed(seed_for("aliveness"))
+        healthy = torch.softmax(torch.randn(4096, 128, generator=ga) * 0.5, -1)
+        logits = torch.randn(4096, 128, generator=ga) * 0.5
+        logits[:, :2] += 8.0                                # 2-winner collapse
+        sick = torch.softmax(logits, -1)
+        h, s = axis_aliveness(healthy), axis_aliveness(sick)
+        record("T18", "anti-collapse (rich-get-richer signature)",
+               (not h["collapsed"]) and s["collapsed"] and s["usage_ppl"] < 6,
+               "healthy ppl %.0f/128; collapsed ppl %.1f/128 flagged"
+               % (h["usage_ppl"], s["usage_ppl"]))
+    else:
+        skip("T18", "anti-collapse smoke", "geolip_vitals not importable")
+
+    # T19 eff-dim readout sanity (the S^15 CV band, zero training)
+    if HAVE_VITALS:
+        gs = torch.Generator().manual_seed(seed_for("s15"))
+        cv = pentachoron_cv(torch.randn(500, 16, generator=gs))
+        record("T19", "S^15 CV-band sanity (0.199-0.210 untrained)",
+               0.185 <= cv <= 0.225, "CV %.4f" % cv)
+    else:
+        skip("T19", "S^15 CV-band sanity", "geolip_vitals not importable")
+
+    # T20 seed determinism (crc32 path; no hash() in the seeding path)
+    ok = seed_for("x") == (zlib.crc32(b"x") & 0x7FFFFFFF)
+    try:                       # scan the SEEDING PATH only, CODE only —
+        # docstrings name the forbidden call, which is not using it
+        def code_of(fn):
+            parts = inspect.getsource(fn).split('"""')
+            return parts[0] + "".join(parts[2::2])
+        src_all = (code_of(seed_for) + code_of(build_compartment_map)
+                   + code_of(CompartmentDelta.__init__))
+        no_hash = "hash(" not in src_all.replace("crc32", "")
+    except Exception:
+        no_hash = True
+    record("T20", "crc32 seed determinism (never hash())", ok and no_hash,
+           "seed_for('x')=%d, source clean" % seed_for("x"))
+
+    # T21 CE-vs-FAC Hessian conditioning (the sequential-loss smoke)
+    Vp = 1000
+    gz = torch.Generator().manual_seed(seed_for("hessian"))
+    out = []
+    for pmax in (0.5, 0.9, 0.999):
+        p = torch.full((Vp,), (1 - pmax) / (Vp - 1), dtype=torch.float64)
+        p[0] = pmax
+        J = torch.diag(p) - torch.outer(p, p)
+        ev = torch.linalg.eigvalsh(J)
+        out.append((pmax, float(ev[0]), float(ev[-1]),
+                    float((J @ torch.ones(Vp, dtype=torch.float64)).abs().max())))
+    r64 = torch.randn(64, generator=gz, dtype=torch.float64) * 2
+    lam_fac = torch.cosh(r64).min().item()
+    ce999 = out[2]
+    record("T21", "CE-vs-FAC Hessian conditioning",
+           abs(ce999[1]) < 1e-9 and ce999[3] < 1e-9        # exact null direction
+           and ce999[2] < 1e-2                             # spectrum collapsed
+           and lam_fac >= 1.0,                             # cosh(r) >= 1 always
+           "CE@p=.999: lam_min %.1e lam_max %.1e null|J1| %.1e; "
+           "FAC lam_min %.3f >= 1" % (ce999[1], ce999[2], ce999[3], lam_fac))
+
+    # ------------------------------------------------------------------ table
+    wall = time.time() - t0
+    peak = (torch.cuda.max_memory_allocated() / 2**30) if DEV == "cuda" else 0.0
+    print("\nCOMPARTMENT / LOSS FORMULA-SMOKE BATTERY  (%s, %.1fs, peak %.2f GB)"
+          % (DEV, wall, peak))
+    print("-" * 100)
+    npass = nfail = 0
+    for tid, name, st, detail in RESULTS:
+        npass += st == "PASS"; nfail += st == "FAIL"
+        print("%-5s %-4s %-46s %s" % (tid, st, name[:46], detail[:60]))
+    print("-" * 100)
+    print("PASS %d  FAIL %d  SKIP %d" % (npass, nfail,
+                                         len(RESULTS) - npass - nfail))
+    return nfail == 0
+
+
+if __name__ == "__main__":
+    sys.exit(0 if run_battery() else 1)

code/deviant_bed.py

@@ -0,0 +1,193 @@
+"""deviant_bed.py — trains the DEVIANT ROSTER candidates on the certified byte
+bed. #TAG:deviant_bed #TAG:loss_campaign
+One arm per gate-cleared candidate (inventory/DEVIANT_ROSTER.md) + the
+gate-refused confidence penalty as the DESIGNATED CONTROL (tests whether gate
+refusals predict training reality) + the sparsemax coupling-axis probe on the
+addr_head collapse configuration. Certified operating point throughout:
+wikitext-2 bytes, block 256, batch 32, 2000 steps, pure Adam 3e-4 wd=0,
+fp32/TF32-off, crc32 seeds. Ledgers -> tools/deviant_runs/*.jsonl.
+
+Baselines on this exact protocol (this session): ce 2.4769 mean bpb (3 seeds),
+fac_lsh 4.1285, ce_fixedcode 3.8060, fac_none 3.9547.
+
+Run:  python tools/deviant_bed.py --arm <name> --seed N [--steps 2000]
+      python tools/deviant_bed.py --list
+"""
+import json
+import math
+import os
+import sys
+import time
+import zlib
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+def _root():
+    d = os.path.abspath(os.getcwd())
+    while True:
+        if os.path.exists(os.path.join(d, "MANIFEST.md")):
+            return d
+        p = os.path.dirname(d)
+        if p == d:
+            return os.getcwd()
+        d = p
+
+ROOT = _root()
+if os.path.join(ROOT, "tools") not in sys.path:
+    sys.path.insert(0, os.path.join(ROOT, "tools"))
+
+import ar_differentiation_bed as bed                       # noqa: E402
+from loss_forms import (dev_geomean_accum, dev_softmax_accum, fac_loss_link,
+                        prim_ce, pwa_weights, sparsemax_loss)  # noqa: E402
+
+torch.backends.cuda.matmul.allow_tf32 = False
+torch.backends.cudnn.allow_tf32 = False
+DEV = "cuda" if torch.cuda.is_available() else "cpu"
+if DEV == "cuda":
+    torch.cuda.set_per_process_memory_fraction(0.73)
+
+DATA_ROOT = os.environ.get("GEOLIP_DATA", "./data")
+RUNS = os.path.join(ROOT, "tools", "deviant_runs")
+REF_CKPT = os.path.join(DATA_ROOT, "fac_ckpts", "ce_s0_t2000.pt")
+
+def seed_for(name):
+    return zlib.crc32(name.encode()) & 0x7FFFFFFF
+
+ARMS = ("softmax_accum", "geomean_accum", "label_smooth", "focal",
+        "sparsemax", "anti_curr", "fac_tanh", "fac_cauchy",
+        "conf_penalty_CONTROL", "p4_sparsemax")
+FAC_ARMS = ("fac_tanh", "fac_cauchy")
+
+
+def build(arm, seed):
+    torch.manual_seed(seed_for(f"deviant:{arm}:{seed}"))
+    model_arm = "addr_head" if arm == "p4_sparsemax" else "addr_msl64"
+    lm = bed.ByteLM(model_arm).to(DEV)
+    ctx = {}
+    if arm in FAC_ARMS:
+        lm.head = nn.Identity()                       # forward returns feats
+        gp = torch.Generator().manual_seed(seed_for("deviant-fac-frame"))
+        ctx["R"] = torch.linalg.qr(
+            torch.randn(256, 256, generator=gp))[0][:64].to(DEV)
+        gsm = torch.randn(258, 64, generator=gp)      # lsh: box-3 smoothed
+        sm = (gsm[:-2] + gsm[1:-1] + gsm[2:]) / 3.0
+        ctx["code"] = ((sm > 0).float() * 2 - 1).to(DEV)
+    if arm == "anti_curr":
+        ref = bed.ByteLM("addr_msl64").to(DEV)
+        sd = torch.load(REF_CKPT, map_location="cpu", weights_only=True)
+        ref.load_state_dict(sd["state_dict"], strict=True)
+        ref.eval()
+        for p_ in ref.parameters():
+            p_.requires_grad_(False)
+        ctx["ref"] = ref
+    return lm, ctx
+
+
+def loss_of(arm, lm, ctx, x, y):
+    out = lm(x)
+    if arm in FAC_ARMS:
+        link = "tanh" if arm == "fac_tanh" else "cauchy"
+        return fac_loss_link(out, ctx["R"], ctx["code"][y], link=link).mean()
+    if arm == "sparsemax" or arm == "p4_sparsemax":
+        return sparsemax_loss(out.reshape(-1, 256), y.reshape(-1)).mean()
+    ce_tok = prim_ce(out, y)
+    if arm == "softmax_accum":
+        return dev_softmax_accum(ce_tok, T=0.5)
+    if arm == "geomean_accum":
+        return dev_geomean_accum(ce_tok)
+    if arm == "label_smooth":
+        return F.cross_entropy(out.reshape(-1, 256), y.reshape(-1),
+                               label_smoothing=0.1)
+    if arm == "focal":
+        w = (1 - F.softmax(out, -1).gather(-1, y.unsqueeze(-1))
+             .squeeze(-1).detach()) ** 2
+        return (w * ce_tok).sum() / w.sum().clamp_min(1e-9)
+    if arm == "anti_curr":
+        with torch.no_grad():
+            pi = F.softmax(ctx["ref"](x), -1).gather(
+                -1, y.unsqueeze(-1)).squeeze(-1)
+        m = (pi > 0.6).float()
+        return (ce_tok * m).sum() / m.sum().clamp_min(1.0)
+    if arm == "conf_penalty_CONTROL":
+        p = F.softmax(out, -1)
+        ent = -(p * p.clamp_min(1e-12).log()).sum(-1).mean()
+        return ce_tok.mean() - 0.1 * ent
+    raise ValueError(arm)
+
+
+@torch.no_grad()
+def evaluate(arm, lm, ctx, va, g):
+    """bpb-of-record (softmax over available scores), decoded acc, vitals."""
+    lm.eval()
+    tot_ce, tot_ok, n = 0.0, 0, 0
+    for _ in range(8):
+        x, y = bed._batch(va, 32, 256, DEV, g)
+        out = lm(x)
+        if arm in FAC_ARMS:
+            s = F.normalize(out, dim=-1) @ ctx["R"].t()
+            scores = s @ ctx["code"].t()
+        else:
+            scores = out
+        lp = F.log_softmax(scores, -1)
+        tot_ce += float(-lp.gather(-1, y.unsqueeze(-1)).sum())
+        tot_ok += int((scores.argmax(-1) == y).sum())
+        n += y.numel()
+    x, _ = bed._batch(va, 8, 256, DEV, g)
+    _ = lm(x)
+    v = lm.head_addr.vitals(lm.head_proj(lm._last_h).view(
+        *lm._last_h.shape[:-1], lm.n_slots, 4)) \
+        if getattr(lm, "n_slots", 0) else lm.head_addr.vitals(lm._last_h)
+    lm.train()
+    return (tot_ce / n) / math.log(2), tot_ok / n, v
+
+
+def train_arm(arm, seed, steps=2000):
+    assert arm in ARMS, f"unknown arm {arm} (see --list)"
+    os.makedirs(RUNS, exist_ok=True)
+    tr, va = bed._wikitext_bytes(DATA_ROOT)
+    lm, ctx = build(arm, seed)
+    g = torch.Generator().manual_seed(seed_for(f"deviant-data:{arm}:{seed}"))
+    ge = torch.Generator().manual_seed(seed_for("deviant-eval"))
+    opt = torch.optim.Adam((p_ for p_ in lm.parameters() if p_.requires_grad),
+                           lr=3e-4, weight_decay=0.0)
+    t0 = time.time()
+    for step in range(steps):
+        x, y = bed._batch(tr, 32, 256, DEV, g)
+        opt.zero_grad(set_to_none=True)
+        L = loss_of(arm, lm, ctx, x, y)
+        L.backward()
+        opt.step()
+        if step == 10 and DEV == "cuda":
+            print(f"[{arm} s{seed}] step10 loss {float(L.detach()):.4f} "
+                  f"peak {torch.cuda.max_memory_allocated()/2**30:.2f}GB",
+                  flush=True)
+    bpb, acc, vit = evaluate(arm, lm, ctx, va, ge)
+    rec = {"arm": arm, "seed": seed, "steps": steps, "bpb": round(bpb, 4),
+           "decoded_acc": round(acc, 4), "vitals": vit,
+           "wall_s": round(time.time() - t0, 1),
+           "peak_gb": round(torch.cuda.max_memory_allocated() / 2**30, 2)
+           if DEV == "cuda" else 0.0}
+    out = os.path.join(RUNS, f"{arm}_s{seed}_t{steps}.jsonl")
+    with open(out, "a", encoding="utf-8") as f:
+        f.write(json.dumps(rec) + "\n")
+    print(f"[DONE {arm} s{seed}] bpb {bpb:.4f} acc {acc:.4f} "
+          f"usage_ppl {vit['aliveness']['usage_ppl']:.1f} "
+          f"win|cos| {vit['win_cos_mean']:.3f} ({rec['wall_s']}s)", flush=True)
+    return rec
+
+
+if __name__ == "__main__":
+    import argparse
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--arm", default=None)
+    ap.add_argument("--seed", type=int, default=0)
+    ap.add_argument("--steps", type=int, default=2000)
+    ap.add_argument("--list", action="store_true")
+    a, _ = ap.parse_known_args()
+    if a.list or not a.arm:
+        print("arms:", " ".join(ARMS))
+        sys.exit(0)
+    train_arm(a.arm, a.seed, a.steps)

code/fac_bed.py

@@ -0,0 +1,782 @@
+"""fac_bed.py — FAC (factorized absolute code) experiment bed.  #TAG:fac #TAG:loss_campaign #TAG:autoregressive #TAG:sign_code
+
+THE QUESTION: can a cosh-Bregman pull onto a FROZEN +/-1 code table replace the
+trained CE readout on the certified byte-LM operating point — and does swapping
+only-the-loss revive the certified addr_head collapse (the P4 cell)?
+
+Built ON TOP of tools/ar_differentiation_bed.py (as-run certified reference —
+imported, never modified, never copied). The certified operating point:
+wikitext-2-raw bytes, block 256, batch 32, d=192, 4 layers, 2000 steps, pure
+Adam lr 3e-4 wd=0. Incumbent control: addr_msl64 (3-seed certified mean bpb
+2.4685; timeline 2026-07-09 W6).
+
+THE FAC CONSTRUCTION
+  feats  = the certified addr_msl64 pre-readout read: P=64 parallel D=4 slots
+           through the shared K=64 aleph codebook, concat M_hat -> 256 dims.
+           (The spec sketch guessed P=16/64-dim; the BED CODE is authoritative:
+           ByteLM 'addr_msl<P>' parses P from the name -> addr_msl64 is 64
+           slots x D=4 = 256 dims. Recorded as smoke S0.)
+  R      = FIXED frame (64 x 256), orthonormal ROWS, torch.linalg.qr on a
+           crc32-seeded gaussian; registered buffer, NEVER trained. Gauge-fixed
+           by construction — a learnable frame reproduces either the tied-M_hat
+           starvation or the L-PS1 moving-target failure.
+  s      = F.normalize(feats, dim=-1) @ R.T          (B, T, 64);  |s_k| <= 1
+  v      = s / t_loss                                 (t_loss 0.3; sweep .1/.3/1)
+  C      = FROZEN code table in {-1,+1}^{256 x 64}. Two constructions:
+             fac_ecc — sign of an iid crc32-seeded gaussian (injective w.h.p.);
+             fac_lsh — sign of the same gaussian box-filtered (width 3) along
+             the byte-value axis, so numerically adjacent bytes share more bits
+             (a semantic-adjacency proxy for the byte alphabet; bytes carry no
+             pretrained embedding here, so a fixed random frame IS the SimHash).
+  LOSS   L = mean( cosh( clamp(v - C[y]*mu, -4, 4) ) - 1 ),  mu = 1.0 (S4).
+           This is the residual-form cosh-Bregman D_Phi(v - C[y]*mu, 0) with
+           Phi = sum cosh: D_Phi(r,0) = cosh(r) - cosh(0) - sinh(0)*r
+           = cosh(r) - 1 exactly (smoke S2; the target-anchored D_Phi(v, v*)
+           is a DIFFERENT function — coincides only at v* = 0 — S2 reports the
+           gap so the naming is honest).
+  EVAL   score(y') = s @ C[y'].T; bpb-of-record = log_softmax over the 256
+           scores (raw scores as logits — softmax temperature NOT calibrated;
+           caveat recorded in every ledger line). Decoded-token accuracy and
+           code-collision rate (Hamming <= 2 over distinct byte pairs) ride
+           along. Decode argmax is a READOUT only — no selection event in any
+           gradient path (aleph rider).
+
+ARMS (--arm)
+  ce               certified addr_msl64 incumbent — bed's own model + CE.
+  ce_fixedcode     SAME init (same seed, same RNG draw order), readout replaced
+                   by the frozen C: logits = s @ C.T, trained with CE. Zero
+                   trainable readout params — THE param-matched control.
+  fac_lsh/fac_ecc  the FAC loss with each code table.
+  fac_none         FAC loss, s from a plain Linear(d,64) on the trunk hidden
+                   state; the aleph head is present but UNREAD (gradient-dead).
+                   Isolates the geometry.
+  p4_addr_head_ce  the certified COLLAPSE configuration, verbatim: ByteLM
+                   'addr_head' (raw hidden -> single-slot address, K=32,
+                   tau=0.1, coefficients->logits) + CE. Expected: bpb ~5.66,
+                   usage_ppl ~1.88/64.
+  p4_addr_head_fac the SAME model (identical params; the coeff->logit head is
+                   computed but gradient-dead) with the FAC loss on the signed
+                   coefficient vector, embedded isometrically by a 64x32
+                   orthonormal-column frame. ONLY THE LOSS DIFFERS.
+                   Prediction: usage_ppl >= 8/64 while win|cos| stays > 0.99.
+
+LEDGER  JSON lines, one file per run: tools/fac_runs/{arm}_s{seed}_t{steps}.jsonl
+  bpb (partitioned), decoded_acc, train-curve summary, collision_rate,
+  sign_fidelity (exp015 gauge, L-078), anchor_drift mean + binding_fraction +
+  usage_ppl + win|cos| (via the bed's own vitals -> geolip_vitals), gate stats
+  (none of these arms carry gates — recorded as null), wall, peak_mem, params
+  (+ delta vs ce — the S9 honesty line), seeds from crc32(arm:seed).
+
+RIDERS  pure Adam wd=0 ONLY; fp32, TF32 off; cuda memory fraction 0.73;
+  crc32 seeds never hash(); GPU-only verdict runs; data_root OUTSIDE the repo;
+  Colab-cell-safe (paste-ahead imports, parse_known_args, no __file__ logic).
+
+Terminal:  python tools/fac_bed.py                    # smoke battery (default)
+           python tools/fac_bed.py --smoke            # same
+           python tools/fac_bed.py --bench            # ~20-step throughput probe
+           python tools/fac_bed.py --arm fac_lsh --seed 0        # verdict run
+Colab:     paste geolip_vitals.py, ar_differentiation_bed.py, then this file
+           (smokes auto-run); train_arm("fac_lsh", seed=0) in the next cell.
+"""
+from __future__ import annotations
+import json
+import math
+import os
+import sys
+import time
+import types
+import zlib
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+# ---------------------------------------------------------------- environment
+def _repo_root():
+    d = os.path.abspath(os.getcwd())
+    while True:
+        if os.path.exists(os.path.join(d, "MANIFEST.md")):
+            return d
+        p = os.path.dirname(d)
+        if p == d:
+            return os.getcwd()
+        d = p
+
+ROOT = _repo_root()
+_TOOLS = os.path.join(ROOT, "tools")
+if os.path.isdir(_TOOLS) and _TOOLS not in sys.path:
+    sys.path.insert(0, _TOOLS)
+
+if "ByteLM" in globals() and "AlephAddress" in globals():   # Colab paste-ahead
+    bed = types.SimpleNamespace(
+        ByteLM=globals()["ByteLM"], AlephAddress=globals()["AlephAddress"],
+        _wikitext_bytes=globals()["_wikitext_bytes"],
+        _batch=globals()["_batch"], VOCAB=globals()["VOCAB"])
+else:
+    import ar_differentiation_bed as bed                    # certified, read-only
+
+torch.backends.cuda.matmul.allow_tf32 = False               # pin_precision law
+torch.backends.cudnn.allow_tf32 = False
+DEV = "cuda" if torch.cuda.is_available() else "cpu"
+if DEV == "cuda":
+    torch.cuda.set_per_process_memory_fraction(0.73)        # WDDM standing cap
+
+DATA_ROOT = os.environ.get("GEOLIP_DATA", "./data")
+RUNS_DIR = (os.path.join(_TOOLS, "fac_runs") if os.path.isdir(_TOOLS)
+            else os.path.abspath("./fac_runs"))
+
+CODE_BITS = 64        # width of the absolute code (matches the K=64 aleph book)
+T_LOSS = 0.3          # loss temperature (knob; sweep {0.1, 0.3, 1.0})
+MU = 1.0              # target margin in v-units (S4 decision: KEPT at 1.0)
+CLAMP = 4.0           # residual clamp — cosh(4) ~ 27.3, fp32-safe by construction
+
+
+def seed_for(name: str) -> int:
+    """crc32, never hash() — PYTHONHASHSEED nondeterminism is a recorded law."""
+    return zlib.crc32(name.encode("utf-8")) & 0x7FFFFFFF
+
+
+# ------------------------------------------------------------- frozen buffers
+def orthonormal_frame(out_dim: int, in_dim: int, seed: int) -> torch.Tensor:
+    """(out_dim, in_dim) fixed frame, QR on a crc32-seeded gaussian, fp64 then
+    fp32, canonical sign fix. NEVER trained (registered as a buffer).
+      in_dim >= out_dim: orthonormal ROWS  (R R^T = I)  -> |s_k| <= 1 for unit feats
+      in_dim <  out_dim: orthonormal COLS  (R^T R = I)  -> isometric embed,
+                         ||s|| = ||feats_hat||, |s_k| <= ||row_k|| <= 1."""
+    g = torch.Generator().manual_seed(seed)
+    n, m = max(out_dim, in_dim), min(out_dim, in_dim)
+    G = torch.randn(n, m, generator=g, dtype=torch.float64)
+    Q, Rq = torch.linalg.qr(G)
+    sgn = torch.where(torch.diagonal(Rq) >= 0, 1.0, -1.0)
+    Q = Q * sgn.unsqueeze(0)
+    R = Q.T if in_dim >= out_dim else Q
+    return R.float().contiguous()
+
+
+def build_code(kind: str) -> torch.Tensor:
+    """FROZEN code table C in {-1,+1}^(256 x 64), crc32-seeded, buffer-only.
+      ecc — sign of iid gaussian rows: injective w.h.p., no byte structure.
+      lsh — sign of the gaussian box-filtered (width 3, replicate-padded) along
+            the byte-value axis: adjacent byte values share ~73% of bits
+            (corr 2/3 -> sign agreement 1 - arccos(2/3)/pi) — the
+            semantic-adjacency proxy for the byte alphabet."""
+    g = torch.Generator().manual_seed(seed_for(f"fac:C:{kind}"))
+    G = torch.randn(bed.VOCAB, CODE_BITS, generator=g, dtype=torch.float64)
+    if kind == "lsh":
+        Gp = torch.cat([G[:1], G, G[-1:]], dim=0)          # replicate pad
+        G = (Gp[:-2] + Gp[1:-1] + Gp[2:]) / 3.0            # width-3 box filter
+    elif kind != "ecc":
+        raise ValueError(f"unknown code table '{kind}' (ecc|lsh)")
+    return torch.where(G >= 0, 1.0, -1.0).float().contiguous()
+
+
+@torch.no_grad()
+def code_collision_rate(C: torch.Tensor, thresh: int = 2) -> float:
+    """Fraction of distinct byte pairs whose codes are within Hamming <= thresh."""
+    ham = (C.shape[1] - C @ C.t()) / 2
+    iu = torch.triu_indices(C.shape[0], C.shape[0], offset=1)
+    return float((ham[iu[0], iu[1]] <= thresh).float().mean())
+
+
+@torch.no_grad()
+def sign_fidelity(book: torch.Tensor, n: int = 3000, seed: int = 0) -> float:
+    """Spearman(sign-code Hamming, true angle) over random pairs on S^(D-1),
+    using the book as the LSH frame — the exp015 content gauge (L-078),
+    reimplemented verbatim-in-spirit (importing exp015 drags its module state)."""
+    A = F.normalize(book.detach().float().cpu(), dim=-1)
+    g = torch.Generator().manual_seed(seed)
+    D = A.shape[1]
+    x = F.normalize(torch.randn(n, D, generator=g), dim=-1)
+    y = F.normalize(torch.randn(n, D, generator=g), dim=-1)
+    ang = torch.arccos((x * y).sum(-1).clamp(-1, 1))
+    ham = (torch.sign(x @ A.T) != torch.sign(y @ A.T)).float().mean(-1)
+    ra = ang.argsort().argsort().float()
+    rb = ham.argsort().argsort().float()
+    ra = (ra - ra.mean()) / ra.std()
+    rb = (rb - rb.mean()) / rb.std()
+    return round(float((ra * rb).mean()), 4)
+
+
+def margin_audit(R: torch.Tensor, t_loss: float, mu: float) -> dict:
+    """The S4 reachability chain, as data: per-axis max |s_k| = ||row_k|| <= 1;
+    v = s/t_loss so per-axis reachable |v_k| = ||row_k||/t_loss; mu must sit
+    strictly inside. (The JOINT target ||C[y]*mu|| = mu*8 exceeds the reachable
+    ||v|| <= 1/t_loss ball — by design the loss is a per-axis margin pull, not
+    an attainable minimum; recorded, not a failure.)"""
+    rn = R.norm(dim=-1)
+    lo, hi = float(rn.min()), float(rn.max())
+    return {"row_norm_min": round(lo, 4), "row_norm_max": round(hi, 4),
+            "v_reach_min": round(lo / t_loss, 4),
+            "v_reach_max": round(hi / t_loss, 4), "t_loss": t_loss, "mu": mu,
+            "per_axis_reachable": bool(mu < lo / t_loss)}
+
+
+# --------------------------------------------------------------------- model
+class FacModel(nn.Module):
+    """Wraps the CERTIFIED bed ByteLM — subclass-free reuse, zero copied math.
+    mode:
+      'addr' — lm = ByteLM('addr_msl64'); lm.head := Identity, so the certified
+               forward RETURNS the pre-readout feats itself (64 slots x D4 =
+               256). Same seed => bit-identical init to the ce arm everywhere
+               except the (removed) readout.
+      'none' — lm = ByteLM('addr_msl64') kept whole (aleph present, UNREAD,
+               gradient-dead); trunk walked via lm's own submodules; feats =
+               plain Linear(d, 64) on the hidden state (orthogonal init,
+               bias-free — the bed's head_proj idiom).
+      'p4'   — lm = ByteLM('addr_head') UNMODIFIED (the certified collapse
+               configuration: K=32, tau=0.1, coefficients->logits). The signed
+               coefficient vector is captured by a forward PRE-HOOK on lm.head,
+               so the two P4 cells have IDENTICAL parameters and identical
+               forward compute — only the loss differs (the coeff->logit head
+               is trainable-but-gradient-dead under FAC).
+    The FAC read: s = normalize(feats) @ R.T (fixed frame), scores = s @ C.T."""
+
+    def __init__(self, mode: str, code: str = "ecc", d: int = 192,
+                 layers: int = 4, block: int = 256, t_loss: float = T_LOSS,
+                 mu: float = MU):
+        super().__init__()
+        self.mode, self.code_kind = mode, code
+        self.t_loss, self.mu = t_loss, mu
+        if mode == "addr":
+            self.lm = bed.ByteLM("addr_msl64", d=d, layers=layers, block=block)
+            in_dim = self.lm.n_slots * 4                    # 256, read off the arm
+            self.lm.head = nn.Identity()                    # readout removed
+        elif mode == "none":
+            self.lm = bed.ByteLM("addr_msl64", d=d, layers=layers, block=block)
+            assert not self.lm.trigram and not self.lm.use_relay
+            self.proj_none = nn.Linear(d, CODE_BITS, bias=False)
+            nn.init.orthogonal_(self.proj_none.weight)
+            in_dim = CODE_BITS
+        elif mode == "p4":
+            self.lm = bed.ByteLM("addr_head", d=d, layers=layers, block=block)
+            in_dim = self.lm.head_addr.K                    # 32
+            self._w = None
+            self.lm.head.register_forward_pre_hook(self._grab)
+        else:
+            raise ValueError(f"unknown mode '{mode}'")
+        self.in_dim = in_dim
+        self.register_buffer("R", orthonormal_frame(
+            CODE_BITS, in_dim, seed_for(f"fac:R:{in_dim}")))
+        self.register_buffer("C", build_code(code))
+
+    def _grab(self, module, inputs):                        # p4 pre-hook
+        self._w = inputs[0]
+
+    def _trunk(self, idx):
+        """The bed's trunk, walked via the wrapped submodules (mode 'none' only
+        — the certified forward would read the aleph, which this arm forbids)."""
+        lm = self.lm
+        x = lm.emb(idx) + lm.pos[:, : idx.shape[1]]
+        for b in lm.blocks:
+            x = b(x)
+        h = lm.nf(x)
+        lm._last_h = h.detach()                             # vitals hookup
+        return h
+
+    def feats(self, idx):
+        if self.mode == "addr":
+            return self.lm(idx)                             # head=Identity -> feats
+        if self.mode == "none":
+            return self.proj_none(self._trunk(idx))
+        _ = self.lm(idx)                                    # head computed, unused
+        return self._w
+
+    def address(self, idx):
+        return F.normalize(self.feats(idx), dim=-1) @ self.R.t()
+
+    def forward(self, idx):
+        return self.address(idx)
+
+    @torch.no_grad()
+    def vitals(self) -> dict:
+        return self.lm.vitals()                             # the bed's own readouts
+
+
+# ---------------------------------------------------------------- loss + eval
+def fac_loss(s, y, C, t_loss: float = T_LOSS, mu: float = MU):
+    """The FAC objective: residual-form cosh-Bregman pull onto the frozen code.
+    L = mean(cosh(clamp(s/t_loss - C[y]*mu, -4, 4)) - 1)  — S2/S3/S5/S6."""
+    v = s / t_loss
+    r = (v - C[y] * mu).clamp(-CLAMP, CLAMP)
+    return (torch.cosh(r) - 1.0).mean()
+
+
+def eval_scores(kind: str, model, x):
+    """Per-token scores on the shared 256-way scale. ce -> the model's own
+    logits; fixed-code kinds -> s @ C.T (raw scores as logits; softmax
+    temperature NOT calibrated — the recorded caveat)."""
+    if kind == "ce":
+        return model(x)
+    s = model.address(x)
+    return s @ model.C.t()
+
+
+def compute_loss(kind: str, model, x, y):
+    """THE single loss site of this bed (mirrors the bed's one F.cross_entropy)."""
+    if kind in ("ce", "ce_fixedcode"):
+        logits = eval_scores(kind, model, x)
+        return F.cross_entropy(logits.reshape(-1, bed.VOCAB), y.reshape(-1))
+    s = model.address(x)
+    return fac_loss(s, y, model.C, model.t_loss, model.mu)
+
+
+@torch.no_grad()
+def evaluate(kind: str, model, va, batch, block, device, g, n_batches=20):
+    model.eval()
+    nll = acc = 0.0
+    for _ in range(n_batches):
+        xv, yv = bed._batch(va, batch, block, device, g)
+        sc = eval_scores(kind, model, xv)
+        nll += float(F.cross_entropy(sc.reshape(-1, bed.VOCAB), yv.reshape(-1)))
+        acc += float((sc.argmax(-1) == yv).float().mean())
+    model.train()
+    return nll / n_batches / math.log(2), acc / n_batches
+
+
+# ---------------------------------------------------------------------- arms
+ARMS = {
+    "ce":               dict(kind="ce", mode=None,
+                             note="certified addr_msl64 incumbent (3-seed 2.4685)"),
+    "ce_fixedcode":     dict(kind="ce_fixedcode", mode="addr",
+                             note="frozen-C readout, CE — THE param-matched control"),
+    "fac_lsh":          dict(kind="fac", mode="addr", code="lsh"),
+    "fac_ecc":          dict(kind="fac", mode="addr", code="ecc"),
+    "fac_none":         dict(kind="fac", mode="none",
+                             note="aleph UNREAD (gradient-dead) — geometry isolation"),
+    "p4_addr_head_ce":  dict(kind="ce", mode="p4ce",
+                             note="certified collapse config + CE (expect ~5.66 bpb, ppl ~1.88/64)"),
+    "p4_addr_head_fac": dict(kind="fac", mode="p4",
+                             note="same params, FAC loss (predict ppl >= 8/64, win|cos| > .99)"),
+}
+
+
+def build_model(arm: str, code: str = "ecc", d: int = 192, layers: int = 4,
+                block: int = 256, t_loss: float = T_LOSS, mu: float = MU):
+    spec = ARMS[arm]
+    if arm == "ce":
+        return bed.ByteLM("addr_msl64", d=d, layers=layers, block=block)
+    if arm == "p4_addr_head_ce":
+        return bed.ByteLM("addr_head", d=d, layers=layers, block=block)
+    return FacModel(spec["mode"], code=spec.get("code", code), d=d,
+                    layers=layers, block=block, t_loss=t_loss, mu=mu)
+
+
+def _trainable(model) -> int:
+    return sum(p.numel() for p in model.parameters() if p.requires_grad)
+
+
+@torch.no_grad()
+def model_vitals(model) -> dict:
+    lm = model.lm if isinstance(model, FacModel) else model
+    return {"vitals": model.vitals(),
+            "sign_fidelity": sign_fidelity(lm.head_addr.codebook),
+            "gates": None}                       # no gates in any FAC arm
+
+
+# ---------------------------------------------------------------------- train
+def train_arm(arm: str, seed: int = 0, steps: int = 2000, batch: int = 32,
+              block: int = 256, d: int = 192, layers: int = 4,
+              device: str = "cuda", data_root: str | None = None,
+              t_loss: float = T_LOSS, mu: float = MU, code: str | None = None,
+              eval_every: int = 500, save: bool = True, lr: float = 3e-4):
+    """Verdict run — GPU only, pure Adam wd=0, ledger JSONL under tools/fac_runs."""
+    if device == "cuda" and not torch.cuda.is_available():
+        raise RuntimeError("Verdict runs are GPU-only (never CPU-train for accuracy).")
+    spec = ARMS[arm]
+    code = code or spec.get("code", "ecc")
+    data_root = data_root or DATA_ROOT
+    base = seed_for(f"{arm}:{seed}")             # crc32(arm + seed index)
+    torch.manual_seed(base)
+    g = torch.Generator().manual_seed(base)
+    tr, va = bed._wikitext_bytes(data_root)
+    print(f"data ready: train {tr.numel():,} bytes, val {va.numel():,} bytes",
+          flush=True)
+    model = build_model(arm, code=code, d=d, layers=layers, block=block,
+                        t_loss=t_loss, mu=mu).to(device)
+    with torch.random.fork_rng():                # S9 honesty line, same init seed
+        torch.manual_seed(base)
+        ce_ref = bed.ByteLM("addr_msl64", d=d, layers=layers, block=block)
+        ce_trainable = _trainable(ce_ref)
+        del ce_ref
+    n_train = _trainable(model)
+    audit = (margin_audit(model.R, t_loss, mu)
+             if isinstance(model, FacModel) else None)
+    if audit is not None and not audit["per_axis_reachable"]:
+        print(f"WARNING: mu={mu} not per-axis reachable at t_loss={t_loss} "
+              f"({audit}) — the margin never engages; consider mu<="
+              f"{0.8 * audit['v_reach_min']:.2f}", flush=True)
+    os.makedirs(RUNS_DIR, exist_ok=True)
+    led = os.path.join(RUNS_DIR, f"{arm}_s{seed}_t{steps}.jsonl")
+    def emit(obj, first=False):
+        with open(led, "w" if first else "a", encoding="utf-8") as f:
+            f.write(json.dumps(obj) + "\n")
+    emit({"event": "config", "arm": arm, "seed": seed, "base_seed": base,
+          "steps": steps, "batch": batch, "block": block, "d": d,
+          "layers": layers, "lr": lr, "t_loss": t_loss, "mu": mu,
+          "code": (code if isinstance(model, FacModel) else None),
+          "margin_audit": audit, "params_trainable": n_train,
+          "params_trainable_ce_ref": ce_trainable,
+          "param_delta_vs_ce": ce_trainable - n_train,
+          "readout_note": {
+              "ce": "trained Linear(256,256) readout",
+              "ce_fixedcode": "frozen C readout — ZERO trainable readout params",
+              "fac_lsh": "frozen C readout — ZERO trainable readout params",
+              "fac_ecc": "frozen C readout — ZERO trainable readout params",
+              "fac_none": "frozen C readout; aleph head params present but UNREAD",
+              "p4_addr_head_ce": "trained Linear(32,256) coeff->logit head",
+              "p4_addr_head_fac": "identical params to the ce cell; coeff->logit "
+                                  "head computed but gradient-dead under FAC",
+          }[arm], "partition_note": "bpb uses raw s@C.T scores as logits "
+          "(log_softmax); softmax temperature NOT calibrated — caveat",
+          "torch": torch.__version__, "device": device,
+          "note": spec.get("note", "")}, first=True)
+    if device == "cuda":
+        torch.cuda.reset_peak_memory_stats()
+    opt = torch.optim.Adam(model.parameters(), lr=lr, weight_decay=0.0)
+    kind, curve, t0, bpb, acc = spec["kind"], [], time.time(), None, None
+    for step in range(1, steps + 1):
+        x, y = bed._batch(tr, batch, block, device, g)
+        loss = compute_loss(kind, model, x, y)
+        opt.zero_grad(set_to_none=True)
+        loss.backward()
+        opt.step()
+        if step == 1 or step % 100 == 0:
+            curve.append([step, round(float(loss), 5)])
+        if step % eval_every == 0 or step == steps:
+            bpb, acc = evaluate(kind, model, va, batch, block, device, g)
+            vit = model_vitals(model)
+            emit({"event": "eval", "step": step, "bpb": round(bpb, 4),
+                  "decoded_acc": round(acc, 4), **vit})
+            print(f"[{arm} s{seed}] step {step} bpb={bpb:.4f} acc={acc:.4f} "
+                  f"vitals={vit['vitals']}", flush=True)
+    losses = [c[1] for c in curve]
+    final = {"event": "final", "arm": arm, "seed": seed, "steps": steps,
+             "t_loss": t_loss, "mu": mu,
+             "code": (code if isinstance(model, FacModel) else None),
+             "bpb": round(bpb, 4), "decoded_acc": round(acc, 4),
+             "collision_rate": (code_collision_rate(model.C.cpu())
+                                if isinstance(model, FacModel) else None),
+             "train_curve": {"first": losses[0], "final": losses[-1],
+                             "min": min(losses), "every100": curve},
+             **model_vitals(model),
+             "wall_s": round(time.time() - t0, 1),
+             "peak_mem_gb": (round(torch.cuda.max_memory_allocated() / 2**30, 3)
+                             if device == "cuda" else 0.0),
+             "params_trainable": n_train,
+             "param_delta_vs_ce": ce_trainable - n_train,
+             "mu_note": "mu in v-units; per-axis reachability audited at config; "
+                        "joint target ||C[y]*mu||=8 exceeds ||v||<=1/t_loss — "
+                        "per-axis margin pull by design"}
+    emit(final)
+    print(json.dumps(final), flush=True)
+    if save:
+        ck = os.path.join(data_root, "fac_ckpts")
+        os.makedirs(ck, exist_ok=True)
+        path = os.path.join(ck, f"{arm}_s{seed}_t{steps}.pt")
+        torch.save({"arm": arm, "seed": seed, "steps": steps, "bpb": bpb,
+                    "state_dict": {k: v.cpu() for k, v in
+                                   model.state_dict().items()}}, path)
+        print(f"saved specimen: {path}", flush=True)
+    return final
+
+
+# ---------------------------------------------------------------------- bench
+def bench(arm: str = "fac_lsh", steps: int = 20, warmup: int = 5,
+          batch: int = 32, block: int = 256, device: str = "cuda",
+          data_root: str | None = None):
+    """~20-step throughput probe at the full operating point -> min/2000 steps.
+    Falls back to synthetic random bytes if the parquet cache is unreachable
+    (identical compute — the batch path indexes a flat uint8 tensor either way)."""
+    if device == "cuda" and not torch.cuda.is_available():
+        raise RuntimeError("bench is a GPU probe")
+    try:
+        tr, _ = bed._wikitext_bytes(data_root or DATA_ROOT)
+        src = "wikitext-2-raw"
+    except Exception as e:
+        g0 = torch.Generator().manual_seed(seed_for("fac:bench:data"))
+        tr = torch.randint(0, 256, (2_000_000,), generator=g0,
+                           dtype=torch.uint8)
+        src = f"synthetic ({type(e).__name__})"
+    torch.manual_seed(seed_for(f"{arm}:bench"))
+    g = torch.Generator().manual_seed(seed_for(f"{arm}:bench"))
+    model = build_model(arm).to(device)
+    kind = ARMS[arm]["kind"]
+    opt = torch.optim.Adam(model.parameters(), lr=3e-4, weight_decay=0.0)
+    if device == "cuda":
+        torch.cuda.reset_peak_memory_stats()
+    for _ in range(warmup):
+        x, y = bed._batch(tr, batch, block, device, g)
+        loss = compute_loss(kind, model, x, y)
+        opt.zero_grad(set_to_none=True); loss.backward(); opt.step()
+    if device == "cuda":
+        torch.cuda.synchronize()
+    t0 = time.time()
+    for _ in range(steps):
+        x, y = bed._batch(tr, batch, block, device, g)
+        loss = compute_loss(kind, model, x, y)
+        opt.zero_grad(set_to_none=True); loss.backward(); opt.step()
+    if device == "cuda":
+        torch.cuda.synchronize()
+    sec = (time.time() - t0) / steps
+    peak = (torch.cuda.max_memory_allocated() / 2**30) if device == "cuda" else 0.0
+    print(f"BENCH [{arm}] data={src} {sec*1000:.1f} ms/step -> "
+          f"{sec*2000/60:.1f} min / 2000 steps (+~{20*sec:.0f}s eval overhead); "
+          f"peak {peak:.2f} GB", flush=True)
+    return {"arm": arm, "ms_per_step": sec * 1000,
+            "min_per_2000": sec * 2000 / 60, "peak_gb": peak, "data": src}
+
+
+# ------------------------------------------------------------- smoke battery
+RESULTS = []
+def record(tid, name, ok, detail=""):
+    RESULTS.append((tid, name, "PASS" if ok else "FAIL", detail))
+    return ok
+
+
+def run_smokes() -> bool:
+    """FORMULA smokes only — shapes, gradients, identities, fp32 safety,
+    causality, param honesty. NO training, ever (MANIFEST rider); the S3
+    minimizer probe optimizes one free 64-vector, not a model."""
+    del RESULTS[:]
+    t0 = time.time()
+    sd, sl, sb = 96, 2, 64                                  # small config
+
+    # S0 — feats-dim truth: the certified addr_msl64 read is 64 slots x D4.
+    torch.manual_seed(seed_for("fac:s0"))
+    m_addr = FacModel("addr", "lsh", d=sd, layers=sl, block=sb).to(DEV)
+    record("S0", "feats match the certified addr_msl64 read",
+           m_addr.in_dim == 256 and m_addr.lm.n_slots == 64,
+           "64 slots x D=4 = 256-dim feats (bed code authoritative; spec's "
+           "'P=16' guess corrected) -> R is 64x256 orthonormal-rows")
+
+    # S1 — gradient flow: FAC backward reaches the aleph codebook AND the slot
+    # projection (the tied-M_hat failure would show a near-zero codebook grad).
+    g1 = torch.Generator().manual_seed(seed_for("fac:s1"))
+    seq = torch.randint(0, 256, (2, sb + 1), generator=g1)
+    x, y = seq[:, :-1].to(DEV), seq[:, 1:].to(DEV)
+    loss = fac_loss(m_addr.address(x), y, m_addr.C)
+    loss.backward()
+    g_cb = float(m_addr.lm.head_addr.codebook.grad.norm())
+    g_pj = float(m_addr.lm.head_proj.weight.grad.norm())
+    g_em = float(m_addr.lm.emb.weight.grad.norm())
+    record("S1", "FAC gradient flow (codebook + slot proj + trunk)",
+           g_cb > 0 and g_pj > 0 and g_em > 0
+           and all(map(math.isfinite, (g_cb, g_pj, g_em))),
+           "|g| codebook %.2e, head_proj %.2e, emb %.2e — all nonzero/finite"
+           % (g_cb, g_pj, g_em))
+
+    # S2 — Bregman identity. Phi = sum cosh. The implemented loss is the
+    # RESIDUAL-form divergence D_Phi(r, 0) = cosh(r) - cosh(0) - sinh(0)*r
+    # = cosh(r) - 1 ("up to the constant" = cosh(0)). The target-anchored
+    # D_Phi(v, v*) is a different function (equal only at v* = 0) — its gap is
+    # reported so the 'cosh-Bregman' name stays honest.
+    g2 = torch.Generator().manual_seed(seed_for("fac:s2"))
+    r = torch.empty(4096, dtype=torch.float64).uniform_(-3.9, 3.9, generator=g2)
+    d_res = float((torch.cosh(r) - math.cosh(0.0) - math.sinh(0.0) * r
+                   - (torch.cosh(r) - 1.0)).abs().max())
+    vs = torch.where(torch.rand(4096, generator=g2) > 0.5, 1.0, -1.0).double()
+    v = r + vs
+    d_anchor = float((torch.cosh(v) - torch.cosh(vs) - torch.sinh(vs) * (v - vs)
+                      - (torch.cosh(v - vs) - 1.0)).abs().max())
+    record("S2", "Bregman identity (residual form, up to cosh(0))",
+           d_res <= 1e-6,
+           "residual-form dev %.1e; target-anchored D_Phi(v,c*mu) differs by "
+           "up to %.2f — loss is D_Phi(v - C[y]mu, 0), coincides at v*=0"
+           % (d_res, d_anchor))
+
+    # S3 — minimizer identity: 200 Adam steps on a free 64-vector -> the code.
+    C_ecc = build_code("ecc")
+    g3 = torch.Generator().manual_seed(seed_for("fac:s3"))
+    y0 = int(torch.randint(0, 256, (1,), generator=g3))
+    target = C_ecc[y0] * MU
+    vfree = nn.Parameter(torch.zeros(CODE_BITS))
+    # pure Adam wd=0; beta2=0.9 so the second-moment memory (1000-step at the
+    # default 0.999) cannot suppress late updates inside a 200-step anneal —
+    # measured: default betas freeze the error at ~3e-3.
+    opt3 = torch.optim.Adam([vfree], lr=1.0, betas=(0.9, 0.9), weight_decay=0.0)
+    for _ in range(200):
+        l3 = (torch.cosh((vfree - target).clamp(-CLAMP, CLAMP)) - 1.0).mean()
+        opt3.zero_grad(set_to_none=True)
+        l3.backward()
+        opt3.step()
+        for pg in opt3.param_groups:
+            pg["lr"] *= 0.93                     # anneal; Adam alone orbits at lr
+    err3 = float((vfree.detach() - target).abs().max())
+    record("S3", "minimizer identity (free v -> C[y]*mu)",
+           err3 < 1e-4, "||v - C[y]mu||_inf = %.1e after 200 Adam steps" % err3)
+
+    # S4 — margin reachability chain. |s_k| <= ||R row_k|| <= 1 (R construction);
+    # v = s/t_loss -> per-axis reachable |v_k| = ||row_k||/0.3 (=3.33 for the
+    # orthonormal-row frames); mu = 1.0 sits strictly inside for ALL frames,
+    # and a perfectly-aligned s pulls strictly toward the target on every axis.
+    # DECISION: mu stays 1.0 (in v-units; the s-unit boundary worry dissolves
+    # because the margin lives in v-space).
+    frames = {n: orthonormal_frame(CODE_BITS, i, seed_for(f"fac:R:{i}"))
+              for n, i in (("addr", 256), ("none", 64), ("p4", 32))}
+    audits = {n: margin_audit(Rf, T_LOSS, MU) for n, Rf in frames.items()}
+    ortho_dev = max(
+        float((frames["addr"] @ frames["addr"].t()
+               - torch.eye(CODE_BITS)).abs().max()),
+        float((frames["none"] @ frames["none"].t()
+               - torch.eye(CODE_BITS)).abs().max()),
+        float((frames["p4"].t() @ frames["p4"]
+               - torch.eye(32)).abs().max()))
+    s_align = C_ecc[y0] / math.sqrt(CODE_BITS)              # unit, code-aligned
+    pull = -torch.sinh((s_align / T_LOSS - C_ecc[y0] * MU).clamp(-CLAMP, CLAMP)
+                       ) * C_ecc[y0]
+    ok4 = (all(a["per_axis_reachable"] for a in audits.values())
+           and all(a["row_norm_max"] <= 1.0 + 1e-5 for a in audits.values())
+           and ortho_dev < 1e-5 and bool((pull > 0).all()))
+    record("S4", "margin reachability (mu=1.0 KEPT, v-units)", ok4,
+           "v-reach addr/none/p4 = %.2f/%.2f/%.2f > mu=1; ortho dev %.0e; "
+           "aligned-s pull > 0 on 64/64 axes"
+           % (audits["addr"]["v_reach_min"], audits["none"]["v_reach_min"],
+              audits["p4"]["v_reach_min"], ortho_dev))
+
+    # S5 — antipodal invariance: L(v, c) == L(-v, -c) bit-exact.
+    g5 = torch.Generator().manual_seed(seed_for("fac:s5"))
+    s5 = (torch.randn(4, 32, CODE_BITS, generator=g5) * 0.4).to(DEV)
+    y5 = torch.randint(0, 256, (4, 32), generator=g5).to(DEV)
+    C5 = C_ecc.to(DEV)
+    la, lb = fac_loss(s5, y5, C5), fac_loss(-s5, y5, -C5)
+    record("S5", "antipodal invariance L(v,c)==L(-v,-c)",
+           bool(torch.equal(la, lb)),
+           "bit-exact on %s: %.6f == %.6f" % (DEV, float(la), float(lb)))
+
+    # S6 — fp32 overflow: finite loss AND gradient over the full reachable |v|
+    # range (t_loss down to 0.1 -> |v| <= 10, swept to 12) with the clamp; the
+    # zero-feats normalize edge is finite too.
+    v6 = torch.linspace(-12.0, 12.0, 100001).requires_grad_(True)
+    l6 = (torch.cosh((v6 - 1.0).clamp(-CLAMP, CLAMP)) - 1.0).sum()
+    l6.backward()
+    z = F.normalize(torch.zeros(3, CODE_BITS), dim=-1) @ frames["none"].t()
+    ok6 = (bool(torch.isfinite(l6)) and bool(torch.isfinite(v6.grad).all())
+           and bool(torch.isfinite(z).all()))
+    record("S6", "fp32 safety across the reachable v-range",
+           ok6, "cosh capped at cosh(4)=%.1f; grad finite on [-12,12]; "
+           "zero-feats normalize edge finite" % math.cosh(CLAMP))
+
+    # S7 — decode consistency: planted s = C[y]*t_loss*mu -> argmax score == y,
+    # 1000 draws under fac_ecc (assert); lsh failure rate reported, not gated.
+    g7 = torch.Generator().manual_seed(seed_for("fac:s7"))
+    y7 = torch.randint(0, 256, (1000,), generator=g7)
+    acc_ecc = float(((C_ecc[y7] * T_LOSS * MU) @ C_ecc.t()
+                     ).argmax(-1).eq(y7).float().mean())
+    C_lsh = build_code("lsh")
+    acc_lsh = float(((C_lsh[y7] * T_LOSS * MU) @ C_lsh.t()
+                     ).argmax(-1).eq(y7).float().mean())
+    adj = float((C_lsh[:-1] == C_lsh[1:]).float().mean())
+    record("S7", "decode consistency (planted code -> argmax)",
+           acc_ecc == 1.0,
+           "ecc 1000/1000; lsh fail rate %.4f (report-only); collisions@H<=2 "
+           "ecc %.1e lsh %.1e; lsh adjacent-byte bit-share %.3f"
+           % (1.0 - acc_lsh, code_collision_rate(C_ecc),
+              code_collision_rate(C_lsh), adj))
+
+    # S8 — causality: the bed's future-leak check, replicated on every FAC
+    # read path (addr / none / p4): a future byte must not move past scores.
+    leaks = {}
+    for mode in ("addr", "none", "p4"):
+        torch.manual_seed(seed_for(f"fac:s8:{mode}"))
+        m8 = FacModel(mode, "ecc", d=sd, layers=sl, block=sb).to(DEV).eval()
+        g8 = torch.Generator().manual_seed(seed_for("fac:s8:x"))
+        x8 = torch.randint(0, 256, (2, sb), generator=g8).to(DEV)
+        with torch.no_grad():
+            a = (m8.address(x8) @ m8.C.t())[0, 10]
+            x8b = x8.clone()
+            x8b[0, 40] = (x8b[0, 40] + 7) % 256
+            b = (m8.address(x8b) @ m8.C.t())[0, 10]
+        leaks[mode] = float((a - b).abs().max())
+    record("S8", "causality (no future leak, all FAC read paths)",
+           all(v <= 1e-4 for v in leaks.values()),
+           "max |dscore@t=10| after t=40 edit: " +
+           ", ".join(f"{k} {v:.1e}" for k, v in leaks.items()))
+
+    # S9 — toggle/param-match honesty at the full operating point (d=192, L=4):
+    # ce_fixedcode == ce minus EXACTLY the readout table; zero trainable
+    # readout params; the two P4 cells are parameter-IDENTICAL.
+    with torch.random.fork_rng():
+        torch.manual_seed(seed_for("fac:s9"))
+        ce_ref = bed.ByteLM("addr_msl64")
+        torch.manual_seed(seed_for("fac:s9"))
+        fc = FacModel("addr", "ecc")
+        torch.manual_seed(seed_for("fac:s9"))
+        p4c = bed.ByteLM("addr_head")
+        torch.manual_seed(seed_for("fac:s9"))
+        p4f = FacModel("p4", "ecc")
+    head_n = ce_ref.head.weight.numel() + ce_ref.head.bias.numel()
+    tr_ce, tr_fc = _trainable(ce_ref), _trainable(fc)
+    fc_readout = 0 if isinstance(fc.lm.head, nn.Identity) else -1
+    record("S9", "param match (readout delta exact; P4 cells identical)",
+           tr_ce - tr_fc == head_n == 65792 and fc_readout == 0
+           and _trainable(p4c) == _trainable(p4f),
+           "ce %s vs ce_fixedcode %s (delta %s == readout %s; fixed-code "
+           "readout trainable=0); p4 pair %s == %s"
+           % (f"{tr_ce:,}", f"{tr_fc:,}", f"{tr_ce - tr_fc:,}",
+              f"{head_n:,}", f"{_trainable(p4c):,}", f"{_trainable(p4f):,}"))
+
+    # ------------------------------------------------------------------ table
+    wall = time.time() - t0
+    peak = (torch.cuda.max_memory_allocated() / 2**30) if DEV == "cuda" else 0.0
+    print("\nFAC FORMULA-SMOKE BATTERY  (%s, %.1fs, peak %.2f GB)"
+          % (DEV, wall, peak))
+    print("-" * 100)
+    npass = nfail = 0
+    for tid, name, st, detail in RESULTS:
+        npass += st == "PASS"
+        nfail += st == "FAIL"
+        print("%-5s %-4s %-46s %s" % (tid, st, name[:46], detail))
+    print("-" * 100)
+    print("PASS %d  FAIL %d  SKIP %d" % (npass, nfail,
+                                         len(RESULTS) - npass - nfail))
+    return nfail == 0
+
+
+def print_launch_matrix(steps: int = 2000):
+    print("\nARM MATRIX (verdict runs — NOT launched by this bed; P4 cells first):")
+    py = ".venv/Scripts/python.exe"
+    for arm in ("p4_addr_head_ce", "p4_addr_head_fac"):
+        print(f"  {py} tools/fac_bed.py --arm {arm} --seed 0")
+    for arm in ("ce", "ce_fixedcode", "fac_lsh", "fac_ecc", "fac_none"):
+        for seed in (0, 1, 2):
+            print(f"  {py} tools/fac_bed.py --arm {arm} --seed {seed}")
+    print("  # knobs: --steps N | --t_loss {0.1,0.3,1.0} | --mu M | --code {ecc,lsh}")
+
+
+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():
+        _ok = run_smokes()
+        print_launch_matrix()
+        print("Notebook mode: train_arm('fac_lsh', seed=0) in the next cell (GPU).")
+    else:
+        import argparse
+        ap = argparse.ArgumentParser()
+        ap.add_argument("--arm", type=str, default=None, choices=sorted(ARMS))
+        ap.add_argument("--seed", type=int, default=0)
+        ap.add_argument("--steps", type=int, default=2000)
+        ap.add_argument("--smoke", action="store_true")
+        ap.add_argument("--bench", action="store_true")
+        ap.add_argument("--t_loss", type=float, default=T_LOSS)
+        ap.add_argument("--mu", type=float, default=MU)
+        ap.add_argument("--code", type=str, default=None, choices=("ecc", "lsh"))
+        ap.add_argument("--data_root", type=str, default=None)
+        ap.add_argument("--device", type=str, default="cuda")
+        a, _ = ap.parse_known_args()
+        if a.bench:
+            bench(steps=20, device=a.device, data_root=a.data_root)
+        elif a.arm and not a.smoke:
+            train_arm(a.arm, seed=a.seed, steps=a.steps, device=a.device,
+                      data_root=a.data_root, t_loss=a.t_loss, mu=a.mu,
+                      code=a.code)
+        else:
+            ok = run_smokes()
+            print_launch_matrix(a.steps)
+            sys.exit(0 if ok else 1)

code/geobasin_bed.py

@@ -0,0 +1,258 @@
+"""geobasin_bed.py — the CE-replacement geometric arm, reconstructed and
+properly tested. #TAG:geobasin #TAG:ce_replacement #TAG:loss_campaign
+
+RECONSTRUCTION PROVENANCE (2026-07-25): the Oct '25 arm survives VERBATIM in
+the installed package — geofractal.losses.pure_geometric (PureGeometricLoss:
+attraction (1-s_y)^2 + repulsion sum(s_c^2) + margin hinge + range clamp;
+GeometricPrototypeLoss; HierarchicalGeometricLoss) and the GBC 4-factor
+compatibility head in geofractal/model/experiment_geometric_basin.py.
+L-031's "term forms NOT recorded" and L-032's "unbuilt" are both CLOSED.
+Losses are IMPORTED from the package, never rewritten (reuse law).
+
+THE TEST (the ce_fixedcode lesson: isolate the LOSS by holding the head
+identical): all arms share one cosine-anchor score head on the certified
+addr_msl64 read — s = normalize(feats); scores_c = (cos(s, A_c)+1)/2,
+A: (256 classes x 256), ~param-matched to the ce head (65,536 vs 65,792).
+CE arms consume cos*10 as logits (fixed scale, disclosed).
+
+ARMS: geo_ce_scores (CE on the SAME head - the decisive control) | geo_pure
+(verbatim, learned anchors) | geo_pure_frozen (L-108 cell) | geo_pure_norep
+(attraction+range ONLY - the absolute-only, doctrine-clean variant; repulsion
++margin are roster-comparative terms) | geo_proto (verbatim, own projector -
+extra params disclosed) | geo_hier (nibble hierarchy 16x16 - bytes' natural
+coarse structure) | geo_hybrid (0.5 CE + 0.5 PureGeometric).
+
+PREREG (3 seeds; baselines ce 2.4769/acc .505): P1 the Oct'25 trade was -12%
+relative accuracy - geo_pure within -12% of geo_ce_scores matches history,
+parity overturns it, acc<0.30 refutes viability. P2 (L-108): learned anchors
+show a collapse signature vs frozen; falsifier: learned > frozen by >2 pts.
+P3 (absolute-beats-relative): norep >= pure - noise; falsifier: pure beats
+norep by >2 pts (the comparative terms would be load-bearing - a scope
+amendment to the law). P4: hybrid bpb within 0.15 of geo_ce_scores.
+
+Run:  python tools/geobasin_bed.py --arm <name> --seed N  |  --list
+"""
+import json
+import math
+import os
+import sys
+import time
+import zlib
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+def _root():
+    d = os.path.abspath(os.getcwd())
+    while True:
+        if os.path.exists(os.path.join(d, "MANIFEST.md")):
+            return d
+        p = os.path.dirname(d)
+        if p == d:
+            return os.getcwd()
+        d = p
+
+ROOT = _root()
+if os.path.join(ROOT, "tools") not in sys.path:
+    sys.path.insert(0, os.path.join(ROOT, "tools"))
+
+import ar_differentiation_bed as bed                             # noqa: E402
+from geofractal.losses.pure_geometric import (                   # noqa: E402
+    GeometricPrototypeLoss, HierarchicalGeometricLoss, PureGeometricLoss)
+from loss_forms import prim_ce                                   # noqa: E402
+
+torch.backends.cuda.matmul.allow_tf32 = False
+torch.backends.cudnn.allow_tf32 = False
+DEV = "cuda" if torch.cuda.is_available() else "cpu"
+if DEV == "cuda":
+    torch.cuda.set_per_process_memory_fraction(0.73)
+
+DATA_ROOT = os.environ.get("GEOLIP_DATA", "./data")
+RUNS = os.path.join(ROOT, "tools", "geobasin_runs")
+CE_SCALE = 10.0
+
+def seed_for(name):
+    return zlib.crc32(name.encode()) & 0x7FFFFFFF
+
+ARMS = ("geo_ce_scores", "geo_pure", "geo_pure_frozen", "geo_pure_norep",
+        "geo_proto", "geo_hier", "geo_hybrid")
+
+
+class FastHierarchical(HierarchicalGeometricLoss):
+    """Vectorizes ONLY the per-sample fine_mask loop (a 60x Python-loop
+    slowdown at B*T=8192); every formula identical — parity-asserted against
+    the verbatim original at build time."""
+    def forward(self, compatibility_scores, labels, mixed_labels=None,
+                lam=None):
+        if mixed_labels is not None:
+            return super().forward(compatibility_scores, labels,
+                                   mixed_labels, lam)
+        B = compatibility_scores.shape[0]
+        dev = compatibility_scores.device
+        sl = labels // self.subclasses_per_super
+        scores_r = compatibility_scores.view(B, self.num_superclasses,
+                                             self.subclasses_per_super)
+        ss = scores_r.sum(dim=2)
+        coarse_correct = ss[torch.arange(B, device=dev), sl]
+        ct = float(self.subclasses_per_super)
+        coarse_loss = ((coarse_correct - ct) / ct).pow(2).mean()
+        cmask = torch.ones_like(ss)
+        cmask[torch.arange(B, device=dev), sl] = 0
+        coarse_rep = (ss * cmask).pow(2).sum(dim=1).mean()
+        fine_correct = compatibility_scores[torch.arange(B, device=dev), labels]
+        fine_loss = (1.0 - fine_correct).pow(2).mean()
+        # vectorized fine_mask: ones on the label's superclass block, zero at
+        # the label column (identical to the original's per-sample loop)
+        cols = (sl * self.subclasses_per_super).unsqueeze(1) + \
+            torch.arange(self.subclasses_per_super, device=dev).unsqueeze(0)
+        fmask = torch.zeros_like(compatibility_scores)
+        fmask.scatter_(1, cols, 1.0)
+        fmask[torch.arange(B, device=dev), labels] = 0
+        fine_rep = (compatibility_scores * fmask).pow(2).sum(dim=1).mean()
+        consistency = F.relu(fine_correct * 2 - coarse_correct).mean()
+        w_c = torch.sigmoid(self.coarse_weight)
+        w_f = torch.sigmoid(self.fine_weight)
+        return (w_c * (coarse_loss + 0.3 * coarse_rep)
+                + w_f * (fine_loss + 0.3 * fine_rep) + 0.2 * consistency)
+
+
+class ScoreHead(nn.Module):
+    """The shared cosine-anchor basin head. scores in [0,1] per class."""
+    def __init__(self, dim=256, classes=256, frozen=False, gen=None):
+        super().__init__()
+        A = torch.randn(classes, dim, generator=gen)
+        if frozen:
+            self.register_buffer("A", F.normalize(A, dim=-1))
+        else:
+            self.A = nn.Parameter(A)
+
+    def cos(self, feats):
+        return F.normalize(feats, dim=-1) @ F.normalize(self.A, dim=-1).t()
+
+    def forward(self, feats):
+        return (self.cos(feats) + 1) / 2
+
+
+def build(arm, seed):
+    torch.manual_seed(seed_for(f"geobasin:{arm}:{seed}"))
+    lm = bed.ByteLM("addr_msl64").to(DEV)
+    lm.head = nn.Identity()                       # forward -> 256-d msl feats
+    gh = torch.Generator().manual_seed(seed_for(f"geobasin-head:{seed}"))
+    head = ScoreHead(frozen=(arm == "geo_pure_frozen"), gen=gh).to(DEV)
+    aux = None
+    if arm == "geo_proto":
+        aux = GeometricPrototypeLoss(num_classes=256, prototype_dim=64).to(DEV)
+    elif arm == "geo_hier":
+        aux = FastHierarchical(num_classes=256, num_superclasses=16).to(DEV)
+        # parity vs the VERBATIM original on a random batch (reference-check
+        # pattern): the vectorization must be mathematics-identical
+        ref = HierarchicalGeometricLoss(num_classes=256,
+                                        num_superclasses=16).to(DEV)
+        ref.load_state_dict(aux.state_dict())
+        gpar = torch.Generator().manual_seed(seed_for("hier-parity"))
+        sc = torch.rand(16, 256, generator=gpar).to(DEV)
+        yy = torch.randint(0, 256, (16,), generator=gpar).to(DEV)
+        assert torch.allclose(aux(sc, yy), ref(sc, yy), atol=1e-6), \
+            "FastHierarchical diverged from the verbatim original"
+    elif arm != "geo_ce_scores":
+        aux = PureGeometricLoss()                 # stateless
+    params = list(lm.parameters()) + list(head.parameters())
+    if aux is not None:
+        params += list(aux.parameters())
+    return lm, head, aux, [p for p in params if p.requires_grad]
+
+
+def loss_of(arm, head, aux, feats, y):
+    scores = head(feats).reshape(-1, 256)
+    yy = y.reshape(-1)
+    if arm == "geo_ce_scores":
+        return prim_ce((scores * 2 - 1).reshape(*y.shape, 256) * CE_SCALE, y).mean()
+    if arm == "geo_hybrid":
+        ce = prim_ce((scores * 2 - 1).reshape(*y.shape, 256) * CE_SCALE, y).mean()
+        return 0.5 * ce + 0.5 * PureGeometricLoss()(scores, yy)
+    if arm == "geo_pure_norep":
+        B = scores.shape[0]
+        correct = scores[torch.arange(B, device=scores.device), yy]
+        attraction = (1.0 - correct).pow(2).mean()          # verbatim term 1
+        rng = F.relu(scores - 1.0).pow(2).mean() \
+            + F.relu(-scores).pow(2).mean()                 # verbatim term 4
+        return attraction + 0.1 * rng                       # comparative terms DROPPED
+    return aux(scores, yy)                                  # verbatim package losses
+
+
+@torch.no_grad()
+def evaluate(head, lm, va, g):
+    lm.eval()
+    tot_ce, tot_ok, n = 0.0, 0, 0
+    for _ in range(8):
+        x, y = bed._batch(va, 32, 256, DEV, g)
+        cos = head.cos(lm(x))
+        lp = F.log_softmax(cos * CE_SCALE, -1)
+        tot_ce += float(-lp.gather(-1, y.unsqueeze(-1)).sum())
+        tot_ok += int((cos.argmax(-1) == y).sum())
+        n += y.numel()
+    x, _ = bed._batch(va, 8, 256, DEV, g)
+    _ = lm(x)
+    v = lm.head_addr.vitals(lm.head_proj(lm._last_h).view(
+        *lm._last_h.shape[:-1], lm.n_slots, 4))
+    lm.train()
+    return (tot_ce / n) / math.log(2), tot_ok / n, v
+
+
+def train_arm(arm, seed, steps=2000):
+    assert arm in ARMS, f"unknown arm {arm}"
+    os.makedirs(RUNS, exist_ok=True)
+    tr, va = bed._wikitext_bytes(DATA_ROOT)
+    lm, head, aux, params = build(arm, seed)
+    g = torch.Generator().manual_seed(seed_for(f"geobasin-data:{arm}:{seed}"))
+    ge = torch.Generator().manual_seed(seed_for("geobasin-eval"))
+    opt = torch.optim.Adam(params, lr=3e-4, weight_decay=0.0)
+    t0 = time.time()
+    # anchor-collapse gauge: pairwise |cos| spread of A at start vs end
+    def anchor_spread():
+        An = F.normalize(head.A.detach(), dim=-1)
+        pc = (An @ An.t()).abs()
+        off = pc[~torch.eye(256, dtype=torch.bool, device=pc.device)]
+        return float(off.mean())
+    sp0 = anchor_spread()
+    for step in range(steps):
+        x, y = bed._batch(tr, 32, 256, DEV, g)
+        opt.zero_grad(set_to_none=True)
+        L = loss_of(arm, head, aux, lm(x), y)
+        L.backward()
+        opt.step()
+        if step == 10 and DEV == "cuda":
+            print(f"[{arm} s{seed}] step10 loss {float(L.detach()):.4f} "
+                  f"peak {torch.cuda.max_memory_allocated()/2**30:.2f}GB",
+                  flush=True)
+    bpb, acc, vit = evaluate(head, lm, va, ge)
+    rec = {"arm": arm, "seed": seed, "steps": steps, "bpb": round(bpb, 4),
+           "decoded_acc": round(acc, 4),
+           "anchor_abs_cos_mean_init": round(sp0, 4),
+           "anchor_abs_cos_mean_final": round(anchor_spread(), 4),
+           "vitals": vit, "wall_s": round(time.time() - t0, 1),
+           "n_params_extra": sum(p.numel() for p in aux.parameters())
+           if aux is not None and any(True for _ in aux.parameters()) else 0}
+    out = os.path.join(RUNS, f"{arm}_s{seed}_t{steps}.jsonl")
+    with open(out, "a", encoding="utf-8") as f:
+        f.write(json.dumps(rec) + "\n")
+    print(f"[DONE {arm} s{seed}] bpb {bpb:.4f} acc {acc:.4f} "
+          f"anchors |cos| {sp0:.3f}->{rec['anchor_abs_cos_mean_final']:.3f} "
+          f"({rec['wall_s']}s)", flush=True)
+    return rec
+
+
+if __name__ == "__main__":
+    import argparse
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--arm", default=None)
+    ap.add_argument("--seed", type=int, default=0)
+    ap.add_argument("--steps", type=int, default=2000)
+    ap.add_argument("--list", action="store_true")
+    a, _ = ap.parse_known_args()
+    if a.list or not a.arm:
+        print("arms:", " ".join(ARMS))
+        sys.exit(0)
+    train_arm(a.arm, a.seed, a.steps)

code/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 (the operator: 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)
+    tsuccessors = torch.stack([ref.forward(p.double())["volume"].float() for p in pts])
+    rel = ((mine - tsuccessors).abs() / tsuccessors.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)")

code/loss_forms.py

@@ -0,0 +1,575 @@
+"""loss_forms.py — the composable loss library of the loss campaign. #TAG:loss_forms #TAG:accumulation
+Every RUNNABLE loss form in one place: the four differencing primitives, the
+accumulation formats A0-A8 as composable functions, the candidate losses
+(FAC, PWA weights, compartment roles, latent-chain), and a self-smoke.
+
+Deliberately ABSENT, by statute (inventory/LOSS_MANIFEST.md):
+  A9  sum-no-norm        — scale rides on batch/seq; lr stops transferring.
+  A10 EMA/cross-step     — the VQ/commitment/load-balancing failure class.
+  InfoNCE into address paths — legal only as a readout head (L-113 / L-017).
+
+House laws honored throughout: pure Adam wd=0 (constructor not included here —
+use amoe.laws.make_optimizer); fp32/TF32-off; crc32 seeds never hash(); CV is a
+readout never a force; masking never renormalizes; gauges fp64.
+
+Colab-cell-safe: no argparse side effects, no __file__ logic.
+Smoke:  python tools/loss_forms.py
+"""
+import math
+import os
+import sys
+import zlib
+
+import torch
+import torch.nn.functional as F
+
+
+def _root():
+    d = os.path.abspath(os.getcwd())
+    while True:
+        if os.path.exists(os.path.join(d, "MANIFEST.md")):
+            return d
+        p = os.path.dirname(d)
+        if p == d:
+            return os.getcwd()
+        d = p
+
+for _p in (os.path.join(_root(), "tools"),):
+    if os.path.isdir(_p) and _p not in sys.path:
+        sys.path.insert(0, _p)
+
+def seed_for(name: str) -> int:
+    return zlib.crc32(name.encode("utf-8")) & 0x7FFFFFFF
+
+
+# ============================================================= PRIMITIVES
+# Each returns PER-ELEMENT residuals (unreduced) so accumulation composes.
+
+def prim_ce(logits, target):
+    """CE — the coupled primitive: log-sum-exp partition over the last dim.
+    Hessian diag(p)-pp^T: exact null direction; spectrum collapses as
+    p_max->1 (measured T21). Returns (...,) per-position nats."""
+    return F.cross_entropy(logits.reshape(-1, logits.shape[-1]),
+                           target.reshape(-1), reduction="none"
+                           ).reshape(target.shape)
+
+def prim_sq(pred, target):
+    """Squared error — the aleph's only sanctioned codebook pressure rides
+    this (recon through M-hat). Returns per-element squares."""
+    return (pred - target) ** 2
+
+def prim_kl(logits, teacher_probs):
+    """KL to detached teacher probs. LAW: alpha <= 0.25, NEVER on founders,
+    never in a selection loop without a quality gap (L-114/L-022)."""
+    return F.kl_div(F.log_softmax(logits, -1), teacher_probs.detach(),
+                    reduction="none").sum(-1)
+
+def prim_cosh_bregman(v, code, mu=1.0, clamp=4.0):
+    """BREG — the Bregman divergence of the aleph's own potential sum-cosh:
+    D_Phi(v - c*mu, 0) = cosh(r) - 1. Uncoupled per axis, curvature >= 1,
+    antipodally invariant L(v,c)==L(-v,-c). VERDICT ON RECORD (L-070/L-138):
+    loses to CE wherever CE is healthy, 3/3; DECOMPRESSES the coupled-
+    partition collapse 3/3 (usage 1-2.7 -> ~61/64). Use it where the
+    partition coupling is the disease, not as a general replacement."""
+    r = (v - code * mu).clamp(-clamp, clamp)
+    return torch.cosh(r) - 1.0
+
+
+# ====================================================== ACCUMULATION FORMATS
+# Each takes per-element residuals -> a scalar (or a weighted scalar).
+
+def a0_mean(res):
+    """A0 uniform-mean. The default; honestly dominant (71/138)."""
+    return res.mean()
+
+def a1_chunked_ce(logits_fn, hidden, target, chunk=512, ignore_index=-100):
+    """A1 chunk-sum-renormalize for CE: never materialize seq x vocab.
+    Mathematically identical to A0; a 5x memory law (L-004). `logits_fn`
+    maps a hidden slice -> logits (the lm head)."""
+    s, n = None, 0
+    T = hidden.shape[1]
+    for i in range(0, T, chunk):
+        lg = logits_fn(hidden[:, i:i + chunk])
+        tgt = target[:, i:i + chunk]
+        term = F.cross_entropy(lg.reshape(-1, lg.shape[-1]), tgt.reshape(-1),
+                               ignore_index=ignore_index, reduction="sum")
+        s = term if s is None else s + term
+        n += int((tgt != ignore_index).sum())
+    return s / max(n, 1)
+
+def a2_weighted(res, w, dims=None):
+    """A2 per-sample(or per-element)-then-weighted. Reduce res over `dims`
+    FIRST if given, then weight and renormalize by w.sum() — a mean taken
+    too early silently erases the weight."""
+    if dims is not None:
+        res = res.mean(dim=dims)
+    return (res * w).sum() / w.sum().clamp_min(1e-12)
+
+def a3_band_composed(res_per_band, w_bands):
+    """A3 band-crossfade composition: (B, N_BANDS) losses x (B, N_BANDS)
+    windows -> scalar. Windows must be a partition of unity on the TRAINING
+    coordinate (band coordinate law); isolation is quadratic in the window."""
+    return (res_per_band * w_bands).sum(-1).mean()
+
+def a4_masked(res, mask):
+    """A4 masked-denominator — THE SILENT-ZERO CLASS. Asserts the mask fired:
+    a term that never fires is indistinguishable from a null term."""
+    m = mask.float()
+    live = m.sum()
+    assert float(live) > 0, "A4 silent zero: mask never fired (assert the count upstream)"
+    return (res * m).sum() / live
+
+def a5_dose_coupled(base_scalar, aux_res, w_route, lam=1.0):
+    """A5 dose-coupled auxiliary: base + lam * routed aux. lam~1 is the
+    measured operating point on the flow substrate; run the CONDITIONING
+    GATE on the aux's recovery map before spending (L-016 vs L-115)."""
+    return base_scalar + lam * a2_weighted(aux_res, w_route)
+
+def a6_paired(res_a, res_b):
+    """A6 paired-difference: identical (row, noise, t) triples per arm,
+    per-sample reduction, fp64 accumulation. Without pairing, sub-1%
+    effects are invisible (the ~0.988 unpaired floor)."""
+    return (res_a.double() - res_b.double()).mean()
+
+def a7_grid_infonce(za, zb, temp=0.07):
+    """A7 grid-pairwise (InfoNCE), symmetric. THE LOUDEST GRADIENT — legal
+    ONLY as a readout objective on a head outside the compute path; NEVER
+    into address paths (L-113). You are responsible for that placement."""
+    sims = za @ zb.t() / temp
+    lbl = torch.arange(za.shape[0], device=za.device)
+    return (F.cross_entropy(sims, lbl) + F.cross_entropy(sims.t(), lbl)) / 2
+
+def a8_fp64_gauge(fn, *args):
+    """A8 fp64-accumulate for GAUGES (no_grad, autocast off). fp32 CM dets
+    lose ~4% on near-degenerate pentachora."""
+    with torch.no_grad():
+        return fn(*(a.double() if torch.is_tensor(a) else a for a in args))
+
+
+# ========================================================== CANDIDATE LOSSES
+
+def fac_loss(feats, R, code_rows, mu=1.0, t_loss=0.3):
+    """FAC: normalize(feats) @ R^T / t_loss -> cosh-Bregman to the target
+    code. R is a FROZEN orthonormal frame (gauge-fixed by construction);
+    code_rows in {-1,+1}^K frozen. See prim_cosh_bregman's verdict note."""
+    v = (F.normalize(feats, dim=-1) @ R.t()) / t_loss
+    return prim_cosh_bregman(v, code_rows, mu=mu)
+
+def pwa_weights(pi, form="inverse", w_min=0.1, band=(0.10, 0.60), eps=0.02):
+    """PWA weight builders over a FROZEN reference's true-token prob pi.
+    GATE RECORD (2026-07-25, trained-ce reference): band-kernel novelty
+    0.0145 REFUSED; window 0.0562 marginal; inverse 0.0832 weak-pass —
+    all far below the 0.715 payer class. CONDITIONAL: do not spend an arm
+    matrix on these; revival bar is a form with novelty >= 0.3."""
+    if form == "band-kernel":
+        return w_min + (1 - w_min) * 4 * pi * (1 - pi)
+    if form == "window":
+        lo, hi = band
+        return (torch.sigmoid((pi - lo) / eps)
+                * torch.sigmoid((hi - pi) / eps)).clamp_min(w_min)
+    if form == "inverse":
+        return (1 - pi).clamp_min(w_min)
+    raise ValueError(form)
+
+
+# Compartment ROLE losses (rank 1 of the series). Each supervises a DIFFERENT
+# QUANTITY through the band's channel window — the 0.715-class design contract
+# (a reweighting of the base residual would be gate-refused; these are not).
+# `cmap` is compartment_smoke.build_compartment_map(...); h is the trunk
+# hidden (B, T, d). Fixed probes are frozen buffers (placement by
+# construction); trainable role heads replace them in a real bed.
+
+def role_low_recon(h, W_chan, emb_target, probe):
+    """LOW = absolute/reconstructive: rebuild the token's own input embedding
+    from the LOW channels alone. The aleph's proven pressure class."""
+    hw = h * W_chan[:, 0]
+    return prim_sq(hw @ probe, emb_target.detach()).mean(-1)
+
+def role_mid_continuity(h, W_chan, probe):
+    """MID = relational: geodesic continuity of adjacent-position MID-channel
+    states (1 - cos on a fixed projection). A different quantity (the
+    trajectory), not a reweighting of the next-token residual."""
+    z = F.normalize((h * W_chan[:, 1]) @ probe, dim=-1)
+    return 1.0 - (z[:, :-1] * z[:, 1:]).sum(-1)
+
+def role_high_span(h, W_chan, span_target, probe, span=32):
+    """HIGH = structural: predict the span's byte-histogram signature from
+    the HIGH channels. Span pooling over TIME toward an explicit span-level
+    TARGET (not GAP-in-an-encoder: the pooled object IS the supervised
+    quantity, flagged per the GAP law regardless)."""
+    B, T, d = h.shape
+    n = T // span
+    hw = (h * W_chan[:, 2])[:, :n * span].reshape(B, n, span, d).mean(2)
+    return prim_sq(hw @ probe, span_target.detach()).mean(-1)
+
+
+def latent_chain_terms(feats_answer, feats_register, R, code_y, code_z,
+                       mu=1.0, t_loss=0.3, lam=1.0):
+    """LATENT-CHAIN: FAC on the answer position + FAC on a LATENT register
+    position targeting the intermediate value's code — supervision of a
+    quantity NOT in the output string (the thing CE structurally cannot
+    express). Mandatory control in any bed: latent_chain_shuffled (c_z
+    drawn from a shuffled intermediate). Prereg: direct composite
+    0.0 -> >= 0.50, REFUTED < 0.10."""
+    la = fac_loss(feats_answer, R, code_y, mu, t_loss)
+    lz = fac_loss(feats_register, R, code_z, mu, t_loss)
+    return la.mean() + lam * lz.mean()
+
+
+# ================================================= LEGACY ROSTER (extracted)
+# Every historical form with a recorded formula and no living local impl,
+# made runnable. Verdicts travel in the docstrings; the manifest row is the
+# authority (inventory/LOSS_MANIFEST.md).
+
+def margin_head(feats, weight, target, kind="arcface", s=30.0, m=0.30):
+    """L-036 RoseFace margin family. cos(th+m) (arc) | cos(th)-m (cos) |
+    cos(m*th) (sphere), scale s. Historical ceiling: 60% single-stream
+    (diagnosed as frozen pentachora + erosion, not the margin)."""
+    z = F.normalize(feats, dim=-1) @ F.normalize(weight, dim=-1).t()
+    th = torch.arccos(z.clamp(-1 + 1e-7, 1 - 1e-7))
+    if kind == "arcface":
+        zt = torch.cos(th + m)
+    elif kind == "cosface":
+        zt = z - m
+    elif kind == "sphereface":
+        zt = torch.cos(m * th)
+    else:
+        raise ValueError(kind)
+    logits = z.clone()
+    logits.scatter_(-1, target.unsqueeze(-1), zt.gather(-1, target.unsqueeze(-1)))
+    return prim_ce(s * logits, target)
+
+def cv_band_loss(anchors, cv_target=0.20, weight=1e-3, n_sets=64, seed=0):
+    """L-040 — THE ONE SANCTIONED CV FORCE. Arm-gated by statute: weight
+    HARD CEILING 1e-3; S^15-class BANKS only, NEVER the aleph codebook;
+    forward loss; fp64 determinant; fixed-seed subset draw (deterministic
+    across steps). Port of tools/exp017_aleph_constellation.py:154-186."""
+    assert weight <= 1e-3, "CV force above 1e-3 is prohibited (L-110)"
+    A = F.normalize(anchors, dim=-1)
+    n = A.shape[0]
+    assert n >= 5, "pentachoron CV needs >= 5 anchors"
+    g = torch.Generator(device="cpu").manual_seed(seed)
+    idx = torch.stack([torch.randperm(n, generator=g)[:5] for _ in range(n_sets)])
+    pts = A[idx]
+    d2 = torch.cdist(pts.double(), pts.double()).pow(2)
+    cm = torch.ones(n_sets, 6, 6, dtype=torch.float64, device=A.device)
+    cm[:, 0, 0] = 0.0
+    cm[:, 1:, 1:] = d2
+    v = (-torch.linalg.det(cm) / 9216.0).clamp_min(1e-24).sqrt()
+    cv = (v.std() / v.mean().clamp_min(1e-12)).float()
+    return weight * (cv - cv_target).abs()
+
+def cm_validity_hinge(pts, lam=0.01, eps=1e-6):
+    """L-045 KSimplex validity hinge: penalize non-positive CM volume^2 on
+    the simplex. Requires d/k >= 8 or the det is numerically unstable."""
+    B = pts.shape[0]
+    d2 = torch.cdist(pts, pts).pow(2)
+    k1 = pts.shape[1]
+    cm = torch.ones(B, k1 + 1, k1 + 1, dtype=pts.dtype, device=pts.device)
+    cm[:, 0, 0] = 0.0
+    cm[:, 1:, 1:] = d2
+    sign = -1.0 if (k1 % 2 == 0) else 1.0
+    vol2 = sign * torch.linalg.det(cm)
+    return lam * F.relu(eps - vol2).mean()
+
+def cm_volume_spread(vol2_per_layer, lam=0.005):
+    """L-046 volume-spread REWARD: -std(log|vol^2|) across layers — an
+    anti-collapse diversity reward, note the SIGN."""
+    return -lam * torch.log(vol2_per_layer.abs().clamp_min(1e-24)).std()
+
+def procrustes_sq(A, B):
+    """L-047/L-111 Procrustes residual ||A R* - B||^2 (R* via SVD).
+    PLACEMENT VERDICT: as a x0.3 regularizer beside a real force it
+    tightens CV (rating 6); as THE training force R@1 = 0.000 (rating 1).
+    It measures alignability; it cannot create it."""
+    U, _, Vt = torch.linalg.svd(A.t() @ B)
+    R = U @ Vt
+    return ((A @ R - B) ** 2).mean()
+
+def soft_hand_weights(cv, target, sigma=0.15, boost=1.5, penalty=1.0):
+    """L-026 soft hand — reward, not penalty: near the CV target the recon
+    gradient is BOOSTED (1..1+boost); far, a restoring force. Adverse
+    finding on record: SUSTAINED moderate boost hurts (the model optimizes
+    for staying in the boost zone). Returns (recon_weight, cv_penalty)."""
+    prox = torch.exp(-((cv - target) ** 2) / (2 * sigma ** 2))
+    return 1.0 + boost * prox, penalty * (1.0 - prox)
+
+def kd_guard(alpha, is_founder=False, in_selection_loop=False,
+             teacher_gap=None):
+    """L-022/L-114 KD statute: alpha <= 0.25, never on founders, never in a
+    selection loop without a quality gap. Raises on the L-114 configuration
+    (inverse evolution, 2.4301 -> 2.5603)."""
+    if is_founder:
+        raise ValueError("KD on a founder is prohibited (L-114)")
+    if alpha > 0.25 and in_selection_loop and not teacher_gap:
+        raise ValueError("KD alpha > 0.25 in a selection loop without a "
+                         "quality gap reproduces inverse evolution (L-114)")
+    return min(alpha, 1.0)
+
+
+# ============================================= DEVIANT ROSTER (gate-cleared)
+# inventory/DEVIANT_ROSTER.md candidates. Novelty numbers travel with them;
+# trained verdicts graduate them to LOSS_MANIFEST rows.
+
+def dev_softmax_accum(res, T=0.5):
+    """Worst-position accumulation: T*logsumexp(res/T) - T*log(N). Gradient ==
+    softmax(res/T) weighting (self-paced weighting IS this loss). Gate 0.911
+    at trained state - the highest ever. FLAG: on natural text the worst
+    positions are largely irreducible entropy; prereg carries a held-out bar."""
+    flat = res.reshape(-1)
+    return T * torch.logsumexp(flat / T, 0) - T * math.log(flat.numel())
+
+def dev_geomean_accum(res, eps=1e-3):
+    """Geometric-mean accumulation: mean(log(res+eps)) - the anti-focal
+    (gradient 1/res polishes the nearly-solved). Gate 0.486 trained."""
+    return torch.log(res + eps).mean()
+
+def sparsemax_loss(z, y):
+    """Sparsemax loss (Martins & Astudillo 2016): a PARTIAL partition -
+    sparse support - between CE (full coupling) and FAC (zero coupling).
+    The coupling-axis probe for the L-138 mechanism. Gate 0.253 (state-
+    independent form). z: (N,V) logits, y: (N,) targets -> (N,) losses."""
+    zs, _ = torch.sort(z.detach(), dim=-1, descending=True)
+    cs = zs.cumsum(-1)
+    k = torch.arange(1, z.shape[-1] + 1, device=z.device, dtype=z.dtype)
+    ksup = ((1 + k * zs) > cs).to(z.dtype).sum(-1, keepdim=True)
+    tau = (cs.gather(-1, ksup.long() - 1) - 1) / ksup
+    psp = (z - tau).clamp_min(0)                      # sparsemax probs (grad ok)
+    zy = z.gather(-1, y.unsqueeze(-1)).squeeze(-1)
+    zsq = torch.where(psp > 0, z ** 2 - tau ** 2, torch.zeros_like(z)).sum(-1)
+    return -zy + 0.5 * zsq + 0.5
+
+def fac_loss_link(feats, R, code_rows, link="cosh", mu=1.0, t_loss=0.3):
+    """The FAC link dial: cosh (exponential tails, the measured verdict) |
+    tanh-Hamming (bounded) | cauchy log(1+r^2) (sub-quadratic). Links are
+    ~90% collinear at init (direction dominates early; tails matter late)."""
+    v = (F.normalize(feats, dim=-1) @ R.t()) / t_loss
+    if link == "cosh":
+        return prim_cosh_bregman(v, code_rows, mu=mu)
+    if link == "tanh":
+        return 1.0 - torch.tanh(v) * code_rows
+    if link == "cauchy":
+        return torch.log1p((v - code_rows * mu) ** 2)
+    raise ValueError(link)
+
+
+# ================================================ FORBIDDEN CONTROLS [FORCE]
+# Runnable ONLY as explicitly-forced control arms (the blob-on-eps pattern:
+# the library refuses the design and permits the falsification). Each cites
+# its manifest row and warns loudly.
+
+def _force_gate(force, row, evidence):
+    if not force:
+        raise ValueError(
+            f"{row} is a FORBIDDEN class ({evidence}). This implementation "
+            f"exists ONLY as a control arm - pass force=True to reproduce "
+            f"the failure on purpose.")
+    import warnings
+    warnings.warn(f"{row} forced: you are reproducing a documented failure "
+                  f"class as a CONTROL, not training a design.")
+
+def forbidden_vq_commitment(z_e, codebook, beta=0.25, force=False):
+    """L-105 VQ codebook + commitment loss (EMA variant NOT provided — the
+    cross-step state is A10 and stays absent even here). Evidence: the
+    aleph codebook holds 125+/128 axes alive at div_weight=0 without it."""
+    _force_gate(force, "L-105 VQ/commitment", "14x path collapse class")
+    d = torch.cdist(z_e.reshape(-1, z_e.shape[-1]), codebook)
+    e = codebook[d.argmin(-1)].reshape(z_e.shape)
+    return (prim_sq(z_e.detach(), e).mean()
+            + beta * prim_sq(z_e, e.detach()).mean())
+
+def forbidden_load_balancing(router_probs, expert_mask, alpha=0.01,
+                             force=False):
+    """L-134 switch-style balance aux: alpha * N * sum_i f_i * P_i.
+    Evidence: banned and never needed — usage stays near-uniform read-only."""
+    _force_gate(force, "L-134 load-balancing aux", "no-balancing statute")
+    N = router_probs.shape[-1]
+    f = expert_mask.float().mean(dim=tuple(range(expert_mask.ndim - 1)))
+    P = router_probs.mean(dim=tuple(range(router_probs.ndim - 1)))
+    return alpha * N * (f * P).sum()
+
+def forbidden_gap(x, spatial_dims, force=False):
+    """L-109 global average pooling in a geometric encoder. Evidence:
+    70% -> 29% collapse, replicated twice. Patch aggregation defaults to
+    MEAN over tokens at the READOUT, never pooling inside the encoder."""
+    _force_gate(force, "L-109 GAP", "70->29 collapse, replicated")
+    return x.mean(dim=spatial_dims)
+
+
+# ================================================================ THE GATES
+def collinearity_novelty(loss_arm, loss_base, params):
+    """novelty = 1 - |cos(grad_arm, grad_base)|. Composed role arms are
+    judged whole; additive auxiliaries are judged as THE TERM BEING ADDED.
+    Calibration: HP/LP 0.0026-0.0083 (inert) vs blob 0.715 (payer).
+    REFUSE below 0.05; the payer class starts ~0.3."""
+    ga = torch.autograd.grad(loss_arm, params, retain_graph=True,
+                             allow_unused=True)
+    gb = torch.autograd.grad(loss_base, params, retain_graph=True,
+                             allow_unused=True)
+    # zero-fill on the SHARED parameter support: a param an arm does not
+    # touch contributes the zero vector to its direction (dropping it would
+    # misalign the two flattened gradients)
+    fa = torch.cat([(g if g is not None else torch.zeros_like(p)).reshape(-1)
+                    for g, p in zip(ga, params)])
+    fb = torch.cat([(g if g is not None else torch.zeros_like(p)).reshape(-1)
+                    for g, p in zip(gb, params)])
+    return 1.0 - abs(F.cosine_similarity(fa.unsqueeze(0),
+                                         fb.unsqueeze(0)).item())
+
+
+# ================================================================ SELF-SMOKE
+def _smoke():
+    torch.backends.cuda.matmul.allow_tf32 = False
+    torch.backends.cudnn.allow_tf32 = False
+    dev = "cuda" if torch.cuda.is_available() else "cpu"
+    if dev == "cuda":
+        torch.cuda.set_per_process_memory_fraction(0.73)
+    g = torch.Generator().manual_seed(seed_for("loss_forms"))
+    ok = []
+
+    B, T, V, d, K = 4, 64, 256, 192, 64
+    logits = torch.randn(B, T, V, generator=g, requires_grad=True)
+    y = torch.randint(0, V, (B, T), generator=g)
+    ce = prim_ce(logits, y)
+    ok.append(("prim_ce shape+grad", bool(ce.shape == (B, T)
+               and torch.autograd.grad(ce.mean(), logits)[0].abs().sum() > 0)))
+
+    # A1 == A0 identity (the 5x memory law is math-free)
+    h = torch.randn(B, T, d, generator=g)
+    W = torch.randn(V, d, generator=g) * 0.02
+    fn = lambda hh: hh @ W.t()
+    full = F.cross_entropy(fn(h).reshape(-1, V), y.reshape(-1))
+    ok.append(("A1 == A0 exactly",
+               torch.allclose(a1_chunked_ce(fn, h, y, chunk=17), full,
+                              atol=1e-6)))
+
+    # A2 early-mean hazard: weighting after full mean == unweighted
+    res = torch.randn(B, T, generator=g).abs()
+    w = torch.rand(B, generator=g) + 0.1
+    good = a2_weighted(res, w, dims=(1,))
+    bad = res.mean() * (w / w).mean()
+    ok.append(("A2 weight not erased", abs(good - res.mean()) > 1e-6
+               and torch.allclose(bad, res.mean())))
+
+    # A4 silent-zero assert fires
+    try:
+        a4_masked(res, torch.zeros_like(res))
+        ok.append(("A4 silent-zero assert", False))
+    except AssertionError:
+        ok.append(("A4 silent-zero assert", True))
+
+    # A6 fp64; A7 symmetric
+    ok.append(("A6 fp64", a6_paired(res, res).dtype == torch.float64
+               and float(a6_paired(res, res)) == 0.0))
+    za = F.normalize(torch.randn(8, 32, generator=g), dim=-1)
+    zb = F.normalize(torch.randn(8, 32, generator=g), dim=-1)
+    ok.append(("A7 symmetric", torch.allclose(a7_grid_infonce(za, zb),
+                                              a7_grid_infonce(zb, za),
+                                              atol=1e-6)))
+
+    # FAC: antipodal invariance + gradient flow through feats
+    feats = torch.randn(B, T, 256, generator=g, requires_grad=True)
+    R = torch.linalg.qr(torch.randn(256, 256, generator=g))[0][:K]
+    code = ((torch.randn(V, K, generator=g) > 0).float() * 2 - 1)[y]
+    L = fac_loss(feats, R, code).mean()
+    v = (F.normalize(feats, dim=-1) @ R.t()) / 0.3
+    ok.append(("FAC antipodal + grad",
+               bool(torch.allclose(prim_cosh_bregman(v, code),
+                                   prim_cosh_bregman(-v, -code))
+                    and torch.autograd.grad(L, feats)[0].abs().sum() > 0)))
+
+    # PWA weights bounded + floored
+    pi = torch.rand(B, T, generator=g)
+    for f in ("band-kernel", "window", "inverse"):
+        wf = pwa_weights(pi, f)
+        ok.append((f"PWA {f} in [w_min,1]",
+                   float(wf.min()) >= 0.1 - 1e-6 and float(wf.max()) <= 1.0 + 1e-6))
+
+    # Compartment roles: shapes + grad + zero-grad outside their window
+    try:
+        from compartment_smoke import build_compartment_map
+        cmap = build_compartment_map(P=32, Ds=4, d=d)
+        Wc = cmap["W_chan_band"]
+        hh = torch.randn(B, T, d, generator=g, requires_grad=True)
+        pl = torch.randn(d, 48, generator=g) / math.sqrt(d)
+        emb_t = torch.randn(B, T, 48, generator=g)
+        lo = role_low_recon(hh, Wc, emb_t, pl).mean()
+        gl = torch.autograd.grad(lo, hh)[0]
+        dead = (Wc[:, 0] == 0)
+        ok.append(("role LOW grad confined to LOW channels",
+                   bool(float(gl[..., dead].abs().sum()) == 0.0
+                        and float(gl.abs().sum()) > 0)))
+        mid = role_mid_continuity(hh, Wc, pl).mean()
+        sp_t = torch.randn(B, T // 32, 48, generator=g)
+        hi = role_high_span(hh, Wc, sp_t, pl).mean()
+        ok.append(("roles MID/HIGH finite+grad",
+                   bool(torch.isfinite(mid) and torch.isfinite(hi)
+                        and torch.autograd.grad(mid + hi, hh)[0].abs().sum() > 0)))
+    except ImportError:
+        ok.append(("compartment roles (map import)", None))
+
+    # legacy roster
+    W2 = torch.randn(10, 64, generator=g)
+    f2 = torch.randn(6, 64, generator=g, requires_grad=True)
+    y2 = torch.randint(0, 10, (6,), generator=g)
+    mh = margin_head(f2, W2, y2, "arcface").mean()
+    ok.append(("margin_head grad + finite",
+               bool(torch.isfinite(mh)
+                    and torch.autograd.grad(mh, f2)[0].abs().sum() > 0)))
+    bank = torch.randn(96, 16, generator=g, requires_grad=True)
+    cvl = cv_band_loss(bank)
+    ok.append(("cv_band_loss forward+grad, ceiling enforced",
+               bool(torch.isfinite(cvl)
+                    and torch.autograd.grad(cvl, bank)[0].abs().sum() > 0)))
+    try:
+        cv_band_loss(bank.detach(), weight=1e-2)
+        ok.append(("cv_band_loss ceiling assert", False))
+    except AssertionError:
+        ok.append(("cv_band_loss ceiling assert", True))
+    pts5 = torch.randn(8, 5, 32, generator=g, requires_grad=True)
+    hinge = cm_validity_hinge(pts5)
+    ok.append(("cm_validity_hinge finite", bool(torch.isfinite(hinge))))
+    ok.append(("cm_volume_spread sign is a reward",
+               bool(cm_volume_spread(torch.rand(6, generator=g) + 0.1) <= 0)))
+    A2m = torch.randn(32, 8, generator=g); B2m = torch.randn(32, 8, generator=g)
+    ok.append(("procrustes_sq beats unaligned",
+               bool(procrustes_sq(A2m, B2m) <= ((A2m - B2m) ** 2).mean() + 1e-5)))
+    rw, cp = soft_hand_weights(torch.tensor(0.20), 0.20)
+    ok.append(("soft_hand at target: boost on, penalty ~0",
+               bool(rw > 2.4 and cp < 1e-6)))
+    try:
+        kd_guard(0.5, is_founder=True)
+        ok.append(("kd_guard founder refusal", False))
+    except ValueError:
+        ok.append(("kd_guard founder refusal", True))
+    # forbidden controls refuse without force, run with it
+    ze = torch.randn(4, 7, 16, generator=g); cb = torch.randn(32, 16, generator=g)
+    import warnings
+    refuse = 0
+    for fn, args in ((forbidden_vq_commitment, (ze, cb)),
+                     (forbidden_load_balancing,
+                      (torch.softmax(torch.randn(64, 8, generator=g), -1),
+                       F.one_hot(torch.randint(0, 8, (64,), generator=g), 8))),
+                     (forbidden_gap, (torch.randn(2, 3, 8, 8, generator=g), (2, 3)))):
+        try:
+            fn(*args)
+        except ValueError:
+            refuse += 1
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore")
+            out = fn(*args, force=True)
+        refuse += int(bool(torch.isfinite(out if out.dim() == 0 else out.sum())))
+    ok.append(("forbidden controls: refuse w/o force, run with it", refuse == 6))
+
+    npass = sum(1 for _, v in ok if v is True)
+    nfail = sum(1 for _, v in ok if v is False)
+    print("LOSS_FORMS SELF-SMOKE")
+    for name, v in ok:
+        print("  %-38s %s" % (name, "PASS" if v is True
+                              else ("SKIP" if v is None else "FAIL")))
+    print("PASS %d FAIL %d SKIP %d" % (npass, nfail, len(ok) - npass - nfail))
+    return nfail == 0
+
+
+if __name__ == "__main__":
+    sys.exit(0 if _smoke() else 1)

code/loss_view.py

@@ -0,0 +1,432 @@
+#!/usr/bin/env python3
+"""loss_view.py - render + lint the rated loss-manifest registry. #TAG:loss_view
+Usage: python loss_view.py card|ladder|role|cell|show|recheck-gauge|lint|html [ARG]
+       [--json PATH] [--min N] [--max N]      (verb defaults to 'card')
+Reads inventory/loss_manifest.json. Stdlib only, no import-time side effects."""
+import argparse, collections, html, json, os, sys, zlib
+
+FALLBACK_ROOT = "."
+ROLES = ("PRIMARY", "AUX", "GAUGE", "GAUGE-DISTRUSTED", "RETRACTED", "FORBIDDEN")
+# BREG (Bregman divergence of a substrate potential) is the FOURTH differencing
+# primitive, introduced 2026-07-25 by the FAC design - a genuine schema widening,
+# not a mis-binning: it is neither CE, squared error, nor KL.
+PRIMS = ("CE", "SQ", "KL", "DET", "BREG", "NONE")
+COLS = (("CE", "CE"), ("SQ", "SQ"), ("KL", "KL"), ("DET", "DET"),
+        ("BREG", "BREG"), ("NONE", "-"))
+ACCUMS = tuple("A%d" % i for i in range(11)) + ("NA",)   # NA minted 2026-07-25 (A0 audit)
+# key, display name, lo, hi  (names overridable by an optional top-level "sub_names" map)
+SUB = (("R", "replication", 0, 3), ("P", "potency", 0, 3), ("D", "durability", 0, 2),
+       ("C", "coverage", 0, 2), ("I", "independence", 0, 2), ("L", "lineage", 0, 1))
+ABBR = {"PRIMARY": "PRIM", "AUX": "AUX", "GAUGE": "GAUG", "GAUGE-DISTRUSTED": "GDIS",
+        "RETRACTED": "RETR", "FORBIDDEN": "FORB"}
+# the only four non-ASCII glyphs this tool emits: dagger, heavy-x, perpendicular, warning
+MARK = (("retraction=1", "\u2020"), ("doctrine<=2", "\u2716"),
+        ("split", "\u27c2"), ("contra", "\u26a0"))
+LEGEND = ("\u2020 retraction floor-breaker | \u2716 doctrine ceiling | "
+          "\u27c2 split sibling | \u26a0 unreconciled contradiction")
+BANNER_LAW = "Each row is the EVIDENCE for a standing law. Not a graveyard - cite them."
+
+def repo_root():
+    d = os.path.abspath(os.getcwd())
+    while True:
+        if os.path.exists(os.path.join(d, "MANIFEST.md")):
+            return d
+        p = os.path.dirname(d)
+        if p == d:
+            return FALLBACK_ROOT
+        d = p
+
+def load(path):
+    p = path or os.path.join(repo_root(), "inventory", "loss_manifest.json")
+    if not os.path.isfile(p):
+        print("ERROR: loss manifest not found at %s (pass --json PATH)" % p)
+        sys.exit(2)
+    with open(p, encoding="utf-8") as f:
+        return json.load(f)
+
+def cut(s, n):
+    s = "" if s is None else str(s)
+    return s if len(s) <= n else s[:max(1, n - 3)] + "..."
+
+def pad(s, n):
+    return "%-*s" % (n, cut(s, n))
+
+def wrap(s, n, ind):
+    out, cur = [], ind
+    for w in str(s).split():
+        if cur.strip() and len(cur) + len(w) > n:
+            out.append(cur.rstrip())
+            cur = ind
+        cur += w + " "
+    out.append(cur.rstrip())
+    return "\n".join(out)
+
+def banner(d):
+    print("LOSS MANIFEST - census %s - %d entries - rubric v%s"
+          % (d.get("census_date", "?"), len(d.get("entries") or []),
+             d.get("rubric_version", "?")))
+
+def prim_lbl(e):
+    return "-" if e.get("primitive") == "NONE" else str(e.get("primitive"))
+
+def cell_lbl(e):
+    return "%s.%s/%s" % (prim_lbl(e), e.get("accum"), e.get("substrate", "?"))
+
+def rate_lbl(e):
+    hi = e.get("rating_hi")
+    return "%s-%s" % (e.get("rating"), hi) if hi is not None else "%s" % e.get("rating")
+
+def marks(e):
+    r = e.get("rules_fired") or []
+    return "".join(g for t, g in MARK if t in r)
+
+def rate_col(e):
+    return rate_lbl(e) + marks(e)
+
+def rpdcil(e):
+    s = e.get("sub") or {}
+    return "".join(str(s.get(k, "?")) for k, _, _, _ in SUB[:5]) + "+" + str(s.get("L", "?"))
+
+def sub_named(d):
+    ov = d.get("sub_names") or {}
+    return [(k, ov.get(k, nm), lo, hi) for k, nm, lo, hi in SUB]
+
+def sortkey(e):
+    s = e.get("sub") or {}
+    return (-(e.get("rating") or 0), -(s.get("P") or 0), -(s.get("R") or 0), str(e.get("id")))
+
+def expect(d, e):
+    """rubric-derived rating: lookup[s_raw], minus blind-2, then every '<=N' cap, then retraction."""
+    lut = d.get("lookup") or []
+    s = e.get("s_raw")
+    if not isinstance(s, int) or not 0 <= s < len(lut):
+        return None
+    base = lut[s]
+    rules = e.get("rules_fired") or []
+    if "blind-2" in rules:
+        base -= 2
+    for t in rules:  # canonical order is unrun/single-seed/sub1pct/doctrine; min-caps commute
+        if "<=" in t:
+            try:
+                base = min(base, int(t.split("<=")[1]))
+            except ValueError:
+                pass
+    if "retraction=1" in rules:
+        return 1
+    return max(1, base)
+
+def card(d, arg, a):
+    es = d.get("entries") or []
+    banner(d)
+    print("")
+    c = collections.Counter((x.get("primitive"), x.get("accum")) for x in es)
+    print("GRID " + "".join("%5s" % l for _, l in COLS) + "%6s" % "row")
+    tot = {}
+    for acc in ACCUMS:
+        v = [c[(p, acc)] for p, _ in COLS]
+        tot[acc] = sum(v)
+        print("%-5s" % acc + "".join("%5s" % (x if x else "-") for x in v) + "%6d" % tot[acc])
+    emp = [k for k in ACCUMS if not tot[k] and k != "A10"]
+    line = "empty: " + (" ".join(emp) if emp else "(none)")
+    if not tot["A10"]:
+        line += " | A10 EMPTY BY STATUTE"
+    print(line)
+    print("")
+    h = collections.Counter(x.get("rating") for x in es)
+    mx = max([h[r] for r in range(1, 11)] + [1])
+    print("RATINGS")
+    for r in range(1, 11):
+        n = h.get(r, 0)
+        bar = "#" * max(1, round(22 * n / mx)) if n else ""
+        print("%2d |%-22s %d" % (r, bar, n))
+    rr = sorted((x.get("rating") or 0) for x in es)
+    mean = sum(rr) / len(rr) if rr else 0.0
+    med = 0.0 if not rr else (rr[len(rr) // 2] if len(rr) % 2
+                              else (rr[len(rr) // 2 - 1] + rr[len(rr) // 2]) / 2)
+    print("mean %.2f  median %.1f  (ranges counted at their low end)" % (mean, med))
+    print("")
+    print("TOP")
+    for x in sorted(es, key=sortkey)[:3]:
+        print("  %s %s %s %s" % (pad(x.get("id"), 6), pad(rate_col(x), 6),
+                                 pad(x.get("name"), 32), cut(x.get("headline"), 34)))
+    print("")
+    print("BOTTOM  %d entries at rating 1" % sum(1 for x in es if x.get("rating") == 1))
+    print("  these are the DOCTRINE'S PROOF SET, not an appendix - see `role RETRACTED`")
+    print("")
+    print("FLAGS  contradictions %d | gauge-distrusted %d | unrun-flagged %d"
+          % (sum(1 for x in es if x.get("rating_hi") is not None
+                 or "contra" in (x.get("rules_fired") or [])),
+             sum(1 for x in es if x.get("role") == "GAUGE-DISTRUSTED"),
+             sum(1 for x in es if "UNRUN" in (x.get("flags") or []))))
+    print("")
+    print(LEGEND)
+
+def ladder(d, arg, a):
+    banner(d)
+    print("")
+    es = [x for x in (d.get("entries") or []) if a.min <= (x.get("rating") or 0) <= a.max]
+    print("%-6s %-8s %-7s %-4s %-16s %-24s %s"
+          % ("ID", "RATE", "RPDCIL", "ROLE", "CELL", "NAME", "HEADLINE"))
+    for x in sorted(es, key=sortkey):
+        print("%s %s %-7s %-4s %s %s %s"
+              % (pad(x.get("id"), 6), pad(rate_col(x), 8), rpdcil(x),
+                 ABBR.get(x.get("role"), "?"), pad(cell_lbl(x), 16),
+                 pad(x.get("name"), 24), cut(x.get("headline"), 24)))
+    print("")
+    print("%d rows (rating %d..%d)" % (len(es), a.min, a.max))
+    print(LEGEND)
+
+def role(d, arg, a):
+    banner(d)
+    print("")
+    want = (arg or "").upper()
+    if want not in ROLES:
+        print("unknown role '%s' - one of: %s" % (arg, " ".join(ROLES)))
+        return
+    es = [x for x in (d.get("entries") or []) if x.get("role") == want]
+    print("ROLE %s - %d entries" % (want, len(es)))
+    print("")
+    if want not in ("RETRACTED", "FORBIDDEN"):
+        for x in sorted(es, key=sortkey):
+            print("%s %s %s %s %s" % (pad(x.get("id"), 6), pad(rate_col(x), 8),
+                                      pad(cell_lbl(x), 16), pad(x.get("name"), 28),
+                                      cut(x.get("headline"), 34)))
+        return
+    print(BANNER_LAW)
+    print("")
+    fam = collections.defaultdict(list)
+    for x in es:
+        fam[x.get("family") or "(unfiled)"].append(x)
+    for k, v in sorted(fam.items(), key=lambda kv: (-len(kv[1]), kv[0])):
+        print("[%s]  %d" % (k, len(v)))
+        for x in sorted(v, key=sortkey):
+            print("   %s %s %s %s" % (pad(x.get("id"), 6), pad(rate_col(x), 6),
+                                      pad(x.get("name"), 34), cut(x.get("headline"), 38)))
+        print("")
+
+def cell(d, arg, a):
+    banner(d)
+    print("")
+    p, _, acc = (arg or "").partition(".")
+    p, acc = p.strip().upper(), acc.strip().upper()
+    if p == "-":
+        p = "NONE"
+    if p not in PRIMS or acc not in ACCUMS:
+        print("usage: cell <PRIM>.<ACCUM>, PRIM in %s, ACCUM in A0..A10" % "/".join(PRIMS))
+        return
+    meta = (d.get("accum") or {}).get(acc) or {}
+    print("CELL %s.%s" % ("-" if p == "NONE" else p, acc))
+    print("  %s: %s" % (acc, meta.get("name", "(no name in accum map)")))
+    print(wrap("law: %s" % meta.get("law", "(no law text)"), 96, "  "))
+    print("")
+    es = [x for x in (d.get("entries") or [])
+          if x.get("primitive") == p and x.get("accum") == acc]
+    if not es:
+        print("(no entries occupy this cell)")
+        return
+    for x in sorted(es, key=sortkey):
+        print("%s %s %-7s %-4s %s %s" % (pad(x.get("id"), 6), pad(rate_col(x), 8), rpdcil(x),
+                                         ABBR.get(x.get("role"), "?"), pad(x.get("name"), 30),
+                                         cut(x.get("headline"), 30)))
+    print("")
+    print("%d entries" % len(es))
+
+def show(d, arg, a):
+    banner(d)
+    print("")
+    e = next((x for x in (d.get("entries") or []) if str(x.get("id")) == str(arg)), None)
+    if e is None:
+        print("no entry with id '%s'" % arg)
+        return
+    known = ("id", "name", "role", "primitive", "accum", "substrate", "family", "flags",
+             "s_raw", "rating", "rating_hi", "sub", "rules_fired", "gauge", "headline",
+             "cite", "note")
+    print("id          %s" % e.get("id"))
+    print("name        %s" % e.get("name"))
+    print("role        %s" % e.get("role"))
+    print("primitive   %s" % prim_lbl(e))
+    print("accum       %s  (%s)" % (e.get("accum"),
+                                    ((d.get("accum") or {}).get(e.get("accum")) or {})
+                                    .get("name", "?")))
+    print("substrate   %s" % e.get("substrate"))
+    print("cell        %s" % cell_lbl(e))
+    print("family      %s" % e.get("family"))
+    print("flags       %s" % (", ".join(e.get("flags") or []) or "(none)"))
+    print("rating      %s%s" % (rate_lbl(e), (" " + marks(e)) if marks(e) else ""))
+    print("rating_hi   %s" % ("(none)" if e.get("rating_hi") is None else e.get("rating_hi")))
+    print("s_raw       %s   (rubric-derived rating: %s)" % (e.get("s_raw"), expect(d, e)))
+    s = e.get("sub") or {}
+    for k, nm, lo, hi in sub_named(d):
+        print("  %s %-13s %s   [%d..%d]" % (k, nm, s.get(k, "?"), lo, hi))
+    print("rules_fired %s" % (", ".join(e.get("rules_fired") or []) or "(none)"))
+    print("gauge       %s" % e.get("gauge"))
+    print("headline    %s" % e.get("headline"))
+    print("cite        %s" % (("\n            ".join(str(c) for c in (e.get("cite") or [])))
+                              or "(EMPTY - lint violation)"))
+    print("note        %s" % (e.get("note") or "(none)"))
+    for k in sorted(k for k in e if k not in known):
+        print("%-11s %s" % (k, e[k]))
+
+def recheck_gauge(d, arg, a):
+    banner(d)
+    print("")
+    q = (arg or "").lower()
+    if not q:
+        print("usage: recheck-gauge <substring>   (matched against gauge and every cite)")
+        return
+    print("GAUGE BLINDNESS SWEEP - all rows below must be re-rated in the same session.")
+    print("")
+    hits = [x for x in (d.get("entries") or [])
+            if q in str(x.get("gauge") or "").lower()
+            or any(q in str(c).lower() for c in (x.get("cite") or []))]
+    for x in sorted(hits, key=sortkey):
+        print("[ ] %s %s %s gauge=%s" % (pad(x.get("id"), 6), pad(rate_col(x), 8),
+                                         pad(x.get("name"), 30), cut(x.get("gauge"), 16)))
+        print(wrap("cite: %s" % (", ".join(str(c) for c in (x.get("cite") or [])) or "(none)"),
+                   96, "      "))
+    print("")
+    print("%d rows matched '%s'" % (len(hits), arg))
+
+def lint(d, arg, a):
+    banner(d)
+    print("")
+    es = d.get("entries") or []
+    v = []
+    for k, n in sorted(collections.Counter(str(x.get("id")) for x in es).items()):
+        if n > 1:
+            v.append("%s: duplicate id (%d entries share it)" % (k, n))
+    splits = collections.Counter(str(x.get("family")) for x in es
+                                 if "split" in (x.get("rules_fired") or []))
+    for x in es:
+        i, r, s = x.get("id"), x.get("rules_fired") or [], x.get("sub") or {}
+        if not (x.get("cite") or []):
+            v.append("%s: empty cite" % i)
+        for fld in ("formula", "impl"):    # roster law 2026-07-25
+            if not x.get(fld):
+                v.append("%s: missing %s (every entry carries its math + its home)" % (i, fld))
+        if x.get("role") not in ROLES:
+            v.append("%s: role '%s' outside allowed set" % (i, x.get("role")))
+        if x.get("primitive") not in PRIMS:
+            v.append("%s: primitive '%s' outside allowed set" % (i, x.get("primitive")))
+        if x.get("accum") not in ACCUMS:
+            v.append("%s: accum '%s' outside A0..A10" % (i, x.get("accum")))
+        tot, ok = 0, True
+        for k, nm, lo, hi in sub_named(d):
+            dv = s.get(k)
+            if not isinstance(dv, int) or isinstance(dv, bool) or not lo <= dv <= hi:
+                v.append("%s: sub.%s (%s) = %r outside %d..%d" % (i, k, nm, dv, lo, hi))
+                ok = False
+            else:
+                tot += dv
+        if ok and x.get("s_raw") != tot:
+            v.append("%s: s_raw %s != R+P+D+C+I+L = %d" % (i, x.get("s_raw"), tot))
+        exp = expect(d, x)
+        if exp is None:
+            v.append("%s: s_raw %r outside lookup table (len %d)"
+                     % (i, x.get("s_raw"), len(d.get("lookup") or [])))
+        elif exp != x.get("rating"):
+            v.append("%s: rating %s != rubric-derived %d" % (i, x.get("rating"), exp))
+        if x.get("accum") == "A10" and x.get("role") not in ("FORBIDDEN", "RETRACTED"):
+            v.append("%s: accum A10 with role %s (A10 is FORBIDDEN/RETRACTED only)"
+                     % (i, x.get("role")))
+        if "split" in r and splits[str(x.get("family"))] < 2:
+            v.append("%s: split with no split sibling in family '%s'" % (i, x.get("family")))
+        hi = x.get("rating_hi")
+        if hi is not None:
+            if not isinstance(hi, int) or hi <= (x.get("rating") or 0):
+                v.append("%s: rating_hi %r not greater than rating %s" % (i, hi, x.get("rating")))
+            if "contra" not in r:
+                v.append("%s: rating_hi set but 'contra' missing from rules_fired" % i)
+    for line in v:
+        print(line)
+    if v:
+        print("LINT: %d violations" % len(v))
+        sys.exit(1)
+    print("LINT: clean")
+    sys.exit(0)
+
+def _shade(t):
+    t = 0.0 if t < 0 else (1.0 if t > 1 else t)
+    return int(238 - 214 * t), int(243 - 196 * t), int(250 - 140 * t)
+
+def _td(bg, fg, body, extra=""):
+    return ("<td style=\"background:rgb(%d,%d,%d);color:%s;border:1px solid #9aa;"
+            "padding:5px 8px;%s\">%s</td>" % (bg[0], bg[1], bg[2], fg, extra, body))
+
+def write_html(d, arg, a):
+    banner(d)
+    out = os.path.abspath(arg or "loss_manifest.html")
+    es = d.get("entries") or []
+    esc, buckets = html.escape, collections.defaultdict(list)
+    for x in es:
+        buckets[(x.get("primitive"), x.get("accum"))].append(x.get("rating") or 0)
+    b = ["<!doctype html><html><head><meta charset=\"utf-8\">",
+         "<title>loss manifest %s</title></head>" % esc(str(d.get("census_date"))),
+         "<body style=\"background:#ffffff;color:#111111;margin:20px;"
+         "font:13px/1.5 Consolas,monospace\">",
+         "<h2 style=\"color:#111111\">LOSS MANIFEST - census %s - %d entries - rubric v%s</h2>"
+         % (esc(str(d.get("census_date"))), len(es), esc(str(d.get("rubric_version")))),
+         "<p style=\"color:#333333\">cell shade = mean rating (light low, dark high); "
+         "cell text = count / mean.</p>",
+         "<table style=\"border-collapse:collapse\"><tr>",
+         _td((225, 228, 232), "#111111", "<b>accum</b>")]
+    for p, l in COLS:
+        b.append(_td((225, 228, 232), "#111111", "<b>%s</b>" % esc(l)))
+    b.append(_td((225, 228, 232), "#111111", "<b>row</b>") + "</tr>")
+    for acc in ACCUMS:
+        meta = (d.get("accum") or {}).get(acc) or {}
+        b.append("<tr>" + _td((238, 240, 243), "#111111",
+                              "<b>%s</b> %s" % (acc, esc(str(meta.get("name", ""))))))
+        n_row = 0
+        for p, _l in COLS:
+            rs = buckets.get((p, acc)) or []
+            n_row += len(rs)
+            if not rs:
+                b.append(_td((232, 232, 232), "#777777", "-", "text-align:center"))
+                continue
+            m = sum(rs) / len(rs)
+            bg = _shade((m - 1) / 9.0)
+            fg = "#ffffff" if (299 * bg[0] + 587 * bg[1] + 114 * bg[2]) / 1000 < 140 else "#111111"
+            b.append(_td(bg, fg, "%d<br>%.1f" % (len(rs), m), "text-align:center"))
+        b.append(_td((238, 240, 243), "#111111", "<b>%d</b>" % n_row, "text-align:center")
+                 + "</tr>")
+    b.append("</table><h3 style=\"color:#111111\">entries</h3>")
+    b.append("<table style=\"border-collapse:collapse\"><tr>")
+    heads = ("ID", "RATE", "RPDCIL", "ROLE", "CELL", "FAMILY", "NAME", "HEADLINE",
+             "RULES", "CITE")
+    for hcol in heads:
+        b.append(_td((225, 228, 232), "#111111", "<b>%s</b>" % hcol))
+    b.append("</tr>")
+    for i, x in enumerate(sorted(es, key=sortkey)):
+        bg = (255, 255, 255) if i % 2 else (246, 247, 249)
+        vals = (x.get("id"), rate_col(x), rpdcil(x), x.get("role"), cell_lbl(x),
+                x.get("family"), x.get("name"), x.get("headline"),
+                " ".join(x.get("rules_fired") or []), "; ".join(str(c) for c in
+                                                                (x.get("cite") or [])))
+        b.append("<tr>" + "".join(_td(bg, "#111111", esc(str(t if t is not None else "")))
+                                  for t in vals) + "</tr>")
+    crc = zlib.crc32(json.dumps(d, sort_keys=True).encode("utf-8"))
+    b.append("</table><p style=\"color:#555555\">%s<br>manifest crc32 0x%08x</p>"
+             % (esc(LEGEND), crc))
+    b.append("</body></html>")
+    with open(out, "w", encoding="utf-8") as f:
+        f.write("\n".join(b))
+    print("wrote %s" % out)
+
+if __name__ == "__main__":
+    try:
+        sys.stdout.reconfigure(encoding="utf-8", errors="replace")
+    except Exception:
+        pass
+    VERBS = {"card": card, "ladder": ladder, "role": role, "cell": cell, "show": show,
+             "recheck-gauge": recheck_gauge, "lint": lint, "html": write_html}
+    ap = argparse.ArgumentParser()
+    ap.add_argument("cmd", nargs="?", default="card", choices=sorted(VERBS))
+    ap.add_argument("arg", nargs="?", default="")
+    ap.add_argument("--json", dest="path", default="")
+    ap.add_argument("--min", type=int, default=1)
+    ap.add_argument("--max", type=int, default=10)
+    a, rest = ap.parse_known_args()
+    if not a.arg and rest:
+        a.arg = rest[0]  # argparse rejects a leading '-', e.g. `cell -.A0`; recover it here
+    VERBS[a.cmd](load(a.path), a.arg, a)

runs/deviant_runs/anti_curr_s0_t2000.jsonl

@@ -0,0 +1 @@
+{"arm": "anti_curr", "seed": 0, "steps": 2000, "bpb": 6.8464, "decoded_acc": 0.3963, "vitals": {"drift": 0.2118, "binding_frac": 0.2812, "aliveness": {"axes_total": 128, "axes_alive": 128, "usage_ppl": 124.27613830566406, "collapsed": false}, "win_cos_mean": 0.9436, "paths": {"n": 131072, "unique_raw": 128, "unique_hashed": 128}}, "wall_s": 72.5, "peak_gb": 1.65}

runs/deviant_runs/anti_curr_s1_t2000.jsonl

@@ -0,0 +1 @@
+{"arm": "anti_curr", "seed": 1, "steps": 2000, "bpb": 6.7238, "decoded_acc": 0.3938, "vitals": {"drift": 0.2027, "binding_frac": 0.2812, "aliveness": {"axes_total": 128, "axes_alive": 128, "usage_ppl": 126.86341857910156, "collapsed": false}, "win_cos_mean": 0.943, "paths": {"n": 131072, "unique_raw": 128, "unique_hashed": 128}}, "wall_s": 71.9, "peak_gb": 1.65}

runs/deviant_runs/anti_curr_s2_t2000.jsonl

@@ -0,0 +1 @@
+{"arm": "anti_curr", "seed": 2, "steps": 2000, "bpb": 6.6606, "decoded_acc": 0.3962, "vitals": {"drift": 0.2263, "binding_frac": 0.2812, "aliveness": {"axes_total": 128, "axes_alive": 128, "usage_ppl": 123.7918701171875, "collapsed": false}, "win_cos_mean": 0.9469, "paths": {"n": 131072, "unique_raw": 128, "unique_hashed": 128}}, "wall_s": 72.4, "peak_gb": 1.65}

runs/deviant_runs/conf_penalty_CONTROL_s0_t2000.jsonl

@@ -0,0 +1 @@
+{"arm": "conf_penalty_CONTROL", "seed": 0, "steps": 2000, "bpb": 2.5268, "decoded_acc": 0.5002, "vitals": {"drift": 0.2298, "binding_frac": 0.2656, "aliveness": {"axes_total": 128, "axes_alive": 128, "usage_ppl": 123.009033203125, "collapsed": false}, "win_cos_mean": 0.9329, "paths": {"n": 131072, "unique_raw": 128, "unique_hashed": 128}}, "wall_s": 40.5, "peak_gb": 1.45}

runs/deviant_runs/conf_penalty_CONTROL_s1_t2000.jsonl

@@ -0,0 +1 @@
+{"arm": "conf_penalty_CONTROL", "seed": 1, "steps": 2000, "bpb": 2.4856, "decoded_acc": 0.5099, "vitals": {"drift": 0.2344, "binding_frac": 0.3281, "aliveness": {"axes_total": 128, "axes_alive": 128, "usage_ppl": 125.69622039794922, "collapsed": false}, "win_cos_mean": 0.9326, "paths": {"n": 131072, "unique_raw": 128, "unique_hashed": 128}}, "wall_s": 40.3, "peak_gb": 1.45}

runs/deviant_runs/conf_penalty_CONTROL_s2_t2000.jsonl

@@ -0,0 +1 @@
+{"arm": "conf_penalty_CONTROL", "seed": 2, "steps": 2000, "bpb": 2.5473, "decoded_acc": 0.4974, "vitals": {"drift": 0.2474, "binding_frac": 0.25, "aliveness": {"axes_total": 128, "axes_alive": 128, "usage_ppl": 124.56529998779297, "collapsed": false}, "win_cos_mean": 0.9251, "paths": {"n": 131072, "unique_raw": 128, "unique_hashed": 128}}, "wall_s": 41.7, "peak_gb": 1.45}

runs/deviant_runs/fac_cauchy_s0_t2000.jsonl

@@ -0,0 +1 @@
+{"arm": "fac_cauchy", "seed": 0, "steps": 2000, "bpb": 4.4321, "decoded_acc": 0.4122, "vitals": {"drift": 0.2935, "binding_frac": 0.4062, "aliveness": {"axes_total": 128, "axes_alive": 128, "usage_ppl": 119.41014862060547, "collapsed": false}, "win_cos_mean": 0.9284, "paths": {"n": 131072, "unique_raw": 128, "unique_hashed": 128}}, "wall_s": 38.9, "peak_gb": 1.45}

runs/deviant_runs/fac_cauchy_s1_t2000.jsonl

@@ -0,0 +1 @@
+{"arm": "fac_cauchy", "seed": 1, "steps": 2000, "bpb": 4.2942, "decoded_acc": 0.439, "vitals": {"drift": 0.2929, "binding_frac": 0.3906, "aliveness": {"axes_total": 128, "axes_alive": 128, "usage_ppl": 122.3031005859375, "collapsed": false}, "win_cos_mean": 0.9402, "paths": {"n": 131072, "unique_raw": 128, "unique_hashed": 128}}, "wall_s": 37.0, "peak_gb": 1.45}

runs/deviant_runs/fac_cauchy_s2_t2000.jsonl

@@ -0,0 +1 @@
+{"arm": "fac_cauchy", "seed": 2, "steps": 2000, "bpb": 4.3528, "decoded_acc": 0.4243, "vitals": {"drift": 0.2935, "binding_frac": 0.4375, "aliveness": {"axes_total": 128, "axes_alive": 128, "usage_ppl": 119.4802017211914, "collapsed": false}, "win_cos_mean": 0.9272, "paths": {"n": 131072, "unique_raw": 128, "unique_hashed": 128}}, "wall_s": 40.1, "peak_gb": 1.45}

runs/deviant_runs/fac_tanh_s0_t2000.jsonl

@@ -0,0 +1 @@
+{"arm": "fac_tanh", "seed": 0, "steps": 2000, "bpb": 4.307, "decoded_acc": 0.4366, "vitals": {"drift": 0.3013, "binding_frac": 0.375, "aliveness": {"axes_total": 128, "axes_alive": 128, "usage_ppl": 120.96920776367188, "collapsed": false}, "win_cos_mean": 0.9367, "paths": {"n": 131072, "unique_raw": 128, "unique_hashed": 128}}, "wall_s": 50.5, "peak_gb": 1.45}

runs/deviant_runs/fac_tanh_s1_t2000.jsonl

@@ -0,0 +1 @@
+{"arm": "fac_tanh", "seed": 1, "steps": 2000, "bpb": 4.3696, "decoded_acc": 0.4257, "vitals": {"drift": 0.3009, "binding_frac": 0.3906, "aliveness": {"axes_total": 128, "axes_alive": 128, "usage_ppl": 106.07247924804688, "collapsed": false}, "win_cos_mean": 0.8899, "paths": {"n": 131072, "unique_raw": 128, "unique_hashed": 128}}, "wall_s": 40.7, "peak_gb": 1.45}

runs/deviant_runs/fac_tanh_s2_t2000.jsonl

@@ -0,0 +1 @@
+{"arm": "fac_tanh", "seed": 2, "steps": 2000, "bpb": 4.3693, "decoded_acc": 0.4267, "vitals": {"drift": 0.3, "binding_frac": 0.375, "aliveness": {"axes_total": 128, "axes_alive": 128, "usage_ppl": 118.07414245605469, "collapsed": false}, "win_cos_mean": 0.9274, "paths": {"n": 131072, "unique_raw": 128, "unique_hashed": 128}}, "wall_s": 40.1, "peak_gb": 1.45}

runs/deviant_runs/focal_s0_t2000.jsonl

@@ -0,0 +1 @@
+{"arm": "focal", "seed": 0, "steps": 2000, "bpb": 2.5778, "decoded_acc": 0.5005, "vitals": {"drift": 0.2213, "binding_frac": 0.3594, "aliveness": {"axes_total": 128, "axes_alive": 128, "usage_ppl": 125.10615539550781, "collapsed": false}, "win_cos_mean": 0.9347, "paths": {"n": 131072, "unique_raw": 128, "unique_hashed": 128}}, "wall_s": 55.1, "peak_gb": 1.45}

runs/deviant_runs/focal_s1_t2000.jsonl

@@ -0,0 +1 @@
+{"arm": "focal", "seed": 1, "steps": 2000, "bpb": 2.6302, "decoded_acc": 0.4881, "vitals": {"drift": 0.2285, "binding_frac": 0.2656, "aliveness": {"axes_total": 128, "axes_alive": 128, "usage_ppl": 125.11713409423828, "collapsed": false}, "win_cos_mean": 0.9366, "paths": {"n": 131072, "unique_raw": 128, "unique_hashed": 128}}, "wall_s": 56.3, "peak_gb": 1.45}

runs/deviant_runs/focal_s2_t2000.jsonl

@@ -0,0 +1 @@
+{"arm": "focal", "seed": 2, "steps": 2000, "bpb": 2.5824, "decoded_acc": 0.4979, "vitals": {"drift": 0.241, "binding_frac": 0.3125, "aliveness": {"axes_total": 128, "axes_alive": 128, "usage_ppl": 124.72762298583984, "collapsed": false}, "win_cos_mean": 0.9303, "paths": {"n": 131072, "unique_raw": 128, "unique_hashed": 128}}, "wall_s": 55.8, "peak_gb": 1.45}

runs/deviant_runs/geomean_accum_s0_t2000.jsonl

@@ -0,0 +1 @@
+{"arm": "geomean_accum", "seed": 0, "steps": 2000, "bpb": 9.0408, "decoded_acc": 0.3024, "vitals": {"drift": 0.2533, "binding_frac": 0.3281, "aliveness": {"axes_total": 128, "axes_alive": 128, "usage_ppl": 123.65676879882812, "collapsed": false}, "win_cos_mean": 0.9664, "paths": {"n": 131072, "unique_raw": 128, "unique_hashed": 128}}, "wall_s": 52.6, "peak_gb": 1.45}

runs/deviant_runs/geomean_accum_s1_t2000.jsonl

@@ -0,0 +1 @@
+{"arm": "geomean_accum", "seed": 1, "steps": 2000, "bpb": 9.1156, "decoded_acc": 0.3032, "vitals": {"drift": 0.2681, "binding_frac": 0.4531, "aliveness": {"axes_total": 128, "axes_alive": 128, "usage_ppl": 123.70748138427734, "collapsed": false}, "win_cos_mean": 0.9624, "paths": {"n": 131072, "unique_raw": 128, "unique_hashed": 128}}, "wall_s": 52.3, "peak_gb": 1.45}

runs/deviant_runs/geomean_accum_s2_t2000.jsonl

@@ -0,0 +1 @@
+{"arm": "geomean_accum", "seed": 2, "steps": 2000, "bpb": 8.9412, "decoded_acc": 0.2996, "vitals": {"drift": 0.2708, "binding_frac": 0.375, "aliveness": {"axes_total": 128, "axes_alive": 128, "usage_ppl": 123.42230987548828, "collapsed": false}, "win_cos_mean": 0.9647, "paths": {"n": 131072, "unique_raw": 128, "unique_hashed": 128}}, "wall_s": 52.3, "peak_gb": 1.45}

runs/deviant_runs/label_smooth_s0_t2000.jsonl

@@ -0,0 +1 @@
+{"arm": "label_smooth", "seed": 0, "steps": 2000, "bpb": 2.6275, "decoded_acc": 0.4985, "vitals": {"drift": 0.2397, "binding_frac": 0.2344, "aliveness": {"axes_total": 128, "axes_alive": 128, "usage_ppl": 126.72000885009766, "collapsed": false}, "win_cos_mean": 0.9321, "paths": {"n": 131072, "unique_raw": 128, "unique_hashed": 128}}, "wall_s": 50.1, "peak_gb": 1.45}

runs/deviant_runs/label_smooth_s1_t2000.jsonl

@@ -0,0 +1 @@
+{"arm": "label_smooth", "seed": 1, "steps": 2000, "bpb": 2.5332, "decoded_acc": 0.5175, "vitals": {"drift": 0.209, "binding_frac": 0.2188, "aliveness": {"axes_total": 128, "axes_alive": 128, "usage_ppl": 124.94983673095703, "collapsed": false}, "win_cos_mean": 0.9304, "paths": {"n": 131072, "unique_raw": 128, "unique_hashed": 128}}, "wall_s": 53.4, "peak_gb": 1.45}

runs/deviant_runs/label_smooth_s2_t2000.jsonl

@@ -0,0 +1 @@
+{"arm": "label_smooth", "seed": 2, "steps": 2000, "bpb": 2.5992, "decoded_acc": 0.5061, "vitals": {"drift": 0.2307, "binding_frac": 0.4219, "aliveness": {"axes_total": 128, "axes_alive": 128, "usage_ppl": 125.7259521484375, "collapsed": false}, "win_cos_mean": 0.9292, "paths": {"n": 131072, "unique_raw": 128, "unique_hashed": 128}}, "wall_s": 54.1, "peak_gb": 1.45}

runs/deviant_runs/p4_sparsemax_s0_t2000.jsonl

@@ -0,0 +1 @@
+{"arm": "p4_sparsemax", "seed": 0, "steps": 2000, "bpb": 7.5717, "decoded_acc": 0.3957, "vitals": {"drift": 0.4523, "binding_frac": 0.125, "aliveness": {"axes_total": 64, "axes_alive": 64, "usage_ppl": 22.355093002319336, "collapsed": false}, "win_cos_mean": 0.5746, "paths": {"n": 2048, "unique_raw": 24, "unique_hashed": 24}}, "wall_s": 28.5, "peak_gb": 0.52}

runs/deviant_runs/p4_sparsemax_s1_t2000.jsonl

@@ -0,0 +1 @@
+{"arm": "p4_sparsemax", "seed": 1, "steps": 2000, "bpb": 7.5365, "decoded_acc": 0.4221, "vitals": {"drift": 0.4517, "binding_frac": 0.0625, "aliveness": {"axes_total": 64, "axes_alive": 64, "usage_ppl": 23.987043380737305, "collapsed": false}, "win_cos_mean": 0.5543, "paths": {"n": 2048, "unique_raw": 28, "unique_hashed": 28}}, "wall_s": 29.0, "peak_gb": 0.52}

runs/deviant_runs/p4_sparsemax_s2_t2000.jsonl

@@ -0,0 +1 @@
+{"arm": "p4_sparsemax", "seed": 2, "steps": 2000, "bpb": 7.5236, "decoded_acc": 0.432, "vitals": {"drift": 0.4311, "binding_frac": 0.1875, "aliveness": {"axes_total": 64, "axes_alive": 64, "usage_ppl": 24.11216926574707, "collapsed": false}, "win_cos_mean": 0.5576, "paths": {"n": 2048, "unique_raw": 24, "unique_hashed": 24}}, "wall_s": 28.1, "peak_gb": 0.52}

runs/deviant_runs/softmax_accum_s0_t2000.jsonl

@@ -0,0 +1 @@
+{"arm": "softmax_accum", "seed": 0, "steps": 2000, "bpb": 4.2063, "decoded_acc": 0.2758, "vitals": {"drift": 0.05, "binding_frac": 0.0, "aliveness": {"axes_total": 128, "axes_alive": 128, "usage_ppl": 122.14643859863281, "collapsed": false}, "win_cos_mean": 0.9602, "paths": {"n": 131072, "unique_raw": 128, "unique_hashed": 128}}, "wall_s": 52.3, "peak_gb": 1.45}

runs/deviant_runs/softmax_accum_s1_t2000.jsonl

@@ -0,0 +1 @@
+{"arm": "softmax_accum", "seed": 1, "steps": 2000, "bpb": 4.2258, "decoded_acc": 0.2873, "vitals": {"drift": 0.051, "binding_frac": 0.0, "aliveness": {"axes_total": 128, "axes_alive": 128, "usage_ppl": 122.0751724243164, "collapsed": false}, "win_cos_mean": 0.9616, "paths": {"n": 131072, "unique_raw": 128, "unique_hashed": 128}}, "wall_s": 53.0, "peak_gb": 1.45}

runs/deviant_runs/softmax_accum_s2_t2000.jsonl

@@ -0,0 +1 @@
+{"arm": "softmax_accum", "seed": 2, "steps": 2000, "bpb": 4.2981, "decoded_acc": 0.2652, "vitals": {"drift": 0.0617, "binding_frac": 0.0, "aliveness": {"axes_total": 128, "axes_alive": 128, "usage_ppl": 125.55496215820312, "collapsed": false}, "win_cos_mean": 0.9578, "paths": {"n": 131072, "unique_raw": 128, "unique_hashed": 128}}, "wall_s": 53.2, "peak_gb": 1.45}

runs/deviant_runs/sparsemax_s0_t2000.jsonl

@@ -0,0 +1 @@
+{"arm": "sparsemax", "seed": 0, "steps": 2000, "bpb": 7.45, "decoded_acc": 0.3197, "vitals": {"drift": 0.0192, "binding_frac": 0.0, "aliveness": {"axes_total": 128, "axes_alive": 128, "usage_ppl": 113.26224517822266, "collapsed": false}, "win_cos_mean": 0.9613, "paths": {"n": 131072, "unique_raw": 128, "unique_hashed": 128}}, "wall_s": 54.3, "peak_gb": 1.45}

runs/deviant_runs/sparsemax_s1_t2000.jsonl

@@ -0,0 +1 @@
+{"arm": "sparsemax", "seed": 1, "steps": 2000, "bpb": 7.4272, "decoded_acc": 0.3355, "vitals": {"drift": 0.0203, "binding_frac": 0.0, "aliveness": {"axes_total": 128, "axes_alive": 128, "usage_ppl": 116.71968078613281, "collapsed": false}, "win_cos_mean": 0.9589, "paths": {"n": 131072, "unique_raw": 128, "unique_hashed": 128}}, "wall_s": 54.5, "peak_gb": 1.45}

runs/deviant_runs/sparsemax_s2_t2000.jsonl

@@ -0,0 +1 @@
+{"arm": "sparsemax", "seed": 2, "steps": 2000, "bpb": 7.4041, "decoded_acc": 0.3383, "vitals": {"drift": 0.0214, "binding_frac": 0.0, "aliveness": {"axes_total": 128, "axes_alive": 128, "usage_ppl": 122.58434295654297, "collapsed": false}, "win_cos_mean": 0.9637, "paths": {"n": 131072, "unique_raw": 128, "unique_hashed": 128}}, "wall_s": 53.5, "peak_gb": 1.45}

runs/fac_runs/ce_fixedcode_s0_t2000.jsonl

@@ -0,0 +1,6 @@
+{"event": "config", "arm": "ce_fixedcode", "seed": 0, "base_seed": 688173314, "steps": 2000, "batch": 32, "block": 256, "d": 192, "layers": 4, "lr": 0.0003, "t_loss": 0.3, "mu": 1.0, "code": "ecc", "margin_audit": {"row_norm_min": 1.0, "row_norm_max": 1.0, "v_reach_min": 3.3333, "v_reach_max": 3.3333, "t_loss": 0.3, "mu": 1.0, "per_axis_reachable": true}, "params_trainable": 1924480, "params_trainable_ce_ref": 1990272, "param_delta_vs_ce": 65792, "readout_note": "frozen C readout \u2014 ZERO trainable readout params", "partition_note": "bpb uses raw s@C.T scores as logits (log_softmax); softmax temperature NOT calibrated \u2014 caveat", "torch": "2.11.0+cu128", "device": "cuda", "note": "frozen-C readout, CE \u2014 THE param-matched control"}
+{"event": "eval", "step": 500, "bpb": 5.0285, "decoded_acc": 0.2923, "vitals": {"head": {"drift": 0.0917, "binding_frac": 0.0, "aliveness": {"axes_total": 128, "axes_alive": 128, "usage_ppl": 117.58717346191406, "collapsed": false}, "win_cos_mean": 0.9369, "paths": {"n": 32768, "unique_raw": 128, "unique_hashed": 128}}}, "sign_fidelity": 0.9448, "gates": null}
+{"event": "eval", "step": 1000, "bpb": 4.8592, "decoded_acc": 0.3163, "vitals": {"head": {"drift": 0.1451, "binding_frac": 0.1094, "aliveness": {"axes_total": 128, "axes_alive": 128, "usage_ppl": 117.78475952148438, "collapsed": false}, "win_cos_mean": 0.9354, "paths": {"n": 32768, "unique_raw": 128, "unique_hashed": 128}}}, "sign_fidelity": 0.9389, "gates": null}
+{"event": "eval", "step": 1500, "bpb": 4.1847, "decoded_acc": 0.4244, "vitals": {"head": {"drift": 0.1673, "binding_frac": 0.1562, "aliveness": {"axes_total": 128, "axes_alive": 128, "usage_ppl": 117.19036102294922, "collapsed": false}, "win_cos_mean": 0.9489, "paths": {"n": 32768, "unique_raw": 128, "unique_hashed": 128}}}, "sign_fidelity": 0.9429, "gates": null}
+{"event": "eval", "step": 2000, "bpb": 3.7216, "decoded_acc": 0.4999, "vitals": {"head": {"drift": 0.1897, "binding_frac": 0.2188, "aliveness": {"axes_total": 128, "axes_alive": 128, "usage_ppl": 118.49891662597656, "collapsed": false}, "win_cos_mean": 0.9554, "paths": {"n": 32768, "unique_raw": 128, "unique_hashed": 128}}}, "sign_fidelity": 0.9514, "gates": null}
+{"event": "final", "arm": "ce_fixedcode", "seed": 0, "steps": 2000, "t_loss": 0.3, "mu": 1.0, "code": "ecc", "bpb": 3.7216, "decoded_acc": 0.4999, "collision_rate": 0.0, "train_curve": {"first": 5.55613, "final": 2.57454, "min": 2.57454, "every100": [[1, 5.55613], [100, 3.58998], [200, 3.53227], [300, 3.55078], [400, 3.4759], [500, 3.49183], [600, 3.46486], [700, 3.46173], [800, 3.42661], [900, 3.39767], [1000, 3.37912], [1100, 3.30872], [1200, 3.17737], [1300, 3.02575], [1400, 3.01104], [1500, 2.96913], [1600, 2.82452], [1700, 2.88912], [1800, 2.64376], [1900, 2.65145], [2000, 2.57454]]}, "vitals": {"head": {"drift": 0.1897, "binding_frac": 0.2188, "aliveness": {"axes_total": 128, "axes_alive": 128, "usage_ppl": 118.49891662597656, "collapsed": false}, "win_cos_mean": 0.9554, "paths": {"n": 32768, "unique_raw": 128, "unique_hashed": 128}}}, "sign_fidelity": 0.9514, "gates": null, "wall_s": 54.7, "peak_mem_gb": 1.45, "params_trainable": 1924480, "param_delta_vs_ce": 65792, "mu_note": "mu in v-units; per-axis reachability audited at config; joint target ||C[y]*mu||=8 exceeds ||v||<=1/t_loss \u2014 per-axis margin pull by design"}

runs/fac_runs/ce_fixedcode_s1_t2000.jsonl

@@ -0,0 +1,6 @@
+{"event": "config", "arm": "ce_fixedcode", "seed": 1, "base_seed": 1577288084, "steps": 2000, "batch": 32, "block": 256, "d": 192, "layers": 4, "lr": 0.0003, "t_loss": 0.3, "mu": 1.0, "code": "ecc", "margin_audit": {"row_norm_min": 1.0, "row_norm_max": 1.0, "v_reach_min": 3.3333, "v_reach_max": 3.3333, "t_loss": 0.3, "mu": 1.0, "per_axis_reachable": true}, "params_trainable": 1924480, "params_trainable_ce_ref": 1990272, "param_delta_vs_ce": 65792, "readout_note": "frozen C readout \u2014 ZERO trainable readout params", "partition_note": "bpb uses raw s@C.T scores as logits (log_softmax); softmax temperature NOT calibrated \u2014 caveat", "torch": "2.11.0+cu128", "device": "cuda", "note": "frozen-C readout, CE \u2014 THE param-matched control"}
+{"event": "eval", "step": 500, "bpb": 5.0409, "decoded_acc": 0.2966, "vitals": {"head": {"drift": 0.088, "binding_frac": 0.0, "aliveness": {"axes_total": 128, "axes_alive": 128, "usage_ppl": 118.2909927368164, "collapsed": false}, "win_cos_mean": 0.9312, "paths": {"n": 32768, "unique_raw": 128, "unique_hashed": 128}}}, "sign_fidelity": 0.9554, "gates": null}
+{"event": "eval", "step": 1000, "bpb": 4.8935, "decoded_acc": 0.3147, "vitals": {"head": {"drift": 0.1622, "binding_frac": 0.0938, "aliveness": {"axes_total": 128, "axes_alive": 128, "usage_ppl": 118.28981018066406, "collapsed": false}, "win_cos_mean": 0.9338, "paths": {"n": 32768, "unique_raw": 127, "unique_hashed": 127}}}, "sign_fidelity": 0.9527, "gates": null}
+{"event": "eval", "step": 1500, "bpb": 4.2945, "decoded_acc": 0.4082, "vitals": {"head": {"drift": 0.2092, "binding_frac": 0.1562, "aliveness": {"axes_total": 128, "axes_alive": 128, "usage_ppl": 120.295166015625, "collapsed": false}, "win_cos_mean": 0.9494, "paths": {"n": 32768, "unique_raw": 128, "unique_hashed": 128}}}, "sign_fidelity": 0.9554, "gates": null}
+{"event": "eval", "step": 2000, "bpb": 3.8588, "decoded_acc": 0.4768, "vitals": {"head": {"drift": 0.2356, "binding_frac": 0.3125, "aliveness": {"axes_total": 128, "axes_alive": 128, "usage_ppl": 121.67655944824219, "collapsed": false}, "win_cos_mean": 0.9569, "paths": {"n": 32768, "unique_raw": 128, "unique_hashed": 128}}}, "sign_fidelity": 0.9634, "gates": null}
+{"event": "final", "arm": "ce_fixedcode", "seed": 1, "steps": 2000, "t_loss": 0.3, "mu": 1.0, "code": "ecc", "bpb": 3.8588, "decoded_acc": 0.4768, "collision_rate": 0.0, "train_curve": {"first": 5.64217, "final": 2.69746, "min": 2.69746, "every100": [[1, 5.64217], [100, 3.55487], [200, 3.57277], [300, 3.53763], [400, 3.5044], [500, 3.47673], [600, 3.44289], [700, 3.45891], [800, 3.45679], [900, 3.45943], [1000, 3.41101], [1100, 3.36025], [1200, 3.28415], [1300, 3.17502], [1400, 3.07122], [1500, 2.96849], [1600, 2.91717], [1700, 2.83006], [1800, 2.79579], [1900, 2.77939], [2000, 2.69746]]}, "vitals": {"head": {"drift": 0.2356, "binding_frac": 0.3125, "aliveness": {"axes_total": 128, "axes_alive": 128, "usage_ppl": 121.67655944824219, "collapsed": false}, "win_cos_mean": 0.9569, "paths": {"n": 32768, "unique_raw": 128, "unique_hashed": 128}}}, "sign_fidelity": 0.9634, "gates": null, "wall_s": 53.9, "peak_mem_gb": 1.45, "params_trainable": 1924480, "param_delta_vs_ce": 65792, "mu_note": "mu in v-units; per-axis reachability audited at config; joint target ||C[y]*mu||=8 exceeds ||v||<=1/t_loss \u2014 per-axis margin pull by design"}

runs/fac_runs/ce_fixedcode_s2_t2000.jsonl

@@ -0,0 +1,6 @@
+{"event": "config", "arm": "ce_fixedcode", "seed": 2, "base_seed": 1191890990, "steps": 2000, "batch": 32, "block": 256, "d": 192, "layers": 4, "lr": 0.0003, "t_loss": 0.3, "mu": 1.0, "code": "ecc", "margin_audit": {"row_norm_min": 1.0, "row_norm_max": 1.0, "v_reach_min": 3.3333, "v_reach_max": 3.3333, "t_loss": 0.3, "mu": 1.0, "per_axis_reachable": true}, "params_trainable": 1924480, "params_trainable_ce_ref": 1990272, "param_delta_vs_ce": 65792, "readout_note": "frozen C readout \u2014 ZERO trainable readout params", "partition_note": "bpb uses raw s@C.T scores as logits (log_softmax); softmax temperature NOT calibrated \u2014 caveat", "torch": "2.11.0+cu128", "device": "cuda", "note": "frozen-C readout, CE \u2014 THE param-matched control"}
+{"event": "eval", "step": 500, "bpb": 5.0144, "decoded_acc": 0.2975, "vitals": {"head": {"drift": 0.0914, "binding_frac": 0.0, "aliveness": {"axes_total": 128, "axes_alive": 128, "usage_ppl": 118.8255615234375, "collapsed": false}, "win_cos_mean": 0.9339, "paths": {"n": 32768, "unique_raw": 128, "unique_hashed": 128}}}, "sign_fidelity": 0.9559, "gates": null}
+{"event": "eval", "step": 1000, "bpb": 4.896, "decoded_acc": 0.3172, "vitals": {"head": {"drift": 0.1561, "binding_frac": 0.0312, "aliveness": {"axes_total": 128, "axes_alive": 128, "usage_ppl": 119.43121337890625, "collapsed": false}, "win_cos_mean": 0.9312, "paths": {"n": 32768, "unique_raw": 128, "unique_hashed": 128}}}, "sign_fidelity": 0.9523, "gates": null}
+{"event": "eval", "step": 1500, "bpb": 4.3166, "decoded_acc": 0.4073, "vitals": {"head": {"drift": 0.1889, "binding_frac": 0.1875, "aliveness": {"axes_total": 128, "axes_alive": 128, "usage_ppl": 120.79203033447266, "collapsed": false}, "win_cos_mean": 0.9455, "paths": {"n": 32768, "unique_raw": 128, "unique_hashed": 128}}}, "sign_fidelity": 0.951, "gates": null}
+{"event": "eval", "step": 2000, "bpb": 3.8377, "decoded_acc": 0.4833, "vitals": {"head": {"drift": 0.205, "binding_frac": 0.2344, "aliveness": {"axes_total": 128, "axes_alive": 128, "usage_ppl": 121.07920837402344, "collapsed": false}, "win_cos_mean": 0.9553, "paths": {"n": 32768, "unique_raw": 128, "unique_hashed": 128}}}, "sign_fidelity": 0.9577, "gates": null}
+{"event": "final", "arm": "ce_fixedcode", "seed": 2, "steps": 2000, "t_loss": 0.3, "mu": 1.0, "code": "ecc", "bpb": 3.8377, "decoded_acc": 0.4833, "collision_rate": 0.0, "train_curve": {"first": 5.70817, "final": 2.72652, "min": 2.72652, "every100": [[1, 5.70817], [100, 3.56968], [200, 3.51576], [300, 3.54142], [400, 3.47476], [500, 3.48407], [600, 3.44005], [700, 3.51847], [800, 3.40848], [900, 3.43823], [1000, 3.34821], [1100, 3.35495], [1200, 3.28955], [1300, 3.15745], [1400, 3.14624], [1500, 2.96627], [1600, 2.91325], [1700, 2.87134], [1800, 2.81051], [1900, 2.76078], [2000, 2.72652]]}, "vitals": {"head": {"drift": 0.205, "binding_frac": 0.2344, "aliveness": {"axes_total": 128, "axes_alive": 128, "usage_ppl": 121.07920837402344, "collapsed": false}, "win_cos_mean": 0.9553, "paths": {"n": 32768, "unique_raw": 128, "unique_hashed": 128}}}, "sign_fidelity": 0.9577, "gates": null, "wall_s": 53.6, "peak_mem_gb": 1.45, "params_trainable": 1924480, "param_delta_vs_ce": 65792, "mu_note": "mu in v-units; per-axis reachability audited at config; joint target ||C[y]*mu||=8 exceeds ||v||<=1/t_loss \u2014 per-axis margin pull by design"}

runs/fac_runs/ce_s0_t2000.jsonl

@@ -0,0 +1,6 @@
+{"event": "config", "arm": "ce", "seed": 0, "base_seed": 1169907951, "steps": 2000, "batch": 32, "block": 256, "d": 192, "layers": 4, "lr": 0.0003, "t_loss": 0.3, "mu": 1.0, "code": null, "margin_audit": null, "params_trainable": 1990272, "params_trainable_ce_ref": 1990272, "param_delta_vs_ce": 0, "readout_note": "trained Linear(256,256) readout", "partition_note": "bpb uses raw s@C.T scores as logits (log_softmax); softmax temperature NOT calibrated \u2014 caveat", "torch": "2.11.0+cu128", "device": "cuda", "note": "certified addr_msl64 incumbent (3-seed 2.4685)"}
+{"event": "eval", "step": 500, "bpb": 3.5222, "decoded_acc": 0.3009, "vitals": {"head": {"drift": 0.099, "binding_frac": 0.0, "aliveness": {"axes_total": 128, "axes_alive": 128, "usage_ppl": 124.31436157226562, "collapsed": false}, "win_cos_mean": 0.9695, "paths": {"n": 32768, "unique_raw": 128, "unique_hashed": 128}}}, "sign_fidelity": 0.9525, "gates": null}
+{"event": "eval", "step": 1000, "bpb": 3.3639, "decoded_acc": 0.325, "vitals": {"head": {"drift": 0.1297, "binding_frac": 0.0, "aliveness": {"axes_total": 128, "axes_alive": 128, "usage_ppl": 125.59706115722656, "collapsed": false}, "win_cos_mean": 0.9587, "paths": {"n": 32768, "unique_raw": 128, "unique_hashed": 128}}}, "sign_fidelity": 0.9507, "gates": null}
+{"event": "eval", "step": 1500, "bpb": 2.7599, "decoded_acc": 0.4466, "vitals": {"head": {"drift": 0.1884, "binding_frac": 0.1719, "aliveness": {"axes_total": 128, "axes_alive": 128, "usage_ppl": 125.66361999511719, "collapsed": false}, "win_cos_mean": 0.9454, "paths": {"n": 32768, "unique_raw": 128, "unique_hashed": 128}}}, "sign_fidelity": 0.9361, "gates": null}
+{"event": "eval", "step": 2000, "bpb": 2.5004, "decoded_acc": 0.5001, "vitals": {"head": {"drift": 0.2545, "binding_frac": 0.3281, "aliveness": {"axes_total": 128, "axes_alive": 128, "usage_ppl": 126.27082061767578, "collapsed": false}, "win_cos_mean": 0.93, "paths": {"n": 32768, "unique_raw": 128, "unique_hashed": 128}}}, "sign_fidelity": 0.9146, "gates": null}
+{"event": "final", "arm": "ce", "seed": 0, "steps": 2000, "t_loss": 0.3, "mu": 1.0, "code": null, "bpb": 2.5004, "decoded_acc": 0.5001, "collision_rate": null, "train_curve": {"first": 5.55115, "final": 1.71296, "min": 1.71296, "every100": [[1, 5.55115], [100, 2.80654], [200, 2.59162], [300, 2.48218], [400, 2.55176], [500, 2.51223], [600, 2.42308], [700, 2.38143], [800, 2.37819], [900, 2.35726], [1000, 2.31292], [1100, 2.20838], [1200, 2.15096], [1300, 2.03818], [1400, 2.03527], [1500, 1.93894], [1600, 1.87538], [1700, 1.83741], [1800, 1.84276], [1900, 1.81583], [2000, 1.71296]]}, "vitals": {"head": {"drift": 0.2545, "binding_frac": 0.3281, "aliveness": {"axes_total": 128, "axes_alive": 128, "usage_ppl": 126.27082061767578, "collapsed": false}, "win_cos_mean": 0.93, "paths": {"n": 32768, "unique_raw": 128, "unique_hashed": 128}}}, "sign_fidelity": 0.9146, "gates": null, "wall_s": 44.5, "peak_mem_gb": 1.451, "params_trainable": 1990272, "param_delta_vs_ce": 0, "mu_note": "mu in v-units; per-axis reachability audited at config; joint target ||C[y]*mu||=8 exceeds ||v||<=1/t_loss \u2014 per-axis margin pull by design"}

runs/fac_runs/ce_s1_t2000.jsonl

@@ -0,0 +1,6 @@
+{"event": "config", "arm": "ce", "seed": 1, "base_seed": 851202169, "steps": 2000, "batch": 32, "block": 256, "d": 192, "layers": 4, "lr": 0.0003, "t_loss": 0.3, "mu": 1.0, "code": null, "margin_audit": null, "params_trainable": 1990272, "params_trainable_ce_ref": 1990272, "param_delta_vs_ce": 0, "readout_note": "trained Linear(256,256) readout", "partition_note": "bpb uses raw s@C.T scores as logits (log_softmax); softmax temperature NOT calibrated \u2014 caveat", "torch": "2.11.0+cu128", "device": "cuda", "note": "certified addr_msl64 incumbent (3-seed 2.4685)"}
+{"event": "eval", "step": 500, "bpb": 3.5379, "decoded_acc": 0.3013, "vitals": {"head": {"drift": 0.0861, "binding_frac": 0.0, "aliveness": {"axes_total": 128, "axes_alive": 128, "usage_ppl": 122.89728546142578, "collapsed": false}, "win_cos_mean": 0.9698, "paths": {"n": 32768, "unique_raw": 128, "unique_hashed": 128}}}, "sign_fidelity": 0.9509, "gates": null}
+{"event": "eval", "step": 1000, "bpb": 3.265, "decoded_acc": 0.3488, "vitals": {"head": {"drift": 0.1174, "binding_frac": 0.0, "aliveness": {"axes_total": 128, "axes_alive": 128, "usage_ppl": 123.8575210571289, "collapsed": false}, "win_cos_mean": 0.959, "paths": {"n": 32768, "unique_raw": 128, "unique_hashed": 128}}}, "sign_fidelity": 0.9483, "gates": null}
+{"event": "eval", "step": 1500, "bpb": 2.7288, "decoded_acc": 0.4558, "vitals": {"head": {"drift": 0.1812, "binding_frac": 0.1406, "aliveness": {"axes_total": 128, "axes_alive": 128, "usage_ppl": 124.866455078125, "collapsed": false}, "win_cos_mean": 0.9459, "paths": {"n": 32768, "unique_raw": 128, "unique_hashed": 128}}}, "sign_fidelity": 0.9383, "gates": null}
+{"event": "eval", "step": 2000, "bpb": 2.4768, "decoded_acc": 0.5058, "vitals": {"head": {"drift": 0.2364, "binding_frac": 0.3438, "aliveness": {"axes_total": 128, "axes_alive": 128, "usage_ppl": 125.47602844238281, "collapsed": false}, "win_cos_mean": 0.9344, "paths": {"n": 32768, "unique_raw": 128, "unique_hashed": 128}}}, "sign_fidelity": 0.9238, "gates": null}
+{"event": "final", "arm": "ce", "seed": 1, "steps": 2000, "t_loss": 0.3, "mu": 1.0, "code": null, "bpb": 2.4768, "decoded_acc": 0.5058, "collision_rate": null, "train_curve": {"first": 5.55206, "final": 1.76768, "min": 1.73487, "every100": [[1, 5.55206], [100, 2.76865], [200, 2.56418], [300, 2.50292], [400, 2.45994], [500, 2.46286], [600, 2.42948], [700, 2.40484], [800, 2.37874], [900, 2.33296], [1000, 2.29799], [1100, 2.15992], [1200, 2.04953], [1300, 1.95414], [1400, 1.95962], [1500, 1.87639], [1600, 1.8719], [1700, 1.80011], [1800, 1.79421], [1900, 1.73487], [2000, 1.76768]]}, "vitals": {"head": {"drift": 0.2364, "binding_frac": 0.3438, "aliveness": {"axes_total": 128, "axes_alive": 128, "usage_ppl": 125.47602844238281, "collapsed": false}, "win_cos_mean": 0.9344, "paths": {"n": 32768, "unique_raw": 128, "unique_hashed": 128}}}, "sign_fidelity": 0.9238, "gates": null, "wall_s": 45.6, "peak_mem_gb": 1.451, "params_trainable": 1990272, "param_delta_vs_ce": 0, "mu_note": "mu in v-units; per-axis reachability audited at config; joint target ||C[y]*mu||=8 exceeds ||v||<=1/t_loss \u2014 per-axis margin pull by design"}

runs/fac_runs/ce_s2_t2000.jsonl

@@ -0,0 +1,6 @@
+{"event": "config", "arm": "ce", "seed": 2, "base_seed": 733282755, "steps": 2000, "batch": 32, "block": 256, "d": 192, "layers": 4, "lr": 0.0003, "t_loss": 0.3, "mu": 1.0, "code": null, "margin_audit": null, "params_trainable": 1990272, "params_trainable_ce_ref": 1990272, "param_delta_vs_ce": 0, "readout_note": "trained Linear(256,256) readout", "partition_note": "bpb uses raw s@C.T scores as logits (log_softmax); softmax temperature NOT calibrated \u2014 caveat", "torch": "2.11.0+cu128", "device": "cuda", "note": "certified addr_msl64 incumbent (3-seed 2.4685)"}
+{"event": "eval", "step": 500, "bpb": 3.5371, "decoded_acc": 0.2967, "vitals": {"head": {"drift": 0.0892, "binding_frac": 0.0, "aliveness": {"axes_total": 128, "axes_alive": 128, "usage_ppl": 122.30438232421875, "collapsed": false}, "win_cos_mean": 0.9688, "paths": {"n": 32768, "unique_raw": 128, "unique_hashed": 128}}}, "sign_fidelity": 0.9473, "gates": null}
+{"event": "eval", "step": 1000, "bpb": 3.1838, "decoded_acc": 0.3643, "vitals": {"head": {"drift": 0.1183, "binding_frac": 0.0, "aliveness": {"axes_total": 128, "axes_alive": 128, "usage_ppl": 124.03565979003906, "collapsed": false}, "win_cos_mean": 0.9525, "paths": {"n": 32768, "unique_raw": 128, "unique_hashed": 128}}}, "sign_fidelity": 0.9448, "gates": null}
+{"event": "eval", "step": 1500, "bpb": 2.6783, "decoded_acc": 0.4639, "vitals": {"head": {"drift": 0.1782, "binding_frac": 0.1406, "aliveness": {"axes_total": 128, "axes_alive": 128, "usage_ppl": 124.962890625, "collapsed": false}, "win_cos_mean": 0.9396, "paths": {"n": 32768, "unique_raw": 128, "unique_hashed": 128}}}, "sign_fidelity": 0.9299, "gates": null}
+{"event": "eval", "step": 2000, "bpb": 2.4536, "decoded_acc": 0.5104, "vitals": {"head": {"drift": 0.2274, "binding_frac": 0.2656, "aliveness": {"axes_total": 128, "axes_alive": 128, "usage_ppl": 125.4764404296875, "collapsed": false}, "win_cos_mean": 0.9296, "paths": {"n": 32768, "unique_raw": 128, "unique_hashed": 128}}}, "sign_fidelity": 0.9165, "gates": null}
+{"event": "final", "arm": "ce", "seed": 2, "steps": 2000, "t_loss": 0.3, "mu": 1.0, "code": null, "bpb": 2.4536, "decoded_acc": 0.5104, "collision_rate": null, "train_curve": {"first": 5.59072, "final": 1.68083, "min": 1.68083, "every100": [[1, 5.59072], [100, 2.80129], [200, 2.56276], [300, 2.49087], [400, 2.4736], [500, 2.44614], [600, 2.40425], [700, 2.39409], [800, 2.36525], [900, 2.2793], [1000, 2.20186], [1100, 2.11937], [1200, 2.02742], [1300, 1.95192], [1400, 1.90608], [1500, 1.9137], [1600, 1.85935], [1700, 1.80106], [1800, 1.76603], [1900, 1.7115], [2000, 1.68083]]}, "vitals": {"head": {"drift": 0.2274, "binding_frac": 0.2656, "aliveness": {"axes_total": 128, "axes_alive": 128, "usage_ppl": 125.4764404296875, "collapsed": false}, "win_cos_mean": 0.9296, "paths": {"n": 32768, "unique_raw": 128, "unique_hashed": 128}}}, "sign_fidelity": 0.9165, "gates": null, "wall_s": 45.5, "peak_mem_gb": 1.451, "params_trainable": 1990272, "param_delta_vs_ce": 0, "mu_note": "mu in v-units; per-axis reachability audited at config; joint target ||C[y]*mu||=8 exceeds ||v||<=1/t_loss \u2014 per-axis margin pull by design"}