diff --git a/research/qq16-map-parity-floor-seed-ed361f3c/LICENSE b/research/qq16-map-parity-floor-seed-ed361f3c/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/qq16-map-parity-floor-seed-ed361f3c/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/research/qq16-map-parity-floor-seed-ed361f3c/PR-BODY.md b/research/qq16-map-parity-floor-seed-ed361f3c/PR-BODY.md new file mode 100644 index 0000000000..b5e8a6b23d --- /dev/null +++ b/research/qq16-map-parity-floor-seed-ed361f3c/PR-BODY.md @@ -0,0 +1,30 @@ +## Scope and result + +**Scoped all-depth obstruction; no new kappa.** At the exact post-`B_1_2` QQ16 cut, the eight `Y_A` output frames each have 18 odd Z4 terms, while the existing private fields `C0..C7` return in the zero frame. Every registered cover map applies an invertible binary owner transform and adds only coefficient 2. Modulo two, the payload shift vanishes and the owner transform preserves odd-support size. Therefore every finite composition of cover maps leaves all eight frames at odd-support weight 18; this rules out depth-one, depth-two, depth-three, and longer map-only normalization. + +In the declared one-term native-line model, one rank-one correction changes at most one parity bit. Reaching the private zero frames requires at least 18 corrections per output, or **144 rank-one line calls** total. This exceeds by 72 times the favorable budget of at most two extra rank-one-equivalent operations after the rank-eight output charge. The bill also includes 288 associated full-cover map operations, eight scalar copies priced at 32 real primitives, and up to eight terminal clear primitives (zero additional clears if the existing next core follows). Further map implementation, hosting, source routing, and precision charges cannot lower the line floor. + +This extends the released one-map / one-term result in PR #2197 with an all-depth invariant. It is limited to the pinned eight frames, registered invertible cover maps, and one-term Z4 corrections. Alternate field layouts and multi-term native operations remain open. No full controller, supplier admission, or selected-bound change is claimed. + +## Exact evidence and reproduction + +The source-pinned verifier reconstructs the eight port frames from the native recipes, checks all 3,650 owner maps for rank 73, applies every map to every port frame (29,200 checks), and validates a two-map positive control. Negative controls demonstrate that an odd coefficient shift could cancel a parity bit and that a singular owner map violates the invariant's hypothesis. + +```sh +python3 -I -B research/qq16-map-parity-floor-seed-ed361f3c/verify.py +python3 scripts/research_package.py --package research/qq16-map-parity-floor-seed-ed361f3c --check-only +``` + +Both commands pass locally under CPython 3.14.7. The registered package replay requests Python 3.12, which is unavailable locally. + +## Pins and predecessor attribution + +- Seed `ed361f3c876dd81e664556c9f95bd36e`; `recursive-interfaces`, `joint-query-controller`, priority revision 4. +- Scientific base `0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2`. +- Selected-result SHA-256 `10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32`. +- Catalogue SHA-256 `d46eb6d5b3e279428753d770653663fbdf1063e55c255ea073d768f344927ef7`. +- Map/frame input SHA-256 `a5ed85fac5ebf3c091482a113ab0d351eb5a7892fe2841a35e16017ec1ff49f7`. +- Predecessor [PR #2197](https://github.com/CrocSwap/integer-mult-bounds/pull/2197), head `0a6f487ddff27cde0369e225f9ccb328ca2d8043`, identifies the one-map obstruction and releases the depth-two/three question. This package proves the parity floor for every composition depth using the map law in the selected source certificate. +- [PR #2174](https://github.com/CrocSwap/integer-mult-bounds/pull/2174) supplies the conditional two-query decoder; merged [PR #1969](https://github.com/CrocSwap/integer-mult-bounds/pull/1969) supplies retained QQ16 map and private-field conventions. + +Prepared by Cinna Davis with substantial OpenAI Codex assistance in scope selection, proof development, exact verifier implementation, and packaging. Apache-2.0. diff --git a/research/qq16-map-parity-floor-seed-ed361f3c/PROOF.md b/research/qq16-map-parity-floor-seed-ed361f3c/PROOF.md new file mode 100644 index 0000000000..f65d5163f1 --- /dev/null +++ b/research/qq16-map-parity-floor-seed-ed361f3c/PROOF.md @@ -0,0 +1,44 @@ +# All-depth parity obstruction for QQ16 cover-map normalization + +## Exact object + +Use the pinned QQ16 certificate at the post-`B_1_2` cut. The eight output frames are `f117`, `f124`, `f137`, `f144`, `f153`, `f163`, `f174`, and `f228`; the existing private fields `C0..C7` return in frame `f0`. The frame registry and each `Y_A` port label are bound to the certificate SHA-256 recorded in `SOURCES.json`. + +A frame is a finite function `a: F2^73 -> Z4`, represented by its nonzero `line_terms_Z4`. Define + +```text +odd_support(a) = { x : a(x) is 1 or 3 }. +``` + +The exact source frames each have 18 terms, all with odd coefficient, so `|odd_support|=18`. The private target frame is zero, so its odd-support size is 0. + +## Lemma: cover maps preserve odd-support size + +A registered cover map has the pinned action + +```text +M(g,delta) f(d,z1,...,z_lambda) + = f(d*g, z1 XOR d*delta, ..., z_lambda XOR d*delta). +``` + +On frame axes this applies the invertible owner map `g`; the payload translation adds coefficient 2 on its translated axes. Reducing coefficients modulo 2 removes that translation. Thus the odd support after one map is exactly the image of the original odd support under `g`. Since `g` is invertible, this map preserves support cardinality. + +The claim composes: after any finite sequence of registered cover maps, every one of the eight frames still has odd-support size 18. In particular, no depth-one, depth-two, depth-three, or longer cover-map sequence alone can normalize one of these frames to `f0`. + +The verifier checks all 3,650 registered owner matrices for full rank 73, reconstructs the eight source frames from their pinned port recipes, and checks all 29,200 map/frame actions. These finite checks bind the stated inputs. The all-depth conclusion follows from the preceding invariant, not from a bounded path census. + +## One-term line cost + +In the declared one-term native-line model, one rank-one line correction changes one Z4 frame coefficient by `+1` or `-1`. Modulo 2 this toggles at most one support bit, so it can decrease odd-support size by at most one. Each port therefore needs at least 18 such calls to reach the zero frame. Across eight ports the floor is + +```text +8 * 18 = 144 rank-one line calls. +``` + +The inherited wrapper associates two full-cover map operations with each line call, for 288 map operations. Copying the eight observed scalar values into existing private fields costs eight scalar ADDs, priced at 32 real scalar primitives. If the cut is terminal, clearing eight fields adds eight scalar clear primitives; when the existing next core runs, its clears perform this cleanup with no additional clear charge. Any separate map route only adds operations and cannot lower the line floor. + +The favorable rank-eight output screen in Discussion #2074 leaves at most two additional rank-one-equivalent calls. The lower bound 144 exceeds that allowance by a factor of 72 before source-routing implementation, global hosting, or recursive precision costs. This rules out the multi-map normalization route within the stated one-term line interface. + +## Scope + +This is a structural obstruction for the eight pinned QQ16 frames, the registered invertible cover-map action, and the one-term Z4 line correction model. It does not rule out a different private-field layout, a native operation that changes multiple frame coefficients in one call, or a different controller. It supplies no physical supplier, selected-bound, or kappa result. diff --git a/research/qq16-map-parity-floor-seed-ed361f3c/README.md b/research/qq16-map-parity-floor-seed-ed361f3c/README.md new file mode 100644 index 0000000000..97f43771fb --- /dev/null +++ b/research/qq16-map-parity-floor-seed-ed361f3c/README.md @@ -0,0 +1,48 @@ +# QQ16 cover-map parity floor at the B1 cut + +**Scoped all-depth obstruction; no new kappa.** Every finite composition of the pinned cover maps preserves the 18 odd Z4 frame terms in each of the eight `Y_A` observations at the post-`B_1_2` cut. In the one-term native-line model, clearing them into the existing private `C0..C7` fields requires at least 144 rank-one calls. That is far beyond the two additional rank-one-equivalent operations allowed by the favorable rank-eight output screen. + +This completes the specific depth-two/three follow-up left open by the released claim in Discussion #2192 and PR #2197. The proof uses an all-depth invariant, so no finite map-path search is needed. + +## Model and cost + +The exact eight source frame IDs are `f117`, `f124`, `f137`, `f144`, `f153`, `f163`, `f174`, and `f228`; each has 18 odd coefficients. The private target `f0` has none. A cover map applies an invertible binary owner transformation and adds only coefficient 2. Modulo two, it permutes the odd support without changing its size. A one-term line correction can remove at most one odd coefficient. The full proof is in [PROOF.md](PROOF.md). + +The scoped bill is at least 144 rank-one line calls plus their 288 full-cover map operations, eight scalar copies priced at 32 real scalar primitives, and up to eight clear primitives if no existing next core follows. If that next core runs, its clears absorb the cleanup. The favorable rank-eight envelope leaves at most two additional rank-one-equivalent calls. Physical source access, map implementation, global hosting, and precision remain unpriced, and cannot rescue the line-call floor. + +This is limited to the pinned registered map actions and one-term line model. Alternate private-field layouts or a native multi-term operation would be a different interface. No complete controller, supplier admission, or selected-bound change is claimed. + +## Pins and predecessor + +- Assignment seed: `ed361f3c876dd81e664556c9f95bd36e`, track `recursive-interfaces`, task `joint-query-controller`, priority revision 4. +- Scientific base: `0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2`. +- Selected-result SHA-256: `10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32`. +- Catalogue SHA-256: `d46eb6d5b3e279428753d770653663fbdf1063e55c255ea073d768f344927ef7`. +- Map/frame input: `research/joint-query/certificate.json.gz`, SHA-256 `a5ed85fac5ebf3c091482a113ab0d351eb5a7892fe2841a35e16017ec1ff49f7`. +- Direct predecessor: [PR #2197](https://github.com/CrocSwap/integer-mult-bounds/pull/2197), head `0a6f487ddff27cde0369e225f9ccb328ca2d8043`, which rejects one-map normalization and derives the one-term line floor. This package adds the parity invariant for arbitrary map depth. +- Interface motivation: [PR #2174](https://github.com/CrocSwap/integer-mult-bounds/pull/2174), the conditional two-query decoder; [PR #1969](https://github.com/CrocSwap/integer-mult-bounds/pull/1969), retained QQ16 maps and private fields. + +## Reproduce + +From the repository root: + +```sh +python3 -I -B research/qq16-map-parity-floor-seed-ed361f3c/verify.py +python3 scripts/research_package.py --package research/qq16-map-parity-floor-seed-ed361f3c --check-only +``` + +Expected verifier line: + +```text +PASS_QQ16_MAP_PARITY_FLOOR ports=8 maps=3650 frame_checks=29200 lines=144 cover_maps=288 no_kappa +``` + +The exact verifier and metadata/source-pin check passed locally on CPython 3.14.7. The registered package runner requests Python 3.12; it is unavailable locally. + +## Open next questions + +- **Can a changed private-field layout avoid the parity floor without using multi-term line operations?** This matters because the invariant closes only the fixed `C0..C7` relay. First step: propose exact target frames for all eight fields and compute the mod-2 support distance from each source frame under the same registered map action. Blocker: no native controller currently supplies an alternate owned-field layout with a full hosting and restoration invoice. + +## Credit + +Prepared by Cinna Davis with substantial OpenAI Codex assistance in scope selection, proof development, exact verifier implementation, and packaging. New work is Apache-2.0. diff --git a/research/qq16-map-parity-floor-seed-ed361f3c/RESULT.json b/research/qq16-map-parity-floor-seed-ed361f3c/RESULT.json new file mode 100644 index 0000000000..d00288fafd --- /dev/null +++ b/research/qq16-map-parity-floor-seed-ed361f3c/RESULT.json @@ -0,0 +1,36 @@ +{ + "status": "PASS_QQ16_MAP_PARITY_FLOOR", + "source_base": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2", + "certificate_sha256_compressed": "a5ed85fac5ebf3c091482a113ab0d351eb5a7892fe2841a35e16017ec1ff49f7", + "registered_maps": 3650, + "invertible_owner_maps": 3650, + "source_frames": { + "0": "f117", + "7": "f124", + "20": "f137", + "27": "f144", + "36": "f153", + "46": "f163", + "57": "f174", + "111": "f228" + }, + "odd_terms_per_source_frame": 18, + "target_odd_terms": 0, + "direct_map_frame_checks": 29200, + "two_map_positive_control": "18 odd terms remain after two exact actions", + "one_term_line_calls_lower_bound": 144, + "cover_map_operations_at_two_per_line": 288, + "scalar_copy_primitives": 32, + "terminal_clear_primitives": 8, + "extra_clear_if_existing_next_core_runs": 0, + "favorable_extra_rank_one_equivalent_budget": 2, + "all_depth_conclusion": "cover maps preserve mod-2 odd-support weight; depth two, three, and all larger depths retain the 144-line floor", + "controls": [ + "two-map composition preserves odd-support weight", + "odd coefficient shift can cancel an odd term", + "one-term line correction toggles at most its selected parity bit", + "singular owner action is rejected" + ], + "scope": "Eight pinned Y_A frames at the post-B_1_2 cut; registered invertible cover-map actions and the one-term Z4 line model only.", + "no_controller_or_kappa_claim": true +} diff --git a/research/qq16-map-parity-floor-seed-ed361f3c/SOURCES.json b/research/qq16-map-parity-floor-seed-ed361f3c/SOURCES.json new file mode 100644 index 0000000000..841ec8ca48 --- /dev/null +++ b/research/qq16-map-parity-floor-seed-ed361f3c/SOURCES.json @@ -0,0 +1,67 @@ +{ + "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": "docs/research/community-batch1099-review.md", + "usage": "provenance", + "git_blob": "6cb6ec061a071a06a2d18cd4dc3e9a2b05d28099", + "sha256": "7e76d2c38e5fce30587835b7251df1430488ae4dd372611ef69a3f03f476b6cb" + }, + { + "path": "research/community-frontier1094-audit/SELECTED-SOURCE.json", + "usage": "provenance", + "git_blob": "6a75493790b4eff9c4a98051ef8b01d6aad0d5a8", + "sha256": "79b3de5db3dbcb9829789ba58e9e45758926031e2a7d80667a08429d369be53b" + }, + { + "path": "research/community-frontier1094-audit/ASSEMBLY.json", + "usage": "provenance", + "git_blob": "5fd676df060f3b450782fdf5ff5f6beb63a5eeb0", + "sha256": "1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045" + }, + { + "path": "research/joint-query/certificate.json.gz", + "usage": "input", + "git_blob": "c6e876d8b48d768214deee265ade428f8983b566", + "sha256": "a5ed85fac5ebf3c091482a113ab0d351eb5a7892fe2841a35e16017ec1ff49f7" + }, + { + "path": "research/joint-query/README.md", + "usage": "provenance", + "git_blob": "2bf4fc0aa252c01242278cb58befc350acf7c85f", + "sha256": "419f076e46f5a6ce43efe30a608baed0a535034c388e1ac76a29a2026685ba77" + } + ], + "predecessors": [ + { + "pr": 2197, + "head": "0a6f487ddff27cde0369e225f9ccb328ca2d8043", + "package": "research/qq16-private-da-frame-floor-seed81b017/", + "result_sha256": "9d7914bc44baf37e45f4e8b0c2eb2a8b4ad978a13778bebad13b8474931fd615", + "use": "One-map normalization search and its scoped 144-line floor; this package proves the map-depth invariant independently from the pinned base certificate." + }, + { + "pr": 2174, + "head": "f79470a7931f3943360c10d15b428e0e4e479c22", + "use": "Conditional QQ16 two-query decoder; motivates the d_A observation at this cut." + }, + { + "pr": 1969, + "head": "a6e6ad3936f67b8f63b5b68c5e75d540610a65e7", + "use": "Merged QQ16 cover maps and private-field contract." + } + ] +} diff --git a/research/qq16-map-parity-floor-seed-ed361f3c/TASK.json b/research/qq16-map-parity-floor-seed-ed361f3c/TASK.json new file mode 100644 index 0000000000..6ea9e28c55 --- /dev/null +++ b/research/qq16-map-parity-floor-seed-ed361f3c/TASK.json @@ -0,0 +1,150 @@ +{ + "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": "At the exact post-B_1_2 QQ16 cut, determine whether arbitrary compositions of the 3,650 registered cover maps can normalize the eight Y_A frames f117,f124,f137,f144,f153,f163,f174,f228 into private target f0, including one-term Z4 line corrections between maps.", + "scope_change_reason": "Take the just-released follow-up in Discussion #2192 after PR #2197. Replace a depth-two/three path census with an all-depth parity invariant for the same fixed B1 private-register relay. This supplies a new structural mechanism result and does not audit the predecessor verifier.", + "bottleneck_link": "The conditional QQ16 two-query decoder uses d_A=Y_A at the B1 cut. This result determines whether the retained private C fields can receive that observation within the favorable rank-eight budget.", + "budget_minutes": 60, + "method_and_domain": "For each registered cover map M(g,delta), reduce the exact Z4 frame coefficients modulo two. The invertible owner action permutes the odd-support set and the coefficient-two payload shift vanishes. Verify all 3,650 maps and all eight exact port frames, then use the one-term line contract to derive a uniform lower bound across the eight outputs.", + "stop_rule": "Stop once the source-bound action invariant and all-eight-port cost comparison verify. Do not enumerate finite map paths because the invariant covers every composition depth. Do not generalize beyond the registered map action and one-term line model.", + "outcome": "negative-result", + "evidence": "PROOF.md gives the all-depth invariant and 144-call lower bound. verify.py checks source pins, all eight exact frames, all 3,650 invertible maps, 29,200 frame actions and assumption-breaking controls; RESULT.json records the exact scoped cost ledger.", + "author": "Cinna Davis", + "ai_assistance": "Substantial OpenAI Codex assistance in selecting the handoff, deriving the parity invariant, implementing exact source-bound checks, and writing the package.", + "open_questions": [ + { + "question": "Can a changed private-field layout avoid the parity floor while still carrying all eight d_A coordinates?", + "why_it_matters": "The all-depth invariant closes the fixed C0..C7 relay but leaves alternate owned-field layouts open.", + "first_step": "Specify target frames for eight fields and compute exact mod-2 support distances from each Y_A source under the same registered cover maps.", + "blocked_by": "No native controller currently provides an alternate field layout with a full hosting and restoration invoice." + } + ], + "seed": "ed361f3c876dd81e664556c9f95bd36e", + "track": "recursive-interfaces", + "catalogue_sha256": "d46eb6d5b3e279428753d770653663fbdf1063e55c255ea073d768f344927ef7", + "selected_record_sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32", + "scope_key": "QQ16-B1_2-dA/registered-cover-map-semigroup/parity-weight-and-line-floor", + "discarded_selector_draws": [ + { + "seed": "49f20116f7754f9f503212be56fa41c6", + "track": "adversarial-audit" + } + ], + "predecessors": [ + { + "pr": 2197, + "head": "0a6f487ddff27cde0369e225f9ccb328ca2d8043", + "use": "One-map normalization result; released handoff requests depth-two/three map search." + }, + { + "pr": 2174, + "head": "f79470a7931f3943360c10d15b428e0e4e479c22", + "use": "Conditional two-query decoder." + }, + { + "pr": 1969, + "head": "a6e6ad3936f67b8f63b5b68c5e75d540610a65e7", + "use": "QQ16 maps and private-field contract." + }, + { + "discussion": 2074, + "use": "Favorable rank-eight output budget, leaving at most two more rank-one-equivalent calls." + } + ], + "overlap_check": { + "cached_complete_snapshot": { + "open_prs": 439, + "discussions": 882, + "open_prs_fetched_at_utc": "2026-10-14T23:19:56Z", + "discussions_fetched_at_utc": "2026-10-14T23:21:48Z" + }, + "live_open_pr_scan": "Five pages fetched and searched at entry, including PR #2197 and recent QQ16 work #2189, #2181, #2174, #2153, #2122, #2104, #2093, #2086 and #2079.", + "live_discussion_check": "The latest reply in #2192 at 2026-10-14T23:23:14Z releases the one-map claim and proposes a depth-two/three follow-up. No competing multi-map parity claim was present at claim time.", + "scope_distinction": "Discussion #2074 is the separate pre-F0 B2 X_U observation; this package treats the post-B1_2 d_A private-field relay.", + "final_live_refresh": { + "checked_at_utc": "2026-10-14T23:39:42Z", + "open_prs": 444, + "keyword_matches": 43, + "direct_scope_result": "No newer open PR or claim for arbitrary compositions of registered QQ16 cover maps with mod-2 odd-support analysis. PR #2197 remains the direct one-map predecessor; #2174 and #1969 remain interface predecessors. New PR #2201 concerns arity-four source bundles and is a distinct mechanism.", + "discussion_threads": "Refreshed latest comments in #2192, #2074, and hub #1167. #2192 latest relevant entries are the predecessor handoff and this claim; #2074 is the separate pre-F0 B2 observation; #1167 latest entry points to this claim.", + "refresh_limit": "scripts/find_overlap.py --refresh stalled while paginating Discussion comments earlier in this cycle; final overlap was refreshed with current open-PR search plus direct GraphQL reads of the relevant threads." + } + }, + "optimistic_cost": { + "rank_eight_output_slack": "at most 2 additional rank-one-equivalent calls", + "line_calls_lower_bound": 144, + "cover_map_operations_at_2_per_line": 288, + "scalar_copy_primitives": 32, + "terminal_cleanup_primitives": 8, + "next_core_cleanup": "0 extra clears if the existing core follows", + "other_charges": "Any map route adds operations; source access, full physical map implementation, hosting and precision remain outside this favorable comparison and cannot rescue the 144-call floor." + }, + "verification": { + "interpreter": "CPython 3.14.7", + "direct_verifier": "PASS_QQ16_MAP_PARITY_FLOOR ports=8 maps=3650 frame_checks=29200 lines=144 cover_maps=288 no_kappa", + "registered_runner": "Python 3.12 unavailable locally; package metadata/source pins checked separately.", + "hosted_checks": "Queued at initial PR head as of 2026-10-14T23:40:37Z; no hosted result claimed." + }, + "discussion_claim": "https://github.com/CrocSwap/integer-mult-bounds/discussions/2192#discussioncomment-18936199", + "discussion_hub_pointer": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1167#discussioncomment-18936193", + "claim_expiry_utc": "2026-10-15T01:31:04Z", + "publication": { + "status": "open focused PR; hosted checks queued at initial head", + "path": "research/qq16-map-parity-floor-seed-ed361f3c/", + "base": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2", + "seed": "ed361f3c876dd81e664556c9f95bd36e", + "pr_number": 2204, + "pr_url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2204", + "initial_pr_head": "385a85609729f6b8953ae27a0e6219cf6dff5449", + "opened_at_utc": "2026-10-14T23:40:30Z" + }, + "remaining_obligations": [ + "Hosted CI and registered Python 3.12 replay remain pending; update the claim if they produce a material result.", + "No alternate state layout, physical supplier mapping, selected-result change or kappa improvement is claimed." + ] +} diff --git a/research/qq16-map-parity-floor-seed-ed361f3c/VERIFY.json b/research/qq16-map-parity-floor-seed-ed361f3c/VERIFY.json new file mode 100644 index 0000000000..ff74d1e581 --- /dev/null +++ b/research/qq16-map-parity-floor-seed-ed361f3c/VERIFY.json @@ -0,0 +1,20 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/joint-query/certificate.json.gz" + ], + "commands": [ + { + "argv": [ + "{python}", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Rebuild the eight exact Y_A port frames; check all 3,650 owner maps are invertible; verify the odd-support invariant on 29,200 map/frame actions and a two-map positive control; reject odd-shift and singular-map controls; reproduce the 144-call cost floor." + } + ] +} diff --git a/research/qq16-map-parity-floor-seed-ed361f3c/verify.py b/research/qq16-map-parity-floor-seed-ed361f3c/verify.py new file mode 100644 index 0000000000..fbcb5919ec --- /dev/null +++ b/research/qq16-map-parity-floor-seed-ed361f3c/verify.py @@ -0,0 +1,220 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Verify the all-depth parity floor for the pinned QQ16 cover-map action.""" + +from __future__ import annotations + +import gzip +import hashlib +import json +from pathlib import Path + + +ROOT = Path(__file__).resolve().parents[2] +PACKAGE = Path(__file__).resolve().parent +CERTIFICATE = ROOT / "research/joint-query/certificate.json.gz" +CERTIFICATE_SHA256 = "a5ed85fac5ebf3c091482a113ab0d351eb5a7892fe2841a35e16017ec1ff49f7" +BASE_COMMIT = "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2" +PORT_FRAMES = { + 0: "f117", + 7: "f124", + 20: "f137", + 27: "f144", + 36: "f153", + 46: "f163", + 57: "f174", + 111: "f228", +} +PRIVATE_FRAME = "f0" +DIMENSION = 73 + + +def need(condition: bool, message: str) -> None: + if not condition: + raise ValueError(message) + + +def bits(value: int): + while value: + low = value & -value + yield low.bit_length() - 1 + value ^= low + + +def canonical(entries): + coefficients = {} + for axis, coefficient in entries: + coefficients[axis] = (coefficients.get(axis, 0) + coefficient) % 4 + return tuple(sorted((axis, coefficient) + for axis, coefficient in coefficients.items() + if coefficient)) + + +def act(columns, vector: int) -> int: + out = 0 + for index in bits(vector): + out ^= columns[index] + return out + + +def rank_columns(columns) -> int: + basis = {} + for column in columns: + value = column + while value: + pivot = value.bit_length() - 1 + if pivot in basis: + value ^= basis[pivot] + else: + basis[pivot] = value + break + return len(basis) + + +def frame_terms(record): + return canonical((int(axis), int(coefficient)) + for axis, coefficient in record["line_terms_Z4"]) + + +def output_frame(stage: int, port: int, label: int): + """Rebuild the Y-port boundary frame from the pinned native recipe.""" + entries = [(1 << index, 1) for index in range(9 + 8 * stage)] + entries.append((label, -1)) + return canonical(entries) + + +def odd_support(terms): + return frozenset(axis for axis, coefficient in terms if coefficient & 1) + + +def move_frame(terms, mapping): + columns = mapping["owner_right_matrix_columns"] + shift = int(mapping["payload_translation_at_identity_owner"]) + moved = [(act(columns, axis), coefficient) for axis, coefficient in terms] + moved.extend((1 << index, 2) for index in bits(shift)) + return canonical(moved) + + +def load_packet(): + raw = CERTIFICATE.read_bytes() + need(hashlib.sha256(raw).hexdigest() == CERTIFICATE_SHA256, + "pinned QQ16 certificate digest") + task = json.loads((PACKAGE / "TASK.json").read_text()) + need(task["base_commit"] == BASE_COMMIT, "scientific base pin") + return json.loads(gzip.decompress(raw)) + + +def run(): + packet = load_packet() + need(packet["schema"] == "conserved-qq16-full-cover-native-words-v1", + "pinned QQ16 certificate schema") + need("M(g,delta)f(d,z_1,...,z_lambda)=" in packet["cover_map_semantics"], + "cover-map action formula present") + need(packet["map_composition"] == + "(g,a)(h,b)=(g*h,a XOR g*b); inverse=(g^-1,g^-1*a).", + "pinned cover-map composition law") + + frames = packet["native_frame_registry"] + private = frame_terms(frames[PRIVATE_FRAME]) + need(not private, "private C fields return to frame I") + port_terms = {} + for port, frame_id in PORT_FRAMES.items(): + need(frame_id in frames, f"registered frame {frame_id}") + terms = frame_terms(frames[frame_id]) + recipe = packet["native_line_recipes"][f"positive_{port}"] + rebuilt = output_frame(1, port, int(recipe["label"])) + need(terms == rebuilt, f"frame {frame_id} matches the Y_A port recipe") + need(len(terms) == 18, f"18 exact Z4 terms in {frame_id}") + need(all(coefficient in (1, 3) for _, coefficient in terms), + f"all {frame_id} terms are odd") + port_terms[port] = terms + + maps = packet["map_registry"] + need(len(maps) == 3650, "complete registered cover-map inventory") + map_records = list(maps.values()) + for index, mapping in enumerate(map_records): + columns = [int(value) for value in mapping["owner_right_matrix_columns"]] + need(len(columns) == DIMENSION, f"map {index} matrix width") + need(all(0 <= column < (1 << DIMENSION) for column in columns), + f"map {index} matrix range") + need(rank_columns(columns) == DIMENSION, + f"map {index} owner action is invertible") + shift = int(mapping["payload_translation_at_identity_owner"]) + need(0 <= shift < (1 << DIMENSION), f"map {index} translation range") + + checked_actions = 0 + for terms in port_terms.values(): + before = len(odd_support(terms)) + for mapping in map_records: + moved = move_frame(terms, mapping) + need(len(odd_support(moved)) == before, + "cover map changed odd-support weight") + checked_actions += 1 + + # A concrete depth-two path is a positive control for iterated action. + first = map_records[1] + second = map_records[10] + sample = port_terms[0] + direct = move_frame(move_frame(sample, first), second) + need(len(odd_support(direct)) == 18, + "positive control: two composed maps preserve the 18 odd terms") + + # Controls show both hypotheses matter: an odd payload shift can cancel + # an odd term, and a singular owner action is rejected by the rank check. + odd_shift_control = canonical(((1, 1), (1, 3))) + need(not odd_shift_control, "negative control: odd shift can cancel parity") + one_line_edit = canonical(((1, 1), (1, -1))) + need(len(odd_support(((1, 1),))) - len(odd_support(one_line_edit)) == 1, + "one-term line edit can cancel only its selected parity bit") + singular_columns = list(map_records[0]["owner_right_matrix_columns"]) + singular_columns[1] = singular_columns[0] + need(rank_columns(singular_columns) < DIMENSION, + "negative control: duplicated owner column is singular") + + per_port_floor = len(odd_support(next(iter(port_terms.values())))) + need(per_port_floor == 18, "one-term line floor per port") + total_floor = per_port_floor * len(port_terms) + need(total_floor == 144 and total_floor > 2, + "full line floor exceeds favorable two-call slack") + + result = { + "status": "PASS_QQ16_MAP_PARITY_FLOOR", + "source_base": BASE_COMMIT, + "certificate_sha256_compressed": CERTIFICATE_SHA256, + "registered_maps": len(map_records), + "invertible_owner_maps": len(map_records), + "source_frames": {str(port): PORT_FRAMES[port] + for port in PORT_FRAMES}, + "odd_terms_per_source_frame": per_port_floor, + "target_odd_terms": len(odd_support(private)), + "direct_map_frame_checks": checked_actions, + "two_map_positive_control": "18 odd terms remain after two exact actions", + "one_term_line_calls_lower_bound": total_floor, + "cover_map_operations_at_two_per_line": 2 * total_floor, + "scalar_copy_primitives": 8 * 4, + "terminal_clear_primitives": 8, + "extra_clear_if_existing_next_core_runs": 0, + "favorable_extra_rank_one_equivalent_budget": 2, + "all_depth_conclusion": "cover maps preserve mod-2 odd-support weight; depth two, three, and all larger depths retain the 144-line floor", + "controls": [ + "two-map composition preserves odd-support weight", + "odd coefficient shift can cancel an odd term", + "one-term line correction toggles at most its selected parity bit", + "singular owner action is rejected", + ], + "scope": "Eight pinned Y_A frames at the post-B_1_2 cut; registered invertible cover-map actions and the one-term Z4 line model only.", + "no_controller_or_kappa_claim": True, + } + receipt = PACKAGE / "RESULT.json" + if receipt.exists(): + recorded = json.loads(receipt.read_text()) + need(recorded == result, "reproduced result receipt") + print("PASS_QQ16_MAP_PARITY_FLOOR " + f"ports={len(port_terms)} maps={len(map_records)} " + f"frame_checks={checked_actions} lines={total_floor} " + f"cover_maps={2 * total_floor} no_kappa") + return result + + +if __name__ == "__main__": + run()