Implement a native local read of the QQ16 future query

research/qq16-future-x-query/PREDECESSOR.json

@@ -0,0 +1,10 @@
+{
+  "pr": 2443,
+  "head": "545c05e17243c962b112b91e7f84b4c1a41de7b8",
+  "path": "research/qq16-coordinate-cut-decoder/README.md",
+  "sha256": "91d68f5d01d89ee78802ee5f76e8b901199a686aaa62341090eb70c458fd070e",
+  "git_blob": "1ae3d3eb976ed85f795da2c211b58577ed7e8a82",
+  "usage": "Exact access handoff and observation-cut context; no pending code imported.",
+  "retained_copy": "evidence/PR2443-README.md",
+  "url": "https://github.com/CrocSwap/integer-mult-bounds/blob/545c05e17243c962b112b91e7f84b4c1a41de7b8/research/qq16-coordinate-cut-decoder/README.md"
+}

research/qq16-future-x-query/PROOF.md

@@ -0,0 +1,139 @@
+# Future-X query at the post-B1 cut
+
+## Objects, available frames and extra storage
+
+Use the actual disjoint QQ16 A/T minors and their ordinary complement U of
+size 96. Set `C=x2_U` immediately after `B_1_2`. The retained contract gives
+each X source p at owner d the completed native frame
+
+```
+T_X(d) = F_(d U1),      U1=L+E1.
+```
+
+The logical values C are arbitrary; in PR2443 they equal `-y_U^initial`.
+No use is made of that equality, of selected endpoint values, or of a later
+former-Y hole. The new word owns eight output arrays. It clears them before
+use and returns them live in the common query frame. Those arrays are not
+claimed to come free from the selected helper bank or to preserve dirty input.
+
+For p in U, let `q_p` be its actual nine-bit normal and let `rho_p=rho_2(p)`.
+This involution fixes q_p and exchanges its eight chart axes with E2. Write
+`delta_p=q_p+lift_2(beta_p)`. The source's future-Y alignment and inverse are
+
+```
+A_p = M(rho_p, delta_p),
+A_p^-1 = M(rho_p, rho_p delta_p),
+M(g,a) f(d,z_1,...,z_lambda)
+   = f(dg,z_1+d a,...,z_lambda+d a).
+```
+
+It changes owners and translates every payload layer. It does not apply g
+to the payload address. All fields at different owner/port indices remain
+independent. Every per-field map is a bijection of its full array.
+
+## The unavailable zero-line shortcut and the exact repair
+
+Let `T_c(d)=F_(d(E1+E2))` and let `D_p=M(rho_p,0)` be the logical route.
+The retained bridge identity, for a Y-type source before chart 2, is
+
+```
+A_p [F_(d U1) C_(d q_p)^-1] = T_c(d) D_p.
+```
+
+Here `C_q=(1+i)I/2+(1-i)T_q/2` is the signed native rank-one line operator.
+Since rho_p fixes q_p, omitting that inverse line leaves exactly C_q:
+
+```
+after A_p, the X source frame is T_c(d) C_(d q_p).
+```
+
+This residual is not the identity. At an identity-owner Fourier character
+w with `q_p dot w=1`, its multiplier is i. The receipt supplies such a w for
+each of the 96 actual ports. Therefore the future-Y scalar query cannot be
+applied directly to these unnormalized X fields in its common output frame.
+This does not exclude other physical implementations or other observation cuts.
+
+Normalize source p first with `C_(d q_p)^-1`. Native frames are products of
+commuting address translations/line operators, so this changes its frame
+to the required Y type while retaining its arbitrary logical value. Applying
+A_p then puts it in frame T_c with logical content D_p C_p. All 96 source
+fields now have exactly the same native frame at each common owner.
+
+Clear eight owned output arrays. Zero is compatible with T_c, so no native
+line preparation of a nonzero dirty output is assumed. For each k, perform
+the literal signed scalar additions
+
+```
+Q_k += R[k,p] * aligned_C_p,  for p in U with R[k,p] != 0.
+```
+
+This yields `Q=R_U D_(2,U) C=B2 C`, in frame T_c. Scalar additions leave
+every source field unchanged. Undo every A_p, then apply `C_(d q_p)` to each
+source. Both physical and logical source endpoints are exactly restored.
+The output arrays are intentionally retained; they are the requested observation.
+
+All normalization, alignment, accumulation, undo and restoration sweeps are
+completed in that order before the next sweep. At a fixed owner, all ADDs
+use different source and output fields in matching frames. Finishing each
+full-cover sweep prevents reads from partially updated other owners. The
+word can therefore be inserted before the next source-modifying operation,
+subject to separate global scheduling and child-hosting obligations.
+
+## Literal rank-one kernels
+
+For every actual nonzero q in the nine-dimensional local block, choose an
+invertible binary G with `G e0=q`. The verifier takes q as its first column
+and the other eight coordinate axes except one pivot of q as the remaining
+columns. Define P_G by sending the basis vector at address x to the basis
+vector at address Gx. Then
+
+```
+P_G C_e0 P_G^-1 = C_q,
+T_q P_G C_e0 P_G^-1 = C_q^-1.
+```
+
+The source rank-one primitive C_e0 has two Gaussian coefficients
+`(1+i)/2` and `(1-i)/2`. Both signed words therefore use one rank-one child
+and two monomial wrappers. The inverse translation is fused into the left
+wrapper, exactly as in the retained QQ16 convention. The checker verifies
+both Gaussian coefficients at every one of the 512 local basis addresses
+for all 96 ports and both signs: 98,304 exact columns. External axes are
+spectators. The identities lift ownerwise and to every positive tensor power.
+
+These are operator recipes and recursive rank counts. They do not themselves
+assign available helper owners or bound the physical address implementation.
+
+## Phase and logical verification
+
+A field's Fourier phase is represented as a sum of binary parities with
+integer coefficients modulo four. Such a function has a unique multilinear
+polynomial of degree at most two modulo four: its linear coefficients are
+modulo four and each cross coefficient is zero or two. Equality of these
+polynomials is an identity on all 73-bit characters, not a random test.
+
+A native line appends the term `+/- (q dot w)`. A map M(g,a) changes each
+phase axis v to gv and adds `2(a dot w)`. The checker applies exactly these
+rules after every literal operation and requires matching phases for each
+ADD. Alongside the phase it tracks an exact rational linear combination of
+104 independent logical input arrays, carrying actual owner matrix products.
+Native lines change frames; cover maps apply their logical owner routes.
+Final checks require all 96 source rows to be the original independent input
+and the eight output rows to be precisely R_U D_(2,U), with no dependence on
+the discarded owned inputs. This jointly proves content and frame correctness
+under the stated native semantics.
+
+## Complete local invoice and boundary
+
+There are 96 inverse and 96 positive lines, hence 192 rank-one children and
+384 native wrapper maps. Each of 96 sources has one full-cover alignment and
+one inverse, hence 192 full-cover maps. Each actual ordinary R column has
+four signed unit coefficients, so there are 384 ADDs and eight CLEARs.
+The retained per-real-component bounds are four primitives per ADD and one
+per CLEAR; two components give `2*(384*4+8)=3088`. No SCALE or implicit COPY
+is omitted. The eight owned output arrays are additional live storage.
+
+The result is a complete local operator read and an explicit local count,
+not the complete PR2443 decoder or a favorable global bill. Other retained
+cut arrays, query output conversions, stream/address costs, global child
+delivery, storage lifetime, cleanup, precision and all-size supplier admission
+remain open. This word alone does not change a moment or an exponent.

