QQ16: add an F0-B1 selected-state shear

research/qq16-f0-b1-shear-seedccce426/CLAIM.md

@@ -0,0 +1,32 @@
+CLAIM — QQ16 F0-to-B1 selected A/T shear using existing query width (Cycle 38; recursive-interfaces, priority revision 4)
+
+**Assignment pins:** selector seed `ccce426f938ce02908e39f554d0187b2`; task `joint-query-controller`, key `0e34adbc1dd119161c3a`; exact base `0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2`; catalogue SHA-256 `d46eb6d5b3e279428753d770653663fbdf1063e55c255ea073d768f344927ef7`; selected-record SHA-256 `10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32`.
+
+**Object / question:** Insert the reversible selected-state shear immediately after F0 and before B1: `X_T <- X_T + X_A`, `Y_T <- Y_T - X_A`, with all other fields fixed. Does this make the actual post-B1 selected output injective on the eight-dimensional selected-input defect from the fixed QQ16 witness, while using the existing query and recursive-child counts?
+
+**Changed assumption and bounded method:** Permit one A-to-T shear on the already-produced selected fields, with identity coordinate map only. I will derive the exact 8-by-8 transfer on the pinned witness span using the actual QQ16 selected sections and ordered B1 maps, then compare identity shear, zero shear, and a sign-corrupted control. The experiment covers this witness span and this one shear; it does not claim a full controller or all-size supplier.
+
+**Optimistic full local charge:** 16 scalar additions per owner (eight to X_T and eight to Y_T), eight copied values hosted in existing selected fields, zero new helpers, zero added recursive children, and no new coefficient precision for C=I. The B1 and F0 children stay as before. Frame/address transitions and restoration are provisionally granted free for the initial screen; any exact map or hosting cost found in the route calculation will be added. The local source/F0/B1 invoice remains 211210/214986 scalar primitives with 8/24 added rank-one children before the shear. The favorable selected profile has only two rank-one-equivalent operations of slack after an ideal rank-eight output charge, so any added child is a stop condition. No supplier or κ gain is presumed.
+
+**Nearest work / distinct contribution:** PR #2086 treats arbitrary changes to the first A logger with the old T output fixed and names changed T records as open. PR #2093 and the completed B2-read work add ordinary-source observations. PR #2174 recovers pair 0 only with privileged post-B1 selected-cut values. PR #2189 gives a read-only transcript-width bound. This scope instead changes the selected state between the two calls by an invertible sum-preserving shear; no extra observation is added. The live exact-term scan at 23:47Z covered 445 open PRs and 892 Discussion records with complete pagination and no warnings, and returned no matches.
+
+**Expected result / stop:** an exact rank-eight transfer or a counterexample on the witness span, with a source-bound reproducible check and charged local operations. Stop if the map is not injective or if implementation needs any extra recursive child. Claim expires 2026-10-15T01:50Z.
+
+**Predecessor credit:** Ali Romman and the retained joint-query lineage (PR #1969) supply the local maps and witness; Cinna Davis (PR #2079) and Adam Gall (PR #2093) supply adjacent observation analyses. Substantial AI assistance from OpenAI Codex.
+
+## FINDING — exact witness repaired at the B1 cut
+
+The all-route group-algebra replay passes for all eight pinned `h_k`
+directions. It verifies `B1 h_k=0`, the `2112 I` identity coefficient of
+`B2 h_k`, rank eight in the post-F0 A field, rank zero in the zero-shear B1
+T output, and rank eight in the sheared B1 T output. An exact eight-row
+minor has determinant `-1/4096`; its group-map keys and rational
+coefficients are in `RESULT.json`.
+
+The shear costs 16 scalar additions per owner at the common `completed(0)`
+frame, uses existing A/T fields, preserves selected sums, and adds no
+helper, cover map, precision, or recursive child. This is a fixed-witness
+interface mechanism, not a full controller, supplier, or kappa result.
+Package and source pins pass; the final verifier passed locally on Python
+3.14.7. The registered package replay targets Python 3.12 and remains for
+hosted CI.

research/qq16-f0-b1-shear-seedccce426/NOTICE.md

@@ -0,0 +1,10 @@
+New work in this package is released under Apache-2.0.
+
+Predecessor credit: Ali Romman and the retained joint-query lineage supply
+the QQ16 maps, ordered local words, route model, and erased-input witness
+(merged PR #1969). Cinna Davis's PR #2079 and Adam Gall's PR #2093 study
+additional ordinary observations. PR #2086 studies changed A logging while
+leaving the T output fixed. Their code and frozen sources are not modified.
+
+Substantial AI assistance: OpenAI Codex derived, implemented, checked, and
+wrote this scoped result. No independent human review is claimed.

research/qq16-f0-b1-shear-seedccce426/PROOF.md

@@ -0,0 +1,91 @@
+# Exact witness calculation
+
+## Frozen object and witness
+
+The source and route model is the selected QQ16 package at the base pinned
+in `SOURCES.json`. The inherited witness uses the actual sets
+
+```text
+A = [0, 7, 20, 27, 36, 46, 57, 111]
+T = [21, 37, 47, 76, 81, 87, 92, 110]
+U = the other 96 ports.
+```
+
+For each centre basis vector `e_k` at the identity owner, the checker builds
+
+```text
+h_k = (48 I - B1* B1) B2* e_k,       k=0,...,7.
+```
+
+`B_s` is the actual stage-s query restricted to U, including each port's
+exact stage owner map. The checker works in the group algebra of the 73-bit
+owner linear maps and uses rational coefficients. Payload translations are
+omitted only because every payload block is held constant, as in the
+predecessor witness. The exact checks give `B1 h_k = 0` and identity
+coefficient `2112 e_k` in `B2 h_k` for all eight k. Applying the invertible
+stage-2 A section gives an eight-dimensional vector `a_k=P_(2,A)B2 h_k`.
+
+The ordered F0 witness state immediately before B1 is
+
+```text
+X_U = Y_U = h_k
+X_A = a_k,  Y_A = -a_k
+X_T = Y_T = 0.
+```
+
+At zero shear, the retained B1 word returns the erased selected output on
+this family; the checker verifies that its T output is the zero group-ring
+vector for every k.
+
+## The changed interface
+
+Insert the coordinatewise shear
+
+```text
+X_T <- X_T + X_A
+Y_T <- Y_T - X_A.
+```
+
+For each T coordinate the change in `X_T+Y_T` is zero. The full map is
+invertible, with inverse `X_T <- X_T-X_A`, `Y_T <- Y_T+X_A`; it uses no
+scratch field. After the shear the B1 inputs have
+
+```text
+X_T = a_k,  Y_T = -a_k.
+```
+
+In the ordered B word, write `u=E_2 Y`, `a=ell_1 X`, and `b=R_1 u`. Its T
+output is `P_(1,T)(b+12a)`. Thus the shear's exact effect is
+
+```text
+Delta X'_T = P_(1,T) (12 ell_1 - R_1 E_2) iota_T a_k,
+```
+
+where each term is evaluated with the pinned 73-bit owner routes. The
+verifier propagates all eight `a_k` as sparse rational group-algebra
+vectors. It finds 287,368 distinct owner-map labels in the T outputs and
+extracts eight rows, indexed by T port and exact owner map, whose coefficient
+matrix has determinant `-1/4096`. This proves the post-B1 T outputs are
+linearly independent on the eight-dimensional witness family. The sparse
+rows, route keys, and exact coefficients are in `RESULT.json`; the checker
+recomputes them from the pinned source.
+
+The zero-shear control has rank zero. The positive result is limited to this
+fixed erased family and this post-F0 state shear. It does not prove that
+subsequent events retain the output, restore every selected input, or form
+a complete controller.
+
+## Cost and remaining obligations
+
+At the F0/B1 boundary all data fields use the common `completed(0)` frame.
+The shear therefore uses same-owner scalar adds without changing an owner
+map or a frame. Its exact local cost is 16 scalar additions per owner, zero
+new helpers, zero new recursive children, zero new coefficient precision,
+and zero temporary storage. It reads the existing A fields, writes existing
+T fields, and preserves the logical selected sums. The ordinary helper
+restoration contract is unchanged.
+
+The route test establishes an exact interface effect, not a priced complete
+supplier. Any integration must still propagate the state through the
+remaining tail and prove final output/restoration for arbitrary inputs.
+There is no new κ claim.

research/qq16-f0-b1-shear-seedccce426/README.md

@@ -0,0 +1,70 @@
+# QQ16 selected-state shear at the F0/B1 cut
+
+This package tests one reversible data-map insertion between the retained
+forward `F0` and backward `B1` calls. For each of the eight selected A/T
+coordinate pairs it applies
+
+```text
+X_T <- X_T + X_A
+Y_T <- Y_T - X_A
+```
+
+The map preserves every selected `X_T + Y_T` sum and is invertible. On the
+exact eight-direction selected-input witness for the fixed QQ16 pair, the
+zero-shear B1 T output is zero. With the shear, the post-B1 T output has rank
+eight over the exact payload-constant regular-cover group algebra. The
+verifier emits eight output coordinates with exact minor determinant
+`-1/4096`.
+
+This is a local interface mechanism. It resolves the cited witness at the
+post-B1 cut; it does not show that the later controller tail keeps these
+values, produce a complete controller, admit a supplier, or improve κ.
+
+## Reproduce
+
+From the repository root, with Python 3.10 or later and only the standard
+library:
+
+```sh
+python3 -I -B research/qq16-f0-b1-shear-seedccce426/verify.py
+```
+
+Expected output:
+
+```text
+PASS_QQ16_F0_B1_IDENTITY_SHEAR_WITNESS
+source_A_rank=8; zero_shear_T_rank=0; sheared_post_B1_T_rank=8
+exact_nonzero_8x8_minor_det=-1/4096
+```
+
+The checker rebuilds the pinned QQ16 scalar matrix and all 73-bit owner
+routes, constructs the eight `h_k` inputs from the exact group-algebra
+formula, verifies `B1 h_k = 0` and the `2112 I` identity coefficient of
+`B2 h_k`, then propagates both the control and sheared states through the
+ordered B1 map. `RESULT.json` records an explicit nonsingular eight-row
+minor, including its exact owner-map keys and rational coefficients.
+
+## Local charge
+
+At the common `completed(0)` data frame, the inserted map costs 16 scalar
+additions per owner: eight writes into existing `X_T` fields and eight into
+existing `Y_T` fields. It allocates no helper, changes no coefficient or
+precision, and adds no recursive child or cover-map operation. The A source
+is not overwritten; the A/T addresses are distinct; the inverse shear is
+available by reversing the two signs. The operation preserves the selected
+sums and leaves the inherited 480 ordinary helpers untouched.
+
+This is the complete local data-map charge. The full controller, subsequent
+tail behavior, and supplier cost are open, so these 16 additions are not a
+κ claim or a complete supplier invoice.
+
+## Open next questions
+
+- Does the retained ordinary tail preserve the eight values revealed in the
+  T output, or do later events erase them again? First step: propagate the
+  exact sheared witness through the next frozen event and test the complete
+  selected-output kernel. Blocker: the current package stops at B1.
+- Can the shear be integrated into a full controller with its complete
+  address, hosting, precision, and restoration bill? First step: derive the
+  next ordered interface identity before pricing any longer word. Blocker:
+  no full controller or supplier is supplied here.