From 0dfc4d2cd2461f5622402249143225be0a336237 Mon Sep 17 00:00:00 2001 From: Cinna Davis <1337isnot1337@users.noreply.github.com> Date: Wed, 14 Oct 2026 21:50:11 -0500 Subject: [PATCH 1/2] Research QQ16 ordinary-source tap witness repair --- .../NOTICE.md | 6 + .../README.md | 105 ++ .../RESULT.json | 898 ++++++++++++++++++ .../SOURCES.json | 90 ++ .../TASK.json | 108 +++ .../VERIFY.json | 27 + .../references/pr2093/SOURCES.json | 60 ++ .../references/pr2093/verify.py | 403 ++++++++ .../references/pr2216/NOTICE.md | 10 + .../references/pr2216/SOURCES.json | 114 +++ .../references/pr2216/verify.py | 291 ++++++ .../verify.py | 274 ++++++ .../verify_b1_tap.py | 296 ++++++ 13 files changed, 2682 insertions(+) create mode 100644 research/qq16-ordinary-source-tap-seed3794b3/NOTICE.md create mode 100644 research/qq16-ordinary-source-tap-seed3794b3/README.md create mode 100644 research/qq16-ordinary-source-tap-seed3794b3/RESULT.json create mode 100644 research/qq16-ordinary-source-tap-seed3794b3/SOURCES.json create mode 100644 research/qq16-ordinary-source-tap-seed3794b3/TASK.json create mode 100644 research/qq16-ordinary-source-tap-seed3794b3/VERIFY.json create mode 100644 research/qq16-ordinary-source-tap-seed3794b3/references/pr2093/SOURCES.json create mode 100644 research/qq16-ordinary-source-tap-seed3794b3/references/pr2093/verify.py create mode 100644 research/qq16-ordinary-source-tap-seed3794b3/references/pr2216/NOTICE.md create mode 100644 research/qq16-ordinary-source-tap-seed3794b3/references/pr2216/SOURCES.json create mode 100644 research/qq16-ordinary-source-tap-seed3794b3/references/pr2216/verify.py create mode 100644 research/qq16-ordinary-source-tap-seed3794b3/verify.py create mode 100644 research/qq16-ordinary-source-tap-seed3794b3/verify_b1_tap.py diff --git a/research/qq16-ordinary-source-tap-seed3794b3/NOTICE.md b/research/qq16-ordinary-source-tap-seed3794b3/NOTICE.md new file mode 100644 index 0000000000..b868a7a367 --- /dev/null +++ b/research/qq16-ordinary-source-tap-seed3794b3/NOTICE.md @@ -0,0 +1,6 @@ +Apache-2.0. This contribution retains predecessor attribution and pins exact source blobs in SOURCES.json. + +- `references/pr2093/verify.py` is copied unchanged from PR #2093 at commit `8b21a900eb520e4f11ea177b310f66316f8e8983`; its source header attributes the QQ16 hidden-witness replay and substantial Codex assistance. +- `references/pr2216/verify.py` is copied unchanged from PR #2216 at commit `b80e9ba43367fb8b20877a97da1cb677c34f9264`; its source header and accompanying `NOTICE.md` retain its original attribution and license. +- `verify_b1_tap.py` is an adaptation of the PR #2216 verifier with the stated U2-to-T21 tap and read-only receipt behavior. +- The QQ16 source maps, witness data and retained-tail inputs remain pinned to the scientific base listed in TASK.json and SOURCES.json. diff --git a/research/qq16-ordinary-source-tap-seed3794b3/README.md b/research/qq16-ordinary-source-tap-seed3794b3/README.md new file mode 100644 index 0000000000..c80a4320fe --- /dev/null +++ b/research/qq16-ordinary-source-tap-seed3794b3/README.md @@ -0,0 +1,105 @@ +# One ordinary-source tap repairs the QQ16 h witness + +**New local interface mechanism; no full controller or κ claim.** On the exact +three-port ordinary-source witness from [PR #2093](https://github.com/CrocSwap/integer-mult-bounds/pull/2093), keep the sum-preserving +`X_T += X_A; Y_T -= X_A` shear from [PR #2216](https://github.com/CrocSwap/integer-mult-bounds/pull/2216) and add one paired tap at the shared `completed(0)` frame: + +```text +X_21 <- X_21 + X_2 +Y_21 <- Y_21 - X_2 +``` + +This uses one already-live ordinary register (`U` port 2) and one existing +selected pair (`T` port 21). It adds no query, helper, recursive child or frame +transition. The paired operations preserve `X_21 + Y_21` and leave `X_2` +unchanged. + +## Exact result + +The pinned hidden witness is + +```text +h_p(d) = c_p bit_0(d b_(p,0)) +c_2 = -1, c_8 = 1, c_85 = 1; all other c_p = 0. +``` + +After F0 it is supported on ordinary ports 2, 8 and 85; all selected A/T +fields are zero. The existing A-to-T shear by itself still produces no selected +output through the retained tail. With the extra `U2 -> T21` tap, the exact +full-tail result contains 34 selected outputs, four forward-history values and +65 completed-X values. In final bank 0, component X, port 21 is exactly +`11 f_37`; at the identity owner its value is 11. This is a concrete selected +endpoint that distinguishes the witness from the zero input. + +The tap also preserves PR #2216's eight-direction B1 result: the pinned +post-B1 T-output family remains rank eight, with exact minor determinant +`-1/4096`. This check ends at B1; those eight directions have not been replayed +through the remaining tail here. + +The search uses the witness support to reduce the one-port/one-T-pair domain to +3 × 8 = 24 nontrivial taps. All 24 were visible at B1. The first tested tap, +`U2 -> T21`, survived the complete retained tail, so the search stopped there. +The other 23 full tails were not run. + +## Cost and scope + +The added tap costs exactly **2 scalar additions per owner**. Its coefficients +are `+1` and `-1`, so it adds no coefficient precision. By the triangle bound, +charge up to a factor of two in the two changed field envelopes (one extra +magnitude bit) at this local interface. The source is read in the common +`completed(0)` frame and is not changed. No dirty helper is introduced. + +This establishes one exact kernel-witness repair, not full injectivity. Global +precision, controller coverage, owner placement, restoration outside this +local state change, all-size admission and the complete recursive moment remain +open. The selected record and κ are unchanged. + +## Reproduce + +From the repository root: + +```sh +python3 -I -B research/qq16-ordinary-source-tap-seed3794b3/verify.py +python3 scripts/research_package.py --package research/qq16-ordinary-source-tap-seed3794b3 --check-only +``` + +The first command authenticates the selected archive and both pinned +predecessor verifiers, checks the no-tap and wrong-source controls, replays the +whole retained tail, compares the complete exact output receipt, and runs the +eight-direction B1 control. The package runner is registered for Python 3.12; +local direct checks use the available Python runtime and are reported +separately from hosted CI. + +## Provenance and coordination + +Scientific base: `0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2`; selected-record +SHA-256: `10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32`. +The exact predecessor heads and copied verifier hashes are in +[SOURCES.json](SOURCES.json). The selected QQ16 maps and witness are pinned +from the base commit; the two unmerged predecessor verifiers are retained under +`references/` for reproducible comparison. + +Cycle 30 seed: `3794b3df6e4fb4a017103a787d6f6b32`, track +`recursive-interfaces`, priority revision 4, task `joint-query-controller` +(refined). The live overlap refresh at 2026-10-15 02:18 UTC covered 482 open +PRs and 960 Discussion records with complete pagination and no warnings; the +exact one-port ordinary-source-tap terms had no direct match. The claim and +handoff are in [Discussion #2205](https://github.com/CrocSwap/integer-mult-bounds/discussions/2205#discussioncomment-18938845). + +## Open next questions + +- Does the one-bit local envelope fit the complete QQ16 precision and all-size + contracts? +- Do the eight PR #2216 directions remain visible through the retained tail + after the new tap? +- Can the full ordered kernel be made injective with this and other priced + existing-field changes? + +## Credit + +PR #1969 supplies the retained QQ16 maps and local words. PR #2093 supplies the +three-port hidden h witness and its exact tail. PR #2216 supplies the existing +A-to-T shear and eight-direction B1 certificate. PR #2079 supplies the earlier +ordinary-source observation context. New mechanism, integration and replay: +Cinna Davis with substantial OpenAI Codex assistance. No independent human +review is claimed. Apache-2.0. diff --git a/research/qq16-ordinary-source-tap-seed3794b3/RESULT.json b/research/qq16-ordinary-source-tap-seed3794b3/RESULT.json new file mode 100644 index 0000000000..c43ee1e66b --- /dev/null +++ b/research/qq16-ordinary-source-tap-seed3794b3/RESULT.json @@ -0,0 +1,898 @@ +{ + "base_commit": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2", + "existing_eight_direction_control": { + "minor_determinant": "-1/4096", + "post_B1_T_rank": 8, + "status": "PASS_QQ16_F0_B1_IDENTITY_SHEAR_WITNESS" + }, + "external_references": { + "references/pr2093/SOURCES.json": { + "commit": "8b21a900eb520e4f11ea177b310f66316f8e8983", + "git_blob": "50d83b201a2488645493c7efe9e3e48b4587a081", + "path": "references/pr2093/SOURCES.json", + "pr": 2093, + "sha256": "39b3c78d7d96725cc9e74febf2950b735aeea427ae2bd9b0163100c92421de0b" + }, + "references/pr2093/verify.py": { + "commit": "8b21a900eb520e4f11ea177b310f66316f8e8983", + "git_blob": "bc07d47ddf9999986d93e1bbbf9ff259e0296605", + "path": "references/pr2093/verify.py", + "pr": 2093, + "sha256": "1009fc5dc4843051d6d8e40edfbf1f5254b024623b5e8f73f10a4cfd756df15c" + }, + "references/pr2216/SOURCES.json": { + "commit": "b80e9ba43367fb8b20877a97da1cb677c34f9264", + "git_blob": "79cb7e9b2fb97ce827356f44d4bcc21fff3dcc34", + "path": "references/pr2216/SOURCES.json", + "pr": 2216, + "sha256": "2477692eb67873ca342242283e9a77b49c2dc662899edf5202cac1725bd11d5f" + }, + "references/pr2216/verify.py": { + "commit": "b80e9ba43367fb8b20877a97da1cb677c34f9264", + "git_blob": "c4f60ff948f23a51b964588e7f77c93adbb1430a", + "path": "references/pr2216/verify.py", + "pr": 2216, + "sha256": "e78e2444b2c755bf0d1d5e800e9f146f5bb3a330e62d9a22431d39d151906ad8" + } + }, + "limits": [ + "This disables one exact kernel witness; it does not prove full controller injectivity.", + "The PR2216 eight-direction family is rechecked only at B1, not through the tail.", + "The one-bit payload envelope is a local triangle bound; global precision, hosting, and supplier admission remain open.", + "No supplier, selected exponent, or kappa improvement is claimed." + ], + "mechanism": { + "added_helpers": 0, + "added_recursive_children": 0, + "added_scalar_additions_per_owner": 2, + "added_tap": "X_21 += X_2; Y_21 -= X_2", + "changed_pair_magnitude_envelope": "at most 2x by the triangle bound (one extra magnitude bit charged)", + "coefficient_precision": "unchanged; tap coefficients are +1 and -1", + "common_frame": "completed(0), verified identity map on all 112 fields", + "existing_shear": "X_T += X_A; Y_T -= X_A", + "selected_sum_preserved": true + }, + "negative_controls": { + "A_to_T_shear_only_full_tail_observations": 0, + "off_support_U1_tap_full_tail_observations": 0, + "wrong_sign_breaks_selected_sum": true + }, + "retained_tail": { + "at_identity": "11", + "complete_observations": [ + { + "bank": 0, + "component": "X", + "kind": "selected", + "map": { + "37": "5" + }, + "port": 20 + }, + { + "bank": 0, + "component": "X", + "kind": "selected", + "map": { + "181": "5" + }, + "port": 36 + }, + { + "bank": 0, + "component": "X", + "kind": "selected", + "map": { + "171": "-5" + }, + "port": 46 + }, + { + "bank": 0, + "component": "X", + "kind": "selected", + "map": { + "217": "5" + }, + "port": 111 + }, + { + "bank": 0, + "component": "X", + "kind": "selected", + "map": { + "37": "11" + }, + "port": 21 + }, + { + "bank": 0, + "component": "Y", + "kind": "selected", + "map": { + "37": "5" + }, + "port": 20 + }, + { + "bank": 0, + "component": "Y", + "kind": "selected", + "map": { + "181": "5" + }, + "port": 36 + }, + { + "bank": 0, + "component": "Y", + "kind": "selected", + "map": { + "171": "-5" + }, + "port": 46 + }, + { + "bank": 0, + "component": "Y", + "kind": "selected", + "map": { + "217": "5" + }, + "port": 111 + }, + { + "bank": 0, + "component": "Y", + "kind": "selected", + "map": { + "37": "11" + }, + "port": 21 + }, + { + "bank": 1, + "component": "X", + "kind": "selected", + "map": { + "37": "-132" + }, + "port": 20 + }, + { + "bank": 1, + "component": "X", + "kind": "selected", + "map": { + "181": "-132" + }, + "port": 36 + }, + { + "bank": 1, + "component": "X", + "kind": "selected", + "map": { + "171": "132" + }, + "port": 46 + }, + { + "bank": 1, + "component": "X", + "kind": "selected", + "map": { + "217": "-132" + }, + "port": 111 + }, + { + "bank": 1, + "component": "Y", + "kind": "selected", + "map": { + "37": "-132" + }, + "port": 20 + }, + { + "bank": 1, + "component": "Y", + "kind": "selected", + "map": { + "181": "-132" + }, + "port": 36 + }, + { + "bank": 1, + "component": "Y", + "kind": "selected", + "map": { + "171": "132" + }, + "port": 46 + }, + { + "bank": 1, + "component": "Y", + "kind": "selected", + "map": { + "217": "-132" + }, + "port": 111 + }, + { + "bank": 2, + "component": "X", + "kind": "selected", + "map": { + "37": "132" + }, + "port": 20 + }, + { + "bank": 2, + "component": "X", + "kind": "selected", + "map": { + "181": "132" + }, + "port": 36 + }, + { + "bank": 2, + "component": "X", + "kind": "selected", + "map": { + "171": "-132" + }, + "port": 46 + }, + { + "bank": 2, + "component": "X", + "kind": "selected", + "map": { + "217": "132" + }, + "port": 111 + }, + { + "bank": 2, + "component": "Y", + "kind": "selected", + "map": { + "37": "132" + }, + "port": 20 + }, + { + "bank": 2, + "component": "Y", + "kind": "selected", + "map": { + "181": "132" + }, + "port": 36 + }, + { + "bank": 2, + "component": "Y", + "kind": "selected", + "map": { + "171": "-132" + }, + "port": 46 + }, + { + "bank": 2, + "component": "Y", + "kind": "selected", + "map": { + "217": "132" + }, + "port": 111 + }, + { + "bank": 3, + "component": "X", + "kind": "selected", + "map": { + "37": "-132" + }, + "port": 20 + }, + { + "bank": 3, + "component": "X", + "kind": "selected", + "map": { + "181": "-132" + }, + "port": 36 + }, + { + "bank": 3, + "component": "X", + "kind": "selected", + "map": { + "171": "132" + }, + "port": 46 + }, + { + "bank": 3, + "component": "X", + "kind": "selected", + "map": { + "217": "-132" + }, + "port": 111 + }, + { + "bank": 3, + "component": "Y", + "kind": "selected", + "map": { + "37": "-132" + }, + "port": 20 + }, + { + "bank": 3, + "component": "Y", + "kind": "selected", + "map": { + "181": "-132" + }, + "port": 36 + }, + { + "bank": 3, + "component": "Y", + "kind": "selected", + "map": { + "171": "132" + }, + "port": 46 + }, + { + "bank": 3, + "component": "Y", + "kind": "selected", + "map": { + "217": "-132" + }, + "port": 111 + }, + { + "index": 4, + "kind": "history", + "map": { + "2490368": "-11" + }, + "stage": 2 + }, + { + "index": 5, + "kind": "history", + "map": { + "2490368": "-11" + }, + "stage": 2 + }, + { + "index": 6, + "kind": "history", + "map": { + "2490368": "-11" + }, + "stage": 2 + }, + { + "index": 7, + "kind": "history", + "map": { + "2490368": "11" + }, + "stage": 2 + }, + { + "index": 2, + "kind": "completed-X", + "map": { + "4": "11/2" + } + }, + { + "index": 5, + "kind": "completed-X", + "map": { + "35": "11/2" + } + }, + { + "index": 8, + "kind": "completed-X", + "map": { + "2": "11/2" + } + }, + { + "index": 11, + "kind": "completed-X", + "map": { + "37": "-11/2" + } + }, + { + "index": 12, + "kind": "completed-X", + "map": { + "37": "11/2" + } + }, + { + "index": 15, + "kind": "completed-X", + "map": { + "302": "11/2" + } + }, + { + "index": 16, + "kind": "completed-X", + "map": { + "37": "11/2" + } + }, + { + "index": 19, + "kind": "completed-X", + "map": { + "310": "-11/2" + } + }, + { + "index": 20, + "kind": "completed-X", + "map": { + "37": "-5" + } + }, + { + "index": 21, + "kind": "completed-X", + "map": { + "37": "-11" + } + }, + { + "index": 23, + "kind": "completed-X", + "map": { + "358": "-11/2" + } + }, + { + "index": 24, + "kind": "completed-X", + "map": { + "422": "-11/2" + } + }, + { + "index": 25, + "kind": "completed-X", + "map": { + "38": "-11/2" + } + }, + { + "index": 26, + "kind": "completed-X", + "map": { + "38": "-11/2" + } + }, + { + "index": 28, + "kind": "completed-X", + "map": { + "38": "-11/2" + } + }, + { + "index": 29, + "kind": "completed-X", + "map": { + "38": "-11/2" + } + }, + { + "index": 31, + "kind": "completed-X", + "map": { + "61": "-11/2" + } + }, + { + "index": 32, + "kind": "completed-X", + "map": { + "109": "-11/2" + } + }, + { + "index": 33, + "kind": "completed-X", + "map": { + "173": "-11/2" + } + }, + { + "index": 36, + "kind": "completed-X", + "map": { + "181": "-5" + } + }, + { + "index": 40, + "kind": "completed-X", + "map": { + "38": "11/2" + } + }, + { + "index": 41, + "kind": "completed-X", + "map": { + "229": "11/2" + } + }, + { + "index": 44, + "kind": "completed-X", + "map": { + "59": "-11/2" + } + }, + { + "index": 46, + "kind": "completed-X", + "map": { + "171": "5" + } + }, + { + "index": 48, + "kind": "completed-X", + "map": { + "115": "11/2" + } + }, + { + "index": 49, + "kind": "completed-X", + "map": { + "179": "11/2" + } + }, + { + "index": 53, + "kind": "completed-X", + "map": { + "38": "-11/2" + } + }, + { + "index": 54, + "kind": "completed-X", + "map": { + "227": "11/2" + } + }, + { + "index": 58, + "kind": "completed-X", + "map": { + "38": "11/2" + } + }, + { + "index": 59, + "kind": "completed-X", + "map": { + "38": "11/2" + } + }, + { + "index": 63, + "kind": "completed-X", + "map": { + "271": "11/2" + } + }, + { + "index": 64, + "kind": "completed-X", + "map": { + "38": "11/2" + } + }, + { + "index": 69, + "kind": "completed-X", + "map": { + "279": "-11/2" + } + }, + { + "index": 70, + "kind": "completed-X", + "map": { + "38": "11/2" + } + }, + { + "index": 74, + "kind": "completed-X", + "map": { + "327": "-11/2" + } + }, + { + "index": 75, + "kind": "completed-X", + "map": { + "391": "-11/2" + } + }, + { + "index": 77, + "kind": "completed-X", + "map": { + "38": "-11/2" + } + }, + { + "index": 78, + "kind": "completed-X", + "map": { + "38": "11/2" + } + }, + { + "index": 79, + "kind": "completed-X", + "map": { + "465": "-11/2" + } + }, + { + "index": 80, + "kind": "completed-X", + "map": { + "457": "11/2" + } + }, + { + "index": 82, + "kind": "completed-X", + "map": { + "409": "11/2" + } + }, + { + "index": 83, + "kind": "completed-X", + "map": { + "345": "11/2" + } + }, + { + "index": 88, + "kind": "completed-X", + "map": { + "37": "-11/2" + } + }, + { + "index": 91, + "kind": "completed-X", + "map": { + "218": "-11/2" + } + }, + { + "index": 94, + "kind": "completed-X", + "map": { + "35": "11/2" + } + }, + { + "index": 97, + "kind": "completed-X", + "map": { + "220": "-11/2" + } + }, + { + "index": 99, + "kind": "completed-X", + "map": { + "38": "-11/2" + } + }, + { + "index": 102, + "kind": "completed-X", + "map": { + "217": "-11/2" + } + }, + { + "index": 103, + "kind": "completed-X", + "map": { + "38": "11/2" + } + }, + { + "index": 106, + "kind": "completed-X", + "map": { + "217": "-11/2" + } + }, + { + "index": 107, + "kind": "completed-X", + "map": { + "440": "11/2" + } + }, + { + "index": 108, + "kind": "completed-X", + "map": { + "376": "11/2" + } + }, + { + "index": 111, + "kind": "completed-X", + "map": { + "217": "-5" + } + }, + { + "index": 132, + "kind": "completed-X", + "map": { + "37": "132" + } + }, + { + "index": 148, + "kind": "completed-X", + "map": { + "181": "132" + } + }, + { + "index": 158, + "kind": "completed-X", + "map": { + "171": "-132" + } + }, + { + "index": 223, + "kind": "completed-X", + "map": { + "217": "132" + } + }, + { + "index": 244, + "kind": "completed-X", + "map": { + "37": "-132" + } + }, + { + "index": 260, + "kind": "completed-X", + "map": { + "181": "-132" + } + }, + { + "index": 270, + "kind": "completed-X", + "map": { + "171": "132" + } + }, + { + "index": 335, + "kind": "completed-X", + "map": { + "217": "-132" + } + }, + { + "index": 356, + "kind": "completed-X", + "map": { + "37": "132" + } + }, + { + "index": 372, + "kind": "completed-X", + "map": { + "181": "132" + } + }, + { + "index": 382, + "kind": "completed-X", + "map": { + "171": "-132" + } + }, + { + "index": 447, + "kind": "completed-X", + "map": { + "217": "132" + } + } + ], + "exact_final_witness_output": { + "bank": 0, + "component": "X", + "kind": "selected", + "map": { + "37": "11" + }, + "port": 21 + }, + "observable_rows": { + "completed-X": 65, + "history": 4, + "selected": 34 + } + }, + "scope": "The exact PR2093 ordinary-source h witness, with the PR2216 A-to-T shear retained and one paired U2-to-T21 tap, through the full retained QQ16 tail.", + "status": "PASS_QQ16_ORDINARY_SOURCE_TAP", + "witness": { + "coefficients": { + "2": -1, + "8": 1, + "85": 1 + }, + "definition": "h_p(d)=c_p bit_0(d b_(p,0))", + "post_F0_active_U_ports": [ + 2, + 8, + 85 + ], + "pre_F0_B2_and_B1_zero": true, + "required_initial_A_at_identity": [ + "1/2", + "0", + "1/2", + "1/2", + "0", + "-1/2", + "0", + "0" + ] + } +} diff --git a/research/qq16-ordinary-source-tap-seed3794b3/SOURCES.json b/research/qq16-ordinary-source-tap-seed3794b3/SOURCES.json new file mode 100644 index 0000000000..87279929be --- /dev/null +++ b/research/qq16-ordinary-source-tap-seed3794b3/SOURCES.json @@ -0,0 +1,90 @@ +{ + "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/BRIDGE-REVIEW.md", + "usage": "input", + "git_blob": "86139908c418235588045324f0873de6ac9f9707", + "sha256": "d01b5f4959f7c91f835496d050dfae3eeab9dee2f581571c316a42571eaa1cd3" + }, + { + "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" + }, + { + "path": "research/joint-query/evidence/QQ16-SELECTED-WITNESS.md", + "usage": "input", + "git_blob": "307650f45e37c28d14fe913958efa4fb429242b7", + "sha256": "52f2ee565320f05282c637aa79eee100606c24240b1b5866f0c8d62e7913c9fc" + } + ], + "external_references": [ + { + "path": "references/pr2093/verify.py", + "pr": 2093, + "commit": "8b21a900eb520e4f11ea177b310f66316f8e8983", + "git_blob": "bc07d47ddf9999986d93e1bbbf9ff259e0296605", + "sha256": "1009fc5dc4843051d6d8e40edfbf1f5254b024623b5e8f73f10a4cfd756df15c" + }, + { + "path": "references/pr2093/SOURCES.json", + "pr": 2093, + "commit": "8b21a900eb520e4f11ea177b310f66316f8e8983", + "git_blob": "50d83b201a2488645493c7efe9e3e48b4587a081", + "sha256": "39b3c78d7d96725cc9e74febf2950b735aeea427ae2bd9b0163100c92421de0b" + }, + { + "path": "references/pr2216/verify.py", + "pr": 2216, + "commit": "b80e9ba43367fb8b20877a97da1cb677c34f9264", + "git_blob": "c4f60ff948f23a51b964588e7f77c93adbb1430a", + "sha256": "e78e2444b2c755bf0d1d5e800e9f146f5bb3a330e62d9a22431d39d151906ad8" + }, + { + "path": "references/pr2216/SOURCES.json", + "pr": 2216, + "commit": "b80e9ba43367fb8b20877a97da1cb677c34f9264", + "git_blob": "79cb7e9b2fb97ce827356f44d4bcc21fff3dcc34", + "sha256": "2477692eb67873ca342242283e9a77b49c2dc662899edf5202cac1725bd11d5f" + } + ] +} diff --git a/research/qq16-ordinary-source-tap-seed3794b3/TASK.json b/research/qq16-ordinary-source-tap-seed3794b3/TASK.json new file mode 100644 index 0000000000..8dee3a245d --- /dev/null +++ b/research/qq16-ordinary-source-tap-seed3794b3/TASK.json @@ -0,0 +1,108 @@ +{ + "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": "On the exact PR2093 ordinary-source h witness, retain the PR2216 A-to-T shear and add one common-frame, sum-preserving tap X_21 += X_2; Y_21 -= X_2. Replay through the complete retained QQ16 tail and verify the eight PR2216 directions remain rank eight at the B1 cut.", + "scope_change_reason": "The generic QQ16 fixed-pair and centre/coverage alternatives have direct overlap. This is a distinct, single-port state change that reuses an already-live ordinary field, combines the PR2093 hidden h trajectory with PR2216 state shear, and adds no observation or recursive child. It tests a new interface mechanism rather than rechecking either predecessor witness.", + "bottleneck_link": "PR2093 exhibits a nonzero ordinary-source input whose selected state and all retained observations vanish under the unchanged F0/B1 path. This tap exposes that exact input in selected outputs through the retained tail, while keeping the prior eight-direction B1 rank result.", + "budget_minutes": 60, + "stop_rule": "The exact h support is only U ports 2, 8, and 85. Screen its 3 x 8 one-source/one-T-pair taps at B1; stop on the first tap that survives the complete retained tail. Do not expand to multi-port taps or claim full-controller injectivity. Stop immediately if a new recursive child or frame transition is required.", + "outcome": "completed", + "evidence": "RESULT.json and verify.py reproduce the exact full-tail endpoint; verify_b1_tap.py preserves the PR2216 eight-direction B1 rank result. Scope, cost, sources and limitations are in README.md.", + "author": "Cinna Davis with substantial OpenAI Codex assistance", + "ai_assistance": "Substantial OpenAI Codex assistance in task selection, exact model implementation, source-pinned replay, cost accounting and packaging. No independent human review is claimed.", + "open_questions": [ + { + "question": "Does the one-bit local payload envelope fit the full QQ16 recursive precision and all-size contracts?", + "why_it_matters": "The exact finite tap is not a supplier admission without a proved precision budget for every child prefix.", + "first_step": "Bind the tap into the full native prefix ledger and compare its positive bounds at every affected stage.", + "blocked_by": "No global owner map, full recursive child precision model or all-size controller is supplied." + }, + { + "question": "Do the eight PR2216 directions remain visible through the ordinary tail after this tap?", + "why_it_matters": "Only their B1 rank-eight result is checked here; a full controller needs endpoint visibility for the whole witness family.", + "first_step": "Propagate the eight exact group-algebra columns through the retained schedule with the tap.", + "blocked_by": "The current contribution deliberately stops after the h witness succeeds and a B1 control passes." + }, + { + "question": "Can this local mechanism be integrated with a complete controller that handles all source inputs?", + "why_it_matters": "One witness repair does not establish global injectivity or a new exponent.", + "first_step": "Derive the full ordered kernel after the changed interface and price all observations, cover maps and restoration.", + "blocked_by": "No complete controller is constructed." + } + ], + "track": "recursive-interfaces", + "seed": "3794b3df6e4fb4a017103a787d6f6b32", + "catalog_sha256": "d46eb6d5b3e279428753d770653663fbdf1063e55c255ea073d768f344927ef7", + "selected_record_sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32", + "selector_key": "0e34adbc1dd119161c3a", + "claim_url": "https://github.com/CrocSwap/integer-mult-bounds/discussions/2205#discussioncomment-18938845", + "claim_expiry_utc": "2026-10-15T04:19:00Z", + "overlap_snapshot": { + "checked_at_utc": "2026-10-15T02:49:15Z", + "open_prs": 490, + "discussion_records": 975, + "complete_pagination": true, + "warnings": [], + "exact_terms": [ + "ordinary-source tap", + "U2-to-T21" + ], + "matches": 0, + "relevant_open_heads": { + "PR2093": "8b21a900eb520e4f11ea177b310f66316f8e8983", + "PR2216": "b80e9ba43367fb8b20877a97da1cb677c34f9264", + "PR2079": "49df8190b158e3028e702b2c6b798117006f7249" + }, + "distinction": "PR2216 remains open; this result adds a common-frame ordinary U2-to-T21 paired tap and carries PR2093 h through the full tail, while the related PR2216 result concerns its A-to-T shear and eight directions only through B1." + }, + "predecessor_heads": { + "PR2093": "8b21a900eb520e4f11ea177b310f66316f8e8983", + "PR2216": "b80e9ba43367fb8b20877a97da1cb677c34f9264", + "PR2079": "49df8190b158e3028e702b2c6b798117006f7249" + } +} diff --git a/research/qq16-ordinary-source-tap-seed3794b3/VERIFY.json b/research/qq16-ordinary-source-tap-seed3794b3/VERIFY.json new file mode 100644 index 0000000000..926b016a0f --- /dev/null +++ b/research/qq16-ordinary-source-tap-seed3794b3/VERIFY.json @@ -0,0 +1,27 @@ +{ + "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/BRIDGE-REVIEW.md", + "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", + "research/joint-query/evidence/QQ16-SELECTED-WITNESS.md" + ], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 300, + "checks": "Authenticates selected inputs and both predecessor references; verifies the hidden no-tap control; applies the sum-preserving U2-to-T21 tap; replays the entire tail and exact output receipt; checks wrong-source and wrong-sign controls; runs the retained eight-direction B1 witness verifier." + } + ] +} diff --git a/research/qq16-ordinary-source-tap-seed3794b3/references/pr2093/SOURCES.json b/research/qq16-ordinary-source-tap-seed3794b3/references/pr2093/SOURCES.json new file mode 100644 index 0000000000..50d83b201a --- /dev/null +++ b/research/qq16-ordinary-source-tap-seed3794b3/references/pr2093/SOURCES.json @@ -0,0 +1,60 @@ +{ + "schema_version": 1, + "base_commit": "564148b82ae9df72163f22106f15e73efca8aff2", + "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.md", + "usage": "input", + "git_blob": "307650f45e37c28d14fe913958efa4fb429242b7", + "sha256": "52f2ee565320f05282c637aa79eee100606c24240b1b5866f0c8d62e7913c9fc" + }, + { + "path": "research/joint-query/evidence/QQ16-SELECTED-WITNESS.json", + "usage": "input", + "git_blob": "5082d791d0b993492cbc5bf61ac3b69e82c96f3f", + "sha256": "e35e5868a1322e406191079c0675975b139692ba50b1e2e5fb8a40b6480519f4" + }, + { + "path": "research/joint-query/evidence/BRIDGE-REVIEW.md", + "usage": "input", + "git_blob": "86139908c418235588045324f0873de6ac9f9707", + "sha256": "d01b5f4959f7c91f835496d050dfae3eeab9dee2f581571c316a42571eaa1cd3" + } + ] +} diff --git a/research/qq16-ordinary-source-tap-seed3794b3/references/pr2093/verify.py b/research/qq16-ordinary-source-tap-seed3794b3/references/pr2093/verify.py new file mode 100644 index 0000000000..bc07d47ddf --- /dev/null +++ b/research/qq16-ordinary-source-tap-seed3794b3/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-ordinary-source-tap-seed3794b3/references/pr2216/NOTICE.md b/research/qq16-ordinary-source-tap-seed3794b3/references/pr2216/NOTICE.md new file mode 100644 index 0000000000..c9c4692de9 --- /dev/null +++ b/research/qq16-ordinary-source-tap-seed3794b3/references/pr2216/NOTICE.md @@ -0,0 +1,10 @@ +New work in this package is released under Apache-2.0. + +Predecessor credit: Ali Romman and the retained joint-query lineage supply +the QQ16 maps, ordered local words, route model, and erased-input witness +(merged PR #1969). Cinna Davis's PR #2079 and Adam Gall's PR #2093 study +additional ordinary observations. PR #2086 studies changed A logging while +leaving the T output fixed. Their code and frozen sources are not modified. + +Substantial AI assistance: OpenAI Codex derived, implemented, checked, and +wrote this scoped result. No independent human review is claimed. diff --git a/research/qq16-ordinary-source-tap-seed3794b3/references/pr2216/SOURCES.json b/research/qq16-ordinary-source-tap-seed3794b3/references/pr2216/SOURCES.json new file mode 100644 index 0000000000..79cb7e9b2f --- /dev/null +++ b/research/qq16-ordinary-source-tap-seed3794b3/references/pr2216/SOURCES.json @@ -0,0 +1,114 @@ +{ + "base_commit": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2", + "files": [ + { + "git_blob": "e8870e5917057d59b730eb14721a778639eca050", + "path": "docs/research/agent-task-catalog.json", + "sha256": "d46eb6d5b3e279428753d770653663fbdf1063e55c255ea073d768f344927ef7", + "usage": "input" + }, + { + "git_blob": "ae6a99f28aa468649eb66a361e764d769363bf11", + "path": "certificates/selected-result.json", + "sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32", + "usage": "input" + }, + { + "git_blob": "3e66629292d42f592a0d73a4a42f7f3a02bd62a5", + "path": "research/joint-query/SOURCES.json", + "sha256": "fabc6686e5d3ac0e4bb4397c147037b9285abfa671614590dad6d4e16b4dc0fc", + "usage": "input" + }, + { + "git_blob": "c6e876d8b48d768214deee265ade428f8983b566", + "path": "research/joint-query/certificate.json.gz", + "sha256": "a5ed85fac5ebf3c091482a113ab0d351eb5a7892fe2841a35e16017ec1ff49f7", + "usage": "input" + }, + { + "git_blob": "c9d465ed47500304bef65fcb588befe356c5cf09", + "path": "research/joint-query/source_data.py", + "sha256": "d23924511e3aed41e5e64511ca70126a636d91c8aa02e656cb61d6ceca1fe0a0", + "usage": "input" + }, + { + "git_blob": "ede9e7e42744dd0c96790516a9acdfe07d180018", + "path": "research/joint-query/verify_native.py", + "sha256": "1c58e7b6e8e1cde4df455c2129601c145ed763fc63a3ab427eb1058d1fc08bd2", + "usage": "input" + }, + { + "git_blob": "e85527fed48be411a132fa44d93f5d1632fe7a91", + "path": "research/joint-query/verify_ordered.py", + "sha256": "0e23ed4bef58ed8375a9d43b0b9cbcab8e825ec7d5d702e74973ccc41d97ffa6", + "usage": "input" + }, + { + "git_blob": "4639583c1be02c2fb60ed8a8072c9969ef1569ce", + "path": "research/joint-query/evidence/CONSERVED-QQ16.md", + "sha256": "60f0de3a7205ba5046b5ae7ffa8bf2b1ea42ea46b498face0a77966b59e7f3fb", + "usage": "provenance" + }, + { + "git_blob": "525b38dbdefed0e8192a9c5165e802136cc05034", + "path": "research/joint-query/evidence/NATIVE-REVIEW.md", + "sha256": "2247e3cbe73f3f0da55c647ffae15f98dd9445b2366ba9e255b9bebc9f742b70", + "usage": "provenance" + }, + { + "git_blob": "67699da21b75c3de89fbb3a96daa4719febb555b", + "path": "research/joint-query/evidence/NATIVE-CHECKS.json", + "sha256": "fe959be0bf2490f99efcf6b8109b19cc8d79036d9df54b59598f32de92295054", + "usage": "provenance" + }, + { + "git_blob": "307650f45e37c28d14fe913958efa4fb429242b7", + "path": "research/joint-query/evidence/QQ16-SELECTED-WITNESS.md", + "sha256": "52f2ee565320f05282c637aa79eee100606c24240b1b5866f0c8d62e7913c9fc", + "usage": "provenance" + }, + { + "git_blob": "5082d791d0b993492cbc5bf61ac3b69e82c96f3f", + "path": "research/joint-query/evidence/QQ16-SELECTED-WITNESS.json", + "sha256": "e35e5868a1322e406191079c0675975b139692ba50b1e2e5fb8a40b6480519f4", + "usage": "provenance" + }, + { + "git_blob": "c6ecf75654a084a9cc001bd62663f341976bae7a", + "path": "research/joint-query/evidence/QQ16-RATIONAL-OBSERVATION-REVIEW.md", + "sha256": "9a06ff40830ef80d3566fce77c78639cb64d519d487a0a7f57d543c3146e2c49", + "usage": "provenance" + }, + { + "git_blob": "e649641e9b44af2fff9742df51d439890c1a19cc", + "path": "research/joint-query/evidence/QQ16-RATIONAL-OBSERVATION-REVIEW.json", + "sha256": "588a3ce4593576ae921e97c6ced6a050f88736f29708cfee117385b254cd358f", + "usage": "provenance" + } + ], + "schema_version": 1, + "selected_record_sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32", + "transitive_source_manifest": { + "archive_path": "research/community-frontier1042-audit/selected-replay.tar.gz", + "archive_sha256": "22c3f4dce4b897a1d423d1388801933e288b6a6b1906cb15e1b16a5eb68db754", + "base": "bce54fb3f895cbe5cd4c0eb477c3afeed100190f", + "credit_sources": { + "LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "research/gauge44-slots-t16/NOTICE.md": "7a8d17b04da1e6c9d0ec217fb5bda72faa09d9a21695128722dd1e2827870fcf", + "research/gauge44-slots-t16/UPSTREAM-NOTICE.md": "a75967ebc34e3bf2ff2c25c08e6c7f1a61b0c0d171cfd1b62196ae2caaf2c610", + "research/gauge44-slots-t16/construction/NOTICE.md": "defe7e44af610e25a6c50c1c3b2efd0972d0690574995c0c872fc50eebf4c816", + "research/gauge44-slots-t16/t16/NOTICE.md": "902370e6bfcd39dbea2ece474f15fccbcce3b8e966b2b94066bd03e5174591b5" + }, + "decompressed_payloads": { + "CANONICAL-WORD.json.gz": "4ddb29fb9bc6f27e0c0fbfcf19a2a93a3496ad900d0f6d89059d0305c9576c0c", + "LOCAL-PROGRAMS.json.gz": "9f41d53659e9be84e20c661560c5687abbf5cd0660cdecbe01ad5eb29e6b8ee3" + }, + "members": { + "slots/local/CANONICAL-WORD.json.gz": "16bc0ebb04b4be6c0ade74badc6a0c0cdba4215eda86e4ff9f13abf8ecebd219", + "slots/local/CLIFFORD-RECIPES.json": "d0768f2164d5f64a2fdbec422f1cfde4e400818792f1904ca541958377243731", + "slots/local/LOCAL-PROGRAMS.json.gz": "241fde27d4e43f5a9cb6b128f9f76c5131a53d09f0371676163f914d0b0fef3a", + "slots/local/RESIDUAL-ADAPTERS.json": "383f40aadd00a4ac700dfd0d4c22d6c6c0be9a9863116e4d69c7acd23bafae0c", + "t16/global/base/work/complex-nine-native/DATA-PHASES.json": "c5916ff312678f12aba403847643fbbc29f643acec60bdf836fa56cd3e8251fa" + } + } +} diff --git a/research/qq16-ordinary-source-tap-seed3794b3/references/pr2216/verify.py b/research/qq16-ordinary-source-tap-seed3794b3/references/pr2216/verify.py new file mode 100644 index 0000000000..c4f60ff948 --- /dev/null +++ b/research/qq16-ordinary-source-tap-seed3794b3/references/pr2216/verify.py @@ -0,0 +1,291 @@ +"""Exploratory exact group-algebra probe for the QQ16 A/T shear.""" +from __future__ import annotations + +from fractions import Fraction as F +from functools import lru_cache +from pathlib import Path +import json +import sys + + +ROOT = Path(__file__).resolve().parents[2] +sys.path.insert(0, str(ROOT / "research/joint-query")) +import source_data # noqa: E402 +import verify_native # noqa: E402 + +A = [0, 7, 20, 27, 36, 46, 57, 111] +T = [21, 37, 47, 76, 81, 87, 92, 110] +U = [p for p in range(112) if p not in A + T] +AXES = tuple(1 << i for i in range(73)) +ID = AXES + + +def need(ok, message): + if not ok: + raise AssertionError(message) + + +def add(x, y, scale=F(1)): + out = x.copy() + for g, c in y.items(): + v = out.get(g, F(0)) + scale * c + if v: + out[g] = v + else: + out.pop(g, None) + return out + + +def scaled(x, c): + return {g: c * v for g, v in x.items() if c * v} + + +@lru_cache(None) +def gm(g, h): + return verify_native.product((g, 0), (h, 0))[0] + + +@lru_cache(None) +def gi(g): + return verify_native.inverse((g, 0))[0] + + +def left(g, x): + out = {} + for h, c in x.items(): + gh = gm(g, h) + out[gh] = out.get(gh, F(0)) + c + return {k: v for k, v in out.items() if v} + + +def coeff(x, r): + return scaled(x, r) + + +def query(R, routes, stage, values, ports): + out = [{} for _ in range(8)] + for p in ports: + v = values[p] + if not v: + continue + routed = left(routes[p][stage], v) + for i in range(8): + c = R[i].get(p, F(0)) + if c: + out[i] = add(out[i], routed, c) + return out + + +def query_adjoint(R, routes, stage, q, ports): + out = [{} for _ in range(112)] + for p in ports: + rg = gi(routes[p][stage]) + v = {} + for i in range(8): + c = R[i].get(p, F(0)) + if c: + v = add(v, q[i], c) + out[p] = left(rg, v) + return out + + +def section(R, routes, stage, q, ports): + """D_stage^-1 iota_ports R_ports^-1 q, using R_ports^-1=R_ports^T/4.""" + out = [{} for _ in range(112)] + for p in ports: + v = {} + for i in range(8): + c = R[i].get(p, F(0)) / 4 + if c: + v = add(v, q[i], c) + out[p] = left(gi(routes[p][stage]), v) + return out + + +def selected_query(R, routes, stage, values, ports): + return query(R, routes, stage, values, ports) + + +def identity_columns(values, ports): + return [[values[p].get(ID, F(0)) for p in ports]] + + +def family_rank(families, ports): + """Rank of columns in a sparse Q-vector space keyed by (port, owner map).""" + basis = {} + for family in families: + v = {(p, g): c for p in ports for g, c in family[p].items() if c} + while v: + pivot = min(v, key=repr) + if pivot not in basis: + scale = v[pivot] + basis[pivot] = {k: c / scale for k, c in v.items()} + break + scale = v[pivot] + for key, c in basis[pivot].items(): + z = v.get(key, F(0)) - scale * c + if z: + v[key] = z + else: + v.pop(key, None) + return len(basis) + + +def det(M): + a = [list(row) for row in M] + n = len(a) + result, sign = F(1), 1 + for j in range(n): + pivot = next((i for i in range(j, n) if a[i][j]), None) + if pivot is None: + return F(0) + if pivot != j: + a[j], a[pivot] = a[pivot], a[j] + sign = -sign + value = a[j][j] + result *= value + for i in range(j + 1, n): + factor = a[i][j] / value + for k in range(j + 1, n): + a[i][k] -= factor * a[j][k] + return sign * result + + +def minor_certificate(families, ports): + """Find eight exact output coordinates with a nonsingular witness matrix.""" + pivots, selected = [], [] + for p in ports: + maps = sorted({g for family in families for g in family[p]}) + for g in maps: + row = [family[p].get(g, F(0)) for family in families] + raw = row[:] + for pivot, normalized in pivots: + factor = row[pivot] + if factor: + row = [x - factor*y for x, y in zip(row, normalized)] + pivot = next((j for j, value in enumerate(row) if value), None) + if pivot is None: + continue + scale = row[pivot] + pivots.append((pivot, [x / scale for x in row])) + selected.append({ + "port": p, + "owner_map_columns_hex": [hex(x) for x in g], + "coefficients": [str(x) for x in raw], + }) + if len(pivots) == 8: + matrix = [[F(value) for value in item["coefficients"]] + for item in selected] + return selected, str(det(matrix)) + return selected, str(F(0)) + + +def main(): + d = source_data.reconstruct(ROOT) + R = d["R"] + phases = d["phases"] + routes = [] + for p, record in enumerate(phases["recipes"]): + b = tuple([record["q"]] + record["idle_children"][0]["orthogonal_axes"][:8]) + AXES[9:] + stages = [] + for s in range(3): + if s == 0: + actual = AXES + else: + swaps = [b[i+1] ^ AXES[9+8*(s-1)+i] for i in range(8)] + actual = tuple(v ^ verify_native.act( + swaps, sum(((v & axis).bit_count() % 2) << i + for i, axis in enumerate(swaps))) for v in AXES) + stages.append(actual) + routes.append(stages) + + source_witness_images = [] + old_t_outputs = [] + new_t_outputs = [] + for k in range(8): + e = [{ID: F(i == k)} for i in range(8)] + b2star = query_adjoint(R, routes, 2, e, U) + b1b2 = query(R, routes, 1, b2star, U) + b1starb1b2 = query_adjoint(R, routes, 1, b1b2, U) + h = [add(scaled(b2star[p], 48), b1starb1b2[p], -1) for p in range(112)] + need(query(R, routes, 1, h, U) == [{} for _ in range(8)], "B1 h_k is not zero") + b2h = query(R, routes, 2, h, U) + need([v.get(ID, F(0)) for v in b2h] == [F(2112 * (i == k)) for i in range(8)], + "B2 h_k identity coefficient differs from the pinned witness") + a = section(R, routes, 2, b2h, A) + + # The reviewed post-F0 state: X_U=Y_U=h; X_A=a, Y_A=-a; X_T=Y_T=0. + x, y = [v.copy() for v in h], [v.copy() for v in h] + for j, p in enumerate(A): + x[p], y[p] = a[p].copy(), scaled(a[p], -1) + for p in T: + x[p], y[p] = {}, {} + + def b1_t_output(xx, yy): + # E_2 y = y + P_(2,A)(R_2 - ell_(2,A)) y. + r2y = query(R, routes, 2, yy, range(112)) + l2ay = query(R, routes, 2, yy, A) + u = [v.copy() for v in yy] + correction = section(R, routes, 2, + [add(v, w, -1) for v, w in zip(r2y, l2ay)], A) + u = [add(v, w) for v, w in zip(u, correction)] + aa = selected_query(R, routes, 1, xx, T) + bb = query(R, routes, 1, u, range(112)) + return section(R, routes, 1, + [add(v, w, 12) for v, w in zip(bb, aa)], T) + + old = b1_t_output(x, y) + need(all(not old[p] for p in T), "Zero-shear negative control did not retain the erased T output") + old_t_outputs.append(old) + + # Sum-preserving A-to-T shear: x_T += x_A and y_T -= x_A. + for j, (pa, pt) in enumerate(zip(A, T)): + x[pt] = add(x[pt], x[pa]) + y[pt] = add(y[pt], x[pa], -1) + new = b1_t_output(x, y) + new_t_outputs.append(new) + source_witness_images.append(a) + + source_rank = family_rank(source_witness_images, A) + output_rank = family_rank(new_t_outputs, T) + zero_rank = family_rank(old_t_outputs, T) + need(source_rank == 8, "The post-F0 A witness family is not full rank") + need(output_rank == 8, "The shear did not reveal eight independent T outputs") + need(zero_rank == 0, "The zero-shear control should retain the erased output") + minor_rows, minor_det = minor_certificate(new_t_outputs, T) + need(len(minor_rows) == 8 and F(minor_det) != 0, + "The exact post-B1 output minor is singular") + result = { + "status": "PASS_QQ16_F0_B1_IDENTITY_SHEAR_WITNESS", + "scope": "Exact payload-constant regular-cover group algebra on the eight pinned h_k witnesses; one identity-coordinate shear between F0 and B1; not a full controller or supplier.", + "witness_checks": { + "B1_h_zero_for_all_eight": True, + "B2h_identity_coefficient": "2112*I8", + "post_F0_A_family_rank": source_rank, + }, + "control": {"zero_shear_post_B1_T_rank": zero_rank}, + "result": { + "post_B1_T_family_rank": output_rank, + "distinct_owner_maps_in_T_output": len({g for col in new_t_outputs for p in T for g in col[p]}), + "nonsingular_minor_determinant": minor_det, + "minor_rows": minor_rows, + }, + "local_cost": { + "selected_additions_per_owner": 16, + "new_helpers": 0, + "new_recursive_children": 0, + "new_coefficients_or_precision": 0, + "selected_sum_preserved": True, + "frame_boundary": "F0 output and B1 input share the completed(0) data frame", + }, + "no_claim": "No complete-controller, recursive supplier, or kappa improvement is established.", + } + (Path(__file__).resolve().parent / "RESULT.json").write_text( + json.dumps(result, indent=2, sort_keys=True) + "\n") + print(result["status"]) + print("source_A_rank=8; zero_shear_T_rank=0; sheared_post_B1_T_rank=8") + print("exact_nonzero_8x8_minor_det=" + minor_det) + + +if __name__ == "__main__": + main() diff --git a/research/qq16-ordinary-source-tap-seed3794b3/verify.py b/research/qq16-ordinary-source-tap-seed3794b3/verify.py new file mode 100644 index 0000000000..6f03a77c08 --- /dev/null +++ b/research/qq16-ordinary-source-tap-seed3794b3/verify.py @@ -0,0 +1,274 @@ +#!/usr/bin/env python3 +"""Replay one exact QQ16 ordinary-source tap through the retained tail.""" +from collections import Counter +from fractions import Fraction as Q +import hashlib +import importlib.util +import json +from pathlib import Path +import subprocess +import sys + +PACKAGE = Path(__file__).resolve().parent +ROOT = PACKAGE.parents[1] +PR2093 = PACKAGE / "references/pr2093" + + +def need(ok, message): + if not ok: + raise ValueError(message) + + +def canonical(value): + return json.dumps(value, sort_keys=True, separators=(",", ":")) + + +def load_b2(): + path = PR2093 / "verify.py" + module_name = "qq16_b2_reference" + spec = importlib.util.spec_from_file_location(module_name, path) + module = importlib.util.module_from_spec(spec) + sys.modules[module_name] = module + spec.loader.exec_module(module) + module.PACKAGE = PR2093 + module.ROOT = ROOT + return module + + +def pre_f0_state(model, b2): + h = [{} for _ in range(112)] + for port, coefficient in b2.COEFFICIENTS.items(): + h[port] = {model.bases[port][0]: Q(coefficient)} + b0 = model.query(0, h) + initial_a = model.inject(0, b2.A, b0) + x, y = [row.copy() for row in h], [{} for _ in range(112)] + for port in b2.A: + x[port] = b2.linear((-1, initial_a[port])) + y[port] = b2.linear((-1, x[port])) + input_a_identity = [str(b2.at_identity(x[p])) for p in b2.A] + x, y, f0 = model.forward(0, x, y) + need(not any(f0), "pinned h witness has nonzero F0 history") + need(not any(x[p] or y[p] for p in b2.A + b2.T), + "pinned h witness has nonzero selected state after F0") + return h, x, y, f0, input_a_identity + + +def add_a_shear(x, y, b2): + x, y = [row.copy() for row in x], [row.copy() for row in y] + for source, target in zip(b2.A, b2.T): + before = b2.linear((1, x[target]), (1, y[target])) + x[target] = b2.linear((1, x[target]), (1, x[source])) + y[target] = b2.linear((1, y[target]), (-1, x[source])) + need(b2.linear((1, x[target]), (1, y[target])) == before, + "inherited A-to-T shear changed selected sum") + return x, y + + +def add_single_tap(x, y, source_port, target_port, b2, sign=-1): + """Apply X_t += X_u, Y_t -= X_u, or a deliberately wrong-sign control.""" + x, y = [row.copy() for row in x], [row.copy() for row in y] + before = b2.linear((1, x[target_port]), (1, y[target_port])) + source = x[source_port].copy() + x[target_port] = b2.linear((1, x[target_port]), (1, source)) + y[target_port] = b2.linear((1, y[target_port]), (sign, source)) + after = b2.linear((1, x[target_port]), (1, y[target_port])) + return x, y, before, after, source + + +def replay_tail(model, template, f0, bx, by, b2): + empty = lambda: [{} for _ in range(112)] + banks = [[bx, by]] + [[empty(), empty()] for _ in range(3)] + histories = {0: f0} + completed_x = [] + for event in template["recipe"][2:]: + kind = event["kind"] + if kind == "bridge": + src, dst, coefficient = event["src"], event["dst"], event["coefficient"] + for port in b2.U: + banks[dst][0][port] = b2.linear( + (1, banks[dst][0][port]), (coefficient, banks[src][0][port])) + banks[src][1][port] = b2.linear( + (1, banks[src][1][port]), (-coefficient, banks[dst][1][port])) + elif kind == "local": + stage, pair = event["stage"], event["pair"] + bx0, by0 = banks[pair] + if event["reverse"]: + banks[pair] = list(model.backward(stage, stage + 1, bx0, by0)) + else: + bx0, by0, history = model.forward(stage, bx0, by0) + banks[pair] = [bx0, by0] + histories[stage] = history + else: + need(kind == "terminal", "unexpected retained-template event") + completed_x = [row.copy() for pair in banks for row in pair[0]] + banks = [[by0, [b2.linear((-1, row)) for row in bx0]] + for bx0, by0 in banks] + + observations = [] + for bank, pair in enumerate(banks): + for component, fields in zip(("X", "Y"), pair): + for port in b2.A + b2.T: + if fields[port]: + observations.append({ + "kind": "selected", "bank": bank, "component": component, + "port": port, "map": {str(k): str(v) + for k, v in sorted(fields[port].items())}}) + for stage, history in sorted(histories.items()): + for index, row in enumerate(history): + if row: + observations.append({ + "kind": "history", "stage": stage, "index": index, + "map": {str(k): str(v) for k, v in sorted(row.items())}}) + for index, row in enumerate(completed_x): + if row: + observations.append({ + "kind": "completed-X", "index": index, + "map": {str(k): str(v) for k, v in sorted(row.items())}}) + return observations + + +def build_result(): + manifest = json.loads((PACKAGE / "SOURCES.json").read_text()) + external = {row["path"]: row for row in manifest["external_references"]} + for relative, reference in external.items(): + payload = (PACKAGE / relative).read_bytes() + need(hashlib.sha256(payload).hexdigest() == reference["sha256"], + "external reference hash: " + relative) + pr2216_manifest = json.loads( + (PACKAGE / "references/pr2216/SOURCES.json").read_text()) + for row in pr2216_manifest["files"]: + if row.get("usage") == "input": + need(hashlib.sha256((ROOT / row["path"]).read_bytes()).hexdigest() + == row["sha256"], "PR2216 base input hash: " + row["path"]) + + b2 = load_b2() + inputs = {row["path"]: row["sha256"] for row in manifest["files"] + if row["usage"] == "input"} + need(inputs == b2.INPUTS, "the source inventory differs from PR2093's pinned inputs") + members, certificate, previous = b2.load_sources() + word = members["CANONICAL-WORD.json.gz"] + programs = members["LOCAL-PROGRAMS.json.gz"] + phases = members["DATA-PHASES.json"] + template = members["GLOBAL-TEMPLATE.json.gz"] + R = b2.reconstruct_R(word, programs) + need(R == [[Q(row.get(str(p), "0")) for p in range(112)] + for row in certificate["R_rows"]], "operation-derived R binding") + model = b2.Model(R, phases) + h, x0, y0, f0, input_a_identity = pre_f0_state(model, b2) + need(all(model.routes[p][0] == b2.AXES for p in range(112)), + "the 112 fields do not share the completed(0) coordinate map") + + # The released A-to-T shear alone leaves this witness hidden at B1 and later. + xa, ya = add_a_shear(x0, y0, b2) + old_bx, old_by = model.backward(1, 2, xa, ya) + need(not any(old_bx[p] or old_by[p] for p in b2.A + b2.T), + "A-to-T-only control no longer erases the selected state") + old_signature = replay_tail(model, template, f0, old_bx, old_by, b2) + need(not old_signature, "A-to-T-only control became observable in the retained tail") + + # One ordinary port, one selected pair. The source is left unchanged. + x, y, before, after, source = add_single_tap(xa, ya, 2, 21, b2, sign=-1) + need(source == h[2] and source, "U2 is not the pinned live h source") + need(after == before, "the paired tap did not preserve X21 + Y21") + bx, by = model.backward(1, 2, x, y) + observations = replay_tail(model, template, f0, bx, by, b2) + counts = Counter(row["kind"] for row in observations) + need(counts == Counter({"selected": 34, "history": 4, "completed-X": 65}), + "the exact retained-tail observation census changed") + witness_row = next((row for row in observations + if row["kind"] == "selected" and row["bank"] == 0 + and row["component"] == "X" and row["port"] == 21), None) + need(witness_row == {"kind": "selected", "bank": 0, "component": "X", + "port": 21, "map": {"37": "11"}}, + "expected exact final selected witness changed") + + # An off-support source is an exact negative control. + wx, wy, _, _, wrong_source = add_single_tap(xa, ya, 1, 21, b2, sign=-1) + need(not wrong_source, "off-support U1 unexpectedly carries the witness") + wrong_bx, wrong_by = model.backward(1, 2, wx, wy) + need(not replay_tail(model, template, f0, wrong_bx, wrong_by, b2), + "off-support source control unexpectedly became visible") + + # A one-sided mutation is rejected by the paired-sum contract. + _, _, bad_before, bad_after, bad_source = add_single_tap(xa, ya, 2, 21, b2, sign=1) + need(bad_source and bad_before != bad_after, + "wrong-sign control failed to break the selected-sum invariant") + + # Re-run the PR2216 eight-direction witness with this tap at the B1 cut. + check = subprocess.run([sys.executable, "-I", "-B", str(PACKAGE / "verify_b1_tap.py")], + cwd=ROOT, text=True, capture_output=True, check=False, timeout=180) + need(check.returncode == 0, "eight-direction B1 control failed: " + check.stderr) + need(check.stdout.splitlines() == [ + "PASS_QQ16_F0_B1_IDENTITY_SHEAR_WITNESS", + "source_A_rank=8; zero_shear_T_rank=0; A_shear_plus_U2_T21_tap_rank=8", + "exact_nonzero_8x8_minor_det=-1/4096"], "unexpected eight-direction verifier output") + + return { + "status": "PASS_QQ16_ORDINARY_SOURCE_TAP", + "scope": "The exact PR2093 ordinary-source h witness, with the PR2216 A-to-T shear retained and one paired U2-to-T21 tap, through the full retained QQ16 tail.", + "base_commit": manifest["base_commit"], + "external_references": external, + "witness": { + "definition": "h_p(d)=c_p bit_0(d b_(p,0))", + "coefficients": {str(p): c for p, c in b2.COEFFICIENTS.items()}, + "post_F0_active_U_ports": [2, 8, 85], + "pre_F0_B2_and_B1_zero": True, + "required_initial_A_at_identity": input_a_identity, + }, + "mechanism": { + "existing_shear": "X_T += X_A; Y_T -= X_A", + "added_tap": "X_21 += X_2; Y_21 -= X_2", + "common_frame": "completed(0), verified identity map on all 112 fields", + "added_scalar_additions_per_owner": 2, + "added_helpers": 0, + "added_recursive_children": 0, + "coefficient_precision": "unchanged; tap coefficients are +1 and -1", + "selected_sum_preserved": True, + "changed_pair_magnitude_envelope": "at most 2x by the triangle bound (one extra magnitude bit charged)", + }, + "retained_tail": { + "observable_rows": dict(sorted(counts.items())), + "exact_final_witness_output": witness_row, + "at_identity": "11", + "complete_observations": observations, + }, + "existing_eight_direction_control": { + "status": check.stdout.splitlines()[0], + "post_B1_T_rank": 8, + "minor_determinant": "-1/4096", + }, + "negative_controls": { + "A_to_T_shear_only_full_tail_observations": 0, + "off_support_U1_tap_full_tail_observations": 0, + "wrong_sign_breaks_selected_sum": True, + }, + "limits": [ + "This disables one exact kernel witness; it does not prove full controller injectivity.", + "The PR2216 eight-direction family is rechecked only at B1, not through the tail.", + "The one-bit payload envelope is a local triangle bound; global precision, hosting, and supplier admission remain open.", + "No supplier, selected exponent, or kappa improvement is claimed.", + ], + } + + +def main(): + import argparse + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--write-result", type=Path, + help="write the exact receipt exclusively to a new path") + args = parser.parse_args() + result = build_result() + if args.write_result: + with args.write_result.open("x", encoding="utf-8") as stream: + json.dump(result, stream, indent=2, sort_keys=True) + stream.write("\n") + else: + recorded = json.loads((PACKAGE / "RESULT.json").read_text()) + need(canonical(recorded) == canonical(result), "complete canonical receipt mismatch") + print("PASS_QQ16_ORDINARY_SOURCE_TAP selected=34 histories=4 completedX=65") + print("tap=U2->T21 additions=2 children=0 tail_output_X21=11*f37 at_identity=11") + print("PR2216_B1_rank=8; controls=3; no_full_controller; no_kappa") + + +if __name__ == "__main__": + main() diff --git a/research/qq16-ordinary-source-tap-seed3794b3/verify_b1_tap.py b/research/qq16-ordinary-source-tap-seed3794b3/verify_b1_tap.py new file mode 100644 index 0000000000..bfa1e3e3d4 --- /dev/null +++ b/research/qq16-ordinary-source-tap-seed3794b3/verify_b1_tap.py @@ -0,0 +1,296 @@ +"""PR2216's exact QQ16 witness replay with one U2-to-T21 paired tap.""" +from __future__ import annotations + +from fractions import Fraction as F +from functools import lru_cache +from pathlib import Path +import json +import sys + + +ROOT = Path(__file__).resolve().parents[2] +sys.path.insert(0, str(ROOT / "research/joint-query")) +import source_data # noqa: E402 +import verify_native # noqa: E402 + +A = [0, 7, 20, 27, 36, 46, 57, 111] +T = [21, 37, 47, 76, 81, 87, 92, 110] +U = [p for p in range(112) if p not in A + T] +AXES = tuple(1 << i for i in range(73)) +ID = AXES + + +def need(ok, message): + if not ok: + raise AssertionError(message) + + +def add(x, y, scale=F(1)): + out = x.copy() + for g, c in y.items(): + v = out.get(g, F(0)) + scale * c + if v: + out[g] = v + else: + out.pop(g, None) + return out + + +def scaled(x, c): + return {g: c * v for g, v in x.items() if c * v} + + +@lru_cache(None) +def gm(g, h): + return verify_native.product((g, 0), (h, 0))[0] + + +@lru_cache(None) +def gi(g): + return verify_native.inverse((g, 0))[0] + + +def left(g, x): + out = {} + for h, c in x.items(): + gh = gm(g, h) + out[gh] = out.get(gh, F(0)) + c + return {k: v for k, v in out.items() if v} + + +def coeff(x, r): + return scaled(x, r) + + +def query(R, routes, stage, values, ports): + out = [{} for _ in range(8)] + for p in ports: + v = values[p] + if not v: + continue + routed = left(routes[p][stage], v) + for i in range(8): + c = R[i].get(p, F(0)) + if c: + out[i] = add(out[i], routed, c) + return out + + +def query_adjoint(R, routes, stage, q, ports): + out = [{} for _ in range(112)] + for p in ports: + rg = gi(routes[p][stage]) + v = {} + for i in range(8): + c = R[i].get(p, F(0)) + if c: + v = add(v, q[i], c) + out[p] = left(rg, v) + return out + + +def section(R, routes, stage, q, ports): + """D_stage^-1 iota_ports R_ports^-1 q, using R_ports^-1=R_ports^T/4.""" + out = [{} for _ in range(112)] + for p in ports: + v = {} + for i in range(8): + c = R[i].get(p, F(0)) / 4 + if c: + v = add(v, q[i], c) + out[p] = left(gi(routes[p][stage]), v) + return out + + +def selected_query(R, routes, stage, values, ports): + return query(R, routes, stage, values, ports) + + +def identity_columns(values, ports): + return [[values[p].get(ID, F(0)) for p in ports]] + + +def family_rank(families, ports): + """Rank of columns in a sparse Q-vector space keyed by (port, owner map).""" + basis = {} + for family in families: + v = {(p, g): c for p in ports for g, c in family[p].items() if c} + while v: + pivot = min(v, key=repr) + if pivot not in basis: + scale = v[pivot] + basis[pivot] = {k: c / scale for k, c in v.items()} + break + scale = v[pivot] + for key, c in basis[pivot].items(): + z = v.get(key, F(0)) - scale * c + if z: + v[key] = z + else: + v.pop(key, None) + return len(basis) + + +def det(M): + a = [list(row) for row in M] + n = len(a) + result, sign = F(1), 1 + for j in range(n): + pivot = next((i for i in range(j, n) if a[i][j]), None) + if pivot is None: + return F(0) + if pivot != j: + a[j], a[pivot] = a[pivot], a[j] + sign = -sign + value = a[j][j] + result *= value + for i in range(j + 1, n): + factor = a[i][j] / value + for k in range(j + 1, n): + a[i][k] -= factor * a[j][k] + return sign * result + + +def minor_certificate(families, ports): + """Find eight exact output coordinates with a nonsingular witness matrix.""" + pivots, selected = [], [] + for p in ports: + maps = sorted({g for family in families for g in family[p]}) + for g in maps: + row = [family[p].get(g, F(0)) for family in families] + raw = row[:] + for pivot, normalized in pivots: + factor = row[pivot] + if factor: + row = [x - factor*y for x, y in zip(row, normalized)] + pivot = next((j for j, value in enumerate(row) if value), None) + if pivot is None: + continue + scale = row[pivot] + pivots.append((pivot, [x / scale for x in row])) + selected.append({ + "port": p, + "owner_map_columns_hex": [hex(x) for x in g], + "coefficients": [str(x) for x in raw], + }) + if len(pivots) == 8: + matrix = [[F(value) for value in item["coefficients"]] + for item in selected] + return selected, str(det(matrix)) + return selected, str(F(0)) + + +def main(): + d = source_data.reconstruct(ROOT) + R = d["R"] + phases = d["phases"] + routes = [] + for p, record in enumerate(phases["recipes"]): + b = tuple([record["q"]] + record["idle_children"][0]["orthogonal_axes"][:8]) + AXES[9:] + stages = [] + for s in range(3): + if s == 0: + actual = AXES + else: + swaps = [b[i+1] ^ AXES[9+8*(s-1)+i] for i in range(8)] + actual = tuple(v ^ verify_native.act( + swaps, sum(((v & axis).bit_count() % 2) << i + for i, axis in enumerate(swaps))) for v in AXES) + stages.append(actual) + routes.append(stages) + + source_witness_images = [] + old_t_outputs = [] + new_t_outputs = [] + for k in range(8): + e = [{ID: F(i == k)} for i in range(8)] + b2star = query_adjoint(R, routes, 2, e, U) + b1b2 = query(R, routes, 1, b2star, U) + b1starb1b2 = query_adjoint(R, routes, 1, b1b2, U) + h = [add(scaled(b2star[p], 48), b1starb1b2[p], -1) for p in range(112)] + need(query(R, routes, 1, h, U) == [{} for _ in range(8)], "B1 h_k is not zero") + b2h = query(R, routes, 2, h, U) + need([v.get(ID, F(0)) for v in b2h] == [F(2112 * (i == k)) for i in range(8)], + "B2 h_k identity coefficient differs from the pinned witness") + a = section(R, routes, 2, b2h, A) + + # The reviewed post-F0 state: X_U=Y_U=h; X_A=a, Y_A=-a; X_T=Y_T=0. + x, y = [v.copy() for v in h], [v.copy() for v in h] + for j, p in enumerate(A): + x[p], y[p] = a[p].copy(), scaled(a[p], -1) + for p in T: + x[p], y[p] = {}, {} + + def b1_t_output(xx, yy): + # E_2 y = y + P_(2,A)(R_2 - ell_(2,A)) y. + r2y = query(R, routes, 2, yy, range(112)) + l2ay = query(R, routes, 2, yy, A) + u = [v.copy() for v in yy] + correction = section(R, routes, 2, + [add(v, w, -1) for v, w in zip(r2y, l2ay)], A) + u = [add(v, w) for v, w in zip(u, correction)] + aa = selected_query(R, routes, 1, xx, T) + bb = query(R, routes, 1, u, range(112)) + return section(R, routes, 1, + [add(v, w, 12) for v, w in zip(bb, aa)], T) + + old = b1_t_output(x, y) + need(all(not old[p] for p in T), "Zero-shear negative control did not retain the erased T output") + old_t_outputs.append(old) + + # Sum-preserving A-to-T shear: x_T += x_A and y_T -= x_A. + for j, (pa, pt) in enumerate(zip(A, T)): + x[pt] = add(x[pt], x[pa]) + y[pt] = add(y[pt], x[pa], -1) + # One extra ordinary-source tap, preserving X_T + Y_T at T21. + old_sum = add(x[21], y[21]) + source = x[2].copy() + x[21] = add(x[21], source) + y[21] = add(y[21], source, -1) + need(add(x[21], y[21]) == old_sum, 'ordinary tap changed selected sum') + new = b1_t_output(x, y) + new_t_outputs.append(new) + source_witness_images.append(a) + + source_rank = family_rank(source_witness_images, A) + output_rank = family_rank(new_t_outputs, T) + zero_rank = family_rank(old_t_outputs, T) + need(source_rank == 8, "The post-F0 A witness family is not full rank") + need(output_rank == 8, "The shear did not reveal eight independent T outputs") + need(zero_rank == 0, "The zero-shear control should retain the erased output") + minor_rows, minor_det = minor_certificate(new_t_outputs, T) + need(len(minor_rows) == 8 and F(minor_det) != 0, + "The exact post-B1 output minor is singular") + result = { + "status": "PASS_QQ16_F0_B1_IDENTITY_SHEAR_WITNESS", + "scope": "Exact payload-constant regular-cover group algebra on the eight pinned h_k witnesses; retained A-to-T shear plus one identity-coordinate U2-to-T21 paired tap between F0 and B1; not a full controller or supplier.", + "witness_checks": { + "B1_h_zero_for_all_eight": True, + "B2h_identity_coefficient": "2112*I8", + "post_F0_A_family_rank": source_rank, + }, + "control": {"zero_shear_post_B1_T_rank": zero_rank}, + "result": { + "post_B1_T_family_rank": output_rank, + "distinct_owner_maps_in_T_output": len({g for col in new_t_outputs for p in T for g in col[p]}), + "nonsingular_minor_determinant": minor_det, + "minor_rows": minor_rows, + }, + "local_cost": { + "selected_additions_per_owner": 18, + "ordinary_tap_additions_per_owner": 2, + "new_helpers": 0, + "new_recursive_children": 0, + "new_coefficients_or_precision": 0, + "selected_sum_preserved": True, + "frame_boundary": "F0 output and B1 input share the completed(0) data frame", + }, + "no_claim": "No complete-controller, recursive supplier, or kappa improvement is established.", + } + print(result["status"]) + print("source_A_rank=8; zero_shear_T_rank=0; A_shear_plus_U2_T21_tap_rank=8") + print("exact_nonzero_8x8_minor_det=" + minor_det) + + +if __name__ == "__main__": + main() From daf44bfc752a5e89127defa1cb296210708cf7e6 Mon Sep 17 00:00:00 2001 From: Cinna Davis <1337isnot1337@users.noreply.github.com> Date: Wed, 14 Oct 2026 21:51:08 -0500 Subject: [PATCH 2/2] Record QQ16 tap research handoff --- research/qq16-ordinary-source-tap-seed3794b3/TASK.json | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/research/qq16-ordinary-source-tap-seed3794b3/TASK.json b/research/qq16-ordinary-source-tap-seed3794b3/TASK.json index 8dee3a245d..e669ebba62 100644 --- a/research/qq16-ordinary-source-tap-seed3794b3/TASK.json +++ b/research/qq16-ordinary-source-tap-seed3794b3/TASK.json @@ -104,5 +104,11 @@ "PR2093": "8b21a900eb520e4f11ea177b310f66316f8e8983", "PR2216": "b80e9ba43367fb8b20877a97da1cb677c34f9264", "PR2079": "49df8190b158e3028e702b2c6b798117006f7249" + }, + "submission": { + "status": "open", + "pr_url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2268", + "contribution_commit": "0dfc4d2c", + "claim_update_url": "https://github.com/CrocSwap/integer-mult-bounds/discussions/2205#discussioncomment-18939213" } }