From 4ff7b270e1123861044dfc6a59013599a7c94254 Mon Sep 17 00:00:00 2001 From: Cinna Davis <1337isnot1337@users.noreply.github.com> Date: Wed, 14 Oct 2026 18:06:39 -0500 Subject: [PATCH 1/2] Research: fully price R439 helper-sharing wrap --- .../CERTIFICATE.json | 111 +++++++ .../LICENSE | 201 +++++++++++++ .../NOTICE.md | 5 + .../README.md | 69 +++++ .../SOURCES.json | 66 +++++ .../TASK.json | 169 +++++++++++ .../VERIFY.json | 27 ++ .../verify.py | 274 ++++++++++++++++++ 8 files changed, 922 insertions(+) create mode 100644 research/r439-copyshare-priced-wrap-seedaaa3e40/CERTIFICATE.json create mode 100644 research/r439-copyshare-priced-wrap-seedaaa3e40/LICENSE create mode 100644 research/r439-copyshare-priced-wrap-seedaaa3e40/NOTICE.md create mode 100644 research/r439-copyshare-priced-wrap-seedaaa3e40/README.md create mode 100644 research/r439-copyshare-priced-wrap-seedaaa3e40/SOURCES.json create mode 100644 research/r439-copyshare-priced-wrap-seedaaa3e40/TASK.json create mode 100644 research/r439-copyshare-priced-wrap-seedaaa3e40/VERIFY.json create mode 100644 research/r439-copyshare-priced-wrap-seedaaa3e40/verify.py diff --git a/research/r439-copyshare-priced-wrap-seedaaa3e40/CERTIFICATE.json b/research/r439-copyshare-priced-wrap-seedaaa3e40/CERTIFICATE.json new file mode 100644 index 0000000000..f527d1ef23 --- /dev/null +++ b/research/r439-copyshare-priced-wrap-seedaaa3e40/CERTIFICATE.json @@ -0,0 +1,111 @@ +{ + "invoice": { + "B": { + "base": 1113070, + "candidate": 1196402 + }, + "D_source_ADDs": { + "base": 18085, + "candidate": 11854 + }, + "F": { + "base": 49347, + "candidate": 75381 + }, + "copies_and_erasures": { + "base": [ + 9, + 9 + ], + "candidate": [ + 9, + 9 + ] + }, + "exporter_record_sha256": { + "base": "ea44aa047a2a9cf034de8b56b2166c49cf2dbdf9cd9ed6a20299a4f2b05ef09a", + "candidate": "c2cc0fc6fbcad48f1550b0c52c06e78ac7c5cfed59634690de2c036d80f1a9db" + }, + "local_bits": { + "base": 93, + "candidate": 95, + "limit": 104 + }, + "native_ADDs": { + "base": 24305, + "candidate": 18074, + "saving": 6231 + }, + "nine_stage_bits": { + "base": 177, + "candidate": 180, + "limit": 192 + } + }, + "limits": [ + "The 205-pair matching is inherited from PR848/PR1782; optimality is not claimed.", + "This is a local R439 word construction; selected-supplier adoption, hosting, outer assembly, and kappa are not claimed.", + "The inherited H2/K flags remain false; admission uses the scoped H2-sem contract." + ], + "matching": { + "best_pair": [ + 277, + 434 + ], + "best_saving": 65, + "matching_pairs": 205, + "matching_saving": 6231, + "operands": 430, + "oriented_pairs": 184470, + "positive_pairs": 41404 + }, + "negative_controls": [ + "missing_restore_breaks_full_boundary", + "wrong_restore_destination_breaks_boundary", + "nonzero_frame_helper_gate_fails_H2_sem", + "local_precision_over_104_rejected", + "nine_stage_precision_over_192_rejected" + ], + "scope": "One fixed seed-42 205-pair wrapper on the pinned selected R439 word; no matching optimality claim.", + "source_sha256": { + "research/e8-bit-carrier-skeleton/code/bit/export_records.py": "8a5999601f917dbb492bb9ae9a344611f18cc7cedc53dc3c76496a369e530eb3", + "research/e8-bit-p111-tuned/code/xcheck_p.py": "af3decc877e27c00001cf56f50c6c09566e8e101297ab34c7860aed96a06d80e", + "research/e8-bit-p111-tuned/tune/bitE8mut-p111-tuned.json.gz": "e3e301e62bc2b41dbf1ceac0acf3d35824ebeab1848c5a2142d4577b109da52f", + "research/r439-bsection-stars-seed01/build.py": "15ceb1d806fcd4f903324d3c2aaf7655c08073f2bfa56bd39cbcfd49a0757fa6", + "research/r439-bsection-stars-seed01/verify.py": "eb387243b9071a0309e04248bc088fe6f33067e39f87d9fcd1785866020b97ee", + "research/r439-copyshare-h2sem-admission/SOURCES.json": "be31c22161eec9950d2f7115db7cfd2c8276cff8fe57964dde0885820456c3e6", + "research/r439-copyshare-h2sem-admission/verify.py": "09400f88e9e598bc6022ba32fcc6f9d1f048c5106b4d73b02a6f9f318be1c812", + "research/r439-semantic-d-contract-seed10/PROOF.md": "dfbca8c61a92fdf0db8af450dc4466849da37fc296e28b67f357e196e87327db" + }, + "status": "PASS_R439_COPYSHARE_PRICED_WRAP", + "wrapper": { + "D_gates": { + "base": 111, + "candidate": 521 + }, + "columns_checked_each_direction": 661, + "cut_state_equal": true, + "extra_prep_restore_gates": 410, + "frame_paths_equal": true, + "inherited_failed_flags": [ + "H2_D_frame0_targets_from_helpers", + "K_equals_D" + ], + "paid_profile": { + "1": 1323, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 19 + }, + "paid_rank_mass": 5129, + "pairs": 205, + "semantic_H2": { + "no_target_feedback": true, + "zero_frame_distinct_operands": true + }, + "semantic_N_equals_raw_K": true + } +} diff --git a/research/r439-copyshare-priced-wrap-seedaaa3e40/LICENSE b/research/r439-copyshare-priced-wrap-seedaaa3e40/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/r439-copyshare-priced-wrap-seedaaa3e40/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/r439-copyshare-priced-wrap-seedaaa3e40/NOTICE.md b/research/r439-copyshare-priced-wrap-seedaaa3e40/NOTICE.md new file mode 100644 index 0000000000..c0c2b504ba --- /dev/null +++ b/research/r439-copyshare-priced-wrap-seedaaa3e40/NOTICE.md @@ -0,0 +1,5 @@ +## Attribution and scope + +This package constructs and bills one fixed helper-sharing wrapper. The 205-pair matching and its seed-42 source-read census descend from PR848; Aaron Wang's PR1782 established semantic H2/K admission and exact F2 boundary behavior for that wrapper. Woklerx's PR1194 supplies the semantic D contract and chronological bridge. These contributions are reused and cited; their existing packages and source files are not modified. + +The exact source word retains the authorship and licensing recorded in its pinned source manifest. New package code is licensed under Apache-2.0. Prepared by Cinna Davis with substantial OpenAI Codex assistance. diff --git a/research/r439-copyshare-priced-wrap-seedaaa3e40/README.md b/research/r439-copyshare-priced-wrap-seedaaa3e40/README.md new file mode 100644 index 0000000000..d426601551 --- /dev/null +++ b/research/r439-copyshare-priced-wrap-seedaaa3e40/README.md @@ -0,0 +1,69 @@ +# Fully priced 205-pair R439 helper-sharing wrap + +**Local bit-word construction: 6,231 fewer ADD gates; both inherited precision guards pass. No selected-supplier or κ claim.** + +This package answers the explicit open question from [PR1782](https://github.com/CrocSwap/integer-mult-bounds/pull/1782): bill the semantic-H2-admitted helper-sharing wrapper. On the pinned R439 word, the fixed seed-42 matching of 205 disjoint helper pairs reduces the complete ADD invoice from 24,305 to 18,074 while preserving the full F2 boundary and paid profile. The official record exporter agrees with the literal envelope recurrence, and the local and nine-stage bills remain at 95/104 and 180/192 bits. + +## Exact object and scope + +The object is the pinned selected R439 word `bitE8mut-p111-tuned` at `v=111`, `R=439`. Its D section has 111 frame-zero gates and 18,085 source ADDs. The inherited PR848 census has 430 non-retained helper operands; its deterministic seed-42 greedy matching contains 205 disjoint ordered pairs. This package reuses that exact matching and does not claim it is optimal. + +For each selected pair `(a,b)`, the circuit prepares `a <- a+b` before D, substitutes `a` by `a+b` in every dependent D source row, then restores `a <- a+b` after the D body. All 410 one-source preparation/restoration ADDs are charged. The resulting D has 521 gates. The semantic H2/K contract from PR1194 admits this helper-writing word; the inherited gate-local `H2_D_frame0_targets_from_helpers` and `K_equals_D` flags remain false. + +## Exact result + +| Quantity | Pinned word | Wrapped word | +|---|---:|---:| +| Complete ADD gates | 24,305 | **18,074** | +| Net ADD saving | | **6,231** | +| D source ADDs | 18,085 | 11,854 | +| D gates | 111 | 521 | +| Forward envelope `F` | 49,347 | 75,381 | +| Reverse envelope `B` | 1,113,070 | 1,196,402 | +| Local payload bits | 93 / 104 | **95 / 104** | +| Nine-stage bits | 177 / 192 | **180 / 192** | +| COPY / ERASE records | 9 / 9 | 9 / 9 | + +The local bill uses `64 F^3 B^2`; the nine-stage bill uses `2^18 F^5 B^4`. Both the literal stream calculation and the repository's `export_records.py` produce the same ADD count, `F`, `B`, and local payload precision. The paid profile is unchanged: + +```text +{1:1323, 2:1342, 3:79, 4:44, 5:102, 6:11, 7:19} +rank mass = 5129 +``` + +The full 661-column map is replayed forward and backward. The D boundary is unchanged, the chronological cut state and register frame paths are identical, and the semantic `N` equals the raw K derived from A/scatter/B. The candidate has exactly the two inherited flag failures listed above. + +## Predecessors and overlap + +PR1782 (`1cfe5e10ce38b04209699c1a6b0e62b87e21833f`) established the H2-sem admission and left this complete integer invoice open; this package supplies that priced construction. The current complete overlap snapshot covered 435 open PRs and 877 Discussion records, fetched at 23:03:49Z and 23:05:44Z. The task terms produced no current PR or Discussion match. A live open-PR search also found no same-word construction. Its nearest result, [PR2033](https://github.com/CrocSwap/integer-mult-bounds/pull/2033), studies a fixed pair on a different PR1062 star-composed word and reports no saving there. This package takes the one-word invoice left open by PR1782; it does not repeat PR2033's word or transfer its result. + +## Reproduce + +From the repository root: + +```sh +python3 -I -B research/r439-copyshare-priced-wrap-seedaaa3e40/verify.py +python3 scripts/research_package.py --package research/r439-copyshare-priced-wrap-seedaaa3e40 --check-only +``` + +The verifier rebuilds the fixed matching and wrapper from pinned predecessor code, checks source hashes, replays both directions, compares the paid profile, verifies the full ADD and precision invoices against the official record exporter, and runs five negative controls. Expected final line: + +```text +PASS_R439_COPYSHARE_PRICED_WRAP pairs=205 ADDs=24305->18074 saved=6231 F=49347->75381 B=1113070->1196402 guards=95/104,180/192 profile_mass=5129 controls=5 no_kappa +``` + +`CERTIFICATE.json` holds the exact census, exporter record hashes, boundary results, paid profile and rejected controls. `SOURCES.json` pins the source word, semantic admission package, bound routines, exporter and base. + +## Limits + +This is a source-bound construction for one finite R439 word. It is not a proof that the seed-42 matching is optimal, a reusable all-size compiler, a selected bit-supplier admission, or an integer-multiplication exponent improvement. The selected bit side remains nonbinding; hosting, outer assembly and κ are outside this package. The replacement H2-sem argument is inherited from PR1194 and PR1782 rather than reproved here. + +## Open next questions + +- **Can this wrapper be admitted as a complete supplier candidate under source realization and outer assembly?** That would connect the 6,231 local ADD saving to the conditional multiplication bound. A feasible first step is to build a source-bound supplier manifest and run the existing all-size compiler and hosting checks against the exact candidate. Blocked by the missing source-realization, tape and outer analytic obligations; this package supplies only the local priced word. + +## Credit + +Credit Aaron Wang's PR1782 (`1cfe5e10ce38b04209699c1a6b0e62b87e21833f`) for the semantic H2/K admission, PR1194 for the semantic D contract and chronological bridge, and the PR848 lineage for the helper-pair census and seed-42 matching. PR2033's fixed-pair result concerns a different PR1062 star-composed word and is not reused as evidence here. The source R439 word and inherited review lineage retain their original attribution. + +Prepared by Cinna Davis with substantial OpenAI Codex assistance in scoping, construction, exact invoice verification and packaging. This package's new work is Apache-2.0; inherited source files remain pinned and unmodified. diff --git a/research/r439-copyshare-priced-wrap-seedaaa3e40/SOURCES.json b/research/r439-copyshare-priced-wrap-seedaaa3e40/SOURCES.json new file mode 100644 index 0000000000..dd1b612871 --- /dev/null +++ b/research/r439-copyshare-priced-wrap-seedaaa3e40/SOURCES.json @@ -0,0 +1,66 @@ +{ + "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/e8-bit-carrier-skeleton/code/bit/export_records.py", + "usage": "input", + "git_blob": "3632d370486a02f5456f7643ced03f8c925b2350", + "sha256": "8a5999601f917dbb492bb9ae9a344611f18cc7cedc53dc3c76496a369e530eb3" + }, + { + "path": "research/e8-bit-p111-tuned/code/xcheck_p.py", + "usage": "input", + "git_blob": "184f5dcf94a486cc7db91ca4db5865916bf26009", + "sha256": "af3decc877e27c00001cf56f50c6c09566e8e101297ab34c7860aed96a06d80e" + }, + { + "path": "research/e8-bit-p111-tuned/tune/bitE8mut-p111-tuned.json.gz", + "usage": "input", + "git_blob": "85a4499bf9e4911a705d50567a2c2ef6cf23739a", + "sha256": "e3e301e62bc2b41dbf1ceac0acf3d35824ebeab1848c5a2142d4577b109da52f" + }, + { + "path": "research/r439-bsection-stars-seed01/build.py", + "usage": "input", + "git_blob": "0c9e3253e527f3a409406797914a3aaa8cb36814", + "sha256": "15ceb1d806fcd4f903324d3c2aaf7655c08073f2bfa56bd39cbcfd49a0757fa6" + }, + { + "path": "research/r439-bsection-stars-seed01/verify.py", + "usage": "input", + "git_blob": "be296a579cef6722786d589652f73662a92252fb", + "sha256": "eb387243b9071a0309e04248bc088fe6f33067e39f87d9fcd1785866020b97ee" + }, + { + "path": "research/r439-copyshare-h2sem-admission/SOURCES.json", + "usage": "input", + "git_blob": "10b53805d68327ab8512cf418325a875f573436e", + "sha256": "be31c22161eec9950d2f7115db7cfd2c8276cff8fe57964dde0885820456c3e6" + }, + { + "path": "research/r439-copyshare-h2sem-admission/verify.py", + "usage": "input", + "git_blob": "e24e90390acc3f032041da98340288c21ad398b3", + "sha256": "09400f88e9e598bc6022ba32fcc6f9d1f048c5106b4d73b02a6f9f318be1c812" + }, + { + "path": "research/r439-semantic-d-contract-seed10/PROOF.md", + "usage": "input", + "git_blob": "2707fdb0d2f34c1c6c4ea41c2a68e44904a3e4fd", + "sha256": "dfbca8c61a92fdf0db8af450dc4466849da37fc296e28b67f357e196e87327db" + } + ] +} diff --git a/research/r439-copyshare-priced-wrap-seedaaa3e40/TASK.json b/research/r439-copyshare-priced-wrap-seedaaa3e40/TASK.json new file mode 100644 index 0000000000..4817c959e1 --- /dev/null +++ b/research/r439-copyshare-priced-wrap-seedaaa3e40/TASK.json @@ -0,0 +1,169 @@ +{ + "schema_version": 1, + "task_id": "bit-helper-contract", + "priority_revision": 4, + "base_commit": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2", + "original_card": { + "id": "bit-helper-contract", + "question": "Can one precisely specified helper-mixing word satisfy a replacement for the inherited H2/K interface?", + "starting_points": [ + "research/r439-bsection-stars-seed01/README.md", + "research/r439-copy-path-sharing-barrier/README.md" + ], + "methods": [ + "Derive a replacement interface lemma and price its implementation.", + "Seek an exact dirty-input or chronological-cut counterexample to the proposed replacement." + ], + "acceptance_gate": "A full boundary contract and paid profile; unchanged scalar counts alone are insufficient.", + "first_step": { + "command": [ + "python3", + "-B", + "research/r439-bsection-stars-seed01/verify.py" + ], + "expected": "PASS_R439_BSECTION_STARS", + "inspect": "Compare the two false H2/K flags with the unchanged paid profile in its README.", + "scope": "Positive control / source-bound orientation only; this is not a new construction or full cold replay." + }, + "first_experiment": "Write one replacement H2/K implication for a single helper-star operation, then try to falsify it on dirty inputs.", + "bottleneck_link": "A legitimate replacement could admit a cheaper bit circuit; scalar savings alone do not alter the selected moment.", + "allowed_variations": [ + "Choose one helper-star or quartet instance; narrow to one boundary implication." + ], + "scope_change_triggers": [ + "Changing only source count or scalar addition count without an interface argument." + ], + "overlap_terms": [ + "H2_D_frame0_targets_from_helpers", + "K_equals_D", + "helper-star" + ] + }, + "scope_status": "refined", + "actual_scope": "Materialize and fully charge the fixed seed-42, 205-pair H2-sem admitted helper-sharing wrapper on the pinned selected R439 word. Recompute the complete integer ADD word and intermediate envelopes; determine whether the exact implementation stays within the 104-bit local and 192-bit nine-stage guards.", + "scope_change_reason": "Refine the card from establishing a replacement interface to its outstanding construction obligation. PR1782 already establishes H2-sem admission and arbitrary-dirty F2 boundary equality for the fixed 205-pair wrap; this investigation will produce the literal frame-zero gate word and price its complete integer/precision behavior.", + "bottleneck_link": "This reduces a local R439 bit-word ADD bill by 25.64% while preserving the paid profile and both declared precision guards. It does not change the selected bit supplier or \u03ba because the selected result remains complex-bound; it supplies a priced local word candidate for any later supplier/assembly investigation.", + "budget_minutes": 60, + "stop_rule": "Use only the fixed seed-42 205-pair candidate and stop after exact boundary, paid-profile and precision-gate verification. Do not reroll the matching; stop on any boundary/frame/guard failure, with at most the predeclared single-pair fallback if the full matching fails only at a precision guard.", + "outcome": "completed", + "evidence": "Completed: official integer exporter and literal recurrence agree on the fixed wrapper. Full ADDs 24,305 -> 18,074 (6,231 saved, including all 410 prep/restore gates); D source ADDs 18,085 -> 11,854 and D gates 111 -> 521. F 49,347 -> 75,381; B 1,113,070 -> 1,196,402; local bits 93 -> 95 (limit 104), nine-stage bits 177 -> 180 (limit 192). Paid profile unchanged at {1:1323, 2:1342, 3:79, 4:44, 5:102, 6:11, 7:19}, rank mass 5,129. All 661 columns pass in both directions; semantic N=raw K, cut state/frame paths unchanged; only inherited gate-local H2/K fail. Five negative controls reject.", + "author": "Cinna Davis", + "ai_assistance": "Substantial OpenAI Codex assistance in selecting the scope, generating and pricing the candidate, constructing the verifier, and preparing the package; predecessor assistance is separately credited.", + "open_questions": [ + { + "question": "Does the exact integer realization of the 205-pair admitted wrapper stay within the local and nine-stage precision guards?", + "why_it_matters": "This is the remaining gate between PR1782's F2 semantic admission and a genuine, fully priced local bit-circuit construction.", + "first_step": "Run the original R439 word and fixed wrapped D through the unchanged integer/F/B envelope and invoice machinery.", + "blocked_by": "No published bill exists for the helper-writing intermediate states; if an exact state-relative envelope cannot be derived within the bounded cycle, leave the result as a formal F2 construction only." + } + ], + "track": "bit-mechanisms", + "seed": "aaa3e40dfc71629ff8180ede0cda4c96", + "scope_key": "3475f46c8358c6a9211b", + "catalogue_sha256": "d46eb6d5b3e279428753d770653663fbdf1063e55c255ea073d768f344927ef7", + "selected_record_sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32", + "changed_assumption": "Use PR1194 semantic H2/K for zero-frame helper-writing preparation/restoration pairs, with semantic N preserved and all pair setup/restoration gates charged; the inherited gate-local H2/K flags remain false.", + "predecessors_and_overlap": { + "PR1782": { + "head": "1cfe5e10ce38b04209699c1a6b0e62b87e21833f", + "status": "merged 2026-10-14T16:18:32Z", + "contribution": "H2-sem admission and F2 boundary check; its README explicitly leaves full billing open." + }, + "PR1194": { + "status": "semantic-D contract and chronological bridge, inherited, not re-proved" + }, + "PR848": { + "status": "seed-42 arithmetic pair/matching census; inherited, not claimed as new" + }, + "current_open_PRs": "Fresh exact-term sweep at 2026-10-14T22:54Z found PR2033 (fixed pair on PR1062 star composition, no saving) and no same-word H2-sem priced construction; PR1937 and PR2046 are unrelated helper-star/consolidation work.", + "active_claims": "Complete cached find_overlap snapshot (431 open PRs, 873 Discussion comments/records, fetched 2026-10-14T22:54:48Z) had no active claim matching the exact H2-sem/copyshare terms. The existing claim/result thread is #1166 comments 18920693/18921030; this task replies to its explicit open question to bill the admitted wrap." + }, + "optimistic_full_cost_budget": { + "fixed_domain": "One pinned selected R439 word; exact seed-42 disjoint matching of 205 pairs among 430 helper operands; no search over alternate matchings.", + "base_source_adds": 24305, + "candidate_source_adds_before_precision_screen": 18074, + "net_source_add_saving": 6231, + "base_D_source_adds": 18085, + "candidate_D_source_adds_before_precision_screen": 11854, + "extra_preparation_and_restoration_gates": 410, + "D_gate_count": "111 -> 521", + "frame_changes": "none intended; all new gates and modified D body are frame zero.", + "dirty_state_and_restoration": "All 205 helper pairs are prepared and restored; predecessor verifies exact F2 boundary map on 661 columns.", + "remaining_cost_gate": "Exact integer intermediate bounds, 104-bit local and 192-bit nine-stage guards, and paid profile are acceptance requirements; if any fails, do not claim a priced construction.", + "base_native_ADDs": 24305, + "candidate_native_ADDs_after_first_precision_screen": 18074, + "net_native_ADD_saving": 6231, + "source_add_subtotal_note": "These are complete native ADD counts including scatter ADDs, as independently checked against the official record exporter.", + "first_exact_precision_screen": { + "base": { + "native_ADDs": 24305, + "D_source_ADDs": 18085, + "D_gates": 111, + "F": 49347, + "B": 1113070, + "local_bits": 93, + "nine_stage_bits": 177, + "exporter_record_sha256": "ea44aa047a2a9cf034de8b56b2166c49cf2dbdf9cd9ed6a20299a4f2b05ef09a" + }, + "candidate": { + "native_ADDs": 18074, + "D_source_ADDs": 11854, + "D_gates": 521, + "F": 75381, + "B": 1196402, + "local_bits": 95, + "nine_stage_bits": 180, + "exporter_record_sha256": "c2cc0fc6fbcad48f1550b0c52c06e78ac7c5cfed59634690de2c036d80f1a9db" + }, + "guards": "pass: 95 <= 104 and 180 <= 192" + }, + "paid_profile": { + "1": 1323, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 19 + }, + "paid_rank_mass": 5129, + "initial_cost_conclusion": "A fixed local candidate achieves a 6,231 ADD net saving after all 410 prep/restoration gates and passes both inherited precision guards; no selected-supplier or kappa change is claimed.", + "candidate_source_adds_after_precision_screen": 18074 + }, + "method_and_domain": "Rebuild only the pinned D section using the exact deterministic seed-42 matching from PR848/PR1782. Include all 410 one-source prep/restore ADDs, preserve all other sections, then recompute full boundary, gate/source count, integer transfer and every relevant per-stage envelope/paid-profile quantity for this one candidate.", + "expected_evidence": "Achieved. The reproducible certificate pins the base and inputs, exact 205-pair wrapper, 661-column forward/reverse boundary, semantic H2/K status, unchanged paid profile, full ADD/F/B invoices, precision guards and failure controls.", + "success_stop_rule": "Stop after verifying this single fixed candidate; no matching reroll or optimality claim. It passes the boundary and both precision guards, so no fallback was needed.", + "claim_expiry_utc": "2026-10-15T00:55:41Z", + "claim_status": "Claim posted as a reply to the PR1782 result/open-question thread in Discussion #1166: https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-18935773. It will be updated with the PR result and released on handoff.", + "verified_at_utc": "2026-10-14T23:02:00Z", + "reproduction_commands": [ + "python3 -I -B research/r439-copyshare-priced-wrap-seedaaa3e40/verify.py", + "python3 scripts/research_package.py --package research/r439-copyshare-priced-wrap-seedaaa3e40 --check-only", + "python3 scripts/research_package.py --package research/r439-copyshare-priced-wrap-seedaaa3e40" + ], + "remaining_obligations": [ + "Local registered runner could not run because Python 3.12 is not installed; direct verifier passed under CPython 3.14.7 and package metadata/source pins pass. Hosted registered replay remains to be observed after PR submission.", + "No supplier adoption, selected-result update or kappa is claimed." + ], + "local_verification": { + "interpreter": "CPython 3.14.7", + "direct_verifier": "PASS_R439_COPYSHARE_PRICED_WRAP", + "metadata_and_source_pins": "PASS_PACKAGE_METADATA_AND_PINS", + "registered_runner": "not run locally: repository runner requires Python 3.12; python3.12 is unavailable in this environment" + }, + "final_overlap_refresh": { + "cached_complete_snapshot": { + "open_prs": 435, + "discussions": 877, + "open_prs_fetched_at_utc": "2026-10-14T23:03:49Z", + "discussions_fetched_at_utc": "2026-10-14T23:05:44Z" + }, + "task_term_matches": { + "open_prs": 0, + "discussions": 0 + }, + "live_open_pr_search": "No same-word construction; PR2033 is the nearest result but is limited to a fixed pair on the different PR1062 star-composed word and reports no saving there. PR2046 is post-merge consolidation.", + "coordination": "Current PR1782 result thread #1166 checked; new claim is the only current priced-wrap claim. No other matching claim found.", + "limitation": "find_overlap --refresh did not return before the bounded wait ended; its remote cache contains complete pagination at the timestamps above, and direct live REST/GraphQL checks were performed immediately before submission." + } +} diff --git a/research/r439-copyshare-priced-wrap-seedaaa3e40/VERIFY.json b/research/r439-copyshare-priced-wrap-seedaaa3e40/VERIFY.json new file mode 100644 index 0000000000..c654aa6b99 --- /dev/null +++ b/research/r439-copyshare-priced-wrap-seedaaa3e40/VERIFY.json @@ -0,0 +1,27 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/e8-bit-carrier-skeleton/code/bit/export_records.py", + "research/e8-bit-p111-tuned/code/xcheck_p.py", + "research/e8-bit-p111-tuned/tune/bitE8mut-p111-tuned.json.gz", + "research/r439-bsection-stars-seed01/build.py", + "research/r439-bsection-stars-seed01/verify.py", + "research/r439-copyshare-h2sem-admission/SOURCES.json", + "research/r439-copyshare-h2sem-admission/verify.py", + "research/r439-semantic-d-contract-seed10/PROOF.md" + ], + "commands": [ + { + "argv": [ + "{python}", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Rebuild the fixed wrapper; verify the 661-column dirty map in both directions, semantic H2/K and cut frames, unchanged paid profile, complete ADD/F/B invoices against the repository exporter, both precision guards, and five negative controls." + } + ] +} diff --git a/research/r439-copyshare-priced-wrap-seedaaa3e40/verify.py b/research/r439-copyshare-priced-wrap-seedaaa3e40/verify.py new file mode 100644 index 0000000000..b2fa3ffa4e --- /dev/null +++ b/research/r439-copyshare-priced-wrap-seedaaa3e40/verify.py @@ -0,0 +1,274 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Materialize and price the admitted 205-pair selected-R439 D wrap.""" + +import argparse +import copy +import gzip +import hashlib +import importlib.util +import json +import tempfile +from pathlib import Path + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] +SOURCES = HERE / "SOURCES.json" +CERTIFICATE = HERE / "CERTIFICATE.json" + + +def need(condition, message): + if not condition: + raise ValueError(message) + + +def canonical(value): + return json.dumps(value, sort_keys=True, separators=(",", ":")).encode() + + +def digest(data): + return hashlib.sha256(data).hexdigest() + + +def load_module(name, path): + spec = importlib.util.spec_from_file_location(name, path) + need(spec is not None and spec.loader is not None, "cannot load " + str(path)) + module = importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + return module + + +def verify_source_pins(): + manifest = json.loads(SOURCES.read_text()) + actual = {} + for entry in manifest["files"]: + path = entry["path"] + if entry["usage"] != "input": + continue + raw = (ROOT / path).read_bytes() + actual[path] = digest(raw) + need(actual[path] == entry["sha256"], "source SHA-256 mismatch: " + path) + return actual + + +def failures(hypotheses, conclusions): + return sorted( + name + for name, result in list(hypotheses.items()) + list(conclusions.items()) + if not result + ) + + +def boundary_rows(word, bound): + forward = bound.literal_rows(word) + reverse = bound.literal_rows(word, reverse=True) + return forward, reverse + + +def run(): + input_hashes = verify_source_pins() + h2 = load_module( + "r439_h2sem_predecessor", + ROOT / "research/r439-copyshare-h2sem-admission/verify.py", + ) + bound = load_module( + "r439_bound_predecessor", + ROOT / "research/r439-bsection-stars-seed01/verify.py", + ) + original = json.loads(gzip.decompress(h2.WORD.read_bytes())) + checker = h2.load_checker() + + # The matching is inherited exactly from PR848/PR1782; no matching search + # or optimizer seed is changed in this contribution. + pairs, census = h2.nominate_d(original, h2.SEED) + need(census["operands"] == 430, "helper pool changed") + need(census["matching_pairs"] == 205, "fixed matching size changed") + need(census["matching_saving"] == 6231, "fixed matching invoice changed") + need(census["best_pair"] == [277, 434] and census["best_saving"] == 65, + "single-pair positive control changed") + candidate = h2.construct_d(original, pairs) + + # Positive control: the pinned source word itself meets every inherited + # H1-H5 and U/J/K/C check and has the expected semantic D boundary. + _, _, _, base_h, base_c, _ = checker.check(original) + need(all(base_h.values()) and all(base_c.values()), "pinned baseline checker failed") + base_d, base_cut, base_shape, base_n = h2.d_shape(original, checker) + need(base_shape, "baseline D boundary shape") + base_k = h2.raw_K(original, checker) + need(base_n == base_k, "baseline semantic D != raw K") + + cand_d, cand_cut, cand_shape, cand_n = h2.d_shape(candidate, checker) + need(cand_shape and cand_d == base_d, "candidate D map changed") + need(cand_cut == base_cut, "candidate chronological cut state changed") + need(cand_n == base_n == base_k, "candidate semantic N != pinned raw K") + need(h2.raw_K(candidate, checker) == base_k, "candidate raw K changed") + cond1, cond2 = h2.h2sem_conditions(candidate) + need(cond1 and cond2, "candidate violates H2-sem") + need(h2.literal_N(candidate) != cand_n, + "candidate should expose the inherited gate-local K mismatch") + _, _, _, cand_h, cand_c, _ = checker.check(candidate) + expected_failures = sorted( + ["H2_D_frame0_targets_from_helpers", "K_equals_D"] + ) + need(failures(cand_h, cand_c) == expected_failures, + "unexpected inherited checker failures") + + # Compare the full 661-column map forward and backward, plus exact register + # frame paths and the paid frame-transition/rank profile. + base_forward, base_reverse = boundary_rows(original, bound) + cand_forward, cand_reverse = boundary_rows(candidate, bound) + need(len(cand_forward) == len(cand_reverse) == 661, + "unexpected formal-column count") + need(cand_forward == base_forward, "full forward dirty-input map changed") + need(cand_reverse == base_reverse, "full reverse dirty-input map changed") + need(bound.frame_paths(candidate) == bound.frame_paths(original), + "register frame paths changed") + base_owner = bound.owner(original) + cand_owner = bound.owner(candidate) + need(cand_owner["profile"] == base_owner["profile"], "paid profile changed") + need(sum(rank * count for rank, count in cand_owner["profile"].items()) == 5129, + "paid rank mass changed") + + # The literal ADD stream is checked against the repository's record + # exporter. Every helper setup/restoration ADD is included in both bills. + base_bill = bound.literal_bounds(original) + cand_bill = bound.literal_bounds(candidate) + bound.guard(base_bill) + bound.guard(cand_bill) + need(base_bill["native_ADDs"] == 24305, "baseline ADD count changed") + need(cand_bill["native_ADDs"] == 18074, "candidate ADD count changed") + need(base_bill["D_adds"] == 18085 and cand_bill["D_adds"] == 11854, + "D source-ADD invoice changed") + need(base_bill["native_ADDs"] - cand_bill["native_ADDs"] == 6231, + "complete ADD saving does not match fixed-pair invoice") + need(base_bill["local_bits"] == 93 and cand_bill["local_bits"] == 95, + "local precision bill changed") + need(base_bill["nine_stage_bits"] == 177 and cand_bill["nine_stage_bits"] == 180, + "nine-stage precision bill changed") + with tempfile.TemporaryDirectory(prefix="r439-copyshare-priced-") as temp: + work = Path(temp) + base_export = bound.exporter(original, work / "base") + cand_export = bound.exporter(candidate, work / "candidate") + for label, bill, exported in ( + ("baseline", base_bill, base_export), + ("candidate", cand_bill, cand_export), + ): + need(exported["adds"] == bill["native_ADDs"], label + " exporter ADD count") + need(exported["copies"] == exported["erasures"] == 9, + label + " COPY/ERASE invoice") + need(exported["forward"] == bill["F"], label + " forward envelope") + need(exported["reverse"] == bill["B"], label + " reverse envelope") + need(exported["payload_bits"] == bill["local_bits"], + label + " local payload precision") + + # Failure controls: missing restoration, a wrong restored helper, a + # nonzero-frame helper gate, and synthetic bills immediately beyond both + # declared precision limits must all be rejected. + controls = [] + + def reject(label, action): + try: + action() + except (ValueError, KeyError): + controls.append(label) + return + raise ValueError("negative control accepted: " + label) + + def require_same_boundary(word): + forward, reverse = boundary_rows(word, bound) + need(forward == base_forward and reverse == base_reverse, + "full boundary mismatch") + + def require_h2sem(word): + one, two = h2.h2sem_conditions(word) + need(one and two, "H2-sem condition failed") + + unbalanced = h2.construct_d(original, pairs, restore=False) + reject( + "missing_restore_breaks_full_boundary", + lambda: require_same_boundary(unbalanced), + ) + wrong_restore = {a: a for a, _ in pairs} + wrong_restore[pairs[0][0]] = pairs[0][1] + misrestored = h2.construct_d(original, pairs, restore_map=wrong_restore) + reject( + "wrong_restore_destination_breaks_boundary", + lambda: require_same_boundary(misrestored), + ) + shifted = copy.deepcopy(candidate) + shifted["D"][0][0] = 1 + reject( + "nonzero_frame_helper_gate_fails_H2_sem", + lambda: require_h2sem(shifted), + ) + reject( + "local_precision_over_104_rejected", + lambda: bound.guard({"local_bits": 105, "nine_stage_bits": 180}), + ) + reject( + "nine_stage_precision_over_192_rejected", + lambda: bound.guard({"local_bits": 95, "nine_stage_bits": 193}), + ) + + cert = { + "status": "PASS_R439_COPYSHARE_PRICED_WRAP", + "scope": "One fixed seed-42 205-pair wrapper on the pinned selected R439 word; no matching optimality claim.", + "source_sha256": input_hashes, + "matching": census, + "wrapper": { + "pairs": len(pairs), + "extra_prep_restore_gates": 2 * len(pairs), + "D_gates": {"base": len(original["D"]), "candidate": len(candidate["D"])}, + "semantic_H2": {"zero_frame_distinct_operands": cond1, + "no_target_feedback": cond2}, + "semantic_N_equals_raw_K": cand_n == base_k, + "inherited_failed_flags": expected_failures, + "columns_checked_each_direction": len(cand_forward), + "cut_state_equal": cand_cut == base_cut, + "frame_paths_equal": bound.frame_paths(candidate) == bound.frame_paths(original), + "paid_profile": {str(k): v for k, v in sorted(cand_owner["profile"].items())}, + "paid_rank_mass": 5129, + }, + "invoice": { + "native_ADDs": {"base": base_bill["native_ADDs"], + "candidate": cand_bill["native_ADDs"], + "saving": base_bill["native_ADDs"] - cand_bill["native_ADDs"]}, + "D_source_ADDs": {"base": base_bill["D_adds"], "candidate": cand_bill["D_adds"]}, + "F": {"base": base_bill["F"], "candidate": cand_bill["F"]}, + "B": {"base": base_bill["B"], "candidate": cand_bill["B"]}, + "local_bits": {"base": base_bill["local_bits"], "candidate": cand_bill["local_bits"], "limit": 104}, + "nine_stage_bits": {"base": base_bill["nine_stage_bits"], "candidate": cand_bill["nine_stage_bits"], "limit": 192}, + "exporter_record_sha256": {"base": base_export["record_sha256"], + "candidate": cand_export["record_sha256"]}, + "copies_and_erasures": {"base": [base_export["copies"], base_export["erasures"]], + "candidate": [cand_export["copies"], cand_export["erasures"]]}, + }, + "negative_controls": controls, + "limits": [ + "The 205-pair matching is inherited from PR848/PR1782; optimality is not claimed.", + "This is a local R439 word construction; selected-supplier adoption, hosting, outer assembly, and kappa are not claimed.", + "The inherited H2/K flags remain false; admission uses the scoped H2-sem contract.", + ], + } + return cert + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--write", action="store_true", help="write the deterministic certificate") + args = parser.parse_args() + cert = run() + if args.write: + CERTIFICATE.write_text(json.dumps(cert, indent=2, sort_keys=True) + "\n") + else: + expected = json.loads(CERTIFICATE.read_text()) + need(cert == expected, "certificate mismatch; use --write only for an intentional update") + print( + "PASS_R439_COPYSHARE_PRICED_WRAP pairs=205 ADDs=24305->18074 saved=6231 " + "F=49347->75381 B=1113070->1196402 guards=95/104,180/192 " + "profile_mass=5129 controls=5 no_kappa" + ) + + +if __name__ == "__main__": + main() From c368d1b1f59c28b7a837fd6d080bd57703266d2c Mon Sep 17 00:00:00 2001 From: Cinna Davis <1337isnot1337@users.noreply.github.com> Date: Wed, 14 Oct 2026 18:08:06 -0500 Subject: [PATCH 2/2] Record R439 copy-share construction handoff --- .../TASK.json | 13 +++++++++++-- 1 file changed, 11 insertions(+), 2 deletions(-) diff --git a/research/r439-copyshare-priced-wrap-seedaaa3e40/TASK.json b/research/r439-copyshare-priced-wrap-seedaaa3e40/TASK.json index 4817c959e1..2b43c9ce7d 100644 --- a/research/r439-copyshare-priced-wrap-seedaaa3e40/TASK.json +++ b/research/r439-copyshare-priced-wrap-seedaaa3e40/TASK.json @@ -134,7 +134,7 @@ "expected_evidence": "Achieved. The reproducible certificate pins the base and inputs, exact 205-pair wrapper, 661-column forward/reverse boundary, semantic H2/K status, unchanged paid profile, full ADD/F/B invoices, precision guards and failure controls.", "success_stop_rule": "Stop after verifying this single fixed candidate; no matching reroll or optimality claim. It passes the boundary and both precision guards, so no fallback was needed.", "claim_expiry_utc": "2026-10-15T00:55:41Z", - "claim_status": "Claim posted as a reply to the PR1782 result/open-question thread in Discussion #1166: https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-18935773. It will be updated with the PR result and released on handoff.", + "claim_status": "DONE; scope released. Claim updated with the result and PR link at https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-18935773.", "verified_at_utc": "2026-10-14T23:02:00Z", "reproduction_commands": [ "python3 -I -B research/r439-copyshare-priced-wrap-seedaaa3e40/verify.py", @@ -142,7 +142,7 @@ "python3 scripts/research_package.py --package research/r439-copyshare-priced-wrap-seedaaa3e40" ], "remaining_obligations": [ - "Local registered runner could not run because Python 3.12 is not installed; direct verifier passed under CPython 3.14.7 and package metadata/source pins pass. Hosted registered replay remains to be observed after PR submission.", + "Observe the hosted registered replay and report its actual result; the local direct verifier passed under Python 3.14.7.", "No supplier adoption, selected-result update or kappa is claimed." ], "local_verification": { @@ -165,5 +165,14 @@ "live_open_pr_search": "No same-word construction; PR2033 is the nearest result but is limited to a fixed pair on the different PR1062 star-composed word and reports no saving there. PR2046 is post-merge consolidation.", "coordination": "Current PR1782 result thread #1166 checked; new claim is the only current priced-wrap claim. No other matching claim found.", "limitation": "find_overlap --refresh did not return before the bounded wait ended; its remote cache contains complete pagination at the timestamps above, and direct live REST/GraphQL checks were performed immediately before submission." + }, + "publication": { + "status": "open", + "pull_request": "https://github.com/CrocSwap/integer-mult-bounds/pull/2191", + "package_commit": "4ff7b270e1123861044dfc6a59013599a7c94254", + "base": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2", + "submitted_at_utc": "2026-10-14T23:07:10Z", + "head_was_package_commit_at_submission": true, + "hosted_checks": "pending at first observation; local registered runner unavailable because Python 3.12 is not installed" } }