diff --git a/research/qq16-f0-b1-shear-seedccce426/CLAIM.md b/research/qq16-f0-b1-shear-seedccce426/CLAIM.md new file mode 100644 index 0000000000..24a27daf60 --- /dev/null +++ b/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. diff --git a/research/qq16-f0-b1-shear-seedccce426/NOTICE.md b/research/qq16-f0-b1-shear-seedccce426/NOTICE.md new file mode 100644 index 0000000000..c9c4692de9 --- /dev/null +++ b/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. diff --git a/research/qq16-f0-b1-shear-seedccce426/PROOF.md b/research/qq16-f0-b1-shear-seedccce426/PROOF.md new file mode 100644 index 0000000000..cff9e787d2 --- /dev/null +++ b/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. diff --git a/research/qq16-f0-b1-shear-seedccce426/README.md b/research/qq16-f0-b1-shear-seedccce426/README.md new file mode 100644 index 0000000000..a00f79176d --- /dev/null +++ b/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. diff --git a/research/qq16-f0-b1-shear-seedccce426/RESULT.json b/research/qq16-f0-b1-shear-seedccce426/RESULT.json new file mode 100644 index 0000000000..a8de27d03a --- /dev/null +++ b/research/qq16-f0-b1-shear-seedccce426/RESULT.json @@ -0,0 +1,732 @@ +{ + "control": { + "zero_shear_post_B1_T_rank": 0 + }, + "local_cost": { + "frame_boundary": "F0 output and B1 input share the completed(0) data frame", + "new_coefficients_or_precision": 0, + "new_helpers": 0, + "new_recursive_children": 0, + "selected_additions_per_owner": 16, + "selected_sum_preserved": true + }, + "no_claim": "No complete-controller, recursive supplier, or kappa improvement is established.", + "result": { + "distinct_owner_maps_in_T_output": 287368, + "minor_rows": [ + { + "coefficients": [ + "-1/4", + "0", + "0", + "-1/4", + "1/4", + "0", + "0", + "1/4" + ], + "owner_map_columns_hex": [ + "0x27dc", + "0x879cfd", + "0xc20000", + "0x1f02721", + "0x1e82721", + "0x1d82721", + "0x87bbdc", + "0xf82721", + "0x1be2721", + "0xc54521", + "0xc4dd21", + "0x16a00", + "0x17200", + "0x6121", + "0x4321", + "0x1e200", + "0xc59800", + "0x17e01df", + "0x17e00f9", + "0x17e00f5", + "0x17e00ed", + "0x17e01fe", + "0x17e00bd", + "0x23", + "0x17e007d", + "0x2000000", + "0x4000000", + "0x8000000", + "0x10000000", + "0x20000000", + "0x40000000", + "0x80000000", + "0x100000000", + "0x200000000", + "0x400000000", + "0x800000000", + "0x1000000000", + "0x2000000000", + "0x4000000000", + "0x8000000000", + "0x10000000000", + "0x20000000000", + "0x40000000000", + "0x80000000000", + "0x100000000000", + "0x200000000000", + "0x400000000000", + "0x800000000000", + "0x1000000000000", + "0x2000000000000", + "0x4000000000000", + "0x8000000000000", + "0x10000000000000", + "0x20000000000000", + "0x40000000000000", + "0x80000000000000", + "0x100000000000000", + "0x200000000000000", + "0x400000000000000", + "0x800000000000000", + "0x1000000000000000", + "0x2000000000000000", + "0x4000000000000000", + "0x8000000000000000", + "0x10000000000000000", + "0x20000000000000000", + "0x40000000000000000", + "0x80000000000000000", + "0x100000000000000000", + "0x200000000000000000", + "0x400000000000000000", + "0x800000000000000000", + "0x1000000000000000000" + ], + "port": 21 + }, + { + "coefficients": [ + "0", + "-1/4", + "1/4", + "0", + "1/4", + "0", + "0", + "1/4" + ], + "owner_map_columns_hex": [ + "0x2bdc", + "0x8b9cfd", + "0x1f02b21", + "0xc20000", + "0x1e42b21", + "0x1d42b21", + "0x8bb7dc", + "0xf42b21", + "0x1be2b21", + "0xc94921", + "0x16600", + "0xc8dd21", + "0x17200", + "0x6121", + "0x4321", + "0x1e200", + "0xc99400", + "0x17e01df", + "0x17e00f9", + "0x17e00f5", + "0x17e00ed", + "0x17e01fe", + "0x17e00bd", + "0x23", + "0x17e007d", + "0x2000000", + "0x4000000", + "0x8000000", + "0x10000000", + "0x20000000", + "0x40000000", + "0x80000000", + "0x100000000", + "0x200000000", + "0x400000000", + "0x800000000", + "0x1000000000", + "0x2000000000", + "0x4000000000", + "0x8000000000", + "0x10000000000", + "0x20000000000", + "0x40000000000", + "0x80000000000", + "0x100000000000", + "0x200000000000", + "0x400000000000", + "0x800000000000", + "0x1000000000000", + "0x2000000000000", + "0x4000000000000", + "0x8000000000000", + "0x10000000000000", + "0x20000000000000", + "0x40000000000000", + "0x80000000000000", + "0x100000000000000", + "0x200000000000000", + "0x400000000000000", + "0x800000000000000", + "0x1000000000000000", + "0x2000000000000000", + "0x4000000000000000", + "0x8000000000000000", + "0x10000000000000000", + "0x20000000000000000", + "0x40000000000000000", + "0x80000000000000000", + "0x100000000000000000", + "0x200000000000000000", + "0x400000000000000000", + "0x800000000000000000", + "0x1000000000000000000" + ], + "port": 21 + }, + { + "coefficients": [ + "0", + "0", + "1/4", + "-1/4", + "0", + "0", + "1/4", + "-1/4" + ], + "owner_map_columns_hex": [ + "0x3e8d", + "0x100000", + "0x129b3ac", + "0x125b3ac", + "0x218c8d", + "0x203f21", + "0x400000", + "0x20000", + "0x2db3ac", + "0x803c00", + "0x800921", + "0x800521", + "0xbf21", + "0x13f21", + "0x4000", + "0x801e00", + "0x802e00", + "0xa1", + "0x10c002b", + "0x10c0027", + "0x10", + "0x18d", + "0x40", + "0xe", + "0x10c000c", + "0x2000000", + "0x4000000", + "0x8000000", + "0x10000000", + "0x20000000", + "0x40000000", + "0x80000000", + "0x100000000", + "0x200000000", + "0x400000000", + "0x800000000", + "0x1000000000", + "0x2000000000", + "0x4000000000", + "0x8000000000", + "0x10000000000", + "0x20000000000", + "0x40000000000", + "0x80000000000", + "0x100000000000", + "0x200000000000", + "0x400000000000", + "0x800000000000", + "0x1000000000000", + "0x2000000000000", + "0x4000000000000", + "0x8000000000000", + "0x10000000000000", + "0x20000000000000", + "0x40000000000000", + "0x80000000000000", + "0x100000000000000", + "0x200000000000000", + "0x400000000000000", + "0x800000000000000", + "0x1000000000000000", + "0x2000000000000000", + "0x4000000000000000", + "0x8000000000000000", + "0x10000000000000000", + "0x20000000000000000", + "0x40000000000000000", + "0x80000000000000000", + "0x100000000000000000", + "0x200000000000000000", + "0x400000000000000000", + "0x800000000000000000", + "0x1000000000000000000" + ], + "port": 21 + }, + { + "coefficients": [ + "1/4", + "0", + "0", + "-1/4", + "0", + "-1/4", + "-1/4", + "0" + ], + "owner_map_columns_hex": [ + "0x8efd", + "0x1fd9cfd", + "0x1fa0000", + "0x1f60000", + "0x1be0000", + "0x1de0000", + "0x1fd12fd", + "0xfe0000", + "0x1fc8e00", + "0x2000", + "0x1ef4600", + "0x1ef4a00", + "0x9e00", + "0x1ee4121", + "0x1ef8f21", + "0x1efc200", + "0x1cf21", + "0x17e01df", + "0x17e00f9", + "0x17e00f5", + "0x17e00ed", + "0x17e01fe", + "0x17e00bd", + "0x23", + "0x17e007d", + "0x2000000", + "0x4000000", + "0x8000000", + "0x10000000", + "0x20000000", + "0x40000000", + "0x80000000", + "0x100000000", + "0x200000000", + "0x400000000", + "0x800000000", + "0x1000000000", + "0x2000000000", + "0x4000000000", + "0x8000000000", + "0x10000000000", + "0x20000000000", + "0x40000000000", + "0x80000000000", + "0x100000000000", + "0x200000000000", + "0x400000000000", + "0x800000000000", + "0x1000000000000", + "0x2000000000000", + "0x4000000000000", + "0x8000000000000", + "0x10000000000000", + "0x20000000000000", + "0x40000000000000", + "0x80000000000000", + "0x100000000000000", + "0x200000000000000", + "0x400000000000000", + "0x800000000000000", + "0x1000000000000000", + "0x2000000000000000", + "0x4000000000000000", + "0x8000000000000000", + "0x10000000000000000", + "0x20000000000000000", + "0x40000000000000000", + "0x80000000000000000", + "0x100000000000000000", + "0x200000000000000000", + "0x400000000000000000", + "0x800000000000000000", + "0x1000000000000000000" + ], + "port": 21 + }, + { + "coefficients": [ + "1/4", + "1/4", + "0", + "0", + "0", + "0", + "-1/4", + "1/4" + ], + "owner_map_columns_hex": [ + "0xa200", + "0xcfd21", + "0x166fddc", + "0x16afddc", + "0xbc0000", + "0x1e000fd", + "0x17000fd", + "0x9c00fd", + "0xdc0000", + "0xe5c00", + "0xea921", + "0xea521", + "0xee121", + "0x8321", + "0xeb121", + "0x10000", + "0x2321", + "0x19c01df", + "0x19c00f9", + "0x19c00f5", + "0x19c00ed", + "0x19c01fe", + "0x19c00bd", + "0x23", + "0x19c007d", + "0x2000000", + "0x4000000", + "0x8000000", + "0x10000000", + "0x20000000", + "0x40000000", + "0x80000000", + "0x100000000", + "0x200000000", + "0x400000000", + "0x800000000", + "0x1000000000", + "0x2000000000", + "0x4000000000", + "0x8000000000", + "0x10000000000", + "0x20000000000", + "0x40000000000", + "0x80000000000", + "0x100000000000", + "0x200000000000", + "0x400000000000", + "0x800000000000", + "0x1000000000000", + "0x2000000000000", + "0x4000000000000", + "0x8000000000000", + "0x10000000000000", + "0x20000000000000", + "0x40000000000000", + "0x80000000000000", + "0x100000000000000", + "0x200000000000000", + "0x400000000000000", + "0x800000000000000", + "0x1000000000000000", + "0x2000000000000000", + "0x4000000000000000", + "0x8000000000000000", + "0x10000000000000000", + "0x20000000000000000", + "0x40000000000000000", + "0x80000000000000000", + "0x100000000000000000", + "0x200000000000000000", + "0x400000000000000000", + "0x800000000000000000", + "0x1000000000000000000" + ], + "port": 21 + }, + { + "coefficients": [ + "0", + "1/4", + "0", + "-1/4", + "-1/4", + "0", + "-1/4", + "0" + ], + "owner_map_columns_hex": [ + "0xa200", + "0x14fd21", + "0x166fddc", + "0xbc0000", + "0x172fddc", + "0x1e000fd", + "0x16800fd", + "0x9c00fd", + "0xdc0000", + "0x165c00", + "0x16b121", + "0x16e121", + "0x16a521", + "0x8321", + "0x16a921", + "0x10000", + "0x2321", + "0x19c01df", + "0x19c00f9", + "0x19c00f5", + "0x19c00ed", + "0x19c01fe", + "0x19c00bd", + "0x23", + "0x19c007d", + "0x2000000", + "0x4000000", + "0x8000000", + "0x10000000", + "0x20000000", + "0x40000000", + "0x80000000", + "0x100000000", + "0x200000000", + "0x400000000", + "0x800000000", + "0x1000000000", + "0x2000000000", + "0x4000000000", + "0x8000000000", + "0x10000000000", + "0x20000000000", + "0x40000000000", + "0x80000000000", + "0x100000000000", + "0x200000000000", + "0x400000000000", + "0x800000000000", + "0x1000000000000", + "0x2000000000000", + "0x4000000000000", + "0x8000000000000", + "0x10000000000000", + "0x20000000000000", + "0x40000000000000", + "0x80000000000000", + "0x100000000000000", + "0x200000000000000", + "0x400000000000000", + "0x800000000000000", + "0x1000000000000000", + "0x2000000000000000", + "0x4000000000000000", + "0x8000000000000000", + "0x10000000000000000", + "0x20000000000000000", + "0x40000000000000000", + "0x80000000000000000", + "0x100000000000000000", + "0x200000000000000000", + "0x400000000000000000", + "0x800000000000000000", + "0x1000000000000000000" + ], + "port": 21 + }, + { + "coefficients": [ + "-1/4", + "0", + "0", + "1/4", + "1/4", + "0", + "0", + "1/4" + ], + "owner_map_columns_hex": [ + "0xa200", + "0xb1adac", + "0x11a01ac", + "0x11601ac", + "0xa3adac", + "0x13ac00", + "0x400000", + "0x920000", + "0x1e01ac", + "0x18e00", + "0x331921", + "0x331521", + "0x13f21", + "0x332f21", + "0x4000", + "0x321d21", + "0x333e00", + "0xa1", + "0x10c002b", + "0x10c0027", + "0x10", + "0x18d", + "0x40", + "0xe", + "0x10c000c", + "0x2000000", + "0x4000000", + "0x8000000", + "0x10000000", + "0x20000000", + "0x40000000", + "0x80000000", + "0x100000000", + "0x200000000", + "0x400000000", + "0x800000000", + "0x1000000000", + "0x2000000000", + "0x4000000000", + "0x8000000000", + "0x10000000000", + "0x20000000000", + "0x40000000000", + "0x80000000000", + "0x100000000000", + "0x200000000000", + "0x400000000000", + "0x800000000000", + "0x1000000000000", + "0x2000000000000", + "0x4000000000000", + "0x8000000000000", + "0x10000000000000", + "0x20000000000000", + "0x40000000000000", + "0x80000000000000", + "0x100000000000000", + "0x200000000000000", + "0x400000000000000", + "0x800000000000000", + "0x1000000000000000", + "0x2000000000000000", + "0x4000000000000000", + "0x8000000000000000", + "0x10000000000000000", + "0x20000000000000000", + "0x40000000000000000", + "0x80000000000000000", + "0x100000000000000000", + "0x200000000000000000", + "0x400000000000000000", + "0x800000000000000000", + "0x1000000000000000000" + ], + "port": 21 + }, + { + "coefficients": [ + "0", + "0", + "1/4", + "-1/4", + "1/4", + "1/4", + "0", + "0" + ], + "owner_map_columns_hex": [ + "0x20000", + "0x60028d", + "0x1a8a200", + "0x1a4a200", + "0x100000", + "0x80a3ac", + "0x800321", + "0xe0a08d", + "0xaca200", + "0xc0a200", + "0x400", + "0x800", + "0x1000", + "0x8321", + "0x4000", + "0x10000", + "0x2321", + "0xa1", + "0x10c002b", + "0x10c0027", + "0x10", + "0x18d", + "0x40", + "0xe", + "0x10c000c", + "0x2000000", + "0x4000000", + "0x8000000", + "0x10000000", + "0x20000000", + "0x40000000", + "0x80000000", + "0x100000000", + "0x200000000", + "0x400000000", + "0x800000000", + "0x1000000000", + "0x2000000000", + "0x4000000000", + "0x8000000000", + "0x10000000000", + "0x20000000000", + "0x40000000000", + "0x80000000000", + "0x100000000000", + "0x200000000000", + "0x400000000000", + "0x800000000000", + "0x1000000000000", + "0x2000000000000", + "0x4000000000000", + "0x8000000000000", + "0x10000000000000", + "0x20000000000000", + "0x40000000000000", + "0x80000000000000", + "0x100000000000000", + "0x200000000000000", + "0x400000000000000", + "0x800000000000000", + "0x1000000000000000", + "0x2000000000000000", + "0x4000000000000000", + "0x8000000000000000", + "0x10000000000000000", + "0x20000000000000000", + "0x40000000000000000", + "0x80000000000000000", + "0x100000000000000000", + "0x200000000000000000", + "0x400000000000000000", + "0x800000000000000000", + "0x1000000000000000000" + ], + "port": 21 + } + ], + "nonsingular_minor_determinant": "-1/4096", + "post_B1_T_family_rank": 8 + }, + "scope": "Exact payload-constant regular-cover group algebra on the eight pinned h_k witnesses; one identity-coordinate shear between F0 and B1; not a full controller or supplier.", + "status": "PASS_QQ16_F0_B1_IDENTITY_SHEAR_WITNESS", + "witness_checks": { + "B1_h_zero_for_all_eight": true, + "B2h_identity_coefficient": "2112*I8", + "post_F0_A_family_rank": 8 + } +} diff --git a/research/qq16-f0-b1-shear-seedccce426/SOURCES.json b/research/qq16-f0-b1-shear-seedccce426/SOURCES.json new file mode 100644 index 0000000000..79cb7e9b2f --- /dev/null +++ b/research/qq16-f0-b1-shear-seedccce426/SOURCES.json @@ -0,0 +1,114 @@ +{ + "base_commit": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2", + "files": [ + { + "git_blob": "e8870e5917057d59b730eb14721a778639eca050", + "path": "docs/research/agent-task-catalog.json", + "sha256": "d46eb6d5b3e279428753d770653663fbdf1063e55c255ea073d768f344927ef7", + "usage": "input" + }, + { + "git_blob": "ae6a99f28aa468649eb66a361e764d769363bf11", + "path": "certificates/selected-result.json", + "sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32", + "usage": "input" + }, + { + "git_blob": "3e66629292d42f592a0d73a4a42f7f3a02bd62a5", + "path": "research/joint-query/SOURCES.json", + "sha256": "fabc6686e5d3ac0e4bb4397c147037b9285abfa671614590dad6d4e16b4dc0fc", + "usage": "input" + }, + { + "git_blob": "c6e876d8b48d768214deee265ade428f8983b566", + "path": "research/joint-query/certificate.json.gz", + "sha256": "a5ed85fac5ebf3c091482a113ab0d351eb5a7892fe2841a35e16017ec1ff49f7", + "usage": "input" + }, + { + "git_blob": "c9d465ed47500304bef65fcb588befe356c5cf09", + "path": "research/joint-query/source_data.py", + "sha256": "d23924511e3aed41e5e64511ca70126a636d91c8aa02e656cb61d6ceca1fe0a0", + "usage": "input" + }, + { + "git_blob": "ede9e7e42744dd0c96790516a9acdfe07d180018", + "path": "research/joint-query/verify_native.py", + "sha256": "1c58e7b6e8e1cde4df455c2129601c145ed763fc63a3ab427eb1058d1fc08bd2", + "usage": "input" + }, + { + "git_blob": "e85527fed48be411a132fa44d93f5d1632fe7a91", + "path": "research/joint-query/verify_ordered.py", + "sha256": "0e23ed4bef58ed8375a9d43b0b9cbcab8e825ec7d5d702e74973ccc41d97ffa6", + "usage": "input" + }, + { + "git_blob": "4639583c1be02c2fb60ed8a8072c9969ef1569ce", + "path": "research/joint-query/evidence/CONSERVED-QQ16.md", + "sha256": "60f0de3a7205ba5046b5ae7ffa8bf2b1ea42ea46b498face0a77966b59e7f3fb", + "usage": "provenance" + }, + { + "git_blob": "525b38dbdefed0e8192a9c5165e802136cc05034", + "path": "research/joint-query/evidence/NATIVE-REVIEW.md", + "sha256": "2247e3cbe73f3f0da55c647ffae15f98dd9445b2366ba9e255b9bebc9f742b70", + "usage": "provenance" + }, + { + "git_blob": "67699da21b75c3de89fbb3a96daa4719febb555b", + "path": "research/joint-query/evidence/NATIVE-CHECKS.json", + "sha256": "fe959be0bf2490f99efcf6b8109b19cc8d79036d9df54b59598f32de92295054", + "usage": "provenance" + }, + { + "git_blob": "307650f45e37c28d14fe913958efa4fb429242b7", + "path": "research/joint-query/evidence/QQ16-SELECTED-WITNESS.md", + "sha256": "52f2ee565320f05282c637aa79eee100606c24240b1b5866f0c8d62e7913c9fc", + "usage": "provenance" + }, + { + "git_blob": "5082d791d0b993492cbc5bf61ac3b69e82c96f3f", + "path": "research/joint-query/evidence/QQ16-SELECTED-WITNESS.json", + "sha256": "e35e5868a1322e406191079c0675975b139692ba50b1e2e5fb8a40b6480519f4", + "usage": "provenance" + }, + { + "git_blob": "c6ecf75654a084a9cc001bd62663f341976bae7a", + "path": "research/joint-query/evidence/QQ16-RATIONAL-OBSERVATION-REVIEW.md", + "sha256": "9a06ff40830ef80d3566fce77c78639cb64d519d487a0a7f57d543c3146e2c49", + "usage": "provenance" + }, + { + "git_blob": "e649641e9b44af2fff9742df51d439890c1a19cc", + "path": "research/joint-query/evidence/QQ16-RATIONAL-OBSERVATION-REVIEW.json", + "sha256": "588a3ce4593576ae921e97c6ced6a050f88736f29708cfee117385b254cd358f", + "usage": "provenance" + } + ], + "schema_version": 1, + "selected_record_sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32", + "transitive_source_manifest": { + "archive_path": "research/community-frontier1042-audit/selected-replay.tar.gz", + "archive_sha256": "22c3f4dce4b897a1d423d1388801933e288b6a6b1906cb15e1b16a5eb68db754", + "base": "bce54fb3f895cbe5cd4c0eb477c3afeed100190f", + "credit_sources": { + "LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "research/gauge44-slots-t16/NOTICE.md": "7a8d17b04da1e6c9d0ec217fb5bda72faa09d9a21695128722dd1e2827870fcf", + "research/gauge44-slots-t16/UPSTREAM-NOTICE.md": "a75967ebc34e3bf2ff2c25c08e6c7f1a61b0c0d171cfd1b62196ae2caaf2c610", + "research/gauge44-slots-t16/construction/NOTICE.md": "defe7e44af610e25a6c50c1c3b2efd0972d0690574995c0c872fc50eebf4c816", + "research/gauge44-slots-t16/t16/NOTICE.md": "902370e6bfcd39dbea2ece474f15fccbcce3b8e966b2b94066bd03e5174591b5" + }, + "decompressed_payloads": { + "CANONICAL-WORD.json.gz": "4ddb29fb9bc6f27e0c0fbfcf19a2a93a3496ad900d0f6d89059d0305c9576c0c", + "LOCAL-PROGRAMS.json.gz": "9f41d53659e9be84e20c661560c5687abbf5cd0660cdecbe01ad5eb29e6b8ee3" + }, + "members": { + "slots/local/CANONICAL-WORD.json.gz": "16bc0ebb04b4be6c0ade74badc6a0c0cdba4215eda86e4ff9f13abf8ecebd219", + "slots/local/CLIFFORD-RECIPES.json": "d0768f2164d5f64a2fdbec422f1cfde4e400818792f1904ca541958377243731", + "slots/local/LOCAL-PROGRAMS.json.gz": "241fde27d4e43f5a9cb6b128f9f76c5131a53d09f0371676163f914d0b0fef3a", + "slots/local/RESIDUAL-ADAPTERS.json": "383f40aadd00a4ac700dfd0d4c22d6c6c0be9a9863116e4d69c7acd23bafae0c", + "t16/global/base/work/complex-nine-native/DATA-PHASES.json": "c5916ff312678f12aba403847643fbbc29f643acec60bdf836fa56cd3e8251fa" + } + } +} diff --git a/research/qq16-f0-b1-shear-seedccce426/TASK.json b/research/qq16-f0-b1-shear-seedccce426/TASK.json new file mode 100644 index 0000000000..8cf7b173c4 --- /dev/null +++ b/research/qq16-f0-b1-shear-seedccce426/TASK.json @@ -0,0 +1,84 @@ +{ + "actual_scope": "At the fixed QQ16 F0/B1 cut, insert the identity-coordinate, sum-preserving shear X_T <- X_T + X_A and Y_T <- Y_T - X_A. On the exact eight-dimensional selected-input witness, the B1 T output becomes rank eight without another query or recursive child.", + "ai_assistance": "Substantial AI assistance: OpenAI Codex derived, implemented, checked, and drafted this scoped result. No independent human review is claimed.", + "author": "1337isnot1337 with OpenAI Codex assistance", + "base_commit": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2", + "bottleneck_link": "The retained F0/B1 witness erases eight independent selected-input directions. The shear exposes those directions in the B1 T output while adding no recursive child; integration through the remaining tail is the unresolved step, so no selected kappa change is claimed.", + "catalog_assessed_on": "2026-10-14", + "catalog_sha256": "d46eb6d5b3e279428753d770653663fbdf1063e55c255ea073d768f344927ef7", + "claim_expiry_utc": "2026-10-15T01:50:00Z", + "claim_url": "https://github.com/CrocSwap/integer-mult-bounds/discussions/2205", + "discussion_number": 2205, + "evidence": "PROOF.md and RESULT.json state the exact group-algebra calculation; verify.py reconstructs all pinned 73-bit owner routes and emits a nonsingular exact 8x8 output minor.", + "final_overlap_snapshot": { + "complete_pagination": true, + "discussions": 906, + "local_match": "this package README, added after the remote snapshot", + "local_matches": 1, + "open_prs": 452, + "remote_matches": 0, + "searched_at": "2026-10-15T00:11:16.354294Z", + "warnings": [] + }, + "open_questions": [ + { + "blocked_by": "This package verifies only through B1 and does not establish final-controller restoration.", + "first_step": "Propagate the eight sheared witness columns through the next frozen event and compute the exact selected-output kernel.", + "question": "Does the retained ordinary tail preserve the eight independent T values exposed by this shear?", + "why_it_matters": "If the values survive to final selected outputs, the changed interface may remove the need for a separate paid source observation." + } + ], + "original_card": { + "acceptance_gate": "Name the changed premise of the fixed F0/B1 observation obstruction. Show exactly which query is recovered, legal native reads and restoration, and a full favorable budget including cover maps, helpers and endpoints. Local inverse identities alone do not close the global controller.", + "allowed_variations": [ + "One paid query, one changed first pair, or one precisely specified affine helper state.", + "A counterexample or lower bound for that exact proposed repair." + ], + "bottleneck_link": "The native local words exist; retained query information and its physical access are the missing link to a composed recursive interface.", + "first_experiment": "Apply the existing witness to one proposed extra observation or changed first pair. If it still loses the required record, stop. Otherwise derive one ordered two-call identity and charge the added read, chart maps and restoration before extending to more stages.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read the fixed-first-pair QQ16 witness before designing a controller. The checked #1969 local words do not evade that witness or supply global placement.", + "scope": "Source-bound orientation only. Read the named package and review before relying on its local evidence; this command is not its replay or supplier admission." + }, + "id": "joint-query-controller", + "methods": [ + "Add one explicitly priced ordinary-to-selected observation and derive the ordered two-call map and inverse.", + "Change the first local pair or retained state, then test the existing lost-observation witness and price all new operations." + ], + "overlap_terms": [ + "QQ16", + "joint-query", + "changing-chart controller", + "selected observation", + "1969" + ], + "question": "Can one explicitly changed QQ16 interface recover the missing chart query and close a two-call controller within a favorable full budget?", + "scope_change_triggers": [ + "Retaining the fixed first pair and ordinary schedule while allowing only homogeneous selected-only control, already excluded by the witness.", + "Treating cover-map counts as zero-cost physical address operations." + ], + "starting_points": [ + "research/joint-query/README.md", + "research/joint-query/evidence/QQ16-SELECTED-WITNESS.md", + "research/joint-query/evidence/JOINT-QUERY-TRANSFER.md", + "docs/research/community-efficient1000-review.md" + ] + }, + "outcome": "completed", + "priority_revision": 4, + "schema_version": 1, + "scope_change_reason": "The generic helper-width idea is covered by newer QQ16 transcript results. This run changes a different part of the interface: a reversible selected-state shear between the fixed F0 and B1 calls, with no new ordinary query.", + "scope_status": "refined", + "seed": "ccce426f938ce02908e39f554d0187b2", + "selected_record_sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32", + "selector_key": "0e34adbc1dd119161c3a", + "stop_rule": "Test only the identity-coordinate shear on the exact eight h_k witness family. Stop if B1 h is nonzero, the zero-shear control differs from the pinned erasure, or the sheared T output has rank below eight. Do not extend to a full controller in this package.", + "task_id": "joint-query-controller", + "track": "recursive-interfaces" +} diff --git a/research/qq16-f0-b1-shear-seedccce426/VERIFY.json b/research/qq16-f0-b1-shear-seedccce426/VERIFY.json new file mode 100644 index 0000000000..360d8991bf --- /dev/null +++ b/research/qq16-f0-b1-shear-seedccce426/VERIFY.json @@ -0,0 +1,42 @@ +{ + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/verify.py" + ], + "checks": "Exact source-pinned group-algebra witness, zero-shear control, selected-sum conservation, rank-eight sheared output, and nonsingular minor.", + "timeout_seconds": 600 + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/verify.py" + ], + "checks": "Repeat the exact witness and all explicit controls under optimized Python.", + "timeout_seconds": 600 + } + ], + "inputs": [ + "certificates/selected-result.json", + "docs/research/agent-task-catalog.json", + "research/joint-query/SOURCES.json", + "research/joint-query/certificate.json.gz", + "research/joint-query/source_data.py", + "research/joint-query/verify_native.py", + "research/joint-query/verify_ordered.py", + "research/qq16-f0-b1-shear-seedccce426/README.md", + "research/qq16-f0-b1-shear-seedccce426/SOURCES.json", + "research/qq16-f0-b1-shear-seedccce426/TASK.json", + "research/qq16-f0-b1-shear-seedccce426/verify.py" + ], + "python": "3.12", + "requirements": [], + "schema_version": 1, + "status": "ready" +} diff --git a/research/qq16-f0-b1-shear-seedccce426/verify.py b/research/qq16-f0-b1-shear-seedccce426/verify.py new file mode 100644 index 0000000000..c4f60ff948 --- /dev/null +++ b/research/qq16-f0-b1-shear-seedccce426/verify.py @@ -0,0 +1,291 @@ +"""Exploratory exact group-algebra probe for the QQ16 A/T shear.""" +from __future__ import annotations + +from fractions import Fraction as F +from functools import lru_cache +from pathlib import Path +import json +import sys + + +ROOT = Path(__file__).resolve().parents[2] +sys.path.insert(0, str(ROOT / "research/joint-query")) +import source_data # noqa: E402 +import verify_native # noqa: E402 + +A = [0, 7, 20, 27, 36, 46, 57, 111] +T = [21, 37, 47, 76, 81, 87, 92, 110] +U = [p for p in range(112) if p not in A + T] +AXES = tuple(1 << i for i in range(73)) +ID = AXES + + +def need(ok, message): + if not ok: + raise AssertionError(message) + + +def add(x, y, scale=F(1)): + out = x.copy() + for g, c in y.items(): + v = out.get(g, F(0)) + scale * c + if v: + out[g] = v + else: + out.pop(g, None) + return out + + +def scaled(x, c): + return {g: c * v for g, v in x.items() if c * v} + + +@lru_cache(None) +def gm(g, h): + return verify_native.product((g, 0), (h, 0))[0] + + +@lru_cache(None) +def gi(g): + return verify_native.inverse((g, 0))[0] + + +def left(g, x): + out = {} + for h, c in x.items(): + gh = gm(g, h) + out[gh] = out.get(gh, F(0)) + c + return {k: v for k, v in out.items() if v} + + +def coeff(x, r): + return scaled(x, r) + + +def query(R, routes, stage, values, ports): + out = [{} for _ in range(8)] + for p in ports: + v = values[p] + if not v: + continue + routed = left(routes[p][stage], v) + for i in range(8): + c = R[i].get(p, F(0)) + if c: + out[i] = add(out[i], routed, c) + return out + + +def query_adjoint(R, routes, stage, q, ports): + out = [{} for _ in range(112)] + for p in ports: + rg = gi(routes[p][stage]) + v = {} + for i in range(8): + c = R[i].get(p, F(0)) + if c: + v = add(v, q[i], c) + out[p] = left(rg, v) + return out + + +def section(R, routes, stage, q, ports): + """D_stage^-1 iota_ports R_ports^-1 q, using R_ports^-1=R_ports^T/4.""" + out = [{} for _ in range(112)] + for p in ports: + v = {} + for i in range(8): + c = R[i].get(p, F(0)) / 4 + if c: + v = add(v, q[i], c) + out[p] = left(gi(routes[p][stage]), v) + return out + + +def selected_query(R, routes, stage, values, ports): + return query(R, routes, stage, values, ports) + + +def identity_columns(values, ports): + return [[values[p].get(ID, F(0)) for p in ports]] + + +def family_rank(families, ports): + """Rank of columns in a sparse Q-vector space keyed by (port, owner map).""" + basis = {} + for family in families: + v = {(p, g): c for p in ports for g, c in family[p].items() if c} + while v: + pivot = min(v, key=repr) + if pivot not in basis: + scale = v[pivot] + basis[pivot] = {k: c / scale for k, c in v.items()} + break + scale = v[pivot] + for key, c in basis[pivot].items(): + z = v.get(key, F(0)) - scale * c + if z: + v[key] = z + else: + v.pop(key, None) + return len(basis) + + +def det(M): + a = [list(row) for row in M] + n = len(a) + result, sign = F(1), 1 + for j in range(n): + pivot = next((i for i in range(j, n) if a[i][j]), None) + if pivot is None: + return F(0) + if pivot != j: + a[j], a[pivot] = a[pivot], a[j] + sign = -sign + value = a[j][j] + result *= value + for i in range(j + 1, n): + factor = a[i][j] / value + for k in range(j + 1, n): + a[i][k] -= factor * a[j][k] + return sign * result + + +def minor_certificate(families, ports): + """Find eight exact output coordinates with a nonsingular witness matrix.""" + pivots, selected = [], [] + for p in ports: + maps = sorted({g for family in families for g in family[p]}) + for g in maps: + row = [family[p].get(g, F(0)) for family in families] + raw = row[:] + for pivot, normalized in pivots: + factor = row[pivot] + if factor: + row = [x - factor*y for x, y in zip(row, normalized)] + pivot = next((j for j, value in enumerate(row) if value), None) + if pivot is None: + continue + scale = row[pivot] + pivots.append((pivot, [x / scale for x in row])) + selected.append({ + "port": p, + "owner_map_columns_hex": [hex(x) for x in g], + "coefficients": [str(x) for x in raw], + }) + if len(pivots) == 8: + matrix = [[F(value) for value in item["coefficients"]] + for item in selected] + return selected, str(det(matrix)) + return selected, str(F(0)) + + +def main(): + d = source_data.reconstruct(ROOT) + R = d["R"] + phases = d["phases"] + routes = [] + for p, record in enumerate(phases["recipes"]): + b = tuple([record["q"]] + record["idle_children"][0]["orthogonal_axes"][:8]) + AXES[9:] + stages = [] + for s in range(3): + if s == 0: + actual = AXES + else: + swaps = [b[i+1] ^ AXES[9+8*(s-1)+i] for i in range(8)] + actual = tuple(v ^ verify_native.act( + swaps, sum(((v & axis).bit_count() % 2) << i + for i, axis in enumerate(swaps))) for v in AXES) + stages.append(actual) + routes.append(stages) + + source_witness_images = [] + old_t_outputs = [] + new_t_outputs = [] + for k in range(8): + e = [{ID: F(i == k)} for i in range(8)] + b2star = query_adjoint(R, routes, 2, e, U) + b1b2 = query(R, routes, 1, b2star, U) + b1starb1b2 = query_adjoint(R, routes, 1, b1b2, U) + h = [add(scaled(b2star[p], 48), b1starb1b2[p], -1) for p in range(112)] + need(query(R, routes, 1, h, U) == [{} for _ in range(8)], "B1 h_k is not zero") + b2h = query(R, routes, 2, h, U) + need([v.get(ID, F(0)) for v in b2h] == [F(2112 * (i == k)) for i in range(8)], + "B2 h_k identity coefficient differs from the pinned witness") + a = section(R, routes, 2, b2h, A) + + # The reviewed post-F0 state: X_U=Y_U=h; X_A=a, Y_A=-a; X_T=Y_T=0. + x, y = [v.copy() for v in h], [v.copy() for v in h] + for j, p in enumerate(A): + x[p], y[p] = a[p].copy(), scaled(a[p], -1) + for p in T: + x[p], y[p] = {}, {} + + def b1_t_output(xx, yy): + # E_2 y = y + P_(2,A)(R_2 - ell_(2,A)) y. + r2y = query(R, routes, 2, yy, range(112)) + l2ay = query(R, routes, 2, yy, A) + u = [v.copy() for v in yy] + correction = section(R, routes, 2, + [add(v, w, -1) for v, w in zip(r2y, l2ay)], A) + u = [add(v, w) for v, w in zip(u, correction)] + aa = selected_query(R, routes, 1, xx, T) + bb = query(R, routes, 1, u, range(112)) + return section(R, routes, 1, + [add(v, w, 12) for v, w in zip(bb, aa)], T) + + old = b1_t_output(x, y) + need(all(not old[p] for p in T), "Zero-shear negative control did not retain the erased T output") + old_t_outputs.append(old) + + # Sum-preserving A-to-T shear: x_T += x_A and y_T -= x_A. + for j, (pa, pt) in enumerate(zip(A, T)): + x[pt] = add(x[pt], x[pa]) + y[pt] = add(y[pt], x[pa], -1) + new = b1_t_output(x, y) + new_t_outputs.append(new) + source_witness_images.append(a) + + source_rank = family_rank(source_witness_images, A) + output_rank = family_rank(new_t_outputs, T) + zero_rank = family_rank(old_t_outputs, T) + need(source_rank == 8, "The post-F0 A witness family is not full rank") + need(output_rank == 8, "The shear did not reveal eight independent T outputs") + need(zero_rank == 0, "The zero-shear control should retain the erased output") + minor_rows, minor_det = minor_certificate(new_t_outputs, T) + need(len(minor_rows) == 8 and F(minor_det) != 0, + "The exact post-B1 output minor is singular") + result = { + "status": "PASS_QQ16_F0_B1_IDENTITY_SHEAR_WITNESS", + "scope": "Exact payload-constant regular-cover group algebra on the eight pinned h_k witnesses; one identity-coordinate shear between F0 and B1; not a full controller or supplier.", + "witness_checks": { + "B1_h_zero_for_all_eight": True, + "B2h_identity_coefficient": "2112*I8", + "post_F0_A_family_rank": source_rank, + }, + "control": {"zero_shear_post_B1_T_rank": zero_rank}, + "result": { + "post_B1_T_family_rank": output_rank, + "distinct_owner_maps_in_T_output": len({g for col in new_t_outputs for p in T for g in col[p]}), + "nonsingular_minor_determinant": minor_det, + "minor_rows": minor_rows, + }, + "local_cost": { + "selected_additions_per_owner": 16, + "new_helpers": 0, + "new_recursive_children": 0, + "new_coefficients_or_precision": 0, + "selected_sum_preserved": True, + "frame_boundary": "F0 output and B1 input share the completed(0) data frame", + }, + "no_claim": "No complete-controller, recursive supplier, or kappa improvement is established.", + } + (Path(__file__).resolve().parent / "RESULT.json").write_text( + json.dumps(result, indent=2, sort_keys=True) + "\n") + print(result["status"]) + print("source_A_rank=8; zero_shear_T_rank=0; sheared_post_B1_T_rank=8") + print("exact_nonzero_8x8_minor_det=" + minor_det) + + +if __name__ == "__main__": + main()