Finite research construction: signed P104 mixed-carrier banks and E8 root-line gate (no new kappa)

research/p104-signed-mixed-carrier-bank/CLAIM.md

@@ -0,0 +1,10 @@
+# Bounded innovation experiment: signed mixed-term bank
+
+- Research object: bypass the fixed-term carrier premise of CrocSwap PR #1125 without claiming a new κ.
+- Base geometry: PR #968 and merged PR #1125, with PR #2820 finite projection-width audit as context.
+- Hypothesis: a redundant two-variant bank of reusable pair sums may reduce exact abstract target delivery frame moves and data ADDs, even after paid mixer creation.
+- Explicit class: binary F₂ frame/subspace access and integer ±1 scalar READ/ADD; targets monotone; input and mixed carriers return to home after each read; new helpers permitted to terminate with data; no physical compiler certification.
+- Tested alternatives: 105 perfect matchings and every one of 4096 cube-edge mixer banks; an independent optimizer and exact 2288 sign assignments; one full signed E8 frame pair exemplar.
+- Findings: 12-edge bank, 24 signed helpers, 288 ADDs and 1312 frame rank vs 416 and 2224 in the given direct schedule. Eight-edge bank gives same 288 ADDs, 1328 rank with 16 helpers. Restricted global replacement-basis no-go over Q also independently checked.
+- Stopping rule: terminate after complete finite bank search and verification; do not infer full recursive improvement without physical word, paid host/cleanup and outer moment replay.
+- Attribution: CrocSwap predecessors #968 and #1125 (Ali Romman), user @Chrisbryan17's #2820; substantial GPT-6 assistance. Apache-2.0. No upstream modifications, merge, frontier edit, or new κ claim.

research/p104-signed-mixed-carrier-bank/NATIVE_GATE.md

@@ -0,0 +1,21 @@
+# Native realization gate: direct E8 root-line adapter fails
+
+The prior schematic signed mixed-carrier bank places new scalar values on binary labels \(u_i+u_j\). This is a valid **formal vector-space** line but not an existing E8 **root line**.
+
+In the standard P104 label realization \(u_r=(\mathrm{rootBits}(r),1)\in\mathbb F_2^9\), every root-line label has ninth coordinate 1, whereas a sum of two root-line labels has ninth coordinate 0. Hence no two-root sum equals any root-line label. This applies to all 120 E8 root lines, not just one selected decoder.
+
+`root_line_gate.py` reconstructs the exact 120-by-120 mod-2 pairing signatures from 240 doubled-coordinate E8 roots and checks all 7,140 distinct pairs. No XOR of two root signatures equals another root signature. This is independent of the selected P104 frame.
+
+**Implication:** a proposed implementation cannot simply relabel a mixed sum as another primitive root-line carrier. One must exhibit a legal generalized frame/phase and scalar word, or another encoding. The result does **not** rule out all arbitrary one-dimensional subspaces of the nine-dimensional label space, nor block generalized-frame constructions.
+
+Required next gate: specify permissible registers, phase conversions, and source/copy/erase/restore primitives; compile an exact signed example; count the extra child ranks and cleanup operations; then compare the full paid moment with current selected frontier. Until then, the 30.8% ADD and 41% frame-rank savings are schematic rather than multiplication bounds.
+
+## Follow-up: rank-two home frame avoids the line-label obstruction
+
+The even-parity obstruction excludes *single original E8 root-line names* for mixed values, not the rank-two subspace `U_ij=span(u_i,u_j)` built from **two existing root labels**. A mixed auxiliary can stay in `U_ij` throughout target delivery in the relaxed source/target frame trace. For each target whose support contains both indices, `U_ij` is contained in its target sink, and a single signed arithmetic ADD reads the value.
+
+`rank2_gate.py` constructs these home frames, executes exact symbolic target outputs, returns each original source to its rank-one home, reverses every mixer preparation, and erases all 16 auxiliaries to frame zero. It checks all 2288 signed target cases. Across 4096 cube-edge banks, the 8-edge bank has **320 ADDs, 1520 frame-rank moves, 16 auxiliaries**; the stipulated direct baseline has 416 ADDs, 2224 frame-rank moves. There are six symmetry-related minimizing 8-edge bank masks.
+
+Per 8-edge bank, mixer build+erase costs 64+64 frame-rank units and 32+32 signed ADDs; target paths supply the rest. The two-dimensional carrier home adds a small modeled read cost relative to a non-root composite rank-one label, but eliminates the requirement for a non-existent physical root line. The earlier rank-one bank with explicit cleanup is separately checked by `zero_restore.py` and costs 320 ADDs / 1408 rank units, but still needs new line-alphabet realization.
+
+**This does not certify a native carrier.** The real E8 compiler must prove a legal rank-two carrier storing the mixed scalar, correct operator phase, source access, routing, physical inverse, precision, live helper ownership, all child rank charges, and a complete selected-moment budget. Generalized algebraic frame inclusion alone does not establish these properties.

research/p104-signed-mixed-carrier-bank/PROOF.md

@@ -0,0 +1,54 @@
+# Signed pair-mixture carriers: finite schematic proof and restrictions
+
+## A. The frame-line identity
+
+Let `u_0,...,u_7` denote the independent binary labels in the reviewed P104 model, and `H_t` the target's binary hyperplane. Define `S_t={i:u_i∈H_t}`. For any two distinct indices `i,j`, because `H_t` is the kernel of a linear functional `λ_t`,
+
+`λ_t(u_i+u_j)=λ_t(u_i)+λ_t(u_j)∈F₂`.
+
+Therefore `u_i+u_j∈H_t` iff either `i,j ∈ S_t` or `i,j ∉ S_t`. This identity is independent of target signs. In the former case either integer data `x_i+x_j` or `x_i−x_j` on a *new allowed carrier with line* `<u_i+u_j>` can replace the two individual signed reads: for `c_i,c_j∈{−1,1}` choose `m⁺` if `c_i=c_j`, else `m⁻`, and add it to the target with sign `c_i`. Then exactly `c_i m^± = c_i x_i + c_j x_j`.
+
+This is a necessary algebraic and geometric compatibility statement. Existence of such a new carrier as a physically legal recursive word is a **separate, unproved requirement**.
+
+## B. Constructive schedule inside the relaxed frame model
+
+For each selected edge `(i,j)`, put `U=span(u_i,u_j)` (rank two). Move both original clean source carriers from their rank-one home lines to U (cost one each). Create two zero helpers and move each from frame `0` to U (cost two each). Perform four signed ADDs to create both `m⁺` and `m⁻`. Restore both source carriers to their own home lines (cost one each), and move each new helper down from U to `<u_i+u_j>` (cost one each). The invoice is **10 rank-move units and 4 ADDs per edge**, including helper creation; two new live auxiliaries remain.
+
+For each target support S, select a matching of disjoint available edges inside S. Every selected pair becomes one signed mixer read. Every remaining vertex becomes a singleton read. Their binary labels are independent because their constituent vertex sets are disjoint subsets of the original independent eight `u_i`. All these ingredient lines lie in H_t. Starting with a zero target, read them successively at the monotonically increasing span U_j, then grow the target to H_t. Each source carrier comes up from its home line, executes an ADD, and goes back to its home line. For k ingredients, the target pays **8** frame-rank units and the k individual carrier trips pay `2∑_{j=1}^k(j−1)=k(k−1)`; the target executes k signed ADDs. All scalar identities hold over the integers, not merely mod 2. This verifies the complete *abstract trace*, not its real E8 compiler lowering.
+
+## C. Exhaustive bank optimization
+
+The three-cube has exactly 12 edges. There are 4096 subsets B. For each target S define `matching(S,B)` to be the maximum cardinality matching among edges of B with both endpoints in S. Then `k(S,B)=|S|−matching(S,B)`. For q edges in the bank the complete schematic invoice is:
+
+`ADD(B) = 4 q + ∑_{S∈F} k(S,B)`
+
+`RANK(B) = 10 q + 104·8 + ∑_{S∈F} k(S,B)(k(S,B)−1)`.
+
+The script computes all 4096 masks by an edge-conflict recurrence and identifies the unique minimum RANK at all 12 edges: ADD=288 and RANK=1312. It separately checks this solution by actually evolving register frames and symbolic data. The independent checker derives the maximum matchings using a vertex-delete / pair recurrence, reproducing every one of the 4096 invoices. The unmixed fixed return-home baseline has ADD=416 and RANK=2224. No claim is made that the baseline is the optimal real decoder or that RANK equals the project's actual recursive cost.
+
+## D. Restricted static-basis obstruction (unsigned case)
+
+For the 104 binary incidence masks S, interpret its **unsigned** target coefficient vector as `1_S∈Q^8`. Suppose eight independent persistent carriers encode an invertible linear basis of the eight original term scalars. Each basis carrier j has a fixed nonzero decoding functional `f_j∈Q^8`: its coefficient in the unique expansion of any output y_S equals `f_j(1_S)`. Its fixed geometric home line is a nonzero `v_j∈span_F2(u_0,...,u_7)`. It may only be read when `v_j∈H_S`. Thus `f_j(1_S)=0` whenever `v_j∉H_S`.
+
+For each nonzero binary v, define `Bad(v)={1_S : S∈F, parity(v ∩ (complement S))=1}`. The checker exhibits an explicit set of eight rows in Bad(v) linearly independent modulo 3 for each of the 247 non-singleton v. They are therefore independent over Q and force any f_j vanishing on Bad(v) to be zero, a contradiction. For each of eight singleton v, Bad(v) has rank seven, and the only allowed f_j is a scalar multiple of the original corresponding coordinate. Consequently a global invertible eight-channel home-line basis cannot use nontrivial mixed lines in the unsigned fixed-access model. A redundant dictionary escapes because its channel coefficients need not be a fixed inverse-basis functional across *every* output and it has extra channels.
+
+This excludes neither signed geometry-dependent target coefficients nor dynamic changes to a frame, and says nothing about the general P104 decoding problem.
+
+## E. Limits
+
+Do not conflate these exact finite results with a certificate for a complete recursive multiplication algorithm. The new composite lines and terminated helper values require source/phase/cleanup work not discharged here. Existing P104 price screens may make a full realization uneconomical even when this schematic beats its stipulated direct baseline. Upstream signed E8 geometry is tested for one exemplar and carries inherited assumptions for other instances.
+## F. Constructive zero-restoration and rank-two re-encoding
+
+The relaxed rank-one composite-label bank in sections A-C originally leaves new helper data resident. An exact inverse of its four-ADD preparation at each edge, followed by paid frame descent to rank zero, restores two auxiliaries to zero while preserving original terms; that adds four ADDs and ten frame-rank units per chosen edge. Exhausting all 4096 banks with this correction gives the minimum 320 ADDs and 1408 rank units at an eight-edge bank, with sixteen zero-restored auxiliaries (`zero_restore.py`).
+
+A distinct relaxation avoids the unavailable root-label `u_i+u_j` by storing both signed mixtures on the rank-two frame `U_ij=span(u_i,u_j)`. Each such frame consists of two actual root-line labels. If the target support contains i and j, both source lines and hence U are in the target sink. A mixed read costs one symbolic signed ADD but introduces both frame directions; choose all singleton reads before pair reads to minimize return-home moves. If a target has n terms and p disjoint mixed pairs, the source return-home travel is exactly `n(n-1)-2p(n-p)` rank units. Building and erasing both signed variants costs 8 ADDs and 16 rank units per selected bank edge. The targets collectively cost 832 rank units for their sinks. Thus:
+
+```
+ADD_2D(B)  = 8*|B| + sum_S (|S|-p_B(S))
+RANK_2D(B) = 16*|B| + 832
+              + sum_S (|S|*(|S|-1)-2*p_B(S)*(|S|-p_B(S))).
+```
+
+Here p_B(S) is a maximum matching of available cube edges within target support S. Complete exhaustive cost enumeration gives six eight-edge minimizing banks, each with `ADD_2D=320`, `RANK_2D=1520`, and 16 live supplementary scalar values that are **all returned to zero**. `rank2_gate.py` executes the signed scalar traces and every frame transition and checks all 2288 possible signed output assignments.
+
+These are finite formal F2 frame and scalar ADD identities only. A legal native E8 operator/phase schedule at rank-two homes, recursive child pricing, full source access, and all-size reduction to integer multiplication remain separate obligations.

research/p104-signed-mixed-carrier-bank/PULL_REQUEST.md

@@ -0,0 +1,16 @@
+# Research construction: signed pair mixtures for P104 (schematic frame model, no new κ)
+
+**Classification: finite research construction, not a supplier or bound improvement.**
+
+This package investigates a specific escape from PR #1125's *fixed-term* carrier restriction: redundant, reversible-in-sign **mixed scalar values** `x_i ± x_j` on new pair-label lines `span(u_i+u_j)` (not a reversible full native circuit). Every target picks disjoint pair sums independently of the others. The source values are unchanged and restored to their home frames after mixer construction and reads. **New auxiliaries are not restored/erased at the end**; this is a key open cost obligation.
+
+- Verified target frame inclusion for **one genuine signed E8 decoder** and every required pair/target relation in it. General 7168-decoder support uniformity is inherited from merged PR #1125.
+- Exact per-gate symbolic integer trace, F₂ subspace inclusion and all charged frame transitions in the explicitly relaxed model.
+- Exhaustive **2,288 target/sign configurations**, all **105** perfect matchings and all **4,096** cube-edge mixture banks.
+- Two independent optimization algorithms: edge-conflict DP and vertex recursion. Unique minimum frame-rank bank uses all 12 cube edges, adding 24 auxiliaries (2 signed variants per edge).
+- Against a **specified, non-optimal** unmixed home-return schedule, modeled ADDs decrease 416 to 288; frame-rank moves decrease 2,224 to 1,312. These are finite schematic counts, **not** a κ/runtime gain.
+- Separate restricted exact obstruction: fixed *nonredundant* eight-channel global recoding over Q with home-line-only reads cannot use 247 non-coordinate line labels for the unsigned support family (F₃ full-rank minor witnesses and independent rational verification).
+
+Validation of the committed subset: `python -I -B research/p104-signed-mixed-carrier-bank/RUN_SUBMITTED.py`; standard library only. The larger local laboratory also ran optional independent scripts, but those are not included in this PR. The added `root_line_gate.py` confirms no mixed two-root label is an ordinary E8 root line.
+
+Open gates: physical lowering of composite label lines, actual signed decoder word, new helper ownership/cleanup, paid source access, recursive child ranks, phase frames, full optimized unmixed comparator, full strict moment/outer recheck. This branch changes **no upstream/** file, no selected source and no κ. Upstream PR #1125 and #968 receive credit; PR #2820 supplies parallel projection context. Substantial GPT-6 assistance disclosed. Apache-2.0.