From 4d7463c6f3d2ee1b33603c6180ed71f50819cbe7 Mon Sep 17 00:00:00 2001 From: Cinna Davis <1337isnot1337@users.noreply.github.com> Date: Tue, 13 Oct 2026 18:09:10 -0500 Subject: [PATCH 1/2] Add independent R439 frame-509 matrix replay --- .../CLAIM.json | 27 +++ .../LICENSE | 201 ++++++++++++++++++ .../NOTICE.md | 18 ++ .../README.md | 58 +++++ .../RESULT.json | 41 ++++ .../SOURCES.json | 30 +++ .../VALIDATION.json | 34 +++ .../inputs/PR1221-CANDIDATE.json | 165 ++++++++++++++ .../inputs/PR1221-NOTICE.md | 35 +++ .../inputs/PR973-CANDIDATE.json | 197 +++++++++++++++++ .../inputs/PR973-NOTICE.md | 30 +++ .../test_audit.py | 43 ++++ .../verify.py | 199 +++++++++++++++++ 13 files changed, 1078 insertions(+) create mode 100644 research/seed18-r439-b509-independent-replay/CLAIM.json create mode 100644 research/seed18-r439-b509-independent-replay/LICENSE create mode 100644 research/seed18-r439-b509-independent-replay/NOTICE.md create mode 100644 research/seed18-r439-b509-independent-replay/README.md create mode 100644 research/seed18-r439-b509-independent-replay/RESULT.json create mode 100644 research/seed18-r439-b509-independent-replay/SOURCES.json create mode 100644 research/seed18-r439-b509-independent-replay/VALIDATION.json create mode 100644 research/seed18-r439-b509-independent-replay/inputs/PR1221-CANDIDATE.json create mode 100644 research/seed18-r439-b509-independent-replay/inputs/PR1221-NOTICE.md create mode 100644 research/seed18-r439-b509-independent-replay/inputs/PR973-CANDIDATE.json create mode 100644 research/seed18-r439-b509-independent-replay/inputs/PR973-NOTICE.md create mode 100644 research/seed18-r439-b509-independent-replay/test_audit.py create mode 100644 research/seed18-r439-b509-independent-replay/verify.py diff --git a/research/seed18-r439-b509-independent-replay/CLAIM.json b/research/seed18-r439-b509-independent-replay/CLAIM.json new file mode 100644 index 0000000000..31203d7294 --- /dev/null +++ b/research/seed18-r439-b509-independent-replay/CLAIM.json @@ -0,0 +1,27 @@ +{ + "assignment_seed": 18, + "track": "bit supplier", + "base_commit": "bce54fb3f895cbe5cd4c0eb477c3afeed100190f", + "coordination": "No pinned sprint coordination issue exists; open issue search found only #913 (all-size/compiler) and #650 (Discussions).", + "scope": "Independent audit of PR #1221 at head 6deda901721316fcb61c6e2a6dd6b537de183452: directly replay its R439 frame-509 20-ADD replacement over GF(2) on the 11 local registers and over Z on the local replacement window; rebuild the word to compare ordered frame paths and the full ADD invoice. No new circuit, supplier adoption, or kappa is claimed.", + "method": "Use a direct row-bitset interpreter for the local Boolean map and integer coefficient vectors for the local before/after maps, independent of the proposal's verifier and native checker.", + "expected_deliverable": "Small reproducible verifier, source pins, exact result receipt, and focused controls in this directory; scoped independent verification only.", + "expected_finish_utc": "2026-10-13T23:20:00Z", + "candidate_tasks": [ + { + "task": "R439 frame-509 PR #1221: independent whole-word GF(2) and local integer-map replay", + "decision": "chosen", + "reason": "No review is recorded on #1221; its own validation is extensive, and the proposed row-bitset/Z-map method is code-disjoint." + }, + { + "task": "R420 quad4 all-length cleanup floor", + "decision": "rejected", + "reason": "Recent overlapping results #1266 and #1296 cover this object and claim." + }, + { + "task": "Selected PR589 hosting/provenance/COPY audit", + "decision": "rejected", + "reason": "Recent overlapping results #1307 and #1329 cover these exact boundaries." + } + ] +} diff --git a/research/seed18-r439-b509-independent-replay/LICENSE b/research/seed18-r439-b509-independent-replay/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/seed18-r439-b509-independent-replay/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/seed18-r439-b509-independent-replay/NOTICE.md b/research/seed18-r439-b509-independent-replay/NOTICE.md new file mode 100644 index 0000000000..72ffa32b10 --- /dev/null +++ b/research/seed18-r439-b509-independent-replay/NOTICE.md @@ -0,0 +1,18 @@ +# Attribution and assistance + +This independent audit was prepared and submitted through **@1337isnot1337** +with substantial **OpenAI Codex AI assistance** in task selection, implementation, +verification and writing. No independent human review or delegated worker is +claimed. The package is covered by the repository's Apache-2.0 license; see +`LICENSE`. + +The audited 20-ADD frame-509 candidate is Hanson Sun's (@bbMisk) PR #1221. Its +21-ADD predecessor is Cinna Davis's (@1337isnot1337) PR #973. Their source +notices are retained unchanged under `inputs/`. The frozen selected bit word is +DreamingOfClouds's PR #589 on eumemic's PR #555, with the prior ancestry and +attribution preserved in the selected result and its source manifest. + +This audit replays the local 11-register Boolean and integer maps using a +separate row-bitset / coefficient-vector implementation. It does not replace +the proposal's H1-H5/native checks, adopt its circuit as a supplier, or claim a +new kappa. diff --git a/research/seed18-r439-b509-independent-replay/README.md b/research/seed18-r439-b509-independent-replay/README.md new file mode 100644 index 0000000000..1f7601b892 --- /dev/null +++ b/research/seed18-r439-b509-independent-replay/README.md @@ -0,0 +1,58 @@ +# Independent local replay: R439 frame 509 + +This package independently replays the local matrix claim in Hanson Sun's +[PR #1221](https://github.com/CrocSwap/integer-mult-bounds/pull/1221) at exact +head `6deda901721316fcb61c6e2a6dd6b537de183452`, against Cinna Davis's PR #973 +block at `c05dc72734c25dd069077157224d4dd30c6e8c19` and the selected PR589 word +pinned in `SOURCES.json`. + +The direct row-bitset interpreter checks the complete 11-register local map +over GF(2), independently of the proposal verifier's column/truth-table code. +An integer coefficient-vector replay checks the exact local difference. The +word builder then confirms that the splice yields the reported whole-word ADD +counts and preserves all 661 ordered frame paths. This is an independent +replay of those finite claims; it does not reprove H1-H5 or native legality. + +The exact local result is: + +| Local splice | ADDs | Boolean map | Integer map | +|---|---:|---|---| +| PR973 predecessor | 21 | same as candidate | baseline | +| PR1221 candidate | 20 | same as predecessor | predecessor minus `2 e_468 e_33^T` | + +The full selected / predecessor / candidate word invoice recomputes as +24,305 / 24,285 / 24,283 ADDs. The builder changes only the B/C ADD lists; all +other pinned word fields, including the ret/scatter schedule, remain equal, and +all 661 ordered frame paths match. The separate PR #1221 checker replay also +confirms its complete paid profile. This scalar circuit saving does not change +the selected conditional `κ = 836330098538459/500000000000000000`; the complex +supplier remains binding. + +## Reproduce + +From the repository root, with Python 3.11+ and only the standard library: + +```sh +python3 -I -B research/seed18-r439-b509-independent-replay/verify.py +python3 -I -B research/seed18-r439-b509-independent-replay/test_audit.py -v +``` + +Expected verifier marker: + +```text +PASS_R439_B509_MATRIX_AUDIT local_f2_inputs=11 integer_delta=2*e468e33 frame_paths=661 ADDs=24305/24285/24283 no_new_kappa +``` + +As an additional independent-host replay, the exact PR #1221 package passed +its own verifier, ten package tests, and unchanged C++ native checks here on +Linux x86_64 / CPython 3.14.7 / GCC 16.2.1 / Boost 1.92.0. The reproduced +markers are recorded in `VALIDATION.json`. This supplements the source author's +macOS arm64 run; it does not substitute for human review or hosted CI. + +## Scope + +The result validates only the local finite matrix identity, the pinned splice, +its frame paths, and the listed ADD invoices. The PR #1221 H1-H5/native +obligations are inherited from the candidate's own checks and were rerun as +described above. No global minimum, hosted-supplier adoption, new kappa, or +complete multiplication theorem is claimed. diff --git a/research/seed18-r439-b509-independent-replay/RESULT.json b/research/seed18-r439-b509-independent-replay/RESULT.json new file mode 100644 index 0000000000..f84275074c --- /dev/null +++ b/research/seed18-r439-b509-independent-replay/RESULT.json @@ -0,0 +1,41 @@ +{ + "base_commit": "bce54fb3f895cbe5cd4c0eb477c3afeed100190f", + "candidate_head": "6deda901721316fcb61c6e2a6dd6b537de183452", + "candidate_pr": 1221, + "integer_delta_prior_minus_candidate": [ + { + "destination": 468, + "prior_minus_candidate": 2, + "source": 33 + } + ], + "local_adds": { + "candidate": 20, + "predecessor": 21 + }, + "local_f2_basis_columns_equal": 11, + "local_registers": [ + 17, + 22, + 33, + 38, + 50, + 60, + 67, + 77, + 87, + 92, + 468 + ], + "new_kappa_claimed": false, + "non_splice_fields_unchanged": true, + "ordered_frame_paths_equal": 661, + "predecessor_head": "c05dc72734c25dd069077157224d4dd30c6e8c19", + "predecessor_pr": 973, + "status": "PASS_R439_B509_MATRIX_AUDIT", + "whole_word_ADD_invoice": { + "candidate": 24283, + "predecessor": 24285, + "selected": 24305 + } +} diff --git a/research/seed18-r439-b509-independent-replay/SOURCES.json b/research/seed18-r439-b509-independent-replay/SOURCES.json new file mode 100644 index 0000000000..7015d868fa --- /dev/null +++ b/research/seed18-r439-b509-independent-replay/SOURCES.json @@ -0,0 +1,30 @@ +{ + "format": "seed18-r439-b509-independent-replay/1", + "base_commit": "bce54fb3f895cbe5cd4c0eb477c3afeed100190f", + "candidate_pr": 1221, + "candidate_head": "6deda901721316fcb61c6e2a6dd6b537de183452", + "predecessor_pr": 973, + "predecessor_head": "c05dc72734c25dd069077157224d4dd30c6e8c19", + "selected_bit_lineage": "DreamingOfClouds PR589 on eumemic PR555, as recorded in certificates/selected-result.json and the PR1221 source manifest", + "files": { + "research/seed18-r439-b509-independent-replay/inputs/PR973-CANDIDATE.json": { + "sha256": "4c340610fb641a3699224016b4a322005fa9c578d9761b23220b01bc67ab4068", + "git_blob": "40a28f124a8561b437f0cc0aefbfb49224dcf3a0" + }, + "research/seed18-r439-b509-independent-replay/inputs/PR1221-CANDIDATE.json": { + "sha256": "66bd9ef28754b6d0925d82137c0b2b90cb21b9234ffed18c41d31ab6b4f6192c", + "git_blob": "86f33af1791026ce0cf61a4cc77cd5a9c4813994" + }, + "research/e8-bit-p111-tuned/tune/bitE8mut-p111-tuned.json.gz": { + "sha256": "e3e301e62bc2b41dbf1ceac0acf3d35824ebeab1848c5a2142d4577b109da52f", + "git_blob": "85a4499bf9e4911a705d50567a2c2ef6cf23739a" + } + }, + "replay_environment": { + "os": "Linux x86_64", + "python": "3.14.7", + "cxx": "GCC 16.2.1", + "boost": "1.92.0", + "native_command": "BOOST_INCLUDE=/usr/include python3 -I -B research/r439-b509-boolean-seed05/native.py" + } +} diff --git a/research/seed18-r439-b509-independent-replay/VALIDATION.json b/research/seed18-r439-b509-independent-replay/VALIDATION.json new file mode 100644 index 0000000000..2969668763 --- /dev/null +++ b/research/seed18-r439-b509-independent-replay/VALIDATION.json @@ -0,0 +1,34 @@ +{ + "status": "PASS independent local matrix replay; PASS PR1221 package replay on a second host", + "environment": { + "os": "Linux x86_64", + "python": "3.14.7", + "compiler": "GCC 16.2.1", + "boost": "1.92.0" + }, + "independent_package": { + "command": "python3 -I -B research/seed18-r439-b509-independent-replay/verify.py", + "expected": "PASS_R439_B509_MATRIX_AUDIT local_f2_inputs=11 integer_delta=2*e468e33 frame_paths=661 ADDs=24305/24285/24283 no_new_kappa", + "result": "pass" + }, + "independent_controls": { + "command": "python3 -I -B research/seed18-r439-b509-independent-replay/test_audit.py -v", + "tests": 3, + "result": "pass" + }, + "candidate_package_replay": { + "source_pr": 1221, + "source_head": "6deda901721316fcb61c6e2a6dd6b537de183452", + "commands": [ + "python3 -I -B research/r439-b509-boolean-seed05/verify.py", + "python3 -I -B research/r439-b509-boolean-seed05/test_package.py -v", + "BOOST_INCLUDE=/usr/include python3 -I -B research/r439-b509-boolean-seed05/native.py" + ], + "results": [ + "PASS_R439_B509_BOOLEAN gates=31/21->20 ADDs=24305/24285->24283 columns=661 truth_table=2048 H1-H5 controls=27 no_new_kappa", + "10 tests passed", + "PASS_R439_B509_BOOLEAN_NATIVE words=3 columns=883/1327/1549 bridge_controls=144 five_stage_regression=PASS" + ], + "scope_note": "These are the PR1221 package's unchanged checkers rerun locally. The independent code-disjoint audit in this package is narrower and covers the local 11-register maps, splice, frame paths and ADD invoice." + } +} diff --git a/research/seed18-r439-b509-independent-replay/inputs/PR1221-CANDIDATE.json b/research/seed18-r439-b509-independent-replay/inputs/PR1221-CANDIDATE.json new file mode 100644 index 0000000000..86f33af179 --- /dev/null +++ b/research/seed18-r439-b509-independent-replay/inputs/PR1221-CANDIDATE.json @@ -0,0 +1,165 @@ +{ + "assignment_seed": 5, + "base_commit": "1b59b624d21924f8e3537cdc1ac52d3be6eda2fe", + "format": "r439-b509-boolean/1", + "frame": 509, + "gates": [ + [ + 509, + 50, + [ + 67 + ] + ], + [ + 509, + 87, + [ + 77 + ] + ], + [ + 509, + 87, + [ + 22 + ] + ], + [ + 509, + 87, + [ + 92 + ] + ], + [ + 509, + 87, + [ + 38 + ] + ], + [ + 509, + 87, + [ + 50 + ] + ], + [ + 509, + 87, + [ + 60 + ] + ], + [ + 509, + 468, + [ + 38 + ] + ], + [ + 509, + 38, + [ + 33 + ] + ], + [ + 509, + 77, + [ + 33 + ] + ], + [ + 509, + 33, + [ + 87 + ] + ], + [ + 509, + 17, + [ + 33 + ] + ], + [ + 509, + 33, + [ + 22 + ] + ], + [ + 509, + 67, + [ + 17 + ] + ], + [ + 509, + 50, + [ + 17 + ] + ], + [ + 509, + 92, + [ + 33 + ] + ], + [ + 509, + 60, + [ + 17 + ] + ], + [ + 509, + 468, + [ + 92 + ] + ], + [ + 509, + 77, + [ + 17 + ] + ], + [ + 509, + 38, + [ + 17 + ] + ] + ], + "registers": [ + 17, + 22, + 33, + 38, + 50, + 60, + 67, + 77, + 87, + 92, + 468 + ], + "slice": [ + 283, + 314 + ] +} diff --git a/research/seed18-r439-b509-independent-replay/inputs/PR1221-NOTICE.md b/research/seed18-r439-b509-independent-replay/inputs/PR1221-NOTICE.md new file mode 100644 index 0000000000..8f857b7ee0 --- /dev/null +++ b/research/seed18-r439-b509-independent-replay/inputs/PR1221-NOTICE.md @@ -0,0 +1,35 @@ +# Attribution and license + +Hanson Sun (@bbMisk), with substantial OpenAI Codex assistance in research, +implementation, verification and writing. No independent human review is +claimed. New material is Apache-2.0, under the repository's `../../LICENSE`. + +This construction changes one four-gate window of Cinna Davis +(@1337isnot1337)'s PR973 frame-509 program. Aaron Wang (@navinor)'s PR1015 +independently reaches the same prior block length, and his PR1127 uses the +related Boolean triangle identity on the original word. Dugongue's +PR541/PR548 and DreamingOfClouds' PR589 tuner are earlier sources for these +move families. The identity itself is not claimed as new. + +ToikY's concurrent PR1208 independently applies the same cancellation to +PR1015's block in the composed PR1122 word, also reaching 20 block ADDs. +It appeared during this package's verification and is credited without a +priority claim. This package's additional scope is the original H1–H5 +interface on the selected/PR973 lineage. + +DreamingOfClouds' PR589 tuning of eumemic's PR555 supplies the frozen R439 +word and interface checker, with the retained PR543/PR545/PR510 ancestry. +The preceding frame-509 source-sharing result is Anudeep Adiraju's PR843. +Their original notices remain unchanged. + +The native harness adapts Cinna Davis's PR973 harness, itself adapted from +Jerry Chen (@CubeJerry)'s PR906 package. The independent scalar receipt +conventions also follow Gareth Davidson (@bitplane)'s six-wire Boolean +package. Dylan Crow authored the retained exporter/native interfaces with +Anthropic Claude assistance; DaysSky supplied the generalized bridged-stage +schedule. Zhihao Chen, eumemic, DreamingOfClouds and Chafik Boukhalfa are +credited in the unchanged global compiler source. All source-local notices +and licenses are retained. + +Only the new scoped research directory is changed. No predecessor artifact, +`upstream/` file, selected record, or review disposition is edited. diff --git a/research/seed18-r439-b509-independent-replay/inputs/PR973-CANDIDATE.json b/research/seed18-r439-b509-independent-replay/inputs/PR973-CANDIDATE.json new file mode 100644 index 0000000000..40a28f124a --- /dev/null +++ b/research/seed18-r439-b509-independent-replay/inputs/PR973-CANDIDATE.json @@ -0,0 +1,197 @@ +{ + "assignment_seed": 8, + "base_commit": "bbc600db2fc15007b7c914f4f2b2ed55fa909c87", + "baseline_additions": 31, + "candidate_additions": 21, + "format": "r439-frame509-seed08/1", + "frame": 509, + "gates": [ + [ + 509, + 50, + [ + 67 + ] + ], + [ + 509, + 87, + [ + 77 + ] + ], + [ + 509, + 87, + [ + 22 + ] + ], + [ + 509, + 87, + [ + 92 + ] + ], + [ + 509, + 87, + [ + 38 + ] + ], + [ + 509, + 87, + [ + 50 + ] + ], + [ + 509, + 87, + [ + 60 + ] + ], + [ + 509, + 38, + [ + 33 + ] + ], + [ + 509, + 468, + [ + 33 + ] + ], + [ + 509, + 77, + [ + 33 + ] + ], + [ + 509, + 468, + [ + 38 + ] + ], + [ + 509, + 33, + [ + 87 + ] + ], + [ + 509, + 17, + [ + 33 + ] + ], + [ + 509, + 33, + [ + 22 + ] + ], + [ + 509, + 67, + [ + 17 + ] + ], + [ + 509, + 50, + [ + 17 + ] + ], + [ + 509, + 92, + [ + 33 + ] + ], + [ + 509, + 60, + [ + 17 + ] + ], + [ + 509, + 468, + [ + 92 + ] + ], + [ + 509, + 77, + [ + 17 + ] + ], + [ + 509, + 38, + [ + 17 + ] + ] + ], + "registers": [ + 17, + 22, + 33, + 38, + 50, + 60, + 67, + 77, + 87, + 92, + 468 + ], + "search": { + "dead_ends": 1, + "identity_factorizations": 22, + "improvement_trace": [ + { + "additions": 22, + "trial": 0 + }, + { + "additions": 21, + "trial": 44 + } + ], + "incumbent_cutoffs": 11977, + "method": "bidirectional diagonal-preserving nonnegative integer subtraction", + "optimality_claim": false, + "reverse_dominated_factorizations": 22, + "seed": 8, + "stopping_rule": "Exactly 12000 trials; stop a trial at identity, no legal subtraction, or incumbent length.", + "trials": 12000 + }, + "slice": [ + 283, + 314 + ], + "source": "research/e8-bit-p111-tuned/tune/bitE8mut-p111-tuned.json.gz", + "source_sha256": "e3e301e62bc2b41dbf1ceac0acf3d35824ebeab1848c5a2142d4577b109da52f" +} diff --git a/research/seed18-r439-b509-independent-replay/inputs/PR973-NOTICE.md b/research/seed18-r439-b509-independent-replay/inputs/PR973-NOTICE.md new file mode 100644 index 0000000000..a1d170a418 --- /dev/null +++ b/research/seed18-r439-b509-independent-replay/inputs/PR973-NOTICE.md @@ -0,0 +1,30 @@ +# Attribution and assistance + +Submitted through **@1337isnot1337**, prepared with substantial **OpenAI Codex +AI assistance** in research, implementation, exact verification and writing. +No independent human review or delegated worker is claimed. New contributions +are under the repository's Apache-2.0 license, `../../LICENSE`. + +The word and interface checker are DreamingOfClouds' PR589 on eumemic's PR555, +retaining PR543, PR545, PR510 and earlier supplier credit. Their original +notices remain unchanged. Jacob Sussman introduced the E8 unit. Dylan Crow +authored the exporter and native checker interfaces with Anthropic Claude +assistance; DaysSky supplied the bridged stage schedule generalized in +`columns_k.cpp`. All source-local copyright and assistance notices remain. + +Anudeep Adiraju (@anudeepadi), PR843, supplied the preceding 31->26 frame-509 +rewrite and independently hosted it. Its original recipe is retained without +edits at a frozen head. This submission credits that concrete prior result; +its new 21-gate circuit is not a claim of priority for frame-509 source sharing. + +The bidirectional positive-integer reduction search adapts martin Rv +(@martinxxx9)'s PR884 frame-521 method. The independent verifier, native +harness and relocated package-control pattern adapt Jerry Chen (@CubeJerry)'s +PR906 frame-522 package. The adapted files identify their source authors. +Their original files are unchanged and their exact source paths/hashes are +recorded as implementation lineage in `SOURCES.json`. + +Related fixed-factor and prefix contributions include Aaron Wang's +PR873/891, Deftsalt's PR880, Ross Richardson's PR908/914/923/925/936, +Gareth Davidson's PR904, and the semantic-D compensation work PR915/926/941. +None of their candidate circuit savings is silently added to this result. diff --git a/research/seed18-r439-b509-independent-replay/test_audit.py b/research/seed18-r439-b509-independent-replay/test_audit.py new file mode 100644 index 0000000000..aa380c8634 --- /dev/null +++ b/research/seed18-r439-b509-independent-replay/test_audit.py @@ -0,0 +1,43 @@ +#!/usr/bin/env python3 +"""Focused controls for the seed18 R439 frame-509 matrix audit.""" + +import importlib.util +import json +from pathlib import Path +import unittest + +HERE = Path(__file__).resolve().parent +SPEC = importlib.util.spec_from_file_location("seed18_matrix_verify", HERE / "verify.py") +verify = importlib.util.module_from_spec(SPEC) +SPEC.loader.exec_module(verify) + + +class MatrixAuditTests(unittest.TestCase): + @classmethod + def setUpClass(cls): + cls.prior = verify.load_json(verify.HERE / verify.PRIOR) + cls.candidate = verify.load_json(verify.HERE / verify.CANDIDATE) + + def test_receipt_replays(self): + result = verify.audit() + self.assertEqual(result["whole_word_ADD_invoice"], + {"selected": 24305, "predecessor": 24285, "candidate": 24283}) + self.assertEqual(result["integer_delta_prior_minus_candidate"], + [{"destination": 468, "source": 33, "prior_minus_candidate": 2}]) + + def test_wrong_operand_breaks_boolean_endpoint(self): + mutated = json.loads(json.dumps(self.candidate["gates"])) + mutated[0][2][0] = 60 if mutated[0][2][0] != 60 else 67 + before = verify.local_map(self.prior["gates"], verify.WIRES, True) + after = verify.local_map(mutated, verify.WIRES, True) + self.assertNotEqual(before, after) + + def test_omitted_gate_breaks_boolean_endpoint(self): + mutated = self.candidate["gates"][:-1] + before = verify.local_map(self.prior["gates"], verify.WIRES, True) + after = verify.local_map(mutated, verify.WIRES, True) + self.assertNotEqual(before, after) + + +if __name__ == "__main__": + unittest.main(verbosity=2) diff --git a/research/seed18-r439-b509-independent-replay/verify.py b/research/seed18-r439-b509-independent-replay/verify.py new file mode 100644 index 0000000000..8082f2382e --- /dev/null +++ b/research/seed18-r439-b509-independent-replay/verify.py @@ -0,0 +1,199 @@ +#!/usr/bin/env python3 +"""Code-disjoint local matrix replay of the pinned R439 frame-509 splice.""" + +from __future__ import annotations + +import argparse +import copy +import gzip +import hashlib +import json +from pathlib import Path + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] +BASE_WORD = "research/e8-bit-p111-tuned/tune/bitE8mut-p111-tuned.json.gz" +PRIOR = "inputs/PR973-CANDIDATE.json" +CANDIDATE = "inputs/PR1221-CANDIDATE.json" +WIRES = [17, 22, 33, 38, 50, 60, 67, 77, 87, 92, 468] +FRAME = 509 +SLICE = (283, 314) + + +def need(condition: bool, message: str) -> None: + if not condition: + raise ValueError(message) + + +def strict_pairs(items): + out = {} + for key, value in items: + need(key not in out, "duplicate JSON key: " + key) + out[key] = value + return out + + +def load_json(path: Path): + return json.loads(path.read_text(), object_pairs_hook=strict_pairs, + parse_constant=lambda token: (_ for _ in ()).throw(ValueError(token))) + + +def load_word(path: Path): + return json.loads(gzip.decompress(path.read_bytes()), object_pairs_hook=strict_pairs, + parse_constant=lambda token: (_ for _ in ()).throw(ValueError(token))) + + +def git_blob(raw: bytes) -> str: + return hashlib.sha1(b"blob " + str(len(raw)).encode() + b"\0" + raw).hexdigest() + + +def verify_source_pins(): + manifest = load_json(HERE / "SOURCES.json") + need(manifest["base_commit"] == "bce54fb3f895cbe5cd4c0eb477c3afeed100190f", "base commit pin") + for rel, expected in manifest["files"].items(): + raw = (ROOT / rel).read_bytes() + need(hashlib.sha256(raw).hexdigest() == expected["sha256"], "source SHA-256: " + rel) + need(git_blob(raw) == expected["git_blob"], "source Git blob: " + rel) + return manifest + + +def local_map(gates, wires, characteristic_two: bool): + """Replay CNOT-style row additions on the declared 11 local coordinates.""" + index = {wire: i for i, wire in enumerate(wires)} + n = len(wires) + if characteristic_two: + rows = [1 << i for i in range(n)] + for gate in gates: + need(type(gate) is list and len(gate) == 3, "gate shape") + frame, dst, srcs = gate + need(frame == FRAME and len(srcs) == 1, "gate frame/source shape") + src = srcs[0] + need(dst in index and src in index and dst != src, "gate outside local coordinates") + rows[index[dst]] ^= rows[index[src]] + return tuple(rows) + + rows = [[int(i == j) for j in range(n)] for i in range(n)] + for gate in gates: + need(type(gate) is list and len(gate) == 3, "gate shape") + frame, dst, srcs = gate + need(frame == FRAME and len(srcs) == 1, "gate frame/source shape") + src = srcs[0] + need(dst in index and src in index and dst != src, "gate outside local coordinates") + target, source = rows[index[dst]], rows[index[src]] + rows[index[dst]] = [a + b for a, b in zip(target, source)] + return tuple(tuple(row) for row in rows) + + +def rebuild_cleanup(word): + v = word["v"] + word["C"] = [[1, dst, list(srcs)] for _, dst, srcs in + reversed(word["A"] + word["B"]) + if not v <= dst < 2 * v] + return word + + +def splice(base, gates): + word = copy.deepcopy(base) + start, end = SLICE + need(len(word["B"][start:end]) == 31, "selected frame-509 source slice length") + need(all(g[0] == FRAME for g in word["B"][start:end]), "selected source frame") + word["B"][start:end] = copy.deepcopy(gates) + return rebuild_cleanup(word) + + +def frame_paths(word): + paths = [[frame] for frame in word["start"]] + for phase in "DABC": + for frame, dst, srcs in word[phase]: + for register in [dst, *srcs]: + if paths[register][-1] != frame: + paths[register].append(frame) + for register, frame in enumerate(word["final"]): + if paths[register][-1] != frame: + paths[register].append(frame) + return paths + + +def add_count(word): + phase_adds = sum(len(srcs) for phase in "DABC" for _, _, srcs in word[phase]) + scatter_adds = sum(len(readers) for readers in word["scatter"]) + return phase_adds + scatter_adds + + +def audit(): + manifest = verify_source_pins() + prior = load_json(HERE / PRIOR) + candidate = load_json(HERE / CANDIDATE) + for recipe in (prior, candidate): + need(recipe["frame"] == FRAME and recipe["slice"] == list(SLICE), "recipe frame/slice") + need(recipe["registers"] == WIRES, "recipe registers") + need(all(g[0] == FRAME and g[1] in WIRES and g[2][0] in WIRES + for g in recipe["gates"]), "recipe gate domain") + need(prior["format"] == "r439-frame509-seed08/1" and len(prior["gates"]) == 21, + "pinned PR973 recipe") + need(candidate["format"] == "r439-b509-boolean/1" and len(candidate["gates"]) == 20, + "pinned PR1221 recipe") + need(prior["source_sha256"] == manifest["files"][BASE_WORD]["sha256"], "predecessor source binding") + + old_f2 = local_map(prior["gates"], WIRES, True) + new_f2 = local_map(candidate["gates"], WIRES, True) + need(old_f2 == new_f2, "local GF(2) maps differ") + old_z = local_map(prior["gates"], WIRES, False) + new_z = local_map(candidate["gates"], WIRES, False) + delta = [] + for row, (old_row, new_row) in enumerate(zip(old_z, new_z)): + for col, (old_value, new_value) in enumerate(zip(old_row, new_row)): + if old_value != new_value: + delta.append({"destination": WIRES[row], "source": WIRES[col], + "prior_minus_candidate": old_value - new_value}) + expected_delta = [{"destination": 468, "source": 33, "prior_minus_candidate": 2}] + need(delta == expected_delta, "integer local map difference") + + base = load_word(ROOT / BASE_WORD) + prior_word = splice(base, prior["gates"]) + candidate_word = splice(base, candidate["gates"]) + for word in (prior_word, candidate_word): + for key in base: + if key not in ("B", "C"): + need(word[key] == base[key], "non-splice field changed: " + key) + paths = frame_paths(base) + need(len(paths) == 661 and frame_paths(prior_word) == paths + and frame_paths(candidate_word) == paths, "ordered frame paths changed") + invoices = [add_count(word) for word in (base, prior_word, candidate_word)] + need(invoices == [24305, 24285, 24283], "whole-word ADD invoice") + + return { + "status": "PASS_R439_B509_MATRIX_AUDIT", + "base_commit": manifest["base_commit"], + "candidate_pr": manifest["candidate_pr"], + "candidate_head": manifest["candidate_head"], + "predecessor_pr": manifest["predecessor_pr"], + "predecessor_head": manifest["predecessor_head"], + "local_registers": WIRES, + "local_adds": {"predecessor": len(prior["gates"]), "candidate": len(candidate["gates"])}, + "local_f2_basis_columns_equal": len(WIRES), + "integer_delta_prior_minus_candidate": delta, + "whole_word_ADD_invoice": {"selected": invoices[0], "predecessor": invoices[1], + "candidate": invoices[2]}, + "ordered_frame_paths_equal": len(paths), + "non_splice_fields_unchanged": True, + "new_kappa_claimed": False + } + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--write-result", action="store_true") + args = parser.parse_args() + result = audit() + receipt = HERE / "RESULT.json" + if args.write_result: + receipt.write_text(json.dumps(result, sort_keys=True, indent=2) + "\n") + else: + need(receipt.is_file() and load_json(receipt) == result, "result receipt mismatch") + print("PASS_R439_B509_MATRIX_AUDIT local_f2_inputs=11 integer_delta=2*e468e33 " + "frame_paths=661 ADDs=24305/24285/24283 no_new_kappa") + + +if __name__ == "__main__": + main() From a42e525e9868970f3fa2d99dccca45f014aa0fd3 Mon Sep 17 00:00:00 2001 From: Cinna Davis <1337isnot1337@users.noreply.github.com> Date: Tue, 13 Oct 2026 18:10:07 -0500 Subject: [PATCH 2/2] Record seed18 verification handoff --- research/seed18-r439-b509-independent-replay/CLAIM.json | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/research/seed18-r439-b509-independent-replay/CLAIM.json b/research/seed18-r439-b509-independent-replay/CLAIM.json index 31203d7294..aeae0e4a85 100644 --- a/research/seed18-r439-b509-independent-replay/CLAIM.json +++ b/research/seed18-r439-b509-independent-replay/CLAIM.json @@ -7,6 +7,13 @@ "method": "Use a direct row-bitset interpreter for the local Boolean map and integer coefficient vectors for the local before/after maps, independent of the proposal's verifier and native checker.", "expected_deliverable": "Small reproducible verifier, source pins, exact result receipt, and focused controls in this directory; scoped independent verification only.", "expected_finish_utc": "2026-10-13T23:20:00Z", + "result": { + "status": "submitted for review as an independent finite verification; no new circuit or kappa", + "pr": "https://github.com/CrocSwap/integer-mult-bounds/pull/1344", + "commit": "4d7463c6f3d2ee1b33603c6180ed71f50819cbe7", + "finding": "The 21-ADD PR973 and 20-ADD PR1221 local blocks have equal GF(2) maps on 11 registers; their integer map difference is exactly 2 e_468 e_33^T. The selected/predecessor/candidate whole-word ADD invoices are 24305/24285/24283, with 661 unchanged ordered frame paths.", + "checks": "Independent verifier and three controls pass; the exact PR1221 verifier, ten tests, and Linux C++ native suite also pass." + }, "candidate_tasks": [ { "task": "R439 frame-509 PR #1221: independent whole-word GF(2) and local integer-map replay",