diff --git a/research/qq16-coordinate-tap-kernel/NOTICE.md b/research/qq16-coordinate-tap-kernel/NOTICE.md new file mode 100644 index 0000000000..5c0f8970ac --- /dev/null +++ b/research/qq16-coordinate-tap-kernel/NOTICE.md @@ -0,0 +1,22 @@ +# Attribution and license + +New material is Apache-2.0, under the repository's unchanged LICENSE. +Prepared for commdata2338 (@commdata2338), with substantial OpenAI Codex assistance. + +`references/pr2093/verify.py` and `references/pr2093/README.md` are unmodified +files by Adam Gall with substantial OpenAI Codex assistance, from PR2093, +commit `8b21a900eb520e4f11ea177b310f66316f8e8983`. Their Apache-2.0 notice, +original attribution and exact hashes are retained. This package uses their +source reconstruction and logical F/B map implementation; it does not claim +to have independently reimplemented those components. + +Ali Romman's retained QQ16 package supplies the scientific maps and native +contract. The Rohan Arun, Jeremy Kothe, Hao Yan, icekylinx, Chafik Boukhalfa, +Zhihao Chen, DreamingOfClouds and earlier compiler/supplier contributions +remain credited in the unchanged `research/joint-query/NOTICE.md` and its +linked source notices. No frozen source is edited. + +Cinna Davis's PR2216/PR2268, Adam Gall's PR2093, @CubeJerry's PR2306, +Charles Bethin's PR2252 and commdata2338's adjacent transcript work are +mathematical predecessors as detailed in README.md. Pending work is not +treated as supplier admission. No independent human review is claimed. diff --git a/research/qq16-coordinate-tap-kernel/PREDECESSORS.json b/research/qq16-coordinate-tap-kernel/PREDECESSORS.json new file mode 100644 index 0000000000..67dccb0e45 --- /dev/null +++ b/research/qq16-coordinate-tap-kernel/PREDECESSORS.json @@ -0,0 +1,42 @@ +{ + "vendored": [ + { + "path": "references/pr2093/verify.py", + "source_path": "research/qq16-b2-observation-kernel/verify.py", + "commit": "8b21a900eb520e4f11ea177b310f66316f8e8983", + "sha256": "1009fc5dc4843051d6d8e40edfbf1f5254b024623b5e8f73f10a4cfd756df15c", + "author": "Adam Gall, with substantial OpenAI Codex assistance", + "license": "Apache-2.0" + }, + { + "path": "references/pr2093/README.md", + "source_path": "research/qq16-b2-observation-kernel/README.md", + "commit": "8b21a900eb520e4f11ea177b310f66316f8e8983", + "sha256": "a4a7eb47ba7f619836c5a7ca7e20e8c05686a16f1fffc0370c6c189f4153b5dc", + "author": "Adam Gall, with substantial OpenAI Codex assistance", + "license": "Apache-2.0" + } + ], + "context": [ + { + "pr": 2216, + "commit": "b80e9ba43367fb8b20877a97da1cb677c34f9264" + }, + { + "pr": 2268, + "commit": "daf44bfc752a5e89127defa1cb296210708cf7e6" + }, + { + "pr": 2174, + "commit": "f79470a7931f3943360c10d15b428e0e4e479c22" + }, + { + "pr": 2306, + "commit": "4d6e08099c11ff06a8585d04ed59453dd5a62d7d" + }, + { + "pr": 2252, + "commit": "6dd49c2b186e08ef1f3efd08f62e1add97ff04a3" + } + ] +} diff --git a/research/qq16-coordinate-tap-kernel/README.md b/research/qq16-coordinate-tap-kernel/README.md new file mode 100644 index 0000000000..f4dffb4a65 --- /dev/null +++ b/research/qq16-coordinate-tap-kernel/README.md @@ -0,0 +1,300 @@ +# QQ16: a coordinate tap does not close the selected-input kernel + +**Scoped obstruction, with an exact finite certificate; no new supplier or κ.** +The shear and `U2 -> T21` tap in +[PR2268](https://github.com/CrocSwap/integer-mult-bounds/pull/2268) detect the +particular three-port witness from PR2093. A different three-port input, +supported on **1, 16, 88**, remains invisible through the complete retained +QQ16 schedule, although its original selected A input is nonzero. + +The result is stronger than this one counterexample: + +- Every one of the **96 × 8 = 768** ordinary-source-to-T paired taps fails to + recover all original selected inputs, even with the A-to-T shear. +- For each of the 96 possible source ports, an invisible input family spans + **all eight original A values at the identity owner**. This is an + eight-dimensional image at one owner, not eight dimensions per owner. +- If a boundary controller can read only a fixed set of `1 <= k <= 8` ordinary + source ports, a family of dimension at least `9-k` in those A values remains + invisible. Thus **at least nine distinct source ports are necessary in + this coordinate-access model**. Nine are not proved sufficient. + +The positive PR2268 result is preserved: on its old witness, the same tap +still gives final `X_(0,21) = 11 f_37`, with 34 nonzero selected observations, +four forward-history rows and 65 completed-X rows. Detecting that input does +not establish injectivity on the expanded input space. + +## Contract and changed premise + +Keep the local maps, port partition and complete 19-event ordinary recipe +from [Ali Romman's QQ16 package](../joint-query/README.md). Its first calls +are `F0` and `B_1_2` on pair 0. The allowed outputs are the final selected +A/T fields, all completed-X descendants and all five forward-query histories. +Granting the selected values at every complete-event cut also does not help +the counterexamples below. The required result includes the original +individual selected A inputs; recovering only selected pair sums is different. + +After the complete F0 and before B1, permit the logical shear + +```text +X_T += X_A +Y_T -= X_A +``` + +with the A/T lists paired in their displayed order, followed by + +```text +X_t += X_u +Y_t -= X_u u in U96, t in T. +``` + +The ordinary source is unchanged. These equations are granted their intended +logical action for free. They are not a claim that the X and Y physical +frames permit bare scalar additions. PR2252's native-frame objection remains +separate, and is not needed for the information obstruction here. + +For the `k`-port corollary, the controller may make any homogeneous linear +updates to selected fields using those fixed ordinary ports, including +owner mixing, and may retain their complete arrays as observations. It +leaves ordinary fields unchanged. Selected-only homogeneous controls may +also run at subsequent complete-event boundaries. There is no additional +input-dependent pre-F0 record, no change inside F0/B1, no ordinary-source +mixing before these reads, and no access to other ordinary ports. A dense +query such as `B0 X_U` is **not** one source-coordinate read in this model. +The proof does not equate source-port count with recursive rank or cost. + +## Source-bound family and proof + +Let `r_p` be column p of the actual centre matrix R. Write +`b_p = b_(p,0)` for the first local chart axis, and + +```text +f_v(d) = bit_0(d v), interpreted as the rational integer 0 or 1. +h_p(d) = c_p f_(b_p)(d), p in U96. +``` + +The fields are constant in every tensor payload coordinate, but may vary +with owner d. The actual owner routes satisfy + +```text +rho_s(p) b_p = e_(9+8(s-1)), 1 <= s <= 8. +``` + +Consequently, if `R_U c = 0`, then for every owner and every nonzero chart, + +```text +(B_s h)(d) = (sum_p r_p c_p) f_(e_(9+8(s-1)))(d) = 0. +``` + +This uses an exact route identity, not a sampling claim about the owner +group. The verifier reconstructs R from the frozen scalar operations, +compares it with the QQ16 packet, and checks the actual orthonormal axes, +involutions and common-axis images for all 112 ports and nine stages. All 1,008 +reconstructed route matrices must also occur in the actual QQ16 map registry. +These reconstruction and local-map routines are credited, pinned PR2093 +code, not a new independent implementation of its source binder. + +Initialize every other pair to zero, and pair 0 to + +```text +X_U = h, Y_U = 0, +X_A = -P_(0,A) B0 h, Y_A = -X_A, +X_T = Y_T = 0. +``` + +Then `f0 = B0 h + ell_(0,A) X_A = 0`. The ordered F0 formulas give +`X_U = Y_U = h` and every selected field zero. If all accessed source +coordinates satisfy `c_u = 0`, their entire owner arrays are zero. The +shear, all such taps and the more general permitted homogeneous boundary +controller therefore leave this state unchanged. + +At B1, the future logger sees `B2 h = 0`, the old selected T driver is +zero, and the current query is `B1 h = 0`. Thus the complete B1 output is +`Y_(0,U) = h`, with every other field zero. The first ordinary bridge puts +`-h` in `Y_(1,U)`. F2 acts on pair 0 with zero X source; its history is zero. +The negative bridge cancels the extra `-h` before B3. Every subsequent local +call has zero active-pair input. The remaining bridges and terminal leave +only named final `X_(0,U) = h`, carrying the **former-Y native type**. +It is not a completed-X descendant. All selected cuts, all completed-X +descendants and all five histories are zero. Homogeneous selected-only +controls preserve this trajectory. + +This is an exact indistinguishability argument: zero input has the same +allowed observations, while `B0 h != 0` implies a different original A +input because `P_(0,A)` is a selected section. No decoder, linear or +otherwise, can restore both inputs. Rational scaling clears the displayed +denominators if integer input representatives are desired. + +### An explicit witness against U2 -> T21 + +The new source columns and axes obey + +```text +r_1 = r_16 + r_88, +b_1 = 21, b_16 = 50, b_88 = 478, +c_1 = 1, c_16 = -1, c_88 = -1; all other c_p = 0. +``` + +Thus port 2 is identically zero. At the identity owner, + +```text +B0 h = (0, 1, 1, 0, -1, 0, 0, -1), +X_A = (-1/2, 1/2, 0, 0, 1/2, 1/2, 0, 0). +``` + +This supports a complete tail counterexample to PR2268's proposed full +restoration extension. It does not contradict that PR's stated repair of +one witness. Its support is disjoint from PR2093's `{2,8,85}`. Hence for +any single tapped source port, at least one of these two witnesses has +zero at that source, irrespective of the selected destination. The checker +executes all 768 interface cases and reuses the two checked tails only +after verifying that the full post-interface state is unchanged. + +### Eight invisible A dimensions after any one source tap + +Let `epsilon_p = bit_0(b_p)` and `D = R_U diag(epsilon)`. The value of +`B0 h` at the identity owner is `D c`. The exact source certificate gives + +```text +rank(R_U) = 8, rank([R_U; D]) = 16. +``` + +Therefore `dim D(ker R_U) = 8`. More constructively, for each excluded +source u, both parity classes of columns, excluding u, span all of `Q^8`. +The receipt gives two nonsingular 8-by-8 minors for each of the 96 sources. +For example, excluding source 2: + +```text +epsilon=0: [6,8,9,10,11,12,16,44], determinant -16, +epsilon=1: [1,3,4,5,25,26,31,35], determinant 32. +``` + +Call these column matrices E and O. For any `z in Q^8`, assign +`c_even = -E^-1 z`, `c_odd = O^-1 z`, and zero elsewhere. Then + +```text +R_U c = -z + z = 0, c_u = 0, D c = z. +``` + +The original A value at identity is `-R_A^-1 z`, which spans all eight +coordinates. Fraction row reduction, integer Bareiss determinants and +explicit inverse products cross-check each minor. The checker synthesizes +all 96 × 8 basis vectors and checks both equations exactly. The eight +source-2-hidden basis inputs also run through the complete F0/interface/B1 +and 17-event tail; the written ordered argument covers every linear +combination and the other 95 sources. + +### Any fixed set of at most eight source ports + +Let `S` contain k source ports, with `1 <= k <= 8`, and choose any `u in S`. +On `V_u = ker R_U intersect {c_u = 0}`, the preceding 96-case certificate +proves `dim D(V_u) = 8`. Impose the remaining `k-1` equations `c_s = 0`, +`s in S minus {u}`. These are at most `k-1` scalar equations, even though +each read returns an entire owner array: `h_s = c_s f_(b_s)`. Let their +common kernel in `V_u` be W. Then `codim_(V_u) W <= k-1`, so + +```text +dim D(W) >= dim D(V_u) - codim_(V_u) W >= 9-k. +``` + +For `k <= 8` some original A value is still lost. The case `k=0` has +dimension eight already. The inequality follows by choosing a complement +of W in `V_u` and using `D(V_u) = D(W) + D(complement)`. +No independence of the functions `f_v` +on the cover group is presumed: nonzeroness is established at the identity +owner alone. The certificate also includes an explicit eight-port example +constructed from the displayed parity bases: sources `[2,1,3,4,5,25,26,31]`. + +This is a necessary support bound, not a sharp minimum for full recovery. +It does not exclude dense ordinary queries, an earlier retained record, +a different first local map, changed ordinary mixing, or a different final +observation contract. + +## Reproduction and evidence + +From the repository root, standard-library Python 3.12: + +```sh +python3 -I -B scripts/research_package.py --package research/qq16-coordinate-tap-kernel +``` + +The direct replay is + +```sh +python3 -I -O -B research/qq16-coordinate-tap-kernel/verify.py +``` + +Expected direct output: + +```text +PASS_QQ16_COORDINATE_TAP_KERNEL single_taps=768 A_defect=8 ports<=8_excluded controls=13 no_new_kappa +``` + +`RESULT.json` contains the complete deterministic receipt, including all +192 parity minors, the new and credited disjoint witnesses, the source-2 +kernel basis, the eight-port example and source hashes. Replay is read-only; +`--emit-result NEW_PATH` explicitly creates a new receipt without overwrite. +All proof-relevant fields and JSON scalar types are compared. + +The 13 rejecting controls cover a dependency sign, omitted initial +cancellation, a tap moved onto the new witness's support, tap sign, +omitted negative bridge, final native-type confusion, an added detecting +B0 read, a changed chart axis, an absent packet route, wrong F2 pair binding, a singular parity +minor, changed inherited source bytes and receipt type corruption. The +PR2268 positive control checks its exact full-tail observation census and +`11 f_37` endpoint. The generic registered replay also runs focused artifact +integrity tests and optimized Python execution. + +## Cost screen, limits and predecessors + +Even granting every proposed operation, source read, frame conversion, +helper, retention, restoration, hosting and precision step zero cost, the +specified recovery contract fails. There is no successful completed +supplier bill or moment to price for this failed interface. No lower bound +on physical native calls, general transcript width or multiplication is +asserted. No full supplier cold replay, native implementation, all-size +precision argument, proof-assistant check, independent human review or +hosted-CI pass is claimed. + +Scientific base: `0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2`, priority revision 4. +`SOURCES.json` pins the main inputs; `PREDECESSORS.json` pins exact pending +heads and the unmodified source code retained under `references/pr2093/`. +The claim is in [discussion #2205](https://github.com/CrocSwap/integer-mult-bounds/discussions/2205#discussioncomment-18941101). + +- **Ali Romman / PR1969** supplies the ordered local maps, native contract, + route data, retained tail and original selected-output witness. +- **Adam Gall / PR2093** supplies the common-axis bit-function construction, + old `{2,8,85}` witness, source reconstruction and logical F/B interpreter. + Its verifier and README are retained byte-for-byte with their attribution. +- **Cinna Davis / PR2216 and PR2268** supplies the changed selected shear, + ordinary tap and witness-separation results. This package answers their + full-kernel follow-up while reproducing PR2268's positive result. +- **@CubeJerry / PR2306** proves that selected-only interventions, including + a larger deterministic class, cannot repair the credited old witness. + Its model excludes ordinary reads. Here ordinary coordinate reads are + explicitly allowed, and the witness is chosen to vanish at those ports. +- **Charles Bethin / PR2252** identifies the native frame mismatch, a + separate implementation issue. This account's **PR2153, PR2174 and + PR2189** concern read-only transcripts and recorded-cut recovery, not this + in-place source-support restriction. +- Rohan Arun, Jeremy Kothe, Hao Yan, Zhihao Chen, DreamingOfClouds and the + remaining supplier/compiler lineage retain credit through the unchanged + [QQ16 source notices](../joint-query/NOTICE.md). + +Prepared for commdata2338 (@commdata2338), with substantial OpenAI Codex assistance. +New material is Apache-2.0. The new evidence is author-checked; source reuse +is stated explicitly and is not described as an independent local-map audit. + +## Open next questions + +1. **Which priced ordinary observation removes the complete kernel?** A + dense old-chart query is outside this coordinate-support bound. First + specify the actual observation and test the ordered full kernel, including + the unknown final-cut retention premise of PR2174. Native access and a + favorable complete bill remain blockers. +2. **What is the sharp source-support threshold for this restricted family?** + Nine is only necessary. A first step is to characterize fixed S for which + `D(ker R_U intersect ker pi_S)` vanishes, then test owner functions beyond + identity. Eliminating this particular family still would not prove full + controller recovery; further support census alone does not merit a + supplier claim. diff --git a/research/qq16-coordinate-tap-kernel/RESULT.json b/research/qq16-coordinate-tap-kernel/RESULT.json new file mode 100644 index 0000000000..f54ff93d7e --- /dev/null +++ b/research/qq16-coordinate-tap-kernel/RESULT.json @@ -0,0 +1,4138 @@ +{ + "eight_port_fixture": { + "sources": [ + 2, + 1, + 3, + 4, + 5, + 25, + 26, + 31 + ], + "witness": { + "B0_at_identity": [ + "1", + "0", + "0", + "-1", + "-1", + "0", + "0", + "-1" + ], + "axes": { + "10": 134, + "11": 262, + "12": 42, + "16": 50, + "35": 49, + "44": 2, + "6": 14, + "8": 38, + "9": 70 + }, + "coefficients": { + "10": "-1", + "11": "-1", + "12": "2", + "16": "-1", + "35": "1", + "44": "1", + "6": "-2", + "8": "-1", + "9": "-1" + }, + "initial_X_A_at_identity": [ + "0", + "0", + "0", + "-1/2", + "1/2", + "1/2", + "-1/2", + "0" + ], + "tail": [ + { + "coefficient": 1, + "dst": 0, + "kind": "bridge", + "ordinary": [ + 0, + 1, + 0, + -1, + 0, + 0, + 0, + 0 + ], + "src": 1 + }, + { + "kind": "local", + "ordinary": [ + 0, + 1, + 0, + -1, + 0, + 0, + 0, + 0 + ], + "stage": 2 + }, + { + "coefficient": -1, + "dst": 0, + "kind": "bridge", + "ordinary": [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "src": 1 + }, + { + "kind": "local", + "ordinary": [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "stage": 3 + }, + { + "coefficient": 1, + "dst": 1, + "kind": "bridge", + "ordinary": [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "src": 2 + }, + { + "kind": "local", + "ordinary": [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "stage": 4 + }, + { + "coefficient": -1, + "dst": 1, + "kind": "bridge", + "ordinary": [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "src": 2 + }, + { + "kind": "local", + "ordinary": [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "stage": 5 + }, + { + "coefficient": 1, + "dst": 2, + "kind": "bridge", + "ordinary": [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "src": 3 + }, + { + "kind": "local", + "ordinary": [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "stage": 6 + }, + { + "coefficient": -1, + "dst": 2, + "kind": "bridge", + "ordinary": [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "src": 3 + }, + { + "kind": "local", + "ordinary": [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "stage": 7 + }, + { + "kind": "local", + "ordinary": [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "stage": 8 + }, + { + "coefficient": 1, + "dst": 3, + "kind": "bridge", + "ordinary": [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "src": 2 + }, + { + "coefficient": 1, + "dst": 2, + "kind": "bridge", + "ordinary": [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "src": 1 + }, + { + "coefficient": 1, + "dst": 1, + "kind": "bridge", + "ordinary": [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "src": 0 + }, + { + "kind": "terminal", + "ordinary": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + ], + "tap": [ + 1, + 21 + ], + "zero_forward_histories": 5, + "zero_nonzero_chart_queries": 8, + "zero_selected_cuts": 18 + } + }, + "inputs": { + "research/community-frontier1042-audit/selected-replay.tar.gz": "22c3f4dce4b897a1d423d1388801933e288b6a6b1906cb15e1b16a5eb68db754", + "research/joint-query/certificate.json.gz": "a5ed85fac5ebf3c091482a113ab0d351eb5a7892fe2841a35e16017ec1ff49f7", + "research/joint-query/evidence/JOINT-QUERY-TRANSFER.md": "9e13e73ebf3192a6548798c2f1d13bd4d83957e8db0dc34de12b1a5311a52a75", + "research/joint-query/evidence/QQ16-RATIONAL-OBSERVATION-REVIEW.md": "9a06ff40830ef80d3566fce77c78639cb64d519d487a0a7f57d543c3146e2c49", + "research/joint-query/evidence/QQ16-SELECTED-WITNESS.json": "e35e5868a1322e406191079c0675975b139692ba50b1e2e5fb8a40b6480519f4" + }, + "new_witness": { + "B0_at_identity": [ + "0", + "1", + "1", + "0", + "-1", + "0", + "0", + "-1" + ], + "axes": { + "1": 21, + "16": 50, + "88": 478 + }, + "coefficients": { + "1": "1", + "16": "-1", + "88": "-1" + }, + "initial_X_A_at_identity": [ + "-1/2", + "1/2", + "0", + "0", + "1/2", + "1/2", + "0", + "0" + ], + "tail": [ + { + "coefficient": 1, + "dst": 0, + "kind": "bridge", + "ordinary": [ + 0, + 1, + 0, + -1, + 0, + 0, + 0, + 0 + ], + "src": 1 + }, + { + "kind": "local", + "ordinary": [ + 0, + 1, + 0, + -1, + 0, + 0, + 0, + 0 + ], + "stage": 2 + }, + { + "coefficient": -1, + "dst": 0, + "kind": "bridge", + "ordinary": [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "src": 1 + }, + { + "kind": "local", + "ordinary": [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "stage": 3 + }, + { + "coefficient": 1, + "dst": 1, + "kind": "bridge", + "ordinary": [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "src": 2 + }, + { + "kind": "local", + "ordinary": [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "stage": 4 + }, + { + "coefficient": -1, + "dst": 1, + "kind": "bridge", + "ordinary": [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "src": 2 + }, + { + "kind": "local", + "ordinary": [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "stage": 5 + }, + { + "coefficient": 1, + "dst": 2, + "kind": "bridge", + "ordinary": [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "src": 3 + }, + { + "kind": "local", + "ordinary": [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "stage": 6 + }, + { + "coefficient": -1, + "dst": 2, + "kind": "bridge", + "ordinary": [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "src": 3 + }, + { + "kind": "local", + "ordinary": [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "stage": 7 + }, + { + "kind": "local", + "ordinary": [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "stage": 8 + }, + { + "coefficient": 1, + "dst": 3, + "kind": "bridge", + "ordinary": [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "src": 2 + }, + { + "coefficient": 1, + "dst": 2, + "kind": "bridge", + "ordinary": [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "src": 1 + }, + { + "coefficient": 1, + "dst": 1, + "kind": "bridge", + "ordinary": [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "src": 0 + }, + { + "kind": "terminal", + "ordinary": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + ], + "tap": [ + 2, + 21 + ], + "zero_forward_histories": 5, + "zero_nonzero_chart_queries": 8, + "zero_selected_cuts": 18 + }, + "old_disjoint_witness": { + "B0_at_identity": [ + "-1", + "-1", + "0", + "0", + "0", + "0", + "-1", + "1" + ], + "axes": { + "2": 37, + "8": 38, + "85": 506 + }, + "coefficients": { + "2": "-1", + "8": "1", + "85": "1" + }, + "initial_X_A_at_identity": [ + "1/2", + "0", + "1/2", + "1/2", + "0", + "-1/2", + "0", + "0" + ], + "tail": [ + { + "coefficient": 1, + "dst": 0, + "kind": "bridge", + "ordinary": [ + 0, + 1, + 0, + -1, + 0, + 0, + 0, + 0 + ], + "src": 1 + }, + { + "kind": "local", + "ordinary": [ + 0, + 1, + 0, + -1, + 0, + 0, + 0, + 0 + ], + "stage": 2 + }, + { + "coefficient": -1, + "dst": 0, + "kind": "bridge", + "ordinary": [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "src": 1 + }, + { + "kind": "local", + "ordinary": [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "stage": 3 + }, + { + "coefficient": 1, + "dst": 1, + "kind": "bridge", + "ordinary": [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "src": 2 + }, + { + "kind": "local", + "ordinary": [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "stage": 4 + }, + { + "coefficient": -1, + "dst": 1, + "kind": "bridge", + "ordinary": [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "src": 2 + }, + { + "kind": "local", + "ordinary": [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "stage": 5 + }, + { + "coefficient": 1, + "dst": 2, + "kind": "bridge", + "ordinary": [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "src": 3 + }, + { + "kind": "local", + "ordinary": [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "stage": 6 + }, + { + "coefficient": -1, + "dst": 2, + "kind": "bridge", + "ordinary": [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "src": 3 + }, + { + "kind": "local", + "ordinary": [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "stage": 7 + }, + { + "kind": "local", + "ordinary": [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "stage": 8 + }, + { + "coefficient": 1, + "dst": 3, + "kind": "bridge", + "ordinary": [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "src": 2 + }, + { + "coefficient": 1, + "dst": 2, + "kind": "bridge", + "ordinary": [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "src": 1 + }, + { + "coefficient": 1, + "dst": 1, + "kind": "bridge", + "ordinary": [ + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "src": 0 + }, + { + "kind": "terminal", + "ordinary": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + ], + "tap": [ + 1, + 21 + ], + "zero_forward_histories": 5, + "zero_nonzero_chart_queries": 8, + "zero_selected_cuts": 18 + }, + "positive_PR2268_counts": { + "completed_X": 65, + "history": 4, + "selected": 34 + }, + "positive_PR2268_final_X21": { + "37": "11" + }, + "rank_certificate": { + "k_source_dimension_floor": { + "0": 8, + "1": 8, + "2": 7, + "3": 6, + "4": 5, + "5": 4, + "6": 3, + "7": 2, + "8": 1 + }, + "rank_R_U": 8, + "rank_stacked_R_D": 16, + "single_source_cases": [ + { + "determinants": [ + -16, + -32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 12, + 16, + 44 + ], + "excluded_source": 1, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 2, + 3, + 4, + 5, + 25, + 26, + 28, + 31 + ] + }, + { + "determinants": [ + -16, + 32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 12, + 16, + 44 + ], + "excluded_source": 2, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 3, + 4, + 5, + 25, + 26, + 31, + 35 + ] + }, + { + "determinants": [ + -16, + 32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 12, + 16, + 44 + ], + "excluded_source": 3, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 4, + 5, + 25, + 26, + 28, + 31 + ] + }, + { + "determinants": [ + -16, + -32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 12, + 16, + 44 + ], + "excluded_source": 4, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 5, + 25, + 26, + 29, + 31 + ] + }, + { + "determinants": [ + -16, + 32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 12, + 16, + 44 + ], + "excluded_source": 5, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 25, + 26, + 30, + 31 + ] + }, + { + "determinants": [ + -16, + 32 + ], + "even_basis": [ + 8, + 9, + 10, + 11, + 12, + 16, + 22, + 44 + ], + "excluded_source": 6, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 25, + 26, + 31 + ] + }, + { + "determinants": [ + 16, + 32 + ], + "even_basis": [ + 6, + 9, + 10, + 11, + 12, + 13, + 16, + 44 + ], + "excluded_source": 8, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 25, + 26, + 31 + ] + }, + { + "determinants": [ + -16, + 32 + ], + "even_basis": [ + 6, + 8, + 10, + 11, + 12, + 13, + 16, + 44 + ], + "excluded_source": 9, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 25, + 26, + 31 + ] + }, + { + "determinants": [ + 16, + 32 + ], + "even_basis": [ + 6, + 8, + 9, + 11, + 12, + 14, + 16, + 44 + ], + "excluded_source": 10, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 25, + 26, + 31 + ] + }, + { + "determinants": [ + -16, + 32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 12, + 15, + 16, + 44 + ], + "excluded_source": 11, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 25, + 26, + 31 + ] + }, + { + "determinants": [ + -16, + 32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 13, + 16, + 44 + ], + "excluded_source": 12, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 25, + 26, + 31 + ] + }, + { + "determinants": [ + -16, + 32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 12, + 16, + 44 + ], + "excluded_source": 13, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 25, + 26, + 31 + ] + }, + { + "determinants": [ + -16, + 32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 12, + 16, + 44 + ], + "excluded_source": 14, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 25, + 26, + 31 + ] + }, + { + "determinants": [ + -16, + 32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 12, + 16, + 44 + ], + "excluded_source": 15, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 25, + 26, + 31 + ] + }, + { + "determinants": [ + 16, + 32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 12, + 17, + 44 + ], + "excluded_source": 16, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 25, + 26, + 31 + ] + }, + { + "determinants": [ + -16, + 32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 12, + 16, + 44 + ], + "excluded_source": 17, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 25, + 26, + 31 + ] + }, + { + "determinants": [ + -16, + 32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 12, + 16, + 44 + ], + "excluded_source": 18, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 25, + 26, + 31 + ] + }, + { + "determinants": [ + -16, + 32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 12, + 16, + 44 + ], + "excluded_source": 19, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 25, + 26, + 31 + ] + }, + { + "determinants": [ + -16, + 32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 12, + 16, + 44 + ], + "excluded_source": 22, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 25, + 26, + 31 + ] + }, + { + "determinants": [ + -16, + 32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 12, + 16, + 44 + ], + "excluded_source": 23, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 25, + 26, + 31 + ] + }, + { + "determinants": [ + -16, + 32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 12, + 16, + 44 + ], + "excluded_source": 24, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 25, + 26, + 31 + ] + }, + { + "determinants": [ + -16, + -32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 12, + 16, + 44 + ], + "excluded_source": 25, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 26, + 31, + 35 + ] + }, + { + "determinants": [ + -16, + 32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 12, + 16, + 44 + ], + "excluded_source": 26, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 25, + 28, + 31 + ] + }, + { + "determinants": [ + -16, + 32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 12, + 16, + 44 + ], + "excluded_source": 28, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 25, + 26, + 31 + ] + }, + { + "determinants": [ + -16, + 32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 12, + 16, + 44 + ], + "excluded_source": 29, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 25, + 26, + 31 + ] + }, + { + "determinants": [ + -16, + 32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 12, + 16, + 44 + ], + "excluded_source": 30, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 25, + 26, + 31 + ] + }, + { + "determinants": [ + -16, + 32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 12, + 16, + 44 + ], + "excluded_source": 31, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 25, + 26, + 32 + ] + }, + { + "determinants": [ + -16, + 32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 12, + 16, + 44 + ], + "excluded_source": 32, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 25, + 26, + 31 + ] + }, + { + "determinants": [ + -16, + 32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 12, + 16, + 44 + ], + "excluded_source": 33, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 25, + 26, + 31 + ] + }, + { + "determinants": [ + -16, + 32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 12, + 16, + 44 + ], + "excluded_source": 34, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 25, + 26, + 31 + ] + }, + { + "determinants": [ + -16, + 32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 12, + 16, + 44 + ], + "excluded_source": 35, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 25, + 26, + 31 + ] + }, + { + "determinants": [ + -16, + 32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 12, + 16, + 44 + ], + "excluded_source": 38, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 25, + 26, + 31 + ] + }, + { + "determinants": [ + -16, + 32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 12, + 16, + 44 + ], + "excluded_source": 39, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 25, + 26, + 31 + ] + }, + { + "determinants": [ + -16, + 32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 12, + 16, + 44 + ], + "excluded_source": 40, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 25, + 26, + 31 + ] + }, + { + "determinants": [ + -16, + 32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 12, + 16, + 44 + ], + "excluded_source": 41, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 25, + 26, + 31 + ] + }, + { + "determinants": [ + -16, + 32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 12, + 16, + 44 + ], + "excluded_source": 42, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 25, + 26, + 31 + ] + }, + { + "determinants": [ + -16, + 32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 12, + 16, + 44 + ], + "excluded_source": 43, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 25, + 26, + 31 + ] + }, + { + "determinants": [ + -16, + 32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 12, + 16, + 45 + ], + "excluded_source": 44, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 25, + 26, + 31 + ] + }, + { + "determinants": [ + -16, + 32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 12, + 16, + 44 + ], + "excluded_source": 45, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 25, + 26, + 31 + ] + }, + { + "determinants": [ + -16, + 32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 12, + 16, + 44 + ], + "excluded_source": 48, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 25, + 26, + 31 + ] + }, + { + "determinants": [ + -16, + 32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 12, + 16, + 44 + ], + "excluded_source": 49, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 25, + 26, + 31 + ] + }, + { + "determinants": [ + -16, + 32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 12, + 16, + 44 + ], + "excluded_source": 50, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 25, + 26, + 31 + ] + }, + { + "determinants": [ + -16, + 32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 12, + 16, + 44 + ], + "excluded_source": 51, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 25, + 26, + 31 + ] + }, + { + "determinants": [ + -16, + 32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 12, + 16, + 44 + ], + "excluded_source": 52, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 25, + 26, + 31 + ] + }, + { + "determinants": [ + -16, + 32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 12, + 16, + 44 + ], + "excluded_source": 53, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 25, + 26, + 31 + ] + }, + { + "determinants": [ + -16, + 32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 12, + 16, + 44 + ], + "excluded_source": 54, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 25, + 26, + 31 + ] + }, + { + "determinants": [ + -16, + 32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 12, + 16, + 44 + ], + "excluded_source": 55, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 25, + 26, + 31 + ] + }, + { + "determinants": [ + -16, + 32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 12, + 16, + 44 + ], + "excluded_source": 56, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 25, + 26, + 31 + ] + }, + { + "determinants": [ + -16, + 32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 12, + 16, + 44 + ], + "excluded_source": 58, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 25, + 26, + 31 + ] + }, + { + "determinants": [ + -16, + 32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 12, + 16, + 44 + ], + "excluded_source": 59, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 25, + 26, + 31 + ] + }, + { + "determinants": [ + -16, + 32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 12, + 16, + 44 + ], + "excluded_source": 60, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 25, + 26, + 31 + ] + }, + { + "determinants": [ + -16, + 32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 12, + 16, + 44 + ], + "excluded_source": 61, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 25, + 26, + 31 + ] + }, + { + "determinants": [ + -16, + 32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 12, + 16, + 44 + ], + "excluded_source": 62, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 25, + 26, + 31 + ] + }, + { + "determinants": [ + -16, + 32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 12, + 16, + 44 + ], + "excluded_source": 63, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 25, + 26, + 31 + ] + }, + { + "determinants": [ + -16, + 32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 12, + 16, + 44 + ], + "excluded_source": 64, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 25, + 26, + 31 + ] + }, + { + "determinants": [ + -16, + 32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 12, + 16, + 44 + ], + "excluded_source": 65, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 25, + 26, + 31 + ] + }, + { + "determinants": [ + -16, + 32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 12, + 16, + 44 + ], + "excluded_source": 66, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 25, + 26, + 31 + ] + }, + { + "determinants": [ + -16, + 32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 12, + 16, + 44 + ], + "excluded_source": 67, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 25, + 26, + 31 + ] + }, + { + "determinants": [ + -16, + 32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 12, + 16, + 44 + ], + "excluded_source": 68, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 25, + 26, + 31 + ] + }, + { + "determinants": [ + -16, + 32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 12, + 16, + 44 + ], + "excluded_source": 69, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 25, + 26, + 31 + ] + }, + { + "determinants": [ + -16, + 32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 12, + 16, + 44 + ], + "excluded_source": 70, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 25, + 26, + 31 + ] + }, + { + "determinants": [ + -16, + 32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 12, + 16, + 44 + ], + "excluded_source": 71, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 25, + 26, + 31 + ] + }, + { + "determinants": [ + -16, + 32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 12, + 16, + 44 + ], + "excluded_source": 72, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 25, + 26, + 31 + ] + }, + { + "determinants": [ + -16, + 32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 12, + 16, + 44 + ], + "excluded_source": 73, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 25, + 26, + 31 + ] + }, + { + "determinants": [ + -16, + 32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 12, + 16, + 44 + ], + "excluded_source": 74, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 25, + 26, + 31 + ] + }, + { + "determinants": [ + -16, + 32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 12, + 16, + 44 + ], + "excluded_source": 75, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 25, + 26, + 31 + ] + }, + { + "determinants": [ + -16, + 32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 12, + 16, + 44 + ], + "excluded_source": 77, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 25, + 26, + 31 + ] + }, + { + "determinants": [ + -16, + 32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 12, + 16, + 44 + ], + "excluded_source": 78, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 25, + 26, + 31 + ] + }, + { + "determinants": [ + -16, + 32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 12, + 16, + 44 + ], + "excluded_source": 79, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 25, + 26, + 31 + ] + }, + { + "determinants": [ + -16, + 32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 12, + 16, + 44 + ], + "excluded_source": 80, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 25, + 26, + 31 + ] + }, + { + "determinants": [ + -16, + 32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 12, + 16, + 44 + ], + "excluded_source": 82, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 25, + 26, + 31 + ] + }, + { + "determinants": [ + -16, + 32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 12, + 16, + 44 + ], + "excluded_source": 83, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 25, + 26, + 31 + ] + }, + { + "determinants": [ + -16, + 32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 12, + 16, + 44 + ], + "excluded_source": 84, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 25, + 26, + 31 + ] + }, + { + "determinants": [ + -16, + 32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 12, + 16, + 44 + ], + "excluded_source": 85, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 25, + 26, + 31 + ] + }, + { + "determinants": [ + -16, + 32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 12, + 16, + 44 + ], + "excluded_source": 86, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 25, + 26, + 31 + ] + }, + { + "determinants": [ + -16, + 32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 12, + 16, + 44 + ], + "excluded_source": 88, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 25, + 26, + 31 + ] + }, + { + "determinants": [ + -16, + 32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 12, + 16, + 44 + ], + "excluded_source": 89, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 25, + 26, + 31 + ] + }, + { + "determinants": [ + -16, + 32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 12, + 16, + 44 + ], + "excluded_source": 90, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 25, + 26, + 31 + ] + }, + { + "determinants": [ + -16, + 32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 12, + 16, + 44 + ], + "excluded_source": 91, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 25, + 26, + 31 + ] + }, + { + "determinants": [ + -16, + 32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 12, + 16, + 44 + ], + "excluded_source": 93, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 25, + 26, + 31 + ] + }, + { + "determinants": [ + -16, + 32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 12, + 16, + 44 + ], + "excluded_source": 94, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 25, + 26, + 31 + ] + }, + { + "determinants": [ + -16, + 32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 12, + 16, + 44 + ], + "excluded_source": 95, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 25, + 26, + 31 + ] + }, + { + "determinants": [ + -16, + 32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 12, + 16, + 44 + ], + "excluded_source": 96, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 25, + 26, + 31 + ] + }, + { + "determinants": [ + -16, + 32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 12, + 16, + 44 + ], + "excluded_source": 97, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 25, + 26, + 31 + ] + }, + { + "determinants": [ + -16, + 32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 12, + 16, + 44 + ], + "excluded_source": 98, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 25, + 26, + 31 + ] + }, + { + "determinants": [ + -16, + 32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 12, + 16, + 44 + ], + "excluded_source": 99, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 25, + 26, + 31 + ] + }, + { + "determinants": [ + -16, + 32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 12, + 16, + 44 + ], + "excluded_source": 100, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 25, + 26, + 31 + ] + }, + { + "determinants": [ + -16, + 32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 12, + 16, + 44 + ], + "excluded_source": 101, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 25, + 26, + 31 + ] + }, + { + "determinants": [ + -16, + 32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 12, + 16, + 44 + ], + "excluded_source": 102, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 25, + 26, + 31 + ] + }, + { + "determinants": [ + -16, + 32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 12, + 16, + 44 + ], + "excluded_source": 103, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 25, + 26, + 31 + ] + }, + { + "determinants": [ + -16, + 32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 12, + 16, + 44 + ], + "excluded_source": 104, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 25, + 26, + 31 + ] + }, + { + "determinants": [ + -16, + 32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 12, + 16, + 44 + ], + "excluded_source": 105, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 25, + 26, + 31 + ] + }, + { + "determinants": [ + -16, + 32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 12, + 16, + 44 + ], + "excluded_source": 106, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 25, + 26, + 31 + ] + }, + { + "determinants": [ + -16, + 32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 12, + 16, + 44 + ], + "excluded_source": 107, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 25, + 26, + 31 + ] + }, + { + "determinants": [ + -16, + 32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 12, + 16, + 44 + ], + "excluded_source": 108, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 25, + 26, + 31 + ] + }, + { + "determinants": [ + -16, + 32 + ], + "even_basis": [ + 6, + 8, + 9, + 10, + 11, + 12, + 16, + 44 + ], + "excluded_source": 109, + "initial_A_defect_dimension_at_identity": 8, + "odd_basis": [ + 1, + 2, + 3, + 4, + 5, + 25, + 26, + 31 + ] + } + ], + "synthesized_vectors": 768, + "u2_kernel_basis": [ + { + "10": "-1/2", + "11": "-1/2", + "12": "1/2", + "25": "1/2", + "26": "-1/2", + "35": "1/2", + "44": "1/2", + "6": "-1", + "8": "-1/2", + "9": "-1/2" + }, + { + "1": "1/2", + "10": "-1/2", + "11": "-1/2", + "12": "3/2", + "16": "-1/2", + "25": "1/2", + "31": "-1/2", + "44": "1", + "6": "-2", + "8": "-1/2", + "9": "-1/2" + }, + { + "1": "1", + "16": "-1/2", + "25": "1/4", + "26": "-1/2", + "3": "-1/4", + "35": "-1/4", + "4": "-1/4", + "5": "-1/4", + "6": "-1/2", + "8": "1/2" + }, + { + "1": "-1/2", + "25": "-1/4", + "3": "1/4", + "31": "1/2", + "35": "-1/4", + "4": "1/4", + "44": "1/2", + "5": "1/4", + "6": "-1/2", + "8": "1/2" + }, + { + "1": "1/2", + "10": "1/2", + "11": "1/2", + "12": "-1", + "16": "1/2", + "25": "1/2", + "26": "-1/2", + "3": "-1/2", + "31": "-1/2", + "44": "-1/2", + "6": "1" + }, + { + "10": "-1/2", + "11": "1/2", + "4": "-1/2", + "5": "1/2" + }, + { + "1": "1/2", + "12": "-1/2", + "25": "1/4", + "26": "-1/2", + "3": "1/4", + "31": "-1/2", + "35": "1/4", + "4": "-1/4", + "5": "-1/4", + "6": "1/2", + "9": "1/2" + }, + { + "12": "-1/2", + "16": "1/2", + "25": "1/4", + "3": "1/4", + "35": "-1/4", + "4": "-1/4", + "44": "-1/2", + "5": "-1/4", + "6": "1/2", + "9": "1/2" + } + ] + }, + "reference_sha256": "1009fc5dc4843051d6d8e40edfbf1f5254b024623b5e8f73f10a4cfd756df15c", + "rejecting_controls": [ + "wrong dependency coefficient", + "missing initial A cancellation", + "tap reads a live witness port", + "wrong tap sign", + "missing negative bridge", + "wrong final observation type", + "old-chart B0 read detects the witness", + "changed chart axis", + "missing actual packet route", + "wrong later pair binding", + "duplicate parity-minor column", + "corrupt inherited source", + "receipt scalar-type corruption" + ], + "route_bindings": 1008, + "schema": "qq16-coordinate-tap-kernel-v1", + "scope": "Logical source-coordinate taps at F0/B1; no native tariff, full supplier or new kappa.", + "single_source_coverage": [ + { + "source": 1, + "witness": "old" + }, + { + "source": 2, + "witness": "new" + }, + { + "source": 3, + "witness": "old" + }, + { + "source": 4, + "witness": "old" + }, + { + "source": 5, + "witness": "old" + }, + { + "source": 6, + "witness": "old" + }, + { + "source": 8, + "witness": "new" + }, + { + "source": 9, + "witness": "old" + }, + { + "source": 10, + "witness": "old" + }, + { + "source": 11, + "witness": "old" + }, + { + "source": 12, + "witness": "old" + }, + { + "source": 13, + "witness": "old" + }, + { + "source": 14, + "witness": "old" + }, + { + "source": 15, + "witness": "old" + }, + { + "source": 16, + "witness": "old" + }, + { + "source": 17, + "witness": "old" + }, + { + "source": 18, + "witness": "old" + }, + { + "source": 19, + "witness": "old" + }, + { + "source": 22, + "witness": "old" + }, + { + "source": 23, + "witness": "old" + }, + { + "source": 24, + "witness": "old" + }, + { + "source": 25, + "witness": "old" + }, + { + "source": 26, + "witness": "old" + }, + { + "source": 28, + "witness": "old" + }, + { + "source": 29, + "witness": "old" + }, + { + "source": 30, + "witness": "old" + }, + { + "source": 31, + "witness": "old" + }, + { + "source": 32, + "witness": "old" + }, + { + "source": 33, + "witness": "old" + }, + { + "source": 34, + "witness": "old" + }, + { + "source": 35, + "witness": "old" + }, + { + "source": 38, + "witness": "old" + }, + { + "source": 39, + "witness": "old" + }, + { + "source": 40, + "witness": "old" + }, + { + "source": 41, + "witness": "old" + }, + { + "source": 42, + "witness": "old" + }, + { + "source": 43, + "witness": "old" + }, + { + "source": 44, + "witness": "old" + }, + { + "source": 45, + "witness": "old" + }, + { + "source": 48, + "witness": "old" + }, + { + "source": 49, + "witness": "old" + }, + { + "source": 50, + "witness": "old" + }, + { + "source": 51, + "witness": "old" + }, + { + "source": 52, + "witness": "old" + }, + { + "source": 53, + "witness": "old" + }, + { + "source": 54, + "witness": "old" + }, + { + "source": 55, + "witness": "old" + }, + { + "source": 56, + "witness": "old" + }, + { + "source": 58, + "witness": "old" + }, + { + "source": 59, + "witness": "old" + }, + { + "source": 60, + "witness": "old" + }, + { + "source": 61, + "witness": "old" + }, + { + "source": 62, + "witness": "old" + }, + { + "source": 63, + "witness": "old" + }, + { + "source": 64, + "witness": "old" + }, + { + "source": 65, + "witness": "old" + }, + { + "source": 66, + "witness": "old" + }, + { + "source": 67, + "witness": "old" + }, + { + "source": 68, + "witness": "old" + }, + { + "source": 69, + "witness": "old" + }, + { + "source": 70, + "witness": "old" + }, + { + "source": 71, + "witness": "old" + }, + { + "source": 72, + "witness": "old" + }, + { + "source": 73, + "witness": "old" + }, + { + "source": 74, + "witness": "old" + }, + { + "source": 75, + "witness": "old" + }, + { + "source": 77, + "witness": "old" + }, + { + "source": 78, + "witness": "old" + }, + { + "source": 79, + "witness": "old" + }, + { + "source": 80, + "witness": "old" + }, + { + "source": 82, + "witness": "old" + }, + { + "source": 83, + "witness": "old" + }, + { + "source": 84, + "witness": "old" + }, + { + "source": 85, + "witness": "new" + }, + { + "source": 86, + "witness": "old" + }, + { + "source": 88, + "witness": "old" + }, + { + "source": 89, + "witness": "old" + }, + { + "source": 90, + "witness": "old" + }, + { + "source": 91, + "witness": "old" + }, + { + "source": 93, + "witness": "old" + }, + { + "source": 94, + "witness": "old" + }, + { + "source": 95, + "witness": "old" + }, + { + "source": 96, + "witness": "old" + }, + { + "source": 97, + "witness": "old" + }, + { + "source": 98, + "witness": "old" + }, + { + "source": 99, + "witness": "old" + }, + { + "source": 100, + "witness": "old" + }, + { + "source": 101, + "witness": "old" + }, + { + "source": 102, + "witness": "old" + }, + { + "source": 103, + "witness": "old" + }, + { + "source": 104, + "witness": "old" + }, + { + "source": 105, + "witness": "old" + }, + { + "source": 106, + "witness": "old" + }, + { + "source": 107, + "witness": "old" + }, + { + "source": 108, + "witness": "old" + }, + { + "source": 109, + "witness": "old" + } + ], + "single_tap_cases": 768, + "status": "PASS_QQ16_COORDINATE_TAP_KERNEL", + "u2_full_tail_basis_vectors": 8 +} diff --git a/research/qq16-coordinate-tap-kernel/SOURCES.json b/research/qq16-coordinate-tap-kernel/SOURCES.json new file mode 100644 index 0000000000..ee342a11cc --- /dev/null +++ b/research/qq16-coordinate-tap-kernel/SOURCES.json @@ -0,0 +1,48 @@ +{ + "schema_version": 1, + "base_commit": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "ae6a99f28aa468649eb66a361e764d769363bf11", + "sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "e8870e5917057d59b730eb14721a778639eca050", + "sha256": "d46eb6d5b3e279428753d770653663fbdf1063e55c255ea073d768f344927ef7" + }, + { + "path": "research/community-frontier1042-audit/selected-replay.tar.gz", + "usage": "input", + "git_blob": "6f4dc6fe7631d8aacf8081fcaecf32197181685b", + "sha256": "22c3f4dce4b897a1d423d1388801933e288b6a6b1906cb15e1b16a5eb68db754" + }, + { + "path": "research/joint-query/certificate.json.gz", + "usage": "input", + "git_blob": "c6e876d8b48d768214deee265ade428f8983b566", + "sha256": "a5ed85fac5ebf3c091482a113ab0d351eb5a7892fe2841a35e16017ec1ff49f7" + }, + { + "path": "research/joint-query/evidence/JOINT-QUERY-TRANSFER.md", + "usage": "input", + "git_blob": "a6805c58f23132f9420efebf90f5b7e863c2e179", + "sha256": "9e13e73ebf3192a6548798c2f1d13bd4d83957e8db0dc34de12b1a5311a52a75" + }, + { + "path": "research/joint-query/evidence/QQ16-RATIONAL-OBSERVATION-REVIEW.md", + "usage": "input", + "git_blob": "c6ecf75654a084a9cc001bd62663f341976bae7a", + "sha256": "9a06ff40830ef80d3566fce77c78639cb64d519d487a0a7f57d543c3146e2c49" + }, + { + "path": "research/joint-query/evidence/QQ16-SELECTED-WITNESS.json", + "usage": "input", + "git_blob": "5082d791d0b993492cbc5bf61ac3b69e82c96f3f", + "sha256": "e35e5868a1322e406191079c0675975b139692ba50b1e2e5fb8a40b6480519f4" + } + ] +} diff --git a/research/qq16-coordinate-tap-kernel/TASK.json b/research/qq16-coordinate-tap-kernel/TASK.json new file mode 100644 index 0000000000..f64d7cf923 --- /dev/null +++ b/research/qq16-coordinate-tap-kernel/TASK.json @@ -0,0 +1,87 @@ +{ + "schema_version": 1, + "task_id": "joint-query-controller", + "priority_revision": 4, + "base_commit": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2", + "original_card": { + "id": "joint-query-controller", + "question": "Can one explicitly changed QQ16 interface recover the missing chart query and close a two-call controller within a favorable full budget?", + "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" + ], + "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." + ], + "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.", + "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." + }, + "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.", + "bottleneck_link": "The native local words exist; retained query information and its physical access are the missing link to a composed recursive interface.", + "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." + ], + "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." + ], + "overlap_terms": [ + "QQ16", + "joint-query", + "changing-chart controller", + "selected observation", + "1969" + ] + }, + "scope_status": "refined", + "actual_scope": "Full selected-input obstruction for the QQ16 F0/B1 selected shear plus ordinary coordinate taps; all 768 single taps and any fixed set of at most eight ordinary source ports.", + "scope_change_reason": "Take PR2268's explicit full-kernel handoff on the suggested central card. The changed interface permits in-place ordinary-to-selected feedback; the result is a scoped counterexample and support bound, not a complete supplier.", + "bottleneck_link": "The existing shear and tap separate known witness directions but do not prove complete recovery. A surviving kernel rejects this particular restoration interface even with zero implementation costs.", + "budget_minutes": 60, + "stop_rule": "Stop construction after an exact invisible selected-input defect survives the full retained tail; do not infer a native cost bound or full-controller minimum from source support.", + "outcome": "negative-result", + "evidence": "README proof; RESULT.json with 192 exact parity minors, 768 synthesized kernel vectors, 768 single-tap interface checks, full tail for eight independent U2-hidden A defects, an eight-port example, PR2268 positive control and thirteen rejecting controls.", + "author": "commdata2338", + "ai_assistance": "Substantial OpenAI Codex assistance in derivation, implementation, verification and writing. No independent human review claimed.", + "open_questions": [ + { + "question": "Can one priced dense old-chart observation remove the complete selected-input kernel?", + "why_it_matters": "Dense observations are outside the source-coordinate restriction and may recover information no small set of raw ports can retain.", + "first_step": "Specify its native cut and output/retention contract, then derive the complete ordered observation kernel before pricing.", + "blocked_by": "Legal native access, final-cut retention, restoration and a favorable complete supplier bill remain open." + }, + { + "question": "What source sets eliminate this common-axis family?", + "why_it_matters": "The nine-port bound is necessary only and helps screen source-support mechanisms.", + "first_step": "Analyze D(ker R_U intersect ker pi_S), then test beyond identity-owner evaluation.", + "blocked_by": "Eliminating this family is not sufficient for full controller injectivity; no exhaustive support minimum is claimed." + } + ], + "selection": { + "nonce": "b3f7fda4b64212179063ec745ca2c0d8", + "track": "recursive-interfaces", + "scope_key": "22e535909f1d243e7553", + "refined_scope_key": "QQ16/shear-plus-coordinate-tap/full-selected-input-kernel", + "canonical_discussion": 2205, + "claim_comment": 18941101 + }, + "upstream_refresh": { + "checked_at": "2026-10-15T05:16:24.192619+00:00", + "origin_main": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2", + "priority_revision": 4, + "changed_files": "", + "decision": "Continue the source-pinned coordinate-tap obstruction; upstream main is unchanged." + } +} diff --git a/research/qq16-coordinate-tap-kernel/VERIFY.json b/research/qq16-coordinate-tap-kernel/VERIFY.json new file mode 100644 index 0000000000..f7b203d35b --- /dev/null +++ b/research/qq16-coordinate-tap-kernel/VERIFY.json @@ -0,0 +1,46 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/community-frontier1042-audit/selected-replay.tar.gz", + "research/joint-query/certificate.json.gz", + "research/joint-query/evidence/JOINT-QUERY-TRANSFER.md", + "research/joint-query/evidence/QQ16-RATIONAL-OBSERVATION-REVIEW.md", + "research/joint-query/evidence/QQ16-SELECTED-WITNESS.json" + ], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Exact source-bound rank/support certificate, literal tap interface, full retained tail, predecessor positive control, and thirteen rejecting controls." + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "All acceptance and rejection checks remain enabled in optimized Python." + }, + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/test_verify.py" + ], + "timeout_seconds": 120, + "checks": "Relocated replay, complete receipt mutation, pinned executable mutation, and exclusive receipt creation." + } + ] +} diff --git a/research/qq16-coordinate-tap-kernel/references/pr2093/README.md b/research/qq16-coordinate-tap-kernel/references/pr2093/README.md new file mode 100644 index 0000000000..15f6707f8c --- /dev/null +++ b/research/qq16-coordinate-tap-kernel/references/pr2093/README.md @@ -0,0 +1,276 @@ +# A QQ16 kernel invisible to every nonzero-chart source query + +## Result and relevance + +For the actual QQ16 first `F0/B1` pair and retained ordinary schedule, adding +an exact pre-`F0` observation **`B2 X_U` does not suffice to recover the original +selected A input**. A three-port input has + +``` +B1 h = B2 h = 0, B0 h != 0. +``` + +All selected endpoints, all completed-X descendants, all five forward-query +histories, and the added `B2 X_U` observation agree with the zero input. The +required original `X_A` does not. This is an exact indistinguishability result, +not a failed search. Even an arbitrary decoder cannot distinguish these inputs +from that observation set. + +In fact this same `h` has `B_s h=0` for **every `1 <= s <= 8`**. Granting every +nonzero-chart pre-read of this ordinary source still leaves the obstruction. +The eight chart queries are different from eight scalar output coordinates of +one query. Neither statement rules out an old-chart `B0` read, a different +observation, or a change to the first pair. + +This addresses revision 4's concrete missing controller interface without +repeating a selected-root computation. It provides no complete QQ16 supplier, +new exponent, native read implementation, or formal-kernel theorem. + +## What is new relative to the sources + +Ali Romman's [PR1969](https://github.com/CrocSwap/integer-mult-bounds/pull/1969), +retained in [`research/joint-query`](../joint-query/README.md), supplies the +ordered local maps, actual routes, and native local invoices. Its +[selected witness](../joint-query/evidence/QQ16-SELECTED-WITNESS.md) and +[independent rational review](../joint-query/evidence/QQ16-RATIONAL-OBSERVATION-REVIEW.md) +already give eight missing directions with `B1 h=0` and `B2 h!=0`. Their +selected-only obstruction is not claimed as new here. + +[Cinna Davis / PR2079](https://github.com/CrocSwap/integer-mult-bounds/pull/2079), +head `49df8190b158e3028e702b2c6b798117006f7249`, formalizes the +[discussion 2074](https://github.com/CrocSwap/integer-mult-bounds/discussions/2074) +proposal `B2 X_U` and tests it against those eight directions. Its +[pinned proof](https://github.com/CrocSwap/integer-mult-bounds/blob/49df8190b158e3028e702b2c6b798117006f7249/research/joint-query-extra-b2-observation-seed3e62/README.md) +explicitly leaves full-controller injectivity open. Detecting that family is not +the same as recovering all initial selected inputs. The new witness instead +lies in the kernel of the **expanded** observation set and loses initial **A**, +not the predecessor's initial T. It answers PR2079's second open question for +this fixed first pair, without contradicting its restricted detection result. + +Existing scalar/native/ordered reviews are reused as source contracts, not +called independent by importing their checkers. This verifier imports no +predecessor Python code. It reconstructs R from original scalar operations, +reconstructs the owner routes from the actual phase axes, applies the ordered +maps to explicit functions on owners, and replays the source template's tail. + +## Actual source and observation model + +Use the actual 8-by-112 centre matrix R, with + +``` +A = [0, 7, 20, 27, 36, 46, 57, 111] +T = [21, 37, 47, 76, 81, 87, 92, 110] +U = {0,...,111} minus (A union T). +``` + +For owner `d`, let `rho_s(p)` be the actual stage-s owner involution at port +p; stage zero is the identity. The ordinary query is + +``` +(B_s h)(d) = sum_(p in U) r_p h_p(d rho_s(p)), +``` + +where `r_p` is column p of R. The eight local chart axes `b_(p,i)` lie in the +initial 9-dimensional block. The phase source explicitly gives + +``` +rho_s(p) b_(p,i) = e_(9 + 8(s-1) + i), 1 <= s <= 8. +``` + +These are **owner routes**, not payload permutations. Inputs below are +constant in every payload coordinate but vary with the owner. They are valid +at every positive tensor size. Native payload translations and endpoint line +operators fix these constant payloads; this is not an assumption that the +owner array is constant. + +The first pair and ordinary schedule are fixed. Subsequent homogeneous +selected-only linear controls may be arbitrary, including cross-bank, +port and cover maps. They do not read ordinary banks. The extra observation +is retained as a record; it does not rewrite the first pair. Later controls +may use it, because it is zero on the entire counterexample trajectory. + +## Explicit three-port witness + +The reconstructed columns satisfy + +``` +r_2 = (1, 1, 0, 0, 0, 0, 1, -1) +r_8 = (0, 1, 0, -1, 1, 0, 1, 0) +r_85 = (1, 0, 0, 1, -1, 0, 0, -1) +r_2 = r_8 + r_85. +``` + +The actual first local axes, as binary masks, are + +``` +b_(2,0)=37, b_(8,0)=38, b_(85,0)=506. +``` + +Let `f_v(d)=bit_0(d v)`, with the binary bit interpreted as the integer zero +or one. Define + +``` +h_2(d) = -f_37(d), +h_8(d) = f_38(d), +h_85(d) = f_506(d), +h_p(d) = 0 otherwise. +``` + +For every owner d and every `s=1,...,8`, the common-axis identity gives + +``` +(B_s h)(d) = (-r_2+r_8+r_85) bit_0(d e_(9+8(s-1))) = 0. +``` + +This is an all-owner algebraic identity; it is not an enumeration of a few +cover representatives. At the identity owner, only mask 37 has low bit one, +so + +``` +(B0 h)(I) = -r_2 = (-1,-1,0,0,0,0,-1,1) != 0. +``` + +The formal sparse-function representation used by the checker need not assume +that all `f_v` are linearly independent on the cover. Cancellation of the +formal sum is sufficient for zero; evaluation at the actual identity owner +is sufficient for nonzero. + +## Ordered first-pair trajectory + +Let `P_(s,A)` be the actual selected section, so +`ell_(s,A) P_(s,A)=I`. Set every bank except pair zero to zero and set + +``` +X_U=h, Y_U=0, +X_A=-P_(0,A) B0 h, Y_A=-X_A, +X_T=0, Y_T=0. +``` + +Both selected pair sums are zero. At the identity owner the required initial +A values, in the displayed A order, are + +``` +(1/2, 0, 1/2, 1/2, 0, -1/2, 0, 0). +``` + +The initial full query is `f0=B0h+ell_(0,A)X_A=0`. The exact forward map +therefore yields + +``` +X_U=Y_U=h, X_A=Y_A=X_T=Y_T=0. +``` + +The backward future query is `q2=B2h=0`, so its systematic future logger +leaves `u=(h,0,0)`. The old T driver is `a=0`, and `b=B1h=0`. Substituting in +the conserved backward formulas gives + +``` +Y_0,U=h, every other field zero. +``` + +No operator factors have been commuted. The extra pre-`F0` read was +`B2 X_U=B2h=0`, so the new record is identical to the zero-input record. + +## All remaining observations + +The retained positive ordinary bridge `(dst,src)=(0,1)` places `-h` in +`Y_1,U`. `F2` acts on pair zero with zero X source and does not change the +state. The negative bridge removes `-h` before `B3`. Every subsequent active +pair is zero. The final three bridges leave only `Y_0,U=h`. All five forward +queries `f0,f2,f4,f6,f8` are zero. + +All selected states after the first pair are zero. Every later homogeneous +selected-only map, including maps that use the added zero record, preserves +that fact. Thus the argument does not depend on a particular selected-only +controller. + +The terminal signed exchange moves h to **named final `X_0,U`, with the +old-Y native type**. It is not a completed-X descendant. Every completed-X +descendant is zero. Mistaking the named final X array for an available +completed-X observation would invalidate the observation contract; a +negative control deliberately makes that mistake and rejects it. + +The checker reconstructs the original template's `recipe` and binds its +stage/pair/orientation records to the hosted calls. It replays its ordinary +bridges and the actual ordered F/B formulas, and matches the complete retained +witness tail receipt. Ignored idle/frame sweeps preserve logical contents; +all payload operations fix the constant payloads used here. A new full native +supplier replay is not claimed. + +## Complete favorable budget and stopping decision + +This is a functionality obstruction, not a native-cost lower bound. Before +synthesis, grant the proposed B2 extraction, eight output coordinates, source +access, owner/address maps, storage, restoration, endpoint conversion, +chronological hosting and precision **zero added cost**. Even that favorable +completed observation model cannot recover the required A input. + +For orientation, the retained local F and B words have rank masses 5530 and +5546, respectively. Their first-pair mass is 11076. If an additional rank-8 +record were separately charged, those local masses would become 5554 for B +and 11084 for the pair, before any other nonnegative costs. This is a +hypothetical output charge, not a demonstrated native read or a physical +lower bound. No completed recursive moment exists for the failed recovery +proposal, so there is no justified new moment root to compute. More payment +for the same observation cannot remove its information kernel. Feedback +that changes the first pair is outside this test. + +## Reproduction and evidence + +Standard-library CPython 3.12, no network and no predecessor imports: + +```sh +uv run --python 3.12 --no-project python -I -O -B research/qq16-b2-observation-kernel/verify.py +uv run --python 3.12 --no-project python -B scripts/research_package.py --package research/qq16-b2-observation-kernel +``` + +The direct command requires the committed `RESULT.json`, regenerates every +proof-relevant result in memory, and compares the complete canonical JSON +payload. It authenticates all source bytes before parsing the archive or +certificate. `--emit-result NEW_PATH` explicitly creates an external receipt +and refuses to overwrite an existing file. Compression/container hashes are +only immutable-source authentication, not regenerated mathematical equality. + +Expected status: `PASS_QQ16_B2_OBSERVATION_KERNEL`. Eight controls reject changed +dependency coefficients, a changed chart axis, omitted A cancellation, a +missing negative bridge, endpoint type confusion, replacement of the new +read by a detecting B0 read, payload-only routing and altered source bytes. +The B0 control confirms an escape for this witness, not sufficiency of B0 +for the whole controller. + +`SELECTION.json` preserves the single independent chooser draw, seed +`20e7cbb51ab8b49eac12de2f825e100a`, track `independent-verification`. +Scientific base: `564148b82ae9df72163f22106f15e73efca8aff2`, priority revision 4. +Exact input Git blobs and SHA256 pins are in `SOURCES.json`; archive member +pins and the full observation trajectory are in `RESULT.json`. The selected +record and all frozen predecessors are unchanged. The required binding-only +working example passed; this does not imply a selected full cold replay. + +## Open next questions + +1. **Does B0 together with B2 and the retained observations recover the full + fixed-pair selected-input kernel?** This witness proves that B0 detects one + missing component, not a complete repair. First derive the entire ordered + kernel and compare the augmented observation map. Actual native frame access + and a complete physical invoice remain blockers. +2. **Can a changed first pair retain both old-chart components cheaply?** Write + its arbitrary-input identity and fully priced output/restoration contract + before synthesis. The present first pair is fixed; the result is not a + universal obstruction to changed controllers or other ordinary reads. + +## Attribution and limits + +Ali Romman and the credited supplier lineage provide PR1969's local QQ16 +maps, actual routes, retained tail and independent reviews. The selected +gauge44/t16 sources retain icekylinx's contributions, chafreaky's frame work +and their earlier supplier lineage; see the unchanged +[source notices](../joint-query/NOTICE.md). Cinna Davis / `1337isnot1337` +supplies PR2079's explicit B2 pre-read +and bounded old-witness separation result; this audit answers its stated +full-kernel question. + +The new three-port kernel, expanded-observation proof and independent checker +were prepared for Adam Gall with substantial OpenAI Codex assistance. +Apache-2.0. No independent human review, formal-kernel run, complete physical +read, all-size compiler admission, selected supplier replay, hosted-CI pass, +or literature-priority guarantee is claimed. diff --git a/research/qq16-coordinate-tap-kernel/references/pr2093/verify.py b/research/qq16-coordinate-tap-kernel/references/pr2093/verify.py new file mode 100644 index 0000000000..bc07d47ddf --- /dev/null +++ b/research/qq16-coordinate-tap-kernel/references/pr2093/verify.py @@ -0,0 +1,403 @@ +#!/usr/bin/env python3 +"""Exact, producer-independent QQ16 expanded-observation counterexample. + +Sparse functions represent finite sums of f_v(d) = bit_0(d v). A zero +formal sum is zero at every owner; nonzeroness is witnessed at d = I. +No predecessor Python code is imported or executed. Apache-2.0. +Prepared for Adam Gall with substantial OpenAI Codex assistance. +""" + +import argparse +from fractions import Fraction as Q +import gzip +from hashlib import sha256 +from io import BytesIO +import json +from pathlib import Path +import tarfile + +PACKAGE = Path(__file__).resolve().parent +ROOT = PACKAGE.parents[1] +ARCHIVE = "research/community-frontier1042-audit/selected-replay.tar.gz" +CERTIFICATE = "research/joint-query/certificate.json.gz" +EVIDENCE = "research/joint-query/evidence/" +INPUTS = { + ARCHIVE: "22c3f4dce4b897a1d423d1388801933e288b6a6b1906cb15e1b16a5eb68db754", + CERTIFICATE: "a5ed85fac5ebf3c091482a113ab0d351eb5a7892fe2841a35e16017ec1ff49f7", + EVIDENCE + "JOINT-QUERY-TRANSFER.md": "9e13e73ebf3192a6548798c2f1d13bd4d83957e8db0dc34de12b1a5311a52a75", + EVIDENCE + "QQ16-RATIONAL-OBSERVATION-REVIEW.md": "9a06ff40830ef80d3566fce77c78639cb64d519d487a0a7f57d543c3146e2c49", + EVIDENCE + "QQ16-SELECTED-WITNESS.md": "52f2ee565320f05282c637aa79eee100606c24240b1b5866f0c8d62e7913c9fc", + EVIDENCE + "QQ16-SELECTED-WITNESS.json": "e35e5868a1322e406191079c0675975b139692ba50b1e2e5fb8a40b6480519f4", + EVIDENCE + "BRIDGE-REVIEW.md": "d01b5f4959f7c91f835496d050dfae3eeab9dee2f581571c316a42571eaa1cd3", +} +MEMBERS = { + "slots/local/CANONICAL-WORD.json.gz": "16bc0ebb04b4be6c0ade74badc6a0c0cdba4215eda86e4ff9f13abf8ecebd219", + "slots/local/LOCAL-PROGRAMS.json.gz": "241fde27d4e43f5a9cb6b128f9f76c5131a53d09f0371676163f914d0b0fef3a", + "t16/global/base/work/complex-nine-native/DATA-PHASES.json": "c5916ff312678f12aba403847643fbbc29f643acec60bdf836fa56cd3e8251fa", + "t16/global/base/split-centres/GLOBAL-TEMPLATE.json.gz": "a179dad87651aba340a5a8ddbcd86a8e757cad87b8a1f8bad48106fbecd38518", +} +A = (0, 7, 20, 27, 36, 46, 57, 111) +T = (21, 37, 47, 76, 81, 87, 92, 110) +U = tuple(p for p in range(112) if p not in A + T) +COEFFICIENTS = {2: -1, 8: 1, 85: 1} +AXES = tuple(1 << j for j in range(73)) + + +def require(condition, message): + if not condition: + raise ValueError(message) + + +def authenticate(raw, expected, name): + require(sha256(raw).hexdigest() == expected, "source hash: " + name) + return raw + + +def load_sources(): + manifest = json.loads((PACKAGE / "SOURCES.json").read_text()) + require({row["path"]: row["sha256"] for row in manifest["files"] + if row["usage"] == "input"} == INPUTS, "manifest input pins") + raw = {name: authenticate((ROOT / name).read_bytes(), pin, name) + for name, pin in INPUTS.items()} + members = {} + with tarfile.open(fileobj=BytesIO(raw[ARCHIVE]), mode="r:gz") as archive: + for name, pin in MEMBERS.items(): + matches = [m for m in archive.getmembers() if m.name == name] + require(len(matches) == 1 and matches[0].isfile(), "unique member: " + name) + payload = authenticate(archive.extractfile(matches[0]).read(), pin, name) + if name.endswith(".gz"): + payload = gzip.decompress(payload) + members[name.rsplit("/", 1)[-1]] = json.loads(payload) + certificate = json.loads(gzip.decompress(raw[CERTIFICATE])) + previous = json.loads(raw[EVIDENCE + "QQ16-SELECTED-WITNESS.json"]) + return members, certificate, previous + + +def linear(*terms): + """Exact sum of (scalar, sparse row/function) terms, with zero removal.""" + result = {} + for coefficient, row in terms: + for key, value in row.items(): + result[key] = result.get(key, Q(0)) + coefficient * value + return {key: value for key, value in result.items() if value} + + +def reconstruct_R(word, programs): + require((word["v"], word["R"], word["h"]) == (112, 480, 9), "selected geometry") + # Project the original scalar operations to the 112 source input columns. + rows = [{p: Q(1)} if p < 112 else {} for p in range(712)] + reached = False + for event in programs["forward"]: + if event == ["phase", "centers"]: + reached = True + break + if event[0] != "scalar": + continue + op = event[1] + target = op[1][1] + (704 if op[1][0] == "C" else 0) + if op[0] == "clear": + rows[target] = {} + elif op[0] == "scale": + rows[target] = linear((Q(op[2], op[3]), rows[target])) + else: + require(op[0] in ("add", "copy"), "original scalar alphabet") + source = op[2][1] + (704 if op[2][0] == "C" else 0) + rows[target] = (rows[source].copy() if op[0] == "copy" else + linear((1, rows[target]), (Q(op[3], op[4]), rows[source]))) + require(reached, "source centre cut") + return [[rows[c].get(p, Q(0)) for p in range(112)] for c in word["centers"]] + + +def inverse(matrix): + n = len(matrix) + rows = [list(row) + [Q(i == j) for j in range(n)] for i, row in enumerate(matrix)] + for col in range(n): + pivot = next((i for i in range(col, n) if rows[i][col]), None) + require(pivot is not None, "selected minor invertibility") + rows[col], rows[pivot] = rows[pivot], rows[col] + divisor = rows[col][col] + rows[col] = [x / divisor for x in rows[col]] + for i in range(n): + if i != col: + factor = rows[i][col] + rows[i] = [x - factor * y for x, y in zip(rows[i], rows[col])] + return [row[n:] for row in rows] + + +def binary_action(columns, vector): + result = 0 + while vector: + bit = vector & -vector + result ^= columns[bit.bit_length() - 1] + vector ^= bit + return result + + +def route_axis(basis, stage, vector): + if stage == 0: + return vector + for i, axis in enumerate(basis): + swap = axis ^ AXES[9 + 8 * (stage - 1) + i] + if (vector & swap).bit_count() % 2: + vector ^= swap + return vector + + +class Model: + def __init__(self, R, phases, ignore_owner=False): + self.R = R + self.bases = [tuple(row["idle_children"][0]["orthogonal_axes"][:8]) + for row in phases["recipes"]] + self.inverses = {ports: inverse([[R[k][p] for p in ports] for k in range(8)]) + for ports in (A, T)} + self.routes = [] + require(phases["m"] == 73 and len(self.bases) == 112, "actual phase geometry") + for p, (basis, record) in enumerate(zip(self.bases, phases["recipes"])): + local = (record["q"],) + basis + require(record["port"] == p and all(0 < v < (1 << 9) for v in local), + "actual first-block chart") + require(all((local[i] & local[j]).bit_count() % 2 == (i == j) + for i in range(9) for j in range(9)), "orthonormal chart") + routes = [] + for stage in range(9): + columns = tuple(route_axis(basis, stage, v) for v in AXES) + require(all(binary_action(columns, column) == AXES[i] + for i, column in enumerate(columns)), "route involution") + if stage: + require(all(binary_action(columns, basis[i]) == AXES[9 + 8 * (stage - 1) + i] + for i in range(8)), "actual common-axis image") + routes.append(AXES if ignore_owner else columns) + self.routes.append(routes) + + def move(self, stage, port, function): + return linear(*((value, {binary_action(self.routes[port][stage], axis): Q(1)}) + for axis, value in function.items())) + + def query(self, stage, fields, ports=tuple(range(112))): + return [linear(*((self.R[k][p], self.move(stage, p, fields[p])) for p in ports)) + for k in range(8)] + + def inject(self, stage, ports, query): + result = [{} for _ in range(112)] + for i, p in enumerate(ports): + result[p] = self.move(stage, p, linear(*((self.inverses[ports][i][k], query[k]) + for k in range(8)))) + return result + + def ordinary_response(self, stage, query): + result = [{} for _ in range(112)] + for p in U: + result[p] = self.move(stage, p, linear(*((self.R[k][p] / 4, query[k]) + for k in range(8)))) + return result + + def forward(self, stage, x, y): + f = self.query(stage, x) + selected = self.query(stage, x, T) + response = self.ordinary_response(stage, f) + xa, xt = self.inject(stage, A, selected), self.inject(stage, T, f) + out_x, out_y = [{} for _ in range(112)], [{} for _ in range(112)] + for p in U: + out_x[p] = linear((1, x[p]), (-1, response[p])) + out_y[p] = linear((1, y[p]), (1, out_x[p])) + for p in A + T: + out_x[p] = xa[p] if p in A else xt[p] + out_y[p] = linear((1, x[p]), (1, y[p]), (-1, out_x[p])) + return out_x, out_y, f + + def backward(self, stage, future, x, y): + ua = self.inject(future, A, self.query(future, y)) + u = [ua[p] if p in A else y[p].copy() for p in range(112)] + a, b = self.query(stage, x, T), self.query(stage, u) + response = self.ordinary_response(stage, a) + xt = self.inject(stage, T, [linear((1, b[k]), (12, a[k])) for k in range(8)]) + subtract = self.inject(stage, T, [linear((1, b[k]), (11, a[k])) for k in range(8)]) + out_x, out_y = [{} for _ in range(112)], [{} for _ in range(112)] + for p in U: + out_x[p] = linear((1, x[p]), (-1, y[p])) + out_y[p] = linear((1, y[p]), (1, response[p])) + for p in A: + out_x[p] = linear((1, x[p]), (1, y[p]), (-1, u[p])) + out_y[p] = u[p] + for p in T: + out_x[p], out_y[p] = xt[p], linear((1, u[p]), (-1, subtract[p])) + return out_x, out_y + + +def at_identity(function): + return sum(coefficient * (axis & 1) for axis, coefficient in function.items()) + + +def canonical(value): + return json.dumps(value, sort_keys=True, separators=(",", ":")) + + +def experiment(model, template, previous, coefficients=None, axis_mutation=False, + omit_initial_correction=False, omit_minus=False, wrong_endpoint=False, + extra_stage=2): + coefficients = COEFFICIENTS if coefficients is None else coefficients + h = [{} for _ in range(112)] + for p, c in coefficients.items(): + axis_index = 1 if axis_mutation and p == 2 else 0 + h[p] = {model.bases[p][axis_index]: Q(c)} + b0 = model.query(0, h) + require(any(at_identity(row) for row in b0), "nonzero B0 at identity") + require(not any(model.query(1, h)), "B1 kernel") + require(not any(model.query(extra_stage, h)), "extra observation kernel") + initial_a = model.inject(0, A, b0) + x, y = h.copy(), [{} for _ in range(112)] + for p in A: + x[p] = {} if omit_initial_correction else linear((-1, initial_a[p])) + y[p] = linear((-1, x[p])) + required_input = [str(at_identity(x[p])) for p in A] + require(any(at_identity(x[p]) for p in A), "nonzero required original A") + x, y, f0 = model.forward(0, x, y) + require(not any(f0), "zero f0") + require(all(not x[p] and not y[p] for p in A + T), "selected zero after F0") + x, y = model.backward(1, 2, x, y) + require(not any(x) and y == h, "exact first-pair output") + banks = [[x, y]] + [[[{ } for _ in range(112)], [{ } for _ in range(112)]] for _ in range(3)] + histories = {0: f0} + trajectory = [] + recipe = template["recipe"] + require(recipe[:2] == [{"kind": "local", "pair": 0, "reverse": False, "stage": 0}, + {"kind": "local", "pair": 0, "reverse": True, "stage": 1}], + "fixed first pair") + for event in recipe[2:]: + if omit_minus and event == {"kind": "bridge", "src": 1, "dst": 0, "coefficient": -1}: + continue + kind = event["kind"] + if kind == "bridge": + src, dst, c = event["src"], event["dst"], event["coefficient"] + for p in U: + banks[dst][0][p] = linear((1, banks[dst][0][p]), (c, banks[src][0][p])) + banks[src][1][p] = linear((1, banks[src][1][p]), (-c, banks[dst][1][p])) + record = dict(event) + elif kind == "local": + stage, pair = event["stage"], event["pair"] + bx, by = banks[pair] + if event["reverse"]: + banks[pair] = list(model.backward(stage, stage + 1, bx, by)) + else: + bx, by, f = model.forward(stage, bx, by) + banks[pair] = [bx, by] + histories[stage] = f + record = {"kind": "local", "stage": stage} + else: + require(kind == "terminal", "retained schedule alphabet") + # The completed-X descendants are the pre-exchange X fields. + require(not any(row for bx, _ in banks for row in bx), "completed-X descendants") + banks = [[by, [linear((-1, row)) for row in bx]] for bx, by in banks] + record = {"kind": "terminal"} + require(not any(fields[p] for pair in banks for fields in pair for p in A + T), + "selected outputs stay zero") + # Each ordinary bank is an exact scalar multiple of the entire h field. + ordinary = [] + for pair in banks: + for fields in pair: + multiplier = next((c for c in (0, 1, -1) if all( + fields[p] == linear((c, h[p])) for p in U)), None) + require(multiplier is not None, "ordinary trajectory closure") + ordinary.append(multiplier) + record["ordinary"] = ordinary + trajectory.append(record) + require(trajectory == previous["trajectory_after_B1"], "retained full tail trajectory") + require(sorted(histories) == [0, 2, 4, 6, 8] and not any( + row for query in histories.values() for row in query), "all five forward histories") + require(banks[0][0] == h and not any(row for pair in banks[1:] for fields in pair for row in fields), + "only old-Y-typed final X0 survives") + require(not any(row for _, by in banks for row in by), "zero final completed-X descendants") + if wrong_endpoint: + require(not any(row for bx, _ in banks for row in bx), "wrong old-Y endpoint observation") + return { + "B0_h_at_identity": [str(at_identity(row)) for row in b0], + "required_initial_X_A_at_identity": required_input, + "zero_observations": ["all selected endpoints", "all completed-X descendants", + "f0", "f2", "f4", "f6", "f8", "pre-F0 B2 X_U"], + "tail_trajectory": trajectory, + "surviving_unobserved_endpoint": "final X0_U=h, with old-Y native type", + } + + +def rejecting(name, action, controls): + try: + action() + except ValueError: + controls.append(name) + else: + raise ValueError("negative control accepted: " + name) + + +def build_result(): + members, certificate, previous = load_sources() + word = members["CANONICAL-WORD.json.gz"] + R = reconstruct_R(word, members["LOCAL-PROGRAMS.json.gz"]) + require(R == [[Q(row.get(str(p), "0")) for p in range(112)] + for row in certificate["R_rows"]], "operation-derived R equals QQ16 input") + require((certificate["A_ports"], certificate["T_ports"], certificate["U_ports"]) + == (list(A), list(T), list(U)), "actual selected and ordinary ports") + require(all(sum(R[i][p] * R[j][p] for p in U) == (48 if i == j else 0) + for i in range(8) for j in range(8)), "ordinary Gram") + require(all(sum(R[k][p] * c for p, c in COEFFICIENTS.items()) == 0 for k in range(8)), + "three-column exact dependency") + phases = members["DATA-PHASES.json"] + model = Model(R, phases) + template = members["GLOBAL-TEMPLATE.json.gz"] + require(all(phases["recipes"][p]["q"] == word["ports"][p] for p in range(112)), + "phase/root binding") + recipe_calls = {(e["stage"], e["pair"], "backward" if e["reverse"] else "forward") + for e in template["recipe"] if e["kind"] == "local"} + require(recipe_calls == {(c["stage"], c["pair"], c["orientation"]) for c in template["calls"]}, + "recipe/hosted-call binding") + result = experiment(model, template, previous) + # Stronger than required: this h has zero query in all eight nonzero charts. + h = [{model.bases[p][0]: Q(COEFFICIENTS[p])} if p in COEFFICIENTS else {} for p in range(112)] + require(all(not any(model.query(s, h)) for s in range(1, 9)), "all nonzero-stage kernels") + controls = [] + cases = [ + ("changed dependency coefficient", {"coefficients": {2: -1, 8: 1, 85: -1}}), + ("changed chart axis", {"axis_mutation": True}), + ("missing initial A cancellation", {"omit_initial_correction": True}), + ("missing first negative bridge", {"omit_minus": True}), + ("old-Y endpoint mislabeled as completed-X", {"wrong_endpoint": True}), + ("B0 observation detects this witness", {"extra_stage": 0}), + ] + for name, options in cases: + rejecting(name, lambda options=options: experiment(model, template, previous, **options), controls) + rejecting("owner action replaced by payload-only action", + lambda: experiment(Model(R, phases, ignore_owner=True), template, previous), controls) + rejecting("source-byte mutation", lambda: authenticate(b"changed", INPUTS[CERTIFICATE], CERTIFICATE), controls) + return { + "schema": "qq16-b2-observation-kernel-v1", + "status": "PASS_QQ16_B2_OBSERVATION_KERNEL", + "proof_inputs": INPUTS, + "archive_members": MEMBERS, + "source_R_sha256": sha256(canonical([[str(x) for x in row] for row in R]).encode()).hexdigest(), + "witness": {"definition": "h_p(d)=c_p bit_0(d b_(p,0)), constant in every payload coordinate", + "coefficients": {str(p): c for p, c in COEFFICIENTS.items()}, + "axes": {str(p): model.bases[p][0] for p in COEFFICIENTS}, + "vanishing_stages": list(range(1, 9))}, + "observation_audit": result, + "rejecting_controls": controls, + "scope": "Fixed first pair and ordinary schedule; exact B2 pre-read added. No changed feedback, native read, supplier, new kappa, or formal-kernel claim.", + } + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--emit-result", type=Path, help="Create a new receipt exclusively; never overwrite") + args = parser.parse_args() + result = build_result() + if args.emit_result is not None: + with args.emit_result.open("x", encoding="utf-8") as handle: + json.dump(result, handle, indent=2, sort_keys=True) + handle.write("\n") + else: + recorded = json.loads((PACKAGE / "RESULT.json").read_text()) + require(canonical(recorded) == canonical(result), "complete canonical result equality") + print(result["status"]) + print("3 ordinary ports; B1h=B2h=0; original A nonzero; 8 zero observations; 8 rejecting controls") + + +if __name__ == "__main__": + main() diff --git a/research/qq16-coordinate-tap-kernel/test_verify.py b/research/qq16-coordinate-tap-kernel/test_verify.py new file mode 100644 index 0000000000..66a4538ca8 --- /dev/null +++ b/research/qq16-coordinate-tap-kernel/test_verify.py @@ -0,0 +1,67 @@ +#!/usr/bin/env python3 +"""Artifact-integrity checks in an isolated source-bound export. Apache-2.0.""" +import json +from pathlib import Path +import shutil +import subprocess +import sys +import tempfile +import unittest + +PACKAGE = Path(__file__).resolve().parent +ROOT = PACKAGE.parents[1] + + +class ArtifactTests(unittest.TestCase): + def setUp(self): + # An explicitly local temp root also works when system temp is remote. + self.temporary = tempfile.TemporaryDirectory(prefix=".qq16-check-", dir=ROOT) + self.addCleanup(self.temporary.cleanup) + self.root = Path(self.temporary.name) + self.package = self.root / "research" / PACKAGE.name + shutil.copytree(PACKAGE, self.package, ignore=shutil.ignore_patterns("__pycache__")) + manifest = json.loads((PACKAGE / "VERIFY.json").read_text()) + for name in manifest["inputs"]: + target = self.root / name + target.parent.mkdir(parents=True, exist_ok=True) + target.symlink_to(ROOT / name) + + def run_check(self, *extra): + return subprocess.run([sys.executable, "-I", "-O", "-B", str(self.package / "verify.py"), *extra], + cwd=self.root, capture_output=True, text=True, timeout=90) + + def test_relocated_replay_and_exclusive_emission(self): + before = {str(p.relative_to(self.package)): p.read_bytes() + for p in self.package.rglob("*") if p.is_file()} + replay = self.run_check() + self.assertEqual(replay.returncode, 0, replay.stderr) + self.assertIn("single_taps=768 A_defect=8 ports<=8_excluded", replay.stdout) + after = {str(p.relative_to(self.package)): p.read_bytes() + for p in self.package.rglob("*") if p.is_file()} + self.assertEqual(before, after, "default replay modified the package") + destination = self.root / "must-not-overwrite.json" + destination.write_text("existing content\n") + blocked = self.run_check("--emit-result", str(destination)) + self.assertNotEqual(blocked.returncode, 0) + self.assertIn("FileExistsError", blocked.stderr) + self.assertEqual(destination.read_text(), "existing content\n") + + def test_full_receipt_corruption_rejected(self): + path = self.package / "RESULT.json" + result = json.loads(path.read_text()) + result["rank_certificate"]["single_source_cases"][1]["even_basis"][0] = 2 + path.write_text(json.dumps(result)) + replay = self.run_check() + self.assertNotEqual(replay.returncode, 0) + self.assertIn("complete canonical receipt mismatch", replay.stderr) + + def test_reference_source_corruption_rejected(self): + reference = self.package / "references/pr2093/verify.py" + reference.write_bytes(reference.read_bytes() + b"\n# mutated input\n") + replay = self.run_check() + self.assertNotEqual(replay.returncode, 0) + self.assertIn("source hash: PR2093 verifier", replay.stderr) + + +if __name__ == "__main__": + unittest.main() diff --git a/research/qq16-coordinate-tap-kernel/verify.py b/research/qq16-coordinate-tap-kernel/verify.py new file mode 100644 index 0000000000..31ea310000 --- /dev/null +++ b/research/qq16-coordinate-tap-kernel/verify.py @@ -0,0 +1,393 @@ +#!/usr/bin/env python3 +"""Exact QQ16 source-coordinate tap obstruction; standard library, read-only. + +Pinned PR2093 code supplies source reconstruction and logical F/B maps. +The support argument, parity minors, witness synthesis, interface, tail +interpreter and controls here are new. Apache-2.0. +Prepared for commdata2338 with substantial OpenAI Codex assistance. +""" +import argparse +import copy +from fractions import Fraction as Q +import gzip +from hashlib import sha256 +from io import BytesIO +import importlib.util +import json +from pathlib import Path +import tarfile + +PACKAGE = Path(__file__).resolve().parent +ROOT = PACKAGE.parents[1] +REFERENCE_HASH = "1009fc5dc4843051d6d8e40edfbf1f5254b024623b5e8f73f10a4cfd756df15c" +NEW_WITNESS = {1: 1, 16: -1, 88: -1} +OLD_WITNESS = {2: -1, 8: 1, 85: 1} + + +def need(ok, message): + if not ok: + raise ValueError(message) + + +def canonical(value): + # Text comparison preserves JSON scalar types (unlike Python 1 == True). + return json.dumps(value, sort_keys=True, separators=(",", ":")) + + +def authenticate(raw, digest, label): + need(sha256(raw).hexdigest() == digest, "source hash: " + label) + return raw + + +def load(): + reference = PACKAGE / "references/pr2093/verify.py" + authenticate(reference.read_bytes(), REFERENCE_HASH, "PR2093 verifier") + spec = importlib.util.spec_from_file_location("qq16_pr2093", reference) + old = importlib.util.module_from_spec(spec) + spec.loader.exec_module(old) + sources = json.loads((PACKAGE / "SOURCES.json").read_text()) + inputs = {r["path"]: r["sha256"] for r in sources["files"] if r["usage"] == "input"} + for name, digest in inputs.items(): + need(old.INPUTS.get(name) == digest, "inherited source pin: " + name) + required = {old.ARCHIVE, old.CERTIFICATE, + old.EVIDENCE + "JOINT-QUERY-TRANSFER.md", + old.EVIDENCE + "QQ16-SELECTED-WITNESS.json", + old.EVIDENCE + "QQ16-RATIONAL-OBSERVATION-REVIEW.md"} + need(set(inputs) == required, "complete live source inventory") + raw = {n: authenticate((ROOT / n).read_bytes(), h, n) for n, h in inputs.items()} + members = {} + with tarfile.open(fileobj=BytesIO(raw[old.ARCHIVE]), mode="r:gz") as archive: + for name, digest in old.MEMBERS.items(): + matches = [m for m in archive.getmembers() if m.name == name] + need(len(matches) == 1 and matches[0].isfile(), "unique archive member") + data = authenticate(archive.extractfile(matches[0]).read(), digest, name) + members[name.rsplit("/", 1)[-1]] = json.loads(gzip.decompress(data) if name.endswith(".gz") else data) + cert = json.loads(gzip.decompress(raw[old.CERTIFICATE])) + previous = json.loads(raw[old.EVIDENCE + "QQ16-SELECTED-WITNESS.json"]) + R = old.reconstruct_R(members["CANONICAL-WORD.json.gz"], members["LOCAL-PROGRAMS.json.gz"]) + need(R == [[Q(row.get(str(p), "0")) for p in range(112)] for row in cert["R_rows"]], + "operation-derived R binding") + need((cert["A_ports"], cert["T_ports"], cert["U_ports"]) == + (list(old.A), list(old.T), list(old.U)), "port partition binding") + need(all(sum(R[i][p] * R[j][p] for p in old.U) == (48 if i == j else 0) + for i in range(8) for j in range(8)), "ordinary Gram") + phases, word = members["DATA-PHASES.json"], members["CANONICAL-WORD.json.gz"] + need(all(phases["recipes"][p]["q"] == word["ports"][p] for p in range(112)), "phase/root binding") + model = old.Model(R, phases) + registry = {tuple(row["owner_right_matrix_columns"]) for row in cert["map_registry"].values()} + bind_routes(model, registry) + template = members["GLOBAL-TEMPLATE.json.gz"] + bind_template(template) + return old, model, template, previous, inputs, phases, registry + + +def bind_routes(model, registry): + need(all(columns in registry for stages in model.routes for columns in stages), + "actual route absent from packet registry") + + +def bind_template(template): + need(template["recipe"][:2] == [ + {"kind": "local", "pair": 0, "reverse": False, "stage": 0}, + {"kind": "local", "pair": 0, "reverse": True, "stage": 1}], "first pair") + recipe_calls = {(e["stage"], e["pair"], "backward" if e["reverse"] else "forward") + for e in template["recipe"] if e["kind"] == "local"} + need(recipe_calls == {(c["stage"], c["pair"], c["orientation"]) + for c in template["calls"]}, "recipe/hosted-call binding") + + +def pivots(matrix): + """Rational row reduction, separate from the inherited matrix inverse.""" + rows, found = [list(map(Q, row)) for row in matrix], [] + for col in range(len(rows[0])): + row = len(found) + pivot = next((i for i in range(row, len(rows)) if rows[i][col]), None) + if pivot is None: + continue + rows[row], rows[pivot] = rows[pivot], rows[row] + q = rows[row][col] + rows[row] = [x / q for x in rows[row]] + for i in range(row + 1, len(rows)): + q = rows[i][col] + if q: + rows[i] = [x - q * y for x, y in zip(rows[i], rows[row])] + found.append(col) + if len(found) == len(rows): + break + return found + + +def determinant(matrix): + """Separate fraction-free Bareiss check of each displayed integer minor.""" + need(all(Q(x).denominator == 1 for row in matrix for x in row), "integer minor") + a = [[int(x) for x in row] for row in matrix] + n, sign, previous = len(a), 1, 1 + for k in range(n - 1): + if a[k][k] == 0: + row = next((i for i in range(k + 1, n) if a[i][k]), None) + if row is None: + return 0 + a[k], a[row], sign = a[row], a[k], -sign + pivot = a[k][k] + for i in range(k + 1, n): + for j in range(k + 1, n): + numerator = a[i][j] * pivot - a[i][k] * a[k][j] + need(numerator % previous == 0, "Bareiss exact division") + a[i][j] = numerator // previous + a[i][k] = 0 + previous = pivot + return sign * a[-1][-1] + + +def minor(R, ports): + return [[R[k][p] for p in ports] for k in range(8)] + + +def source_certificate(old, model): + R = model.R + C = minor(R, old.U) + D = [[R[k][p] * (model.bases[p][0] & 1) for p in old.U] for k in range(8)] + need((len(pivots(C)), len(pivots(C + D))) == (8, 16), "eight-dimensional defect") + rows, fixture = [], [] + for excluded in old.U: + bases, dets, inverses = [], [], [] + for bit in (0, 1): + pool = [p for p in old.U if p != excluded and model.bases[p][0] & 1 == bit] + chosen = [pool[i] for i in pivots(minor(R, pool))] + need(len(chosen) == 8, "rank-eight parity class after one deletion") + matrix = minor(R, chosen) + det = determinant(matrix) + need(det != 0, "nonzero parity minor") + inv = old.inverse(matrix) + need(all(sum(matrix[i][k] * inv[k][j] for k in range(8)) == (i == j) + for i in range(8) for j in range(8)), "inverse/minor cross-check") + bases.append(chosen) + dets.append(det) + inverses.append(inv) + for j in range(8): + coeff = {p: sign * inverses[bit][i][j] + for bit, sign in ((0, -1), (1, 1)) + for i, p in enumerate(bases[bit]) if inverses[bit][i][j]} + need(excluded not in coeff, "zero tapped source") + need(all(sum(R[k][p] * c for p, c in coeff.items()) == 0 for k in range(8)), "constructed kernel vector") + need(all(sum(R[k][p] * c * (model.bases[p][0] & 1) for p, c in coeff.items()) + == (k == j) for k in range(8)), "constructed identity defect") + if excluded == 2: + fixture.append(coeff) + rows.append({"excluded_source": excluded, "even_basis": bases[0], "odd_basis": bases[1], + "determinants": dets, "initial_A_defect_dimension_at_identity": 8}) + return {"rank_R_U": 8, "rank_stacked_R_D": 16, "single_source_cases": rows, + "synthesized_vectors": len(old.U) * 8, + "u2_kernel_basis": [{str(p): str(c) for p, c in sorted(vector.items())} for vector in fixture], + "k_source_dimension_floor": {str(k): 8 if k == 0 else 9 - k for k in range(9)}}, fixture + + +def start(old, model, coefficients, omit_initial=False): + h = [{model.bases[p][0]: Q(coefficients[p])} if p in coefficients else {} for p in range(112)] + need(all(not any(model.query(s, h)) for s in range(1, 9)), "all nonzero-chart queries") + b0 = model.query(0, h) + need(any(old.at_identity(row) for row in b0), "nonzero B0 at identity") + cancel = model.inject(0, old.A, b0) + x, y = copy.deepcopy(h), [{} for _ in range(112)] + for p in old.A: + x[p] = {} if omit_initial else old.linear((-1, cancel[p])) + y[p] = old.linear((-1, x[p])) + initial = [str(old.at_identity(x[p])) for p in old.A] + x, y, f0 = model.forward(0, x, y) + need(not any(f0), "zero F0 history") + need(x == h and y == h, "post-F0 ordinary-only state") + return h, x, y, f0, initial + + +def interface(old, x, y, source, target, sign=-1): + x, y = copy.deepcopy(x), copy.deepcopy(y) + for a, t in zip(old.A, old.T): + x[t] = old.linear((1, x[t]), (1, x[a])) + y[t] = old.linear((1, y[t]), (-1, x[a])) + before = old.linear((1, x[target]), (1, y[target])) + value = x[source].copy() + x[target] = old.linear((1, x[target]), (1, value)) + y[target] = old.linear((1, y[target]), (sign, value)) + need(before == old.linear((1, x[target]), (1, y[target])), "paired selected sum") + return x, y + + +def run_tail(old, model, template, x, y, f0, omit_minus=False): + empty = lambda: [{} for _ in range(112)] + banks = [[x, y]] + [[empty(), empty()] for _ in range(3)] + histories, trajectory, completed = {0: f0}, [], [] + selected_cuts = [[fields[p] for fields in (x, y) for p in old.A + old.T if fields[p]]] + for event in template["recipe"][2:]: + if omit_minus and event == {"kind": "bridge", "src": 1, "dst": 0, "coefficient": -1}: + continue + kind = event["kind"] + if kind == "bridge": + src, dst, c = event["src"], event["dst"], event["coefficient"] + for p in old.U: + banks[dst][0][p] = old.linear((1, banks[dst][0][p]), (c, banks[src][0][p])) + banks[src][1][p] = old.linear((1, banks[src][1][p]), (-c, banks[dst][1][p])) + record = dict(event) + elif kind == "local": + pair, stage = event["pair"], event["stage"] + if event["reverse"]: + banks[pair] = list(model.backward(stage, stage + 1, *banks[pair])) + else: + bx, by, f = model.forward(stage, *banks[pair]) + banks[pair] = [bx, by] + histories[stage] = f + record = {"kind": "local", "stage": stage} + else: + need(kind == "terminal", "tail event alphabet") + completed = [row.copy() for bx, _ in banks for row in bx] + banks = [[by, [old.linear((-1, row)) for row in bx]] for bx, by in banks] + record = {"kind": "terminal"} + selected_cuts.append([fields[p] for pair in banks for fields in pair for p in old.A + old.T if fields[p]]) + trajectory.append((record, copy.deepcopy(banks))) + return banks, histories, completed, selected_cuts, trajectory + + +def invisible(old, model, template, previous, coefficients, source=2, target=21, + omit_minus=False, wrong_endpoint=False): + h, x, y, f0, initial = start(old, model, coefficients) + x, y = interface(old, x, y, source, target) + need(x == h and y == h, "tap must vanish on this witness") + x, y = model.backward(1, 2, x, y) + need(not any(x) and y == h, "exact B1 erasure") + banks, histories, completed, cuts, trace = run_tail(old, model, template, x, y, f0, omit_minus=omit_minus) + need(not any(cuts), "all selected cuts zero") + need(not any(completed), "completed-X descendants zero") + need(sorted(histories) == [0, 2, 4, 6, 8] and not any(row for q in histories.values() for row in q), + "all five histories zero") + need(banks[0][0] == h and not any(row for bx, by in banks[1:] for fields in (bx, by) for row in fields) + and not any(row for _, by in banks for row in by), "old-Y-typed final X0 only") + actual_trace = [] + for record, states in trace: + multipliers = [] + for pair in states: + for fields in pair: + c = next((c for c in (0, 1, -1) if all(fields[p] == old.linear((c, h[p])) for p in old.U)), None) + need(c is not None, "ordinary trajectory closure") + multipliers.append(c) + actual_trace.append(dict(record, ordinary=multipliers)) + need(actual_trace == previous["trajectory_after_B1"], "complete retained tail binding") + if wrong_endpoint: + need(not any(banks[0][0]), "old-Y endpoint is not completed-X") + return {"coefficients": {str(p): str(c) for p, c in sorted(coefficients.items())}, + "axes": {str(p): model.bases[p][0] for p in sorted(coefficients)}, + "B0_at_identity": [str(old.at_identity(r)) for r in model.query(0, h)], + "initial_X_A_at_identity": initial, "tap": [source, target], + "zero_selected_cuts": len(cuts), "zero_nonzero_chart_queries": 8, + "zero_forward_histories": 5, "tail": actual_trace} + + +def rejection(name, action, expected, records): + try: + action() + except ValueError as error: + need(expected in str(error), "wrong rejection for " + name + ": " + str(error)) + records.append(name) + else: + raise ValueError("negative control accepted: " + name) + + +def build_result(): + old, model, template, previous, inputs, phases, registry = load() + ranks, fixture = source_certificate(old, model) + witness = invisible(old, model, template, previous, NEW_WITNESS) + old_witness = invisible(old, model, template, previous, OLD_WITNESS, source=1) + need(set(NEW_WITNESS).isdisjoint(OLD_WITNESS), "disjoint witness supports") + coverage = [] + for source in old.U: + coeff = OLD_WITNESS if source not in OLD_WITNESS else NEW_WITNESS + h, x, y, _, _ = start(old, model, coeff) + for target in old.T: + tx, ty = interface(old, x, y, source, target) + need(tx == h and ty == h, "single-tap interface coverage") + coverage.append({"source": source, "witness": "old" if coeff is OLD_WITNESS else "new"}) + for coeff in fixture: + invisible(old, model, template, previous, coeff) + # An eight-port example: U2 plus the first seven odd basis ports. + # U2 was excluded in this family; the last odd column kills the other seven. + odd_basis = next(row["odd_basis"] for row in ranks["single_source_cases"] + if row["excluded_source"] == 2) + seven_coeff = {} + for j, vector in enumerate(fixture): + for p, c in vector.items(): + seven_coeff[p] = seven_coeff.get(p, Q(0)) + model.R[j][odd_basis[-1]] * c + seven_coeff = {p: c for p, c in seven_coeff.items() if c} + need(not set(odd_basis[:7]).intersection(seven_coeff), "seven zero source coordinates") + h7, x7, y7, _, _ = start(old, model, seven_coeff) + for source, target in zip([2] + odd_basis[:7], old.T): + x7, y7 = interface(old, x7, y7, source, target) + need(x7 == h7 and y7 == h7, "eight-tap interface remains invisible") + seven_witness = invisible(old, model, template, previous, seven_coeff, + source=odd_basis[0], target=old.T[0]) + # Positive control: the existing tap still repairs PR2093's old witness. + h, x, y, f0, _ = start(old, model, OLD_WITNESS) + tx, ty = interface(old, x, y, 2, 21) + bx, by = model.backward(1, 2, tx, ty) + banks, histories, completed, _, _ = run_tail(old, model, template, bx, by, f0) + need(banks[0][0][21] == {37: Q(11)}, "PR2268 positive tail control") + counts = {"selected": sum(bool(fields[p]) for pair in banks for fields in pair for p in old.A + old.T), + "history": sum(bool(r) for q in histories.values() for r in q), + "completed_X": sum(bool(r) for r in completed)} + need(counts == {"selected": 34, "history": 4, "completed_X": 65}, "PR2268 observation census") + controls = [] + rejection("wrong dependency coefficient", lambda: start(old, model, {1: 1, 16: 1, 88: -1}), + "all nonzero-chart queries", controls) + rejection("missing initial A cancellation", lambda: start(old, model, NEW_WITNESS, omit_initial=True), + "zero F0 history", controls) + rejection("tap reads a live witness port", lambda: invisible(old, model, template, previous, NEW_WITNESS, source=1), + "tap must vanish", controls) + rejection("wrong tap sign", lambda: interface(old, x, y, 2, 21, sign=1), "paired selected sum", controls) + rejection("missing negative bridge", lambda: invisible(old, model, template, previous, NEW_WITNESS, omit_minus=True), + "completed-X descendants zero", controls) + rejection("wrong final observation type", lambda: invisible(old, model, template, previous, NEW_WITNESS, wrong_endpoint=True), + "old-Y endpoint", controls) + rejection("old-chart B0 read detects the witness", lambda: need(not any(model.query(0, [ + {model.bases[p][0]: Q(NEW_WITNESS[p])} if p in NEW_WITNESS else {} for p in range(112)])), + "old-chart observation"), "old-chart observation", controls) + corrupted_phases = copy.deepcopy(phases) + corrupted_phases["recipes"][1]["idle_children"][0]["orthogonal_axes"][0] ^= 1 + rejection("changed chart axis", lambda: old.Model(model.R, corrupted_phases), "orthonormal chart", controls) + rejection("missing actual packet route", lambda: bind_routes(model, registry - {model.routes[1][1]}), + "actual route absent", controls) + corrupted_template = copy.deepcopy(template) + for event in corrupted_template["recipe"]: + if event.get("stage") == 2: + event["pair"] = 1 + rejection("wrong later pair binding", lambda: bind_template(corrupted_template), "recipe/hosted-call binding", controls) + rejection("duplicate parity-minor column", lambda: need(determinant(minor(model.R, [ + ranks["single_source_cases"][0]["even_basis"][0]] * 8)) != 0, "minor singular"), "minor singular", controls) + rejection("corrupt inherited source", lambda: authenticate(b"changed", REFERENCE_HASH, "reference"), "source hash", controls) + result = {"schema": "qq16-coordinate-tap-kernel-v1", "status": "PASS_QQ16_COORDINATE_TAP_KERNEL", + "inputs": inputs, "reference_sha256": REFERENCE_HASH, "rank_certificate": ranks, + "route_bindings": sum(len(stages) for stages in model.routes), + "new_witness": witness, "old_disjoint_witness": old_witness, + "single_source_coverage": coverage, "single_tap_cases": len(coverage) * len(old.T), + "eight_port_fixture": {"sources": [2] + odd_basis[:7], "witness": seven_witness}, + "u2_full_tail_basis_vectors": len(fixture), "positive_PR2268_counts": counts, + "positive_PR2268_final_X21": {"37": "11"}, "rejecting_controls": controls, + "scope": "Logical source-coordinate taps at F0/B1; no native tariff, full supplier or new kappa."} + mutated = copy.deepcopy(result) + mutated["single_tap_cases"] = True + rejection("receipt scalar-type corruption", lambda: need(canonical(mutated) == canonical(result), "receipt mismatch"), + "receipt mismatch", controls) + return result + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--emit-result", type=Path, help="create a receipt exclusively") + args = parser.parse_args() + result = build_result() + if args.emit_result: + with args.emit_result.open("x") as output: + output.write(json.dumps(result, sort_keys=True, indent=2) + "\n") + else: + need(canonical(json.loads((PACKAGE / "RESULT.json").read_text())) == canonical(result), "complete canonical receipt mismatch") + print("PASS_QQ16_COORDINATE_TAP_KERNEL single_taps=768 A_defect=8 ports<=8_excluded controls=13 no_new_kappa") + + +if __name__ == "__main__": + main()