Under review (split-residual interface): cross-copy idle-axis hosting, one residual on two copies of one idle child; computed κ = 0.001330733966732373 not established

[higherbeing]

Conditional κ = 1330733966732373/10¹⁸ ≈ 1.330733966732373·10⁻³, bit-bound, +5.13 % over #447 (1.265848755025709·10⁻³, complex-bound), +7.53 % over #442 and +17.44 % over #434. Neither local word changes: complex #433 (R = 560, m = 73), bit #434 (R = 747, m = 64). The idle windows are #442's.

Change

In #442's idle-axis hosting a whole helper residual sits inside the pending coordinates of one data family. Bit residuals have width 8 − e (637 of width 8, 104 of width 7, 6 of width 4) and complex residuals width 9, while the idle children have ranks 7/14/28/42 (bit) and 8/16/32/48 (complex). A rank-7 child cannot hold a width-8 residual, a rank-14 child holds one and wastes six coordinates, and so on: 6,944 of the 45,360 pending bit coordinates per replica and 5,760 of 51,840 complex ones stay idle and are paid as remainder children.

A child acts on every copy (side, port) of its pair, and all copies share the child's window. This package lets a residual lie across the pending sets of two copies of the same idle child. With P = P₁ + P₂ the identity D_{P₁}·D_{P₂} = D_P (the parents' D_{P'}·D_{P−P'} = D_P) writes the dirty invocation's factor on the residual as a product of a factor on each family; each is moved to the child exactly as in #442 §2, since the window is a property of the pair; and each child's remainder is exact by #442's fact (b). Every child's capacity, copies × rank, is then a multiple of the residual width, so the remainders almost vanish. A residual never spans two children or two pairs. The route is still an elementary coordinate permutation of the address space; the finite invoice charges one further route factor per helper selector.

The selection is an integer programme over counts n(child, stage, width) on the concatenated tape of each child's copies (maximise Σ ln(m/r) × hosted coordinates, subject to availability and, on the bit side, exact width-64 tiling of the leftover). SELECTION.json freezes it; --discover recomputes it with scipy.

Result

supplier	#442 saving	this saving	live stock	hosted residuals (split)	max child
bit, m = 64, R = 747	1.239085·10⁻³	1.332507·10⁻³	9,457 → 8,592	46,160 of 53,784 (12,496)	24
complex, m = 73, R = 560	1.267453·10⁻³	1.437532·10⁻³	8,400 → 7,680	40,320 of 40,320 (13,720)	48

Both rank deficits stay 2496. The bit max child 24 is one partial copy of a rank-28 child; the complex max child 48 is the 133 copies per replica of the rank-48 final children that the complex supply cannot fill (5,040 residuals against 5,760 width-9 slots per replica). Since #447 is complex-bound at 1.267453·10⁻³, the complex component here should also lift #445/#447's eleven-stage bit words; that composition is not claimed.

Validation

python3 -B research/cross-copy-hosting/verify.py /absolute/new/output (Python 3.11+, standard library only; the output directory must not exist). It

1. runs Conditional kappa 0.001249035299298004: hosting-selected rank147 kernel #434's complete verifier from scratch;
2. regenerates both hosted templates from Conditional kappa 0.001249035299298004: hosting-selected rank147 kernel #434's fresh outputs and the frozen selection;
3. runs an independent audit that shares no code with the generators: windows re-derived from each schedule; for every replica and invocation exactly one owner record per helper; every hosted residual has one or two pieces on copies of the child it names, widths summing to the residual width, inside the pending set, pairwise disjoint per (child, copy), inside the window and off the active pair; exact remainder children and bank tilings; profile, live stock and deficit 2496 recomputed; twelve mutation controls rejected (including a split across two children and a split whose widths do not sum to the residual width);
4. prices both suppliers with the two inherited rational moment engines and fresh finite invoices (prefix 226 bits charged 256, two-level coefficient 488 bits charged 512, row coefficient 18,355 < 20,161; complex row coefficient 15,443);
5. runs Conditional kappa 0.001249035299298004: hosting-selected rank147 kernel #434's strict outer assembly: six bootstrap levels and all 47 inequalities, with the next grid point and the zero-η, zero-β and unit-β controls rejected.

Local transcript: PASS_FULL_CROSS_COPY_HOSTING_COMPOSITION on macOS (Apple silicon), Python 3.14.3, 5 min 48 s including the full #434 replay; every value equals EXPECTED.json and both template hashes match. CI is not claimed before it runs.

Scope

This is a written finite extension of #442's hosting interface: a helper residual's physical slot may lie in two data families of one idle child. That is the principal new review point; PROOF.md gives the argument from the parents' two facts. #442's own extension (helper residuals on data streams during idle windows) and all inherited interfaces remain assumptions: the all-size compiler, correlated dirty-bank and compressed-window interfaces, restored work, tape/common grid, precision and analytic transfer. The global operator identity is argued and checked combinatorially, not replayed numerically on the address spaces. No Lean proof and no unconditional integer-multiplication theorem is claimed.

Credits and AI disclosure

Builds on and runs unchanged: #442 (DaysSky, idle-axis hosting; windows and bank tilings reused), #434 (Rohan Arun), #433 (icekylinx), #435/#417 (chafreaky), #426 (ai-nanachi), #425/#386 (Zhihao Chen), #370 (Dylan Crow), Jacob Sussman's E8 unit and interfaces. This branch is #442's branch plus one new directory, research/cross-copy-hosting/; no inherited file is changed. The cross-copy selection, generators, audit, assembly and proof note were prepared by higherbeing with substantial Claude (Anthropic) assistance.

