Open asynchronous whole-owner allocator and a delivery-layer map of the complex word

[higherbeing]

Scope

A research note with tools. Added folder: research/complex-delivery-map-open-allocator/.

What is in it

1. An open asynchronous whole-owner allocator (tools/). The optimisation that produces the frozen ASYNC-OWNERS maps of #505/#508/#512/#514/#517 as runnable code: an aggregate CP-SAT model (helpers per call per width per idle child, port tiling patterns, windows, one helper per call per port, Hall conditions), a lazy-cut loop against the literal per-child nomination, a nominator that writes roles in #505's format, and a profile recount that writes the plan #508's width-generic emitter and audit check against.

Validation: on #505's own order and widths it returns #505's published remainder profile {1:136,3:3432,5:3501,7:2137,16:1,48:408} exactly as the optimum. On #507's widths under #508's offset-six order the aggregate reaches 99,625.66, equal to the timing-free ceiling (all windows open), and the resulting profile gives #512's endpoint b = 0.001389978441615608 through the pinned moment engine. The first-order objective Σ r ln(73/r) over remainders is exact to first order because the rank mass is fixed.

Why: every asynchronous result so far ships only its witness. Anyone who changes the local word needs a fresh allocation; this gives the community a checked one. Requires ortools.

2. A map of where the 560 complex helpers go (code/, results/): exact symbolic replay over Q of the #433, #484 and #507 words. All three share the packet layer (84 single-source copies, 269 four-source packets, 204 eight-source packets, 3 centre sums; coefficients ±1, ±1/2) and the same duplicate structure (90 identical packet copies, 84 sign variants); they differ in how packets reach targets (389 / 380 / 283 helpers copy a source first; 171 / 171 / 255 are built only from helpers). Targets read along nested chains 0 → F₅ → F₆ → cap (#507: 0 → F₆ → F₇ → cap): every 5-frame is private to one target and every 6-frame is shared by exactly two targets; no pre-cap frame is shared by more than two. Merging an identical pair at its readers' shared 7-frame fails post hoc for every pair in every word, because each reader has other pre-cap reads outside that meet.

3. A correction. A plane-section argument ("a register of s above its line serves the readers in one hyperplane section, the largest has 32 of 56, so ≥ 3 branches per source") does not hold: all ports have odd weight, so the planes spanned with v and v + 1 always cover all 56 readers. We had written that bound down privately and withdraw it here so nobody else relies on it. The binding structure is the chain design above.

4. Direction. The complex cost is 72 % helpers and the helpers are mostly delivery of the same 473 packets, copied and re-signed until every target can read them in its own chain, with frames shared only in pairs. Grouping k targets on a shared (9−k)-frame delivers a packet once per group at the price of one extra climb per target per level (≈ 3 Φ against ≈ 25 Φ per helper). Stated as an exact combinatorial problem in the README; not solved here.

Credits and disclosure

#425/#433 (packet word), #484 (gauge/kernel word), #507 (partial-own factory), #505/#508 (asynchronous schedule, width-generic emitter and audit), #512/#517 (independent endpoint and ceiling the allocator reproduces), #446 (rigidity), #496/#442 (whole-owner hosting). Written by higherbeing with Claude Code (Anthropic) assistance. Apache-2.0.

[higherbeing]

Update on §3 ("The direction this points to"): the group-delivery idea is closed for the Hamming packet algebra.

Following up on the delivery map with an exact per-block model (CP-SAT over the actual ports: read each cross-block 8-sum directly, at shared frames, by its four consuming targets, with every register's and target's frames nested, optional second registers allowed). It is infeasible for every block. The reason is structural and checks on all 14 blocks:

1. Two targets of the same tetrad agree on the pair sign of exactly one of the three coordinate partitions, so a target can share a delivery frame below its cap with exactly one partner. Its other two partitions have to be mixed in place and read privately at the cap. That is precisely Split centres and source-basis reuse for conditional κ = 0.001120864952258278 #433's design (one "selected" partition through the target registers, two through in-place 2×2 transforms), and Conditional kappa 0.001393662920776407: blockwise pair exposure, 99 pivots and whole-owner allocation #518's blockwise choice of the selected partition is the only freedom in it.
2. Every own-block face contains a source orthogonal to the target, so a register whose frame has absorbed an own-block face is never readable by that target. That rules out reusing one register for the three 8-sums of a coordinate pair.

Helper accounting of the word by construction role (instrumented complex_construct.py): 560 = 112 own-source copies + 224 block-module helpers + 168 face copies + 56 slot copies; the 168 + 56 copies are forced by the two facts above. So the pairwise sharing seen in the delivery map is not a design choice but the maximum this packet algebra allows, and "deliver once per group of k targets" has no room here. I am leaving §3 in the README as written but flagging it with this comment; the correction is logged in the package's notes. A different packet algebra (the D4 partition: 6- and 8-source packets, 9 reads per target instead of 14) has a different sign structure and is the remaining open variant.

[higherbeing]

Correction to my previous comment. #531 (icekylinx, posted while I was writing) removes exactly the 56 slot copies by delivering the selected cross-block sums in two reads from the existing face copies, with the same coordinate partition in both tetrads. So fact (1) above is right about 8-sum registers but my conclusion was too strong: the per-block model I solved only allowed the assembled 8-sums as delivery units. Delivering the two faces of a sum separately is the legal move it missed, and it is worth the 56 helpers (560 → 504). Fact (2), that own-block faces are never readable by the target, still stands, so the 168 face copies remain forced on this algebra as far as I can tell. The accounting 112 + 224 + 168 + 56 is unchanged; the right reading is "the 56 are removable, the 168 are not".

[Mister-Meeseeks]

Integrated into published main at 681e8923a0f23a19f93c7105c3a9c96149aa8362, preserving the original commits, notices and contributor credit. Thank you for the contribution.

The allocator and delivery diagnostics are incorporated. Maintainer review fixed the UNKNOWN-solver export bug, tested timeout/infeasibility and conservation, reproduced the #433/#484 geometry reports, and clarified rounded-objective and incomplete-nomination limits.

The scoped review and pinned execution receipts record the exact coverage and remaining assumptions. This strengthens specific interfaces and preserves useful research; it does not change the selected κ or establish the complete multiplication theorem. Local checks passed; fresh Linux CI was queued at publication.