research/qq16-future-x-query/README.md

@@ -0,0 +1,121 @@
+# A native local read of QQ16's future query B2 C
+
+This supplies one missing local access in [PR2443](https://github.com/CrocSwap/integer-mult-bounds/pull/2443):
+read `B2 C` from its post-B1 ordinary target block `C=x2_U`, return all 96
+source arrays unchanged, and retain the eight query coordinates in explicitly
+owned output arrays. The complete local word costs **192 rank-one children**.
+It is not a zero-native-line use of the earlier X bridge.
+
+At that cut C has completed-X stage-1 frame `F_(L+E1)`, but the requested
+chart is future chart 2. The retained bridge only promises its zero-line X
+alignment at or after the queried chart. Applying the future-Y alignment to
+this X frame leaves the exact port-specific factor `C_(q_p)`. One inverse
+line per source removes it; one positive line per source restores it after
+the read. This is a constructive local invoice, not an unrestricted lower
+bound on every possible way of obtaining the query.
+
+## Exact interface and invoice
+
+The unchanged source contract places the 96 ordinary X fields in frame
+`F_(d(L+E1))` after `B_1_2`. Their logical values C are arbitrary. Insert this
+read before any following operation changes them. The eight new output arrays
+are **owned**, so their arbitrary previous contents may be cleared. They are
+not borrowed dirty helpers. The output is
+
+```
+Q_k(d, payload) = (B2 C)_k(d, payload),  k=0,...,7,
+native output frame F_(d(E1+E2)).
+```
+
+All original source contents, native frames and owner positions are restored.
+All output arrays remain live. Their later retention, delivery and eventual
+cleanup are separate controller obligations; this word does not hide them in
+the original 480-helper stock.
+
+| Complete local quantity | Count |
+| --- | ---: |
+| Rank-one children / native rank mass | 192 / 192 |
+| Native monomial wrapper maps | 384 |
+| Full-cover maps, including undo | 192 |
+| Signed scalar ADDs | 384 |
+| Owned-output CLEARs | 8 |
+| Real scalar primitive allowance | 3,088 |
+| New live owned output arrays | 8 |
+| Borrowed source arrays restored | 96 |
+| Literal events before expanding line wrappers | 776 |
+
+The scalar allowance is `2*(4*384+8)` under the retained complex-to-real
+ledger. It excludes the separately counted child and map costs. Map counts
+are not a physical addressing-time bound. No complete favorable supplier
+budget or new kappa is established.
+
+## Evidence and reproduction
+
+[PROOF.md](PROOF.md) derives the exact endpoint using the inherited native
+frame conventions and full-cover action. [RESULT.json](RESULT.json) contains
+the literal word, all 192 signed line recipes, the complete invoice and
+rejection receipts. [SOURCES.json](SOURCES.json) pins the immutable archive,
+QQ16 packet and consumed contracts. The R matrix is independently rebuilt
+from the retained scalar prefix. Future route matrices and both payload
+translations are rebuilt from phase geometry and compared with emitted maps.
+
+The motivating access handoff is retained verbatim in
+[PR2443-README.md](evidence/PR2443-README.md), lines 188-191 and 202-212, from
+PR2443 head `545c05e17243c962b112b91e7f84b4c1a41de7b8`.
+[PREDECESSOR.json](PREDECESSOR.json) records its exact path, Git blob and
+SHA-256. The tests bind that copy to both hashes. The runtime query is
+independently defined from the base sources; no pending PR code is imported.
+
+The verifier tracks all 104 independent logical inputs with exact rational
+coefficients and actual owner operators, alongside exact Z4 frame polynomials
+after every event. Every ADD must have identical source/target native phases.
+It checks all 98,304 low-block basis columns of the signed rank-one kernels;
+the external coordinates are spectators. Eight controls reject missing
+normalization/restoration, missing or incorrectly undone translations, an
+uncleared dirty output, a wrong coefficient, an early query and an inverse
+line with the wrong sign. The formal identities apply to arbitrary payloads;
+no floating-point acceptance is used.
+
+```sh
+python3.12 -I -B scripts/research_package.py --package research/qq16-future-x-query
+python3.12 -I -O -B research/qq16-future-x-query/verify.py
+```
+
+Expected status: `PASS_QQ16_FUTURE_X_QUERY`. Replay compares the entire
+recomputed receipt with the committed one and writes nothing. Explicit
+`--write-result` creates a new receipt and refuses an existing path.
+
+## Limits
+
+This is a complete local native-operator sequence under the retained full-cover
+view, signed rank-one primitive and sweep conventions. It does not assign its
+new children to global helper owners, price physical map execution, prove
+recursive precision, or retain the cut through the rest of the controller.
+The other reads, scalar minor inverse, output gauge conversions, storage and
+cleanup in PR2443 remain unpriced. It is not a full decoder implementation.
+
+## Open next questions
+
+1. Can the other two-cut records and this query be hosted and retained with a
+   favorable full invoice? Start with all added arrays, children and maps in
+   one chronological ledger; stop if the optimistic complete bill already
+   misses the supplier target. Global owner delivery is unresolved.
+2. Can an earlier read or fusion with an existing native transition avoid
+   this standalone normalization cost? Specify a changed observation time or
+   word and check the full ordered decoder. This invoice does not exclude
+   such a different interface.
+
+## Credit
+
+`starship-s` / PR2443 supplies the exact `B2 C` access question and two-cut
+decoder. Ali Romman / PR1969 supplies the QQ16 native words, signed line
+conventions, full-cover maps and endpoint frames. The bridge review and its
+underlying Rohan Arun, Jeremy Kothe, DreamingOfClouds and supplier lineage
+retain credit in [the source notice](../joint-query/NOTICE.md). Gareth Davidson
+/ PR2432, commdata2338 / PR2174 and the other coordinate-read predecessors
+retain the attribution in PR2443. This author's PR2456 audited that decoder;
+this package constructs one of its still-missing native reads.
+
+Prepared by ywz65 with substantial OpenAI Codex assistance in derivation,
+implementation, checking and writing. No independent human or proof-assistant
+review is claimed. New work is Apache-2.0; frozen sources remain unchanged.