🤖 Generated with Claude Code

[hipotures]

Independent replay and a note on the split-residual interface (from an outside batch; no claim of our own)

Replay. At the pinned head 359022bc, research/cross-copy-hosting/verify.py passes from a fresh detached worktree with a fresh output directory and reproduces κ = 0.001330733967 exactly. The same holds for #480 at 668c7dd0, which reproduces 0.001372550159. This is part of a batch of 39 pinned frontier replays; 34 of them pass.

Ledger of the produced templates. We wrote a checker that shares no code with the package. It reads bit/ and complex/GLOBAL-TEMPLATE.json.gz and finds the following.

• Coordinate accounting is consistent. There are no overlapping hosted intervals, nothing outside a child's rank and no row outside its window. The windows re-derived from the template's own schedule match the stored ones.
• The split is used heavily. It covers 1562 of 5770 hosted bit residuals (27%) and 1715 of 5040 complex residuals (34%). In Under review (split-residual interface): cross-copy hosting on #472's R715 eleven-stage word; computed κ = 0.001372550159367980 not established #480's bit template it is 14612 of 62920 (23%), and 1807 of 8140 in Conditional κ = 0.001347744547714835: eleven-stage cross-copy hosting with target mixing (+1.278% over #448) #450 and Conditional κ = 0.001350580884553120: gate-frame retiming of #450's eleven-stage cross-copy word (+0.2105%) #469. None of the 61 whole-hosting templates we checked (Conditional kappa 0.001249035299298004: hosting-selected rank147 kernel #434 … Conditional κ = 0.001303530097714685: an E8 bit word with 489 helpers, sources as carriers (0.001325 with #484's draft complex supplier) #493) contains a split.
• The owner table names one family per split helper. Each split helper has one entry in calls[].owners, keyed to the first piece's family, for example [240, ['hosted-split', 0, 8, 6, 241, 0, 2]]. The second family appears only inside the descriptor. Conditional κ ≈ 1.2375517e-3: idle-axis hosting of helper residuals (+9.2% over #434) #442's audit enforces "each helper has exactly one owner".

Where we think the review point is. In your §7 reply on #451, the open question is whether one local register's route may land in two families. We checked exactly this in an exact small model in which each register of the fixed local word is bound to one physical stream and streams form a direct sum.

• The model. The word uses its helper as genuinely dirty scratch (x += A h; h ← F_R h; x −= A F_R⁻¹ h; x ← T x). The coordinate factors are the bit D_S and the complex C_S, the same as in the Conditional κ = 0.001265931727546219: dual eleven-stage whole-residual hosting #451 note and in toy_two_family_check.py.
• Whole hosting (Conditional κ ≈ 1.2375517e-3: idle-axis hosting of helper residuals (+9.2% over #434) #442) works. It equals the original program in all 13 cases.
• A single-register split does not. We enumerated every single-register binding and coordinate placement of a split residual: 152 programs over 18 cases (bit q = 3, 5; complex q = 2; m ≤ 8). None of them equals the original program.
• Two registers do. With one helper per piece, the split equals the original program in all 18 cases. That is a different local word with one more helper per split residual, and it is not the word that was priced.

toy_two_family_check.py composes D_a^A ⊗ D_b^B with the remainder children. As we read it, that already takes as given an invocation that applies one register's residual factor to two streams. Our model asks whether the priced word, with its helper as a single register, can be that invocation. It cannot when a register lives in one stream. So the claim seems to need either an explicit interface for multi-stream registers (with the dirty read A h spanning two families), or the extra helpers priced in. We have not computed κ with the extra helpers.

Code and data:

• report
• stream model, about 10 s
• template ledger

This is our model of the declared execution, not a proof that no other realisation exists. If the hub's compiler interface does allow a register to span two streams at no extra cost, a pointer to where that is stated would settle it.

---

This analysis was carried out by Claude Opus 5.5 (Anthropic) under human supervision.

[higherbeing]

Thank you for the replay and for the stream model; this is the right level to settle it at, and I think your reading is the faithful one.

Where #448 §2 and §7 go wrong, stated plainly: the two-family argument takes the invocation's action on a split residual to be D_a^A ⊗ D_b^B as given. That presupposes that one local register can be read and written across two streams, which is exactly what your single-register enumeration tests and refutes (the dirty read x += A h has to see both pieces). The hub never states a multi-stream register interface; every owner table binds a register to one family, and I cannot point to a place where the compiler admits otherwise. So the realisation that does exist is your two-register control, and it is a different local word.

Pricing that word kills the gain. A second register per split helper must follow the same frame chain to every gate where the helper is an operand, so its climb mass is paid again. On #448's bit template your ledger counts 1,562 split residuals per replica, about 174 per invocation; at the word's average helper cost (≈29 Φ-units per helper per invocation at m = 64) that is roughly +5,000 per invocation, against about 2,100 per invocation saved by removing the remainder children. The complex side is similar. So under the single-stream model cross-copy hosting is a net loss, not a gain, and the figures in #448, #480 and #494, and in #450, #453, #464 and #469 which rest on the same slot, are not established.

I am retitling #448, #480 and #494 as under review on this point and leaving them as drafts with the packages intact, so the record of what was computed stays reproducible. If a multi-stream register interface is ever stated and charged in the hub, the packages apply unchanged; absent that, the whole-residual line is the frontier. Thanks also to chafreaky, whose #451 note pointed at the same gap from the operator side.