Research: execute complete generic packets with nested child dispatch

research/selected-joined-dispatch/NOTICE.md

@@ -0,0 +1,41 @@
+# Attribution and limitations
+
+Jose Manuel (`jmbarrancoml`) prepared the joined executor, descriptor-only
+embedded-child interpretation, complete finite experiments and written
+composition with substantial OpenAI Codex assistance. New work uses
+Apache-2.0. We claim no independent human or new proof-assistant verification.
+
+The good/fallback normal forms and weighted covariance come from the retained
+source527 lineage, commdata2338's PR2160/2188 and Ross Richardson's PR2159.
+Jose Manuel's PR2171/2207 supply the controlled and fallback payload adapters.
+The completed digit-swap/ADD/sign leaf comes from PR2234. PR2310 supplies the
+iterative control continuation and the uniform-control handoff.
+
+In concurrent [PR2332](https://github.com/CrocSwap/integer-mult-bounds/pull/2332),
+commdata2338 connects actual selected matrix preparation to PR2310's control
+tables. We contribute complementary complete generic payload and child
+execution. aakashthakkar and thakrarsagar address borrowing-stock fit in
+[PR2324](https://github.com/CrocSwap/integer-mult-bounds/pull/2324) and
+[PR2343](https://github.com/CrocSwap/integer-mult-bounds/pull/2343), under their
+stated caller contracts. We retain their distinct credit and do not use those
+large-prime bounds to certify the q=3 experiments.
+
+We adapt those formulas and sequential constructions into dimension-aware
+modules with explicit completed-child dispatch. `algebra.py` reimplements
+their fixed-size full-ring preparations; `control.py` generalizes the generated
+weight stack and connects it to actual headers. `streams.py` uses opaque-record
+macros with charged bit volume. We do not claim that these inherited algebraic
+methods are new. The elementary complementary-projector identity serves as a
+generic complete caller for testing, with no literature-priority claim.
+
+commdata2338's PR1379 and OpenAI's stream source supply the marked parking and
+complete-field conventions. We execute payload parking here; host metadata
+and arithmetic still need their separate fixed-tape encoding. The selected
+supplier lineage remains credited in the pending predecessor notices, including
+DreamingOfClouds, eumemic, alephnan and the family/owner contributors.
+
+SOURCES.json pins the exact predecessor code and proof references. We import
+no unchanged predecessor executable at runtime. The new checks establish the
+stated finite generic domains and accompany the written interpretation proof.
+They do not rerun the selected finite construction, its GL64 payload or a full
+multiplication algorithm. We leave the selected frontier unchanged.

research/selected-joined-dispatch/PROOF.md

@@ -0,0 +1,212 @@
+# Completed children on the same high packet
+
+We connect full-ring preparation, generated weight evaluation and sequential
+payload operations through an explicit child dispatcher. The retained physical
+fallback code used a dense address-permutation oracle at this boundary.
+Our child executes digit interchanges, controlled ADDs and signs, or a smaller
+complete generic caller. We keep dense address maps in the checker only.
+
+We prove the descriptor interpretation below for arbitrary complete fields.
+The executable caller uses two complementary projectors in dimension two.
+It provides a closed test of this interface, not an implementation of the
+selected GL64 family/owner/hosting schedule or a new multiplication saving.
+
+## 1. The embedded-child interpretation
+
+Consider a packet whose order is
+
+    [C] x [U] x [B]^n x [G] x [B]^n x [S],  B=q^w.
+
+C indexes the complete frozen-control prefix. U is unused stock; G and S
+are complete intervening and suffix fields. Every record has the same
+payload width. Payload values may have arbitrary correlations.
+
+Choose two ordered k-atom chunks, beginning at atom indices i and j, with
+`0<=i`, `i+k<=j`, and `j+k<=2n`. Neither chunk may cross the old gap.
+Let a and b be their positions in the radix list
+`r=([B]^n,[G],[B]^n)`. Define
+
+    U' = U product_(t<a) r_t,
+    G' = product_(a+k<=t<b) r_t,
+    S' = S product_(t>=b+k) r_t.
+
+Then the very same serialized packet has shape
+
+    [C] x [U'] x [B]^k x [G'] x [B]^k x [S'].
+
+This is equality of lexicographic encodings: expand each collapsed field
+back into its factors. The record order and complete volume stay unchanged.
+The compiler performs no payload permutation to create this view.
+
+Suppose a completed child applies
+
+    F_A(H,D)=(A C_k D, C_k A^-1 H)
+
+on those chunks, fixes its prefix and spectator coordinates, and clears its
+local work. Here C_k reverses the k atom positions, and A is a diagonal unit
+vector depending only on frozen controls. The same child, under the displayed
+interpretation, implements the desired embedded operation in the parent.
+This follows pointwise from the identical encoding and the child's identity
+action on U', G', S' and C.
+
+`Shape.child` checks the volume equation and interval conditions.
+`ChildRequest.admit` checks the full record count, complete prefix count,
+proper width, global field age and entry/return head position. A caller must
+pass the entire packet described by that request. A loop that dispatches
+one separately declared child per current high matrix is a different
+interface, even if a particular endpoint happens to agree.
+
+## 2. Actual full-ring fields and generated weights
+
+Fix an odd prime q and w>=1. For a fixed low class g0 in GL_m(F_q), enumerate
+the complete high cube and form `g=g0+qG` in `Z/q^w`, with m<=64. Each g is
+invertible because its determinant is a unit modulo q. For a coordinate
+projector E_I prepare `P=g E_I g^-1` with modular arithmetic.
+
+The good branch requires its leading rank minors to be units. That property
+depends only on g0, but the actual pivots and coefficients require the full
+g. We retain the source527/PR2160/2171 normal form: unit-lower head/tail
+adapters, the cross ADDs, one weighted child and inverse adapters. The
+remaining Schur block vanishes over the full ring, not merely modulo q.
+`algebra.good` checks this endpoint when preparing its coefficients.
+
+For fallback, we retain first-unit-pivot, unnormalized elimination of the
+full 2m-by-2m residual. We record the original-row permutation at each
+reduction and reconstruct in reverse chronology. If the incoming weights
+form the head-bank conjugator B_A, the weighted reduction state is
+`B_(pi_t) M_t B_A^-1`. Thus a shear uses its own permutation snapshot;
+the diagonal-pair child uses the final permutation. We retain zero slots.
+
+The generated control program carries each ancestor's dimension, low/request
+specification and global field slot. A child appends its actual parent header,
+including its high values, to the frozen history. The iterative evaluator
+then uses the full-ring Good or FallbackPair table for that field. Unit and
+orientation children start weight one while retaining the global age.
+The evaluator accepts no current-fresh-matrix or unused-stock argument.
+
+This generalizes PR2310's prepared-table interpreter to dimension-aware,
+actual full-ring inputs. The host implementation memoizes immutable matrix
+preparations by their complete headers. Its keys include high values. The
+control-cost argument may instead recompute these bounded-dimensional tables
+with the local-control discipline of PR2310; we claim no host-cache access
+bound as a Turing-machine primitive.
+
+## 3. A completed base without a permutation oracle
+
+For each pair `(H_i,D_(k-1-i))` with unit a, execute the retained chronological
+word
+
+    J, L(a), J, L(-a^-1), J, L(a), J, D<- -D.
+
+Here J exchanges the two atoms and L(c) sends the later atom to D+cH.
+Multiplication gives `(H,D)<-(aD,a^-1H)` for arbitrary input digits.
+
+Implement J by exchanging its w corresponding radix-q digits. For one
+digit pair, split the complete stream into q^2 sequential buckets indexed
+by the two digits, then merge them in exchanged order. Every intervening
+field and suffix travels as an opaque block. Reset and erase the buckets
+before the next digit. This is a completed ordinary base, with no recursive
+or address-map oracle.
+
+For L(c), retain the full control prefix and all unused rows. Compute c from
+the permitted frozen fields, hold the current source digit x, and rotate
+the complete later B-block fibre by c*x. Split and merge sequentially.
+Recompute the coefficients in the same order during merging. A sign pass
+keeps block zero and reverses the other block positions while preserving
+the records inside each block.
+
+These operations prove the base for any fixed finite leaf cutoff. `leaf`
+applies them to all k pairs and returns the same complete record count with
+head zero. It allocates no child oracle. Payload records remain opaque.
+
+## 4. A generic caller with real internal children
+
+Let C reverse n atom positions, J be the two-bank reversed swap, and
+
+    Q=diag(P,CPC),  R(P)=I-Q+JQ.
+
+For a projector P, Q is idempotent and commutes with J. Since J^2=I,
+expansion gives `R(P) R(I-P)=J`. Conjugating both residuals by
+`diag(A,I)` gives the complete weighted endpoint F_A.
+
+We use this identity with m=2, rank-one complementary projectors and
+n=2f. Each good child has f atoms. Each fallback weighted/unit child has
+f atoms; orientation reversals use floor(f/2) atoms. The dispatcher brackets
+same-orientation field swaps by the required reversal of the later field.
+Every positive child is smaller than n.
+
+For dyadic n, choose the elementary leaf or the same complementary-residual
+caller at a smaller width. Strong induction on n proves the full endpoint
+and restoration contract. A finite experiment may send a designated unit
+child through the internal caller while using completed leaves for other
+small children; both alternatives implement the same F_A. This permits a
+direct test of unit reset followed by another actual preparation/dispatch.
+
+For internal calls let
+
+    N=|GL2(F_q)| q^(4(w-1)).
+
+Provide unused stock divisible by N^D, where D bounds remaining internal
+depth. Decode one N factor as the current full-ring matrix field. Process
+one low class at a time, retaining all its high lifts and all older controls
+together. Select that whole packet by sequential scans, apply both residuals,
+and replace it before the next low class. The remaining stock fits each
+proper child. Preceding complete body fields may join the child's collapsed
+unused prefix, but the reserved divisor remains available.
+
+The completed operator fixes the current matrix field and unused stock and
+acts as F_A on the body. The incoming A reads only older frozen fields, so
+every current matrix row receives the same completed endpoint. Siblings
+reuse the restored stock. We obtain a genuine generic complete caller.
+Even the two ideal rank-one children have linear rank mass one; fallback
+calls add further work. We claim no exponent saving for this generic caller.
+
+## 5. Sequential payload parking and the measurement boundary
+
+When an internal caller selects one low-class packet, it parks the inactive
+complete source before running that packet. `Parking` appends one marker and
+the source records to a single stack, erases the source work tape, and restores
+only the top frame after return. Nested frames lie above that marker.
+Restoration visits the frame's own suffix and removes its marker; it does not
+scan an older payload frame. The checker retains a nonzero outer frame while
+the nested child executes and verifies its exact return.
+
+The interpreter uses 32-bit opaque payload records. A block copy is a macro
+for sequential copies of those bits; all copied bits and head distances
+remain charged. The stack uses 64-bit slots to distinguish markers from
+payload values, a constant-factor representation change. Scalar and matrix
+arithmetic uses host integers. Immutable control objects and return metadata
+remain host data in this implementation; their fixed-tape encoding and cost
+are the separate control/parking proof obligations. We do not call this a
+complete binary transition-table compiler or infer an asymptotic running
+time from Python timing.
+
+## 6. Exact finite domains and limits
+
+The width-two high tests use m=2, q=3, w=2, n=2, one fixed low class and all
+3^4=81 high matrices. Each packet has all 9^4 body addresses, for 531,441
+distinct opaque records. One low class is good and one is bad. In the good
+class the pivot takes values 2,5,8, each on 27 lifts; the bad class has
+P00=0,3,6, each on 27 lifts. Each child receives all 81 high rows together.
+
+The nested test uses an actual 64-dimensional rank-four preparation to give
+incoming weights `(2,1,1,1)`. A two-dimensional, width-one parent retains a
+complete GL2(F_3) stock of 48 rows. One unit-reset width-two child executes the
+generic internal caller and then completed width-one leaves. Other small
+children use completed leaves. This tests global field age after reset,
+fresh-stock restoration, same-orientation reversals and a buried parking
+frame. The width-one nested experiment tests endpoint algebra; it is not an
+instance of the production root-coupled asymptotic parameter choice.
+
+The checker compares the first residual and the complete weighted endpoint
+against independent direct formulas. It checks every record in the stated
+packets, including unused, gap and suffix coordinates. Negative controls
+target low-only generated coefficients, missing reversal, lost field age,
+incomplete packet admission and insufficient fresh stock.
+
+These are generic normalizer/dispatcher experiments. They do not enumerate
+the selected GL64 family/owner/hosting payload, establish its full compiler
+cost, replace native source certificates, or prove a multiplication exponent.
+We credit source527, PR2160/2159/2171/2188/2207, the completed leaf in PR2234,
+and PR2310's control continuation. Jose Manuel (`jmbarrancoml`) prepared this
+work with substantial OpenAI Codex assistance. Independent review remains open.

research/selected-joined-dispatch/README.md

@@ -0,0 +1,74 @@
+# Full-ring preparation and completed embedded children
+
+We connect actual full-ring preparation, generated control evaluation and
+completed child execution on the same high packet. The child runs sequential
+digit swaps, controlled ADDs and signs, or a smaller complete generic caller.
+We use no child address-permutation oracle in the payload path.
+
+[PROOF.md](PROOF.md) gives the general embedded-field interpretation: retain
+the complete prefix, collapse surrounding fields into spectators and preserve
+the exact volume without moving records. The executable backend uses two
+complementary projector residuals in dimension two. Their product gives the
+weighted interchange. This tests the pending selected-caller interface; it
+does not execute the selected GL64 family/owner/hosting schedule or claim a
+new saving.
+
+## Evidence
+
+We check 1,456,542 distinct 32-bit records at both the first residual and the
+completed weighted endpoint:
+
+| Case | Complete domain | Records |
+|---|---|---:|
+| Good high packet | All 81 high lifts over Z/9 and all 9^4 body addresses | 531,441 |
+| Fallback high packet | The same full sizes, including nonzero nonunits | 531,441 |
+| Nested unit reset | 64-dimensional preparation, 48 fresh GL2 rows and a real internal child | 314,928 |
+| Nonbinary spectators | Unused range 2, gap 2 and suffix 3 with completed leaves | 78,732 |
+
+The call trace accounts for 872 children: 871 completed leaves and one
+internal caller. The latter visits all 48 fresh GL2 low classes after a unit
+reset. It retains global field slots through depth three and returns a buried
+nonzero caller frame. The nested fixture obtains weights `(2,1,1,1)` from an
+actual 64-dimensional full-ring preparation, rather than a supplied weight
+table. Its width-one parameters test endpoint algebra outside the production
+root-coupled asymptotic setup.
+
+Six controls target low-only coefficients, an omitted orientation child,
+compacted global slots, a sliced high-packet request, insufficient fresh stock
+and a chunk crossing the old gap. The checker uses direct adjugate/projector
+and weighted-endpoint formulas separately from the executor.
+
+## Reproduction and scope
+
+Use Python 3.12 and the standard library:
+
+```sh
+python3.12 scripts/research_package.py --package research/selected-joined-dispatch
+```
+
+The registered hook runs complete normal and optimized replays, each with a
+600-second limit. A replay takes several minutes on the development machine.
+`verify.py --emit --progress` prints a fresh receipt and stage progress without
+writing files. [RESULT.json](RESULT.json) retains exact endpoint hashes,
+child profiles, payload traffic and rejection outcomes.
+
+The interpreter copies opaque records through sequential tape macros and
+charges their full bit volume. It executes payload parking and cleanup.
+Host integer arithmetic, memoized immutable preparations and control objects
+remain outside the measured payload machine; their binary encoding and cost
+need the separate control/parking proof. We claim no full transition-table
+compiler, selected-supplier admission, new formal proof or frontier change.
+
+## Open next questions
+
+Connect the dispatcher to the actual selected family, owner and hosting
+schedule, retaining its complete packet and source-alignment contracts.
+Start with the residual child boundary in PR2234 and keep the elementary
+leaf for widths below 64. The selected global XOR/copy/erase interpreter
+still needs its own joined implementation. [TASK.json](TASK.json) records
+the boundary and further review steps.
+
+Jose Manuel ([jmbarrancoml](https://github.com/jmbarrancoml)) prepared this
+contribution with substantial OpenAI Codex assistance. [NOTICE.md](NOTICE.md)
+retains predecessor credit. We coordinate through
+[Discussion2319](https://github.com/CrocSwap/integer-mult-bounds/discussions/2319).