[Draft] Complex supplier b ≈ 1.334e-3 (+5.2%): shared-donor kernel and entrance gauges on the E8 complex word

research/e8-complex-gauge-kernel/NOTICE.md

@@ -0,0 +1,4 @@
+Apache-2.0. `code/audit_cxg.py`, `emit_cxg.py`, `phases_cxg.py` are modified copies of PR #433's `complex_audit.py`,
+`complex_emit.py`, `complex_phases_full.py` (icekylinx with Codex; adapted from PR #425 by jacklightChen / Zhihao Chen).
+`code/hostmodel.py` replicates the profile arithmetic of PR #442's `complex_hosted.py` (DaysSky) for mixed widths.
+Prepared by DreamingOfClouds with Claude Opus 5.5 (Anthropic), via Claude Code.

research/e8-complex-gauge-kernel/PROOF.md

@@ -0,0 +1,59 @@
+# Lemmas used by the draft (both are NEW and are the review points)
+
+Setting: #442's complex word (#433's split-centre R560 word, m = 73, nine stages) with the idle-axis hosting of #442.
+Notation: frames are subspaces of F2^9; T_U = canonical_frame(9, U) (clifford_exact.py); T_FULL is the full Fourier
+transform; a helper normally climbs ∅ → … → FULL and its residual has width 9.
+
+## 0. What is not claimed
+The entrance lines used here are all of EVEN weight, i.e. totally isotropic for the F2 dot product (14 distinct rank-1
+lines in the kernel word; 16 frames of rank 1, 2 and 4 in the combined word). The bit-style criterion of #440
+(`validate_isometries`: an orthonormal basis whose first e rows span E, i.e. coordinate entrances) is therefore NOT met:
+no orthogonal matrix of O(9,2) sends an isotropic E to coordinate axes. `code/iso1.py` shows that, restricted to
+entrances that do meet it, the kernel potential and the number of gauge-eligible helpers are both 0. #442's shipped
+complex audit asserts `w == 9` for hosted residuals (`idle-axis-hosting/audit.py:92`), and #433's emit asserts
+`c['start'][r]==0` for compensated registers (`complex_emit.py:55`). No shipped complex word has a nonzero helper
+entrance. Everything below is therefore CONDITIONAL on Lemma A and Lemma G.
+
+## Lemma A (entrance adapter) — review point 1
+Let E ⊆ F2^9, e = dim E, w = 9 − e, and Φ_E = T_E^† T_FULL (the chain ∅ → E removed from the helper's climb).
+(i) Φ_E = R_E (C_[w] ⊗ I) L_E with R_E, L_E explicit Gaussian monomials (address permutation, quadratic phase, X
+translation), exactly, including the global phase. This is `lower_child` applied to Φ_E: it asserts rank w,
+`compiled.tab == Φ_E.tab` and `compiled.zero_state() == Φ_E.zero_state()`.
+(ii) Claim (assumed, not proved): a helper that starts at frame E and ends at FULL, with its compensation moved off
+the zero frame (kernel: absorbed by donors; gauge: Lemma G), acts on its residual stream as the exact coordinate
+factor P_g C_[w] P_g^-1 that hosting lemma (a) of #442 uses, where the monomials R_E, L_E are rank-zero local gates like
+the endpoint adapters of #425. Its residual block has width w; the e remaining local coordinates carry arbitrary
+dirt and are transformed by Φ_E like any other dirt coordinate, which the arbitrary-dirt restoration identity
+(replayed exactly on all 800 columns) tolerates.
+Evidence: `code/nec4.py` — all 16 entrance frames of `gauge80-kernel42` pass (i); `code/nec3.py` shows the tableaux:
+for coordinate frames Φ_E fixes every X_i, for the isotropic and odd-weight non-coordinate frames it does not, i.e.
+the monomials are genuinely non-orthogonal GL(9,2) address maps. Part (ii) is where a reviewer must look: it is the
+statement that the bank block of width w plus a non-orthogonal monomial adapter is an admissible residual route.
+
+## Lemma K (shared-donor kernel, port of #417/#435/#434)
+A pivot p with exact response relation col(p) = Σ q_d col(d) over donors d, entrance E ⊆ first frame of p and of every
+donor, starts at frame E; each donor receives `d += -q_d p` at frame E before the main word (inverse after the
+cleanup at the full frame); the compensation columns of pivots are dropped. Exactness is the arbitrary-dirt replay
+(donor update is part of the replayed word); frames are checked by the chain assertion. Same statement as in #440,
+with rational coefficients (all denominators are powers of two, as required by `primitive_bound`).
+
+## Lemma G (entrance gauge, nonzero-frame compensation and centre scatter) — review point 2
+For a helper j with entrance E_j (a member of a nested family) its compensation `y_t += c_tj x_j` is executed at
+frame E_j instead of frame 0, as the first gates of the main word; the helper starts at E_j and every target t in its
+response support climbs ∅ → L_t, L_t = the largest E_j with t in the support of j.
+Constraints (all checked): (a) E_j ⊆ first frame of j and ⊆ the first main frame of every target in its support;
+(b) the entrances touching one target are pairwise nested; (c) for every centre k, the levels L_t of the targets it
+scatters into form a chain whose top lies inside the centre frame c_k. The centre scatter then runs as: copy at c_k;
+lower stepwise c_k → (served levels, descending) → lowest served level; scatter into the targets of level L at frame L;
+clear at the lowest level (reversed in the transposed orientation). The total lowering rank equals the baseline 8
+whenever some served target has level ∅, so the rank deficit stays 2496.
+Claim (assumed): a scalar add at frame E between a helper at E and a target raised to E, and the centre scatter at
+frame L between a copy lowered only to L and a target at L, are the same operators as the zero-frame versions up to the
+common exterior window (the common-frame lemma of #425, extended from frame 0 to frame L).
+Evidence: audit (exact arbitrary-dirt and inverse-transpose replay of the full program including the gauge gates),
+emit (literal scalar replay of both orientations on 800 columns, centre lifetimes, `paid` equals the audit profile),
+exact Gaussian recipes for every used transition (2,940 edges for the gauge word).
+
+## Mutation controls (to be added in the full package)
+Not yet run: omit the donor update, flip a gauge coefficient sign, move an entrance out of the first frame, break a
+centre chain. `audit_cxg.py` already rejects frame-chain violations by assertion.

research/e8-complex-gauge-kernel/README.md

@@ -0,0 +1,58 @@
+# Complex supplier b: shared-donor kernel and entrance gauges on the E8 complex word (DRAFT, status: work in progress)
+
+Not a claim yet. The claim is CONDITIONAL on two new lemmas (see `PROOF.md`) and the global package is not built.
+
+## Construction
+On #442's complex word (#433's split-centre R560 word, m = 73, nine stages, idle-axis hosting), two tools of the
+bit side are ported:
+- **Shared-donor kernel** (#417/#435/#434/#439/#440 style): 79 pivots, rank-1 entrances, 14 entrance frames.
+- **Entrance gauges** (#401/#408–#416 style): compensation moved to the entrance frame; 80 helpers, entrance
+  rank 106 (62 rank-1, 14 rank-2, 4 rank-4), nested per target and per centre.
+- Not portable on this word: elimination reuse and early resets (#436/#437): 0 helpers survive the frame-monotonicity
+  check; block retiming (#441/#440): 0 improvement (frame cost unchanged after single-gate and closure moves).
+
+## Measured (hosted b, exact moment engine; the hosting step is my replica of #442's, which reproduces #442's complex b
+1.267453159029119e-3, live stock 8400 and rank deficit 2496 to the last digit)
+| word | helpers entering | total entrance rank | b | gain | κ cap if complex-bound |
+| --- | ---: | ---: | ---: | ---: | ---: |
+| #442 complex | 0 | 0 | 1.267453e-3 | | 1.265849e-3 |
+| kernel only | 79 | 79 | 1.310216e-3 | +3.37% | 1.308502e-3 |
+| gauge only | 80 | 106 | 1.310916e-3 | +3.43% | 1.309200e-3 |
+| gauge + kernel | 122 | 148 | **1.333854e-3** | **+5.24%** | 1.332077e-3 |
+The combined word hosts all 40,320 residuals (live stock 7,680, no bank). The rank deficit is 2496 in every row.
+
+## Checks that PASS (local word only; `sh check.sh DIR`)
+- Exact arbitrary-dirt and inverse-transpose replay of the full word (800 columns), frame chain, paid profile.
+- Emitted local program, literal scalar replay in both orientations on 800 columns with centre lifetimes.
+- Exact Gaussian phase recipes for every used frame transition (`PHASES=1`): 2,932 / 2,940 / 2,952 edges.
+- Entrance-adapter evidence: for all 16 entrance frames E→FULL = monomial · C_[9−e] · monomial exactly
+  (`lower_child`: tableau and state-vector equality, global phase included).
+
+## Plain statements about what is NOT met
+- **The entrances are isotropic** (even-weight lines of F2^9). The bit-style coordinate-entrance criterion (#440's
+  `validate_isometries`) is NOT met, and no orthogonal map of O(9,2) can meet it for these lines. Restricted to
+  entrances that meet it, the gain is 0 (`code/iso1.py`).
+- **#442's shipped complex audit and emit assume `w == 9` and `start == 0`.** No shipped complex word has a nonzero
+  helper entrance. The audit, emit and phase scripts used here are PATCHED copies (`code/audit_cxg.py`, `emit_cxg.py`,
+  `phases_cxg.py`: pre-ops, entrance starts, target levels, centre descent); their defaults are not yet shown to
+  reproduce #442's files byte for byte.
+- The claim is therefore **conditional on Lemma A (entrance adapter) and Lemma G (nonzero-frame compensation and centre
+  scatter)**, which are the headline review points.
+
+## Pending
+Global template, owner tables and hosting generator for mixed residual widths (the hosted b above is a model);
+residual-to-bank routes for each entrance frame; written proofs of Lemma A(ii) and Lemma G; mutation controls;
+finite invoices and the outer assembly (47/47) with a bit word; byte-for-byte regression of the generalised scripts at
+the #442 defaults; two fresh-copy replays.
+
+## Files
+`PROOF.md` lemmas and scope; `check.sh`; `data/words/*/FULL-WORD.json.gz` the three words; `data/selection/*.json`
+frozen selections; `code/` checks (`audit_cxg.py`, `emit_cxg.py`, `phases_cxg.py`, `cxcheck.py`, `hostmodel.py`,
+`final_eval.py`, `nec3.py`, `nec4.py`, `iso1.py`) and the search scripts that produced the selections
+(`kern*.py`, `gauge*.py`, `retime.py`, `reuse*.py`).
+
+## Credits
+Builds on #442 (DaysSky, idle-axis hosting), #433 (icekylinx, split centres), #425 and #386 (jacklightChen / Zhihao
+Chen, mutable packets, compressed windows), the shared-donor kernel of #417/#435 (chafreaky) and #434/#440 (rohanarun,
+chafreaky), the entrance gauges of #401/#408–#416, #370 (Dylan Crow) and Jacob Sussman's E8 unit.
+Prepared by DreamingOfClouds with Claude Opus 5.5 (Anthropic), via Claude Code. Apache-2.0.

research/e8-complex-gauge-kernel/check.sh

@@ -0,0 +1,23 @@
+#!/bin/sh
+# Draft local checks for the complex gauge/kernel words.
+#   CXG_BASE : output directory of `python -B research/idle-axis-hosting/verify.py $CXG_BASE` (PR #442 replay; contains parent/changed/)
+#   CXG_REPO : checkout of PR #442's tree (research/split-centres-global, research/idle-axis-hosting)
+#   PY       : python with numpy + scipy (hosted-b model); stdlib python is enough for the other steps
+#   PHASES=1 : also replay the exact Gaussian phase recipes of every used frame transition (about 160 s per word)
+# usage: sh check.sh /absolute/new/output/dir
+set -e
+: "${CXG_BASE:?}"; : "${CXG_REPO:?}"; PY=${PY:-python3}; OUT=${1:?new output dir}
+PKG=$(cd "$(dirname "$0")" && pwd); export CXG_PKG=$PKG CXG_BASE CXG_REPO PYTHONDONTWRITEBYTECODE=1
+mkdir -p "$OUT"
+for w in kernel79 gauge80 gauge80-kernel42; do
+  d="$OUT/$w"; mkdir -p "$d"
+  cp -RL "$CXG_BASE/parent/changed/split-centres" "$d/split-centres"
+  cp -RL "$CXG_BASE/parent/changed/work" "$d/work"
+  cp "$PKG/data/words/$w/FULL-WORD.json.gz" "$d/split-centres/FULL-WORD.json.gz"
+  echo "== $w: arbitrary-dirt + inverse-transpose replay, frame chain, paid profile"; (cd "$d" && python3 -B "$PKG/code/audit_cxg.py" | tail -3)
+  echo "== $w: emitted program, literal scalar replay (forward and backward, 800 columns, centre lifetimes)"; (cd "$d" && python3 -B "$PKG/code/emit_cxg.py" | tail -2)
+  if [ -n "$PHASES" ]; then echo "== $w: exact Gaussian phase recipes (all used edges)"; (cd "$d" && python3 -B "$PKG/code/phases_cxg.py" | tail -1); fi
+done
+echo "== entrance-adapter evidence (nec3: tableau shapes, nec4: lower_child equality for every entrance frame)"
+(cd "$PKG/code" && python3 -B nec3.py && $PY -B nec4.py)
+echo "== hosted b (exact moment engine) per tool"; (cd "$PKG/code" && CXG_OUT="$OUT" $PY -B final_eval.py | cut -c1-200)