diff --git a/research/complex-temporal-pair-seed28/CLAIM.md b/research/complex-temporal-pair-seed28/CLAIM.md new file mode 100644 index 0000000000..e8403be894 --- /dev/null +++ b/research/complex-temporal-pair-seed28/CLAIM.md @@ -0,0 +1,19 @@ +# Local sprint claim + +- Track and seed: Complex supplier, OS seed 28 (`secrets.randbelow(60)`). +- Base: `bce54fb3f895cbe5cd4c0eb477c3afeed100190f`. +- Object: compose the separately optimized dyadic temporal schedules for helpers L348 and L359 on the selected PR1094/PR1263 complex word. They share ADD event 24336. +- Proposed method: seed 28 chooses index `28 mod 2 = 0` from the two zero-static helper pairs whose individual all-integer schedules both improve and are nonzero at a shared ADD. Compose those exact single-coordinate minima, then compare the complete exact invoice against the sum of separate deltas. +- Expected deliverable: source-pinned finite circuit package with exact schedules, shared-ADD correction, both complete invoices, both 712-column replays and negative controls. No joint optimum or new kappa claim. +- Expected finish: 2026-10-13 23:57 UTC. +- Coordination: no pinned sprint coordination issue found; claim recorded locally. + +Candidate tasks and overlap details are in `research/seed28-complex-reroll-20261013/ASSIGNMENT.json`. + +## Final result and handoff + +Result completed on 2026-10-13. For the seed-selected pair L348/L359, both separate exact minima are improving and active together at ADD 24336. Their solo deltas total -403 real; the shared coefficient contributes a +3 real cross correction, leaving -400 real / 800 complex saved per orientation. The complete invoices, all-scale accounting, paid-profile check, 712-column replays and three controls are recorded in `RESULT.json` and `PROOF.md`. No joint optimum or new kappa is claimed. + +The final overlap refresh found PR #1380, which addresses the same general shared-ADD mechanism but certifies a disjoint finite pair set: all 16 pairs in its certificate contain L225, and none is L348/L359. This contribution adds the distinct PR1369 zero-static pair and composes its exact one-coordinate minima; it does not claim PR #1380's joint-optimality result. PR #1376's L248/L253 schedules have disjoint ADD supports. + +Submitted as [PR #1388](https://github.com/CrocSwap/integer-mult-bounds/pull/1388), an additional-pair finite certificate with no selected-result or kappa change. diff --git a/research/complex-temporal-pair-seed28/LICENSE b/research/complex-temporal-pair-seed28/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/complex-temporal-pair-seed28/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/complex-temporal-pair-seed28/NOTICE.md b/research/complex-temporal-pair-seed28/NOTICE.md new file mode 100644 index 0000000000..313056f072 --- /dev/null +++ b/research/complex-temporal-pair-seed28/NOTICE.md @@ -0,0 +1,5 @@ +New composition code and result are Apache-2.0. The selected predecessor files +under `vendor/pr1369/` are retained from CrocSwap/integer-mult-bounds PR #1369, +commit `f28e1c460cd910886f9b06835abd6b1c96d2992f`; its NOTICE and source pins +are included. Nested PR1263/PR1161/PR1259 sources retain their attribution and +notices. No upstream or frozen source file was modified. diff --git a/research/complex-temporal-pair-seed28/PROOF.md b/research/complex-temporal-pair-seed28/PROOF.md new file mode 100644 index 0000000000..0733e60a1f --- /dev/null +++ b/research/complex-temporal-pair-seed28/PROOF.md @@ -0,0 +1,71 @@ +# Finite paired temporal-gauge certificate + +## Predecessor word and domain + +The verifier pins and replays PR1369's zero-static temporal census on base +`bce54fb3f895cbe5cd4c0eb477c3afeed100190f`, then recovers the exact PR1263 +static word in both orientations. The eligible zero-static helpers are + +`[272,288,348,359,381,440,444,446,447,469,478,479,491,503,507,514,515,519,542]`. + +For each helper and orientation, the attributed exact integer DP optimizes its +incident ADD sequence over the certified finite breakpoint interval. The +verifier checks each new DP result against PR1369's frozen census. It then +enumerates all 171 helper pairs, retaining pairs whose single-coordinate +minima improve and are both nonzero at a shared ADD. The identical candidate +list in both orientations is `[(348,359),(479,515)]`; seed 28 chooses its first +pair. + +This search optimizes one coordinate at a time. It does not claim a joint +minimum for the two-coordinate objective. + +In the final overlap refresh, PR #1376 covered a disjoint-support L248/L253 +composition. The concurrent PR #1380 covered 16 shared-ADD pairs, all with +L225, including L225/L348 but not L348/L359. This certificate prices the +distinct L348/L359 pair from the PR1369 zero-static domain; it does not +duplicate PR #1380's joint-optimum claim. + +## Simultaneous composition + +At each original ADD, the composed coefficient is scaled by the product of +the two selected dyadic gauge factors. Entry and transition scales, with a +terminal restoration when the final gauge is nonzero, are emitted on their +own helper lines at the original ADD frame. The full exact invoice prices +every inserted scale and every changed coefficient; +the complete replay checks both orientations on all 712 formal columns. + +For any shared ADD with original coefficient c, helper signs s1 and s2, and +chosen exponents e1 and e2, its combined price change is + +`price(c * 2^(s1*e1+s2*e2)) - price(c)`. + +At event 24336 the exact data are: + +| Orientation | signs (L348,L359) | exponents | c | separate ADD deltas | combined delta | correction | +|---|---|---|---:|---:|---:|---:| +| Forward | (+1,-1) | (-1,3) | -8 | -1,-4 | -2 | +3 real | +| Backward | (-1,+1) | (1,-3) | 8 | -1,-4 | -2 | +3 real | + +All other incident ADDs are disjoint between the two helpers. Therefore the +joint invoice delta is `-161 - 242 + 3 = -400` real primitives, or 800 complex +primitives. Literal lowerer invoices independently confirm 136002 to 135202 +forward and 136018 to 135218 backward. + +The candidate's paid profile and all non-scalar events equal the static word. +The scale entry, transition, and any necessary terminal restoration work is +included. Prefix ceilings remain 52 and 68 +bits under the existing 192-bit local charge. The selected exponent and +supplier certificate do not change. + +## Controls and limits + +The verifier checks an all-zero schedule identity, rejects a candidate with a +missing L348 transition scale, and rejects a shared-ADD coefficient mutation +that omits the L359 exponent. These controls and the 712-column replay test the +finite scalar map, not all-size hosting or supplier admission. + +The claim depends on the pinned PR1263 source word, PR1369 single-coordinate +DP and PR1161 invoice/replay implementation. It does not show that this pair +is optimal among all two-coordinate temporal schedules, that three or more +gauges compose profitably, or that the operation saving changes the recursive +profile or kappa. diff --git a/research/complex-temporal-pair-seed28/README.md b/research/complex-temporal-pair-seed28/README.md new file mode 100644 index 0000000000..083ee95965 --- /dev/null +++ b/research/complex-temporal-pair-seed28/README.md @@ -0,0 +1,102 @@ +# Two temporal gauges on a shared complex ADD + +**Finite scalar construction; no new kappa.** This result composes two exact +single-helper dyadic schedules, for L348 and L359, on the selected PR1263 +218-helper word. Their schedules are nonzero at the same ADD, so the exact +coefficient cost has a coupled correction. + +## Result + +The separately optimized schedules save 161 and 242 real primitives per +invocation. Their naive sum predicts 403 real primitives. At shared ADD 24336, +the two exponent shifts interact: separate coefficient changes cost -1 and -4 +real primitives, while the combined change costs -2. The shared coefficient +therefore adds back exactly 3 real primitives. The composed word saves **400 +real / 800 complex primitives per orientation** over PR1263's static word. + +| Orientation | PR1094 original | PR1263 static | L348+L359 temporal | Increment over PR1263 | +|---|---:|---:|---:|---:| +| Forward | 149,002 | 136,002 | 135,202 | 800 | +| Backward | 149,018 | 136,018 | 135,218 | 800 | + +All 54 inserted scales (entry, transitions and any necessary terminal +restorations) are charged. The exact full invoice preserves the paid recursive +profile, charged 192-bit payload, and +52/68-bit positive prefixes. Both orientations preserve the complete formal +map on all 712 columns and leave every non-scalar event unchanged. The total +scalar saving against the PR1094 original is 13,800 complex primitives per +orientation. + +This is a feasible composition of two separately optimal one-coordinate +schedules, not a jointly optimized two-coordinate schedule. No new kappa, +selected-supplier adoption, native/hosted admission, or multiplication theorem +is claimed. + +## Assignment and overlap + +- Track: Complex supplier; OS seed 28; exact base + `bce54fb3f895cbe5cd4c0eb477c3afeed100190f`. +- PR #1369 checks one-coordinate temporal schedules on all 19 eligible helpers + with zero static gauge. PR #1310 checks all two-coordinate **constant** + gauge moves and explicitly excludes phase-varying composition. This package + tests a seed-selected pair of phase-varying schedules at a shared ADD. +- The final overlap refresh found PR #1376's L248/L253 temporal composition; + those supports are disjoint. PR #1380's newer shared-ADD result optimizes a + different pair, L225/L350, and tests 16 pairs all containing L225. Its + certificate includes L225/L348 but not L348/L359. This package adds a + distinct zero-static pair: it composes exact separately optimized L348/L359 + schedules and prices their +3-real shared-ADD correction. It does not claim + the joint-optimality result established for PR #1380's own pair. +- Seed 28 indexes the two pairs whose one-coordinate minima both improve and + are simultaneously nonzero at a shared ADD. It selects `(348,359)` at index + `28 mod 2 = 0`. The initial index among all 171 pairs, `(288,491)`, had + disjoint ADD sets; the evidence-driven pivot to the shared-ADD class makes + the coefficient interaction test substantive. +- Other screened directions were the masked-decoder classes covered by + #1212/#1213/#1224/#1226/#1236/#1304/#1320 and current discussion claims, and + the helper-inventory coverage thresholds in #1348 and Discussion #1328. +- The pinned sprint coordination issue search found no open match; the local + claim is in `CLAIM.md`. + +The exact machine-readable schedules, invoices, column digests and control +results are in [`RESULT.json`](RESULT.json). The predecessor snapshots, Git +blob IDs, hashes, selected record and review are listed in `SOURCES.json`. The +exact PR1369 input code is vendored under +`vendor/pr1369/` with its source notices. Its one-coordinate optimizer is +replayed and compared to its pinned certificate before this composition is +priced. + +## Reproduce + +From the repository root, using the Python standard library: + +```sh +python3 -I -O -B research/complex-temporal-pair-seed28/verify.py +``` + +Expected: + +```text +PASS_COMPLEX_TEMPORAL_PAIR seed=28 helpers=348,359 shared_add=24336 cross=+3real saving=800complex/orientation controls=3 no_new_kappa +``` + +## Open next questions + +Can a joint all-integer two-coordinate DP improve on the composition of +separately optimal schedules? That could price a better candidate at shared +ADDs rather than merely compose known one-coordinate minima. First step: derive +a proved finite two-dimensional exponent box from the dyadic ADD breakpoints +and the two restoration paths. The current contribution stops after one +seed-selected pair and makes no joint-optimality claim. + +## Credit and disclosure + +Credit Cinna Davis / @1337isnot1337's PR1369 single-coordinate temporal census, +Sagar Thakrar's PR1259 temporal-gauge method and PR696 lowerer, Philipp / +@mightyOil's PR1263 static word, and the retained PR1094/PR1161 lineage. +Credit bbMisk's PR1310 constant-pair stationarity result as the adjacent +predecessor, with its phase-varying exclusion retained. Credit PR #1376 and +Sagar Thakrar's PR #1380 for the concurrent distinct-pair and disjoint-support +comparisons documented above. Prepared by Cinna Davis with substantial OpenAI +Codex assistance for analysis, implementation, verification and writing. No +independent human review or subagents are claimed. Apache-2.0. diff --git a/research/complex-temporal-pair-seed28/RESULT.json b/research/complex-temporal-pair-seed28/RESULT.json new file mode 100644 index 0000000000..72ad192f4f --- /dev/null +++ b/research/complex-temporal-pair-seed28/RESULT.json @@ -0,0 +1,759 @@ +{ + "status": "PASS_COMPLEX_TEMPORAL_PAIR", + "assignment_seed": 28, + "base_commit": "bce54fb3f895cbe5cd4c0eb477c3afeed100190f", + "selected_kappa_unchanged": "836330098538459/500000000000000000", + "predecessor_pr1369_head": "f28e1c460cd910886f9b06835abd6b1c96d2992f", + "zero_static_helper_count": 19, + "pair_search_domain": "all 171 unordered pairs of the 19 zero-static helpers; retain improving solo DPs active together on a shared ADD", + "qualifying_pairs_both_orientations": [ + [ + 348, + 359, + [ + 24336 + ] + ], + [ + 479, + 515, + [ + 18186 + ] + ] + ], + "seed_index": 0, + "selected_pair": [ + 348, + 359 + ], + "orientations": { + "forward": { + "helpers": [ + 348, + 359 + ], + "helper_schedules": { + "348": { + "domain": [ + -3, + 4 + ], + "schedule": [ + -2, + -2, + -2, + -2, + -2, + -2, + -2, + -2, + -2, + -2, + -2, + -2, + -2, + -2, + -2, + -2, + -2, + -2, + -2, + -2, + -2, + -2, + -2, + -2, + -2, + -2, + -2, + -2, + -2, + -2, + -2, + -2, + -1, + -1, + -1, + -1, + -1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + 0, + 0, + 3, + 3, + 3, + 3, + -1, + -1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 3, + 3, + 3, + 3, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + -1, + -1, + -1, + -1, + 0, + 0, + 0, + 0 + ], + "delta_real": -161, + "transition_scale_macros": 21 + }, + "359": { + "domain": [ + -3, + 7 + ], + "schedule": [ + -2, + -2, + -2, + -2, + -2, + -2, + -2, + -2, + -2, + -2, + -2, + -2, + -2, + -2, + -2, + -2, + -2, + -2, + -2, + -2, + -2, + -2, + -2, + -2, + -2, + -2, + -2, + -2, + -2, + -2, + -2, + -2, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + 0, + 0, + -1, + -1, + -1, + -2, + -2, + -2, + -2, + -1, + 0, + 0, + -2, + -2, + 0, + 0, + 0, + 0, + -1, + -1, + -1, + -1, + -2, + -2, + -2, + -3, + -3, + -3, + -3, + -3, + 7, + 7, + 3, + 3, + 3, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 3, + 4, + 4, + 4, + 3, + 3, + 3, + 4, + 4, + 4, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 4, + 4, + 2, + 2, + 1, + 1, + 1, + 1, + 1, + 1, + 3, + 3, + 3, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 4, + 4, + 4, + 4, + 4, + 3, + 3, + 3, + -1, + -1, + -1, + -1 + ], + "delta_real": -242, + "transition_scale_macros": 33 + } + }, + "single_candidate_invoices": { + "348": { + "real_primitives": 67840, + "complex_primitives": 135680, + "charged_payload_bits": 192, + "prefix_bits": 52 + }, + "359": { + "real_primitives": 67759, + "complex_primitives": 135518, + "charged_payload_bits": 192, + "prefix_bits": 52 + } + }, + "shared_add": { + "index": 24336, + "coefficient": [ + -8, + 1 + ], + "signs": [ + 1, + -1 + ], + "exponents": [ + -1, + 3 + ], + "separate_real_add_deltas": [ + -1, + -4 + ], + "combined_real_add_delta": -2, + "cross_correction_real": 3 + }, + "static_invoice": { + "real_primitives": 68001, + "complex_primitives": 136002, + "charged_payload_bits": 192, + "prefix_bits": 52 + }, + "candidate_invoice": { + "real_primitives": 67601, + "complex_primitives": 135202, + "charged_payload_bits": 192, + "prefix_bits": 52 + }, + "joint_real_delta": -400, + "complex_saving_vs_PR1263": 800, + "complex_saving_vs_PR1094": 13800, + "scale_macros": 54, + "input_event_count": 25203, + "candidate_event_count": 25257, + "non_scalar_events_unchanged": true, + "all_712_columns_equal": true, + "candidate_sha256": "0de2a28179de44c05f5240f626ee5a3e930cd4c59ee5590e3a3dc363d2faf189", + "endpoint_sha256": "a5cdcf515e10c601d029da7924b1abad8942bfd3b4eeee8685d836740c489565", + "controls": { + "zero_schedule_identity": "passed", + "missing_L348_transition_scale": "rejected", + "missing_L359_shared_coefficient": "rejected" + } + }, + "backward": { + "helpers": [ + 348, + 359 + ], + "helper_schedules": { + "348": { + "domain": [ + -4, + 3 + ], + "schedule": [ + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + -1, + -1, + -1, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + -3, + -3, + -3, + -3, + 1, + 1, + -1, + -1, + -1, + -1, + -1, + 0, + 0, + -1, + -1, + -1, + -1, + 0, + 0, + 0, + 0, + 0, + -1, + -1, + -3, + -3, + -3, + -3, + 0, + 0, + 0, + -1, + -1, + -1, + -1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + -1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0 + ], + "delta_real": -161, + "transition_scale_macros": 21 + }, + "359": { + "domain": [ + -7, + 3 + ], + "schedule": [ + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 1, + 1, + 1, + 2, + 2, + 2, + 2, + 1, + 0, + 0, + 2, + 2, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 2, + 2, + 2, + 3, + 3, + 3, + 3, + 3, + -7, + -7, + -3, + -3, + -3, + -2, + -2, + -2, + -2, + -2, + -2, + -2, + -2, + -3, + -4, + -4, + -4, + -3, + -3, + -3, + -4, + -4, + -4, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -4, + -4, + -2, + -2, + -1, + -1, + -1, + -1, + -1, + -1, + -3, + -3, + -3, + -1, + -1, + -1, + 0, + 0, + 0, + 0, + -1, + -1, + 0, + 0, + 0, + -4, + -4, + -4, + -4, + -4, + -3, + -3, + -3, + 1, + 1, + 1, + 1 + ], + "delta_real": -242, + "transition_scale_macros": 33 + } + }, + "single_candidate_invoices": { + "348": { + "real_primitives": 67848, + "complex_primitives": 135696, + "charged_payload_bits": 192, + "prefix_bits": 68 + }, + "359": { + "real_primitives": 67767, + "complex_primitives": 135534, + "charged_payload_bits": 192, + "prefix_bits": 68 + } + }, + "shared_add": { + "index": 24336, + "coefficient": [ + 8, + 1 + ], + "signs": [ + -1, + 1 + ], + "exponents": [ + 1, + -3 + ], + "separate_real_add_deltas": [ + -1, + -4 + ], + "combined_real_add_delta": -2, + "cross_correction_real": 3 + }, + "static_invoice": { + "real_primitives": 68009, + "complex_primitives": 136018, + "charged_payload_bits": 192, + "prefix_bits": 68 + }, + "candidate_invoice": { + "real_primitives": 67609, + "complex_primitives": 135218, + "charged_payload_bits": 192, + "prefix_bits": 68 + }, + "joint_real_delta": -400, + "complex_saving_vs_PR1263": 800, + "complex_saving_vs_PR1094": 13800, + "scale_macros": 54, + "input_event_count": 25203, + "candidate_event_count": 25257, + "non_scalar_events_unchanged": true, + "all_712_columns_equal": true, + "candidate_sha256": "7ec92f12a16dc9b69fc579c034bffc0ee5d7c161632bc8562d70b835d0c52da2", + "endpoint_sha256": "a5cdcf515e10c601d029da7924b1abad8942bfd3b4eeee8685d836740c489565", + "controls": { + "zero_schedule_identity": "passed", + "missing_L348_transition_scale": "rejected", + "missing_L359_shared_coefficient": "rejected" + } + } + }, + "no_joint_optimality_claim": true, + "no_new_kappa": true, + "scope": "Feasible composition of two exact single-coordinate minima on a pinned shared-ADD pair; no two-coordinate optimum, supplier admission, or paid-profile change." +} diff --git a/research/complex-temporal-pair-seed28/SOURCES.json b/research/complex-temporal-pair-seed28/SOURCES.json new file mode 100644 index 0000000000..fe4ec4e739 --- /dev/null +++ b/research/complex-temporal-pair-seed28/SOURCES.json @@ -0,0 +1,182 @@ +{ + "schema_version": 1, + "base_commit": "bce54fb3f895cbe5cd4c0eb477c3afeed100190f", + "base_files": [ + { + "path": "CONTRIBUTING.md", + "git_blob": "e51435543687f1bd88ab22248082dc689ce8b853", + "sha256": "df5b5646602f42cb5da5844f04ac925182ddcd0f627b9de1c96a5095bb7a277a" + }, + { + "path": "certificates/selected-result.json", + "git_blob": "ae6a99f28aa468649eb66a361e764d769363bf11", + "sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32" + }, + { + "path": "docs/research/agent-task-catalog.json", + "git_blob": "c05fafaa25ba95b2d5af86b1800427198e3d20eb", + "sha256": "89b5928bc92c81e2647b6d702a7ad85a6795b8f44e2eb267b2ff3145d8f2b2ce" + }, + { + "path": "docs/research/current-status.md", + "git_blob": "aa3cf49715cd367ad8c4e63ab28856fc0d19794f", + "sha256": "1f59d648763c77d574d18dc59ea8bf62d2ee74aaed3c202c9c8cfa4f901badbd" + }, + { + "path": "docs/research/pr-ledger.md", + "git_blob": "4331ba3175b3418f70fb5cf7ee9689b3505c0678", + "sha256": "8030b58f708e40aee4e40f950a20a0b0ccef3f92b08e6e089fe35db82ec027e6" + }, + { + "path": "docs/research/community-batch1099-review.md", + "git_blob": "6cb6ec061a071a06a2d18cd4dc3e9a2b05d28099", + "sha256": "7e76d2c38e5fce30587835b7251df1430488ae4dd372611ef69a3f03f476b6cb" + }, + { + "path": "research/community-frontier1094-audit/ASSEMBLY.json", + "git_blob": "5fd676df060f3b450782fdf5ff5f6beb63a5eeb0", + "sha256": "1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045" + }, + { + "path": "research/community-frontier1094-audit/SELECTED-SOURCE.json", + "git_blob": "6a75493790b4eff9c4a98051ef8b01d6aad0d5a8", + "sha256": "79b3de5db3dbcb9829789ba58e9e45758926031e2a7d80667a08429d369be53b" + } + ], + "vendored_files": [ + { + "path": "vendor/pr1369/CERTIFICATE.json", + "upstream_path": "research/k8-zero-static-temporal-seed25/CERTIFICATE.json", + "git_blob": "e6f45a1e405fe418a687710943ab39c78c7ae834", + "sha256": "5763aeba455aeee3c7fe82cd513e3588b7c73f14dd67b299ce72a33c18937516" + }, + { + "path": "vendor/pr1369/DEPENDENCIES.json", + "upstream_path": "research/k8-zero-static-temporal-seed25/DEPENDENCIES.json", + "git_blob": "d6526ef9fa882eb2abc88c0c4148b4715726318d", + "sha256": "f1759748e16a70a392544c77bb949abc74eca24b5eaa8490a7335a270030e626" + }, + { + "path": "vendor/pr1369/NOTICE.md", + "upstream_path": "research/k8-zero-static-temporal-seed25/NOTICE.md", + "git_blob": "db9f1414793c017e46845b1d6693a2962f754c9d", + "sha256": "fa4c86ee4cc39ec3fd0b1ee3667b638e8de557d7999a8b785cb01279dc58f4e7" + }, + { + "path": "vendor/pr1369/PR1369-README.md", + "upstream_path": "research/k8-zero-static-temporal-seed25/README.md", + "git_blob": "437d744ac5ced90e5eee87c0f57a6bc0549bdff1", + "sha256": "a2915989825530b4a3308fb98e38db848ef103fd1775ee21e432c47adf4c452c" + }, + { + "path": "vendor/pr1369/SOURCES.json", + "upstream_path": "research/k8-zero-static-temporal-seed25/SOURCES.json", + "git_blob": "baf6c3366895e118dac17e194dc0779dc8daa61c", + "sha256": "4fcd50d8b2767cb5a45a5ca41efaf10ecc3b29346ccaa16eb1474e4a4ac6499b" + }, + { + "path": "vendor/pr1369/independent.py", + "upstream_path": "research/k8-zero-static-temporal-seed25/independent.py", + "git_blob": "415083a91ae83ac4739c7863c42070d1213d3fcd", + "sha256": "a125124e221c7959458789cb2e2c43553af2eb964b6cf27371c77ecb1841a5a0" + }, + { + "path": "vendor/pr1369/vendor/pr1259/search.py", + "upstream_path": "research/k8-zero-static-temporal-seed25/vendor/pr1259/search.py", + "git_blob": "6d9f53c62fe16db66c8bcce6f21a89dabbf4384f", + "sha256": "e096c811109b02284abdd1e5117df0a0caa3f0f379aa6975e75fc202f73c7cf2" + }, + { + "path": "vendor/pr1369/vendor/pr1263/GAUGES.json", + "upstream_path": "research/k8-zero-static-temporal-seed25/vendor/pr1263/GAUGES.json", + "git_blob": "6bd3ef7e0e2c4ea56d7fa2725d2b09f1f3fc0085", + "sha256": "9bdfdb3be598e2df4d4102402d0cd8cba4159a28d939ba51bc668d6f3be314c3" + }, + { + "path": "vendor/pr1369/vendor/pr1263/PREDECESSORS.json", + "upstream_path": "research/k8-zero-static-temporal-seed25/vendor/pr1263/PREDECESSORS.json", + "git_blob": "19d2de16693eee2df760172982a48c547243dfbe", + "sha256": "13f3e91e0625039284da4bbe82bf31ec2d303e59e3a54a9dafb5b367f07cc272" + }, + { + "path": "vendor/pr1369/vendor/pr1263/vendor/pr1161/BASE-SELECTED.json", + "upstream_path": "research/k8-zero-static-temporal-seed25/vendor/pr1263/vendor/pr1161/BASE-SELECTED.json", + "git_blob": "74e4acfe7347dfbb4f8ebab3615b5a282023eff3", + "sha256": "c49e308d209dfbaba184a0d41dbc03cb424663f7ad8136d56aba088bba7f5723" + }, + { + "path": "vendor/pr1369/vendor/pr1263/vendor/pr1161/PROOF.md", + "upstream_path": "research/k8-zero-static-temporal-seed25/vendor/pr1263/vendor/pr1161/PROOF.md", + "git_blob": "d2925051c50ae193c1fc922474d6f14a0bf49977", + "sha256": "89cbba31b4d95b9c7c69e3bbccd9858e45cd43e1968c39472af7e03fea0e3e54" + }, + { + "path": "vendor/pr1369/vendor/pr1263/vendor/pr1161/PROVENANCE.md", + "upstream_path": "research/k8-zero-static-temporal-seed25/vendor/pr1263/vendor/pr1161/PROVENANCE.md", + "git_blob": "6ee8cde472014483ef51daf2299784d08ae8c2c1", + "sha256": "76dca2049e8c008da0398fd722745e421be92c66dac876cf8463295f6cb18518" + }, + { + "path": "vendor/pr1369/vendor/pr1263/vendor/pr1161/SOURCES.json", + "upstream_path": "research/k8-zero-static-temporal-seed25/vendor/pr1263/vendor/pr1161/SOURCES.json", + "git_blob": "841bf21533d4e6bcdca4f320d0f5a3ae500e999e", + "sha256": "45f24dbd27239e499600e497e3d86cf812f3b45122088ad083a836e8d646b320" + }, + { + "path": "vendor/pr1369/vendor/pr1263/vendor/pr1161/engine.py", + "upstream_path": "research/k8-zero-static-temporal-seed25/vendor/pr1263/vendor/pr1161/engine.py", + "git_blob": "33c0db7fe7f51c64565d9500709aaf90926d0d60", + "sha256": "997b34533aea200c339263a96dd6f76facf21bf54b1627ab244e2ae72d348400" + }, + { + "path": "vendor/pr1369/vendor/pr1263/verify.py", + "upstream_path": "research/k8-zero-static-temporal-seed25/vendor/pr1263/verify.py", + "git_blob": "c688f7243562d32d1c6666bdee6ca4ffc59bc5b8", + "sha256": "1e7b91aef01b431ab74efe5e3bab6cd2180802298f43d9f216cca6e4de422440" + }, + { + "path": "vendor/pr1369/verify.py", + "upstream_path": "research/k8-zero-static-temporal-seed25/verify.py", + "git_blob": "805b34f7c855d23183b898c3d170eb0858d4bd6b", + "sha256": "af8793ce280653df48ea8da72e193725e457e047b617901378213512efa40b3c" + } + ], + "predecessors": { + "pr1369": { + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1369", + "head": "f28e1c460cd910886f9b06835abd6b1c96d2992f", + "status_at_selection": "open", + "role": "single-coordinate zero-static temporal census and exact DP source" + }, + "pr1310": { + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1310", + "head": "b9ca10f02fca37c8214d880c244ac14ead6bae7a", + "status_at_selection": "open", + "role": "two-coordinate constant-gauge stationarity; excludes phase-varying composition" + }, + "pr1376": { + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1376", + "head": "49f112ac76e95415fcea8969de28f74c8928b2b1", + "status_at_selection": "open", + "role": "L248/L253 temporal composition with disjoint ADD supports" + }, + "pr1380": { + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1380", + "head": "c2bc6848cffb2e2203095d4c4bbc45b0848c22e7", + "status_at_selection": "open", + "role": "recent paired temporal shared-ADD optimization; tested pair set does not include L348/L359" + }, + "pr1263": { + "head": "5fbaca13028846bddbb001e8e07addc2ab8e5816", + "role": "static 218-helper gauge source word" + }, + "pr1259": { + "head": "61367611154266a982fe25e1a6243a8aad77227d", + "role": "dyadic scalar lowerer and temporal gauge lineage" + }, + "pr1161": { + "head": "d210969d3158a1e6c505e41f67dd84e555c88564", + "role": "exact loader, scalar replay, and invoice source" + } + } +} diff --git a/research/complex-temporal-pair-seed28/vendor/pr1369/CERTIFICATE.json b/research/complex-temporal-pair-seed28/vendor/pr1369/CERTIFICATE.json new file mode 100644 index 0000000000..e6f45a1e40 --- /dev/null +++ b/research/complex-temporal-pair-seed28/vendor/pr1369/CERTIFICATE.json @@ -0,0 +1 @@ +{"assignment_seed":25,"base_commit":"bce54fb3f895cbe5cd4c0eb477c3afeed100190f","domain":{"eligible_helpers":237,"orientation":["forward","backward"],"scan_order":[444,446,447,469,478,479,491,503,507,514,515,519,542,272,288,348,359,381,440],"schedule_values":"all integers, reduced to the exact breakpoint interval","static_gauged_helpers":218,"zero_static_helpers":[272,288,348,359,381,440,444,446,447,469,478,479,491,503,507,514,515,519,542]},"orientations":{"backward":{"baseline_static_invoice":{"charged_payload_bits":192,"complex_primitives":136018,"paid_profile":{"1":2412,"2":418,"3":432,"4":142,"5":82,"8":8},"prefix_bits":68,"prefix_l1":"14824960514781440791821/64","real_primitives":68009},"candidate_invoice":{"charged_payload_bits":192,"complex_primitives":135534,"paid_profile":{"1":2412,"2":418,"3":432,"4":142,"5":82,"8":8},"prefix_bits":68,"prefix_l1":"14824960514781440791821/64","real_primitives":67767},"candidate_sha256":"e13994779e6697ecc2137b802bdea828152696a70bab84e3605b6848048ada5c","formal_endpoint":{"all_restored":true,"centre_columns":8,"data_helper_columns":704,"dirty_helper_columns":480,"formal_input_columns":712},"helpers":[{"best_constant_delta_real":0,"best_constant_exponent":0,"best_delta_real":-14,"domain":[-2,1],"edge_evaluations":452,"helper":444,"incident_adds":29,"transition_scale_macros":2},{"best_constant_delta_real":0,"best_constant_exponent":0,"best_delta_real":-26,"domain":[-2,1],"edge_evaluations":708,"helper":446,"incident_adds":45,"transition_scale_macros":10},{"best_constant_delta_real":0,"best_constant_exponent":0,"best_delta_real":-45,"domain":[-2,1],"edge_evaluations":948,"helper":447,"incident_adds":60,"transition_scale_macros":11},{"best_constant_delta_real":0,"best_constant_exponent":0,"best_delta_real":-22,"domain":[-2,2],"edge_evaluations":755,"helper":469,"incident_adds":31,"transition_scale_macros":8},{"best_constant_delta_real":0,"best_constant_exponent":0,"best_delta_real":-14,"domain":[-2,1],"edge_evaluations":372,"helper":478,"incident_adds":24,"transition_scale_macros":5},{"best_constant_delta_real":0,"best_constant_exponent":0,"best_delta_real":-17,"domain":[-2,13],"edge_evaluations":8720,"helper":479,"incident_adds":35,"transition_scale_macros":8},{"best_constant_delta_real":0,"best_constant_exponent":0,"best_delta_real":-14,"domain":[-2,2],"edge_evaluations":705,"helper":491,"incident_adds":29,"transition_scale_macros":6},{"best_constant_delta_real":0,"best_constant_exponent":0,"best_delta_real":-13,"domain":[-1,3],"edge_evaluations":655,"helper":503,"incident_adds":27,"transition_scale_macros":6},{"best_constant_delta_real":0,"best_constant_exponent":0,"best_delta_real":-24,"domain":[-1,1],"edge_evaluations":282,"helper":507,"incident_adds":32,"transition_scale_macros":4},{"best_constant_delta_real":0,"best_constant_exponent":0,"best_delta_real":-19,"domain":[-1,2],"edge_evaluations":404,"helper":514,"incident_adds":26,"transition_scale_macros":8},{"best_constant_delta_real":0,"best_constant_exponent":0,"best_delta_real":-15,"domain":[-1,2],"edge_evaluations":436,"helper":515,"incident_adds":28,"transition_scale_macros":8},{"best_constant_delta_real":0,"best_constant_exponent":0,"best_delta_real":-30,"domain":[-1,1],"edge_evaluations":291,"helper":519,"incident_adds":33,"transition_scale_macros":6},{"best_constant_delta_real":0,"best_constant_exponent":0,"best_delta_real":-28,"domain":[-1,1],"edge_evaluations":273,"helper":542,"incident_adds":31,"transition_scale_macros":4},{"best_constant_delta_real":0,"best_constant_exponent":0,"best_delta_real":-112,"domain":[-3,3],"edge_evaluations":4907,"helper":272,"incident_adds":101,"transition_scale_macros":21},{"best_constant_delta_real":0,"best_constant_exponent":0,"best_delta_real":-116,"domain":[-1,3],"edge_evaluations":2330,"helper":288,"incident_adds":94,"transition_scale_macros":20},{"best_constant_delta_real":0,"best_constant_exponent":0,"best_delta_real":-161,"domain":[-4,3],"edge_evaluations":7944,"helper":348,"incident_adds":125,"transition_scale_macros":21},{"best_constant_delta_real":0,"best_constant_exponent":0,"best_delta_real":-242,"domain":[-7,3],"edge_evaluations":17677,"helper":359,"incident_adds":147,"transition_scale_macros":33},{"best_constant_delta_real":0,"best_constant_exponent":0,"best_delta_real":-47,"domain":[-2,2],"edge_evaluations":1555,"helper":381,"incident_adds":63,"transition_scale_macros":11},{"best_constant_delta_real":0,"best_constant_exponent":0,"best_delta_real":-14,"domain":[-1,1],"edge_evaluations":246,"helper":440,"incident_adds":28,"transition_scale_macros":2}],"helpers_checked":19,"omitted_transition_scale_rejected":true,"saving_complex_vs_original":13484,"saving_complex_vs_pr1263":484,"winner":359,"winner_delta_real":-242,"winner_domain":[-7,3],"winner_edge_evaluations":17677,"winner_incident_adds":147,"winner_schedule":[[1597,2],[1643,2],[1688,2],[1756,2],[1818,2],[1888,2],[1952,2],[2018,2],[2482,2],[2555,2],[2620,2],[2694,2],[2768,2],[2839,2],[2904,2],[2978,2],[3756,2],[4079,2],[4199,2],[4370,2],[5191,2],[5262,2],[5335,2],[5410,2],[5483,2],[5554,2],[5621,2],[5695,2],[6176,2],[6255,2],[6335,2],[6413,2],[9095,1],[9155,1],[9159,1],[9160,1],[9161,1],[9162,1],[9163,1],[9164,0],[9165,0],[9168,1],[9169,1],[9170,1],[9172,2],[9173,2],[9174,2],[9191,2],[9205,1],[9219,0],[11371,0],[11442,2],[11443,2],[11454,0],[14457,0],[14796,0],[15117,0],[15746,1],[15747,1],[15753,1],[19458,1],[19472,2],[19527,2],[19545,2],[19557,3],[19561,3],[23684,3],[24235,3],[24243,3],[24263,-7],[24264,-7],[24265,-3],[24266,-3],[24267,-3],[24268,-2],[24269,-2],[24270,-2],[24271,-2],[24272,-2],[24273,-2],[24274,-2],[24275,-2],[24276,-3],[24277,-4],[24278,-4],[24279,-4],[24280,-3],[24281,-3],[24282,-3],[24283,-4],[24284,-4],[24285,-4],[24286,-1],[24287,0],[24288,0],[24289,0],[24290,0],[24291,0],[24292,0],[24293,0],[24294,0],[24295,0],[24296,0],[24297,0],[24298,0],[24299,0],[24300,0],[24301,0],[24302,0],[24303,0],[24304,-4],[24305,-4],[24306,-2],[24307,-2],[24308,-1],[24309,-1],[24310,-1],[24311,-1],[24312,-1],[24313,-1],[24314,-3],[24315,-3],[24316,-3],[24317,-1],[24318,-1],[24319,-1],[24320,0],[24321,0],[24322,0],[24323,0],[24324,-1],[24325,-1],[24326,0],[24327,0],[24328,0],[24329,-4],[24330,-4],[24331,-4],[24332,-4],[24333,-4],[24334,-3],[24335,-3],[24336,-3],[24337,1],[24338,1],[24374,1],[24653,1]],"winner_transition_scale_macros":33,"winner_transition_scale_work":62},"forward":{"baseline_static_invoice":{"charged_payload_bits":192,"complex_primitives":136002,"paid_profile":{"1":2412,"2":418,"3":432,"4":142,"5":82,"8":8},"prefix_bits":52,"prefix_l1":"2765345294379392599/1024","real_primitives":68001},"candidate_invoice":{"charged_payload_bits":192,"complex_primitives":135518,"paid_profile":{"1":2412,"2":418,"3":432,"4":142,"5":82,"8":8},"prefix_bits":52,"prefix_l1":"2765345294379392599/1024","real_primitives":67759},"candidate_sha256":"4dd186f72172c5b55bbdf53131b4b7e88e4157502e569d80adbcdf17620cccce","formal_endpoint":{"all_restored":true,"centre_columns":8,"data_helper_columns":704,"dirty_helper_columns":480,"formal_input_columns":712},"helpers":[{"best_constant_delta_real":0,"best_constant_exponent":0,"best_delta_real":-14,"domain":[-1,2],"edge_evaluations":452,"helper":444,"incident_adds":29,"transition_scale_macros":2},{"best_constant_delta_real":0,"best_constant_exponent":0,"best_delta_real":-26,"domain":[-1,2],"edge_evaluations":708,"helper":446,"incident_adds":45,"transition_scale_macros":10},{"best_constant_delta_real":0,"best_constant_exponent":0,"best_delta_real":-45,"domain":[-1,2],"edge_evaluations":948,"helper":447,"incident_adds":60,"transition_scale_macros":11},{"best_constant_delta_real":0,"best_constant_exponent":0,"best_delta_real":-22,"domain":[-2,2],"edge_evaluations":755,"helper":469,"incident_adds":31,"transition_scale_macros":8},{"best_constant_delta_real":0,"best_constant_exponent":0,"best_delta_real":-14,"domain":[-1,2],"edge_evaluations":372,"helper":478,"incident_adds":24,"transition_scale_macros":5},{"best_constant_delta_real":0,"best_constant_exponent":0,"best_delta_real":-17,"domain":[-13,2],"edge_evaluations":8720,"helper":479,"incident_adds":35,"transition_scale_macros":8},{"best_constant_delta_real":0,"best_constant_exponent":0,"best_delta_real":-14,"domain":[-2,2],"edge_evaluations":705,"helper":491,"incident_adds":29,"transition_scale_macros":6},{"best_constant_delta_real":0,"best_constant_exponent":0,"best_delta_real":-13,"domain":[-3,1],"edge_evaluations":655,"helper":503,"incident_adds":27,"transition_scale_macros":6},{"best_constant_delta_real":0,"best_constant_exponent":0,"best_delta_real":-24,"domain":[-1,1],"edge_evaluations":282,"helper":507,"incident_adds":32,"transition_scale_macros":4},{"best_constant_delta_real":0,"best_constant_exponent":0,"best_delta_real":-19,"domain":[-2,1],"edge_evaluations":404,"helper":514,"incident_adds":26,"transition_scale_macros":8},{"best_constant_delta_real":0,"best_constant_exponent":0,"best_delta_real":-15,"domain":[-2,1],"edge_evaluations":436,"helper":515,"incident_adds":28,"transition_scale_macros":8},{"best_constant_delta_real":0,"best_constant_exponent":0,"best_delta_real":-30,"domain":[-1,1],"edge_evaluations":291,"helper":519,"incident_adds":33,"transition_scale_macros":6},{"best_constant_delta_real":0,"best_constant_exponent":0,"best_delta_real":-28,"domain":[-1,1],"edge_evaluations":273,"helper":542,"incident_adds":31,"transition_scale_macros":4},{"best_constant_delta_real":0,"best_constant_exponent":0,"best_delta_real":-112,"domain":[-3,3],"edge_evaluations":4907,"helper":272,"incident_adds":101,"transition_scale_macros":21},{"best_constant_delta_real":0,"best_constant_exponent":0,"best_delta_real":-116,"domain":[-3,1],"edge_evaluations":2330,"helper":288,"incident_adds":94,"transition_scale_macros":20},{"best_constant_delta_real":0,"best_constant_exponent":0,"best_delta_real":-161,"domain":[-3,4],"edge_evaluations":7944,"helper":348,"incident_adds":125,"transition_scale_macros":21},{"best_constant_delta_real":0,"best_constant_exponent":0,"best_delta_real":-242,"domain":[-3,7],"edge_evaluations":17677,"helper":359,"incident_adds":147,"transition_scale_macros":33},{"best_constant_delta_real":0,"best_constant_exponent":0,"best_delta_real":-47,"domain":[-2,2],"edge_evaluations":1555,"helper":381,"incident_adds":63,"transition_scale_macros":11},{"best_constant_delta_real":0,"best_constant_exponent":0,"best_delta_real":-14,"domain":[-1,1],"edge_evaluations":246,"helper":440,"incident_adds":28,"transition_scale_macros":2}],"helpers_checked":19,"omitted_transition_scale_rejected":true,"saving_complex_vs_original":13484,"saving_complex_vs_pr1263":484,"winner":359,"winner_delta_real":-242,"winner_domain":[-3,7],"winner_edge_evaluations":17677,"winner_incident_adds":147,"winner_schedule":[[1597,-2],[1643,-2],[1688,-2],[1756,-2],[1818,-2],[1888,-2],[1952,-2],[2018,-2],[2482,-2],[2555,-2],[2620,-2],[2694,-2],[2768,-2],[2839,-2],[2904,-2],[2978,-2],[3756,-2],[4079,-2],[4199,-2],[4370,-2],[5191,-2],[5262,-2],[5335,-2],[5410,-2],[5483,-2],[5554,-2],[5621,-2],[5695,-2],[6176,-2],[6255,-2],[6335,-2],[6413,-2],[9095,-1],[9155,-1],[9159,-1],[9160,-1],[9161,-1],[9162,-1],[9163,-1],[9164,0],[9165,0],[9168,-1],[9169,-1],[9170,-1],[9172,-2],[9173,-2],[9174,-2],[9191,-2],[9205,-1],[9219,0],[11371,0],[11442,-2],[11443,-2],[11454,0],[14457,0],[14796,0],[15117,0],[15746,-1],[15747,-1],[15753,-1],[19458,-1],[19472,-2],[19527,-2],[19545,-2],[19557,-3],[19561,-3],[23684,-3],[24235,-3],[24243,-3],[24263,7],[24264,7],[24265,3],[24266,3],[24267,3],[24268,2],[24269,2],[24270,2],[24271,2],[24272,2],[24273,2],[24274,2],[24275,2],[24276,3],[24277,4],[24278,4],[24279,4],[24280,3],[24281,3],[24282,3],[24283,4],[24284,4],[24285,4],[24286,1],[24287,0],[24288,0],[24289,0],[24290,0],[24291,0],[24292,0],[24293,0],[24294,0],[24295,0],[24296,0],[24297,0],[24298,0],[24299,0],[24300,0],[24301,0],[24302,0],[24303,0],[24304,4],[24305,4],[24306,2],[24307,2],[24308,1],[24309,1],[24310,1],[24311,1],[24312,1],[24313,1],[24314,3],[24315,3],[24316,3],[24317,1],[24318,1],[24319,1],[24320,0],[24321,0],[24322,0],[24323,0],[24324,1],[24325,1],[24326,0],[24327,0],[24328,0],[24329,4],[24330,4],[24331,4],[24332,4],[24333,4],[24334,3],[24335,3],[24336,3],[24337,-1],[24338,-1],[24374,-1],[24653,-1]],"winner_transition_scale_macros":33,"winner_transition_scale_work":62}},"predecessors":{"pr1259_head":"61367611154266a982fe25e1a6243a8aad77227d","pr1263_head":"5fbaca13028846bddbb001e8e07addc2ab8e5816"},"selected_certificate_sha256":"1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045","selected_kappa":"836330098538459/500000000000000000","status":"PASS_ZERO_STATIC_TEMPORAL_CENSUS","track":"complex supplier"} diff --git a/research/complex-temporal-pair-seed28/vendor/pr1369/DEPENDENCIES.json b/research/complex-temporal-pair-seed28/vendor/pr1369/DEPENDENCIES.json new file mode 100644 index 0000000000..d6526ef9fa --- /dev/null +++ b/research/complex-temporal-pair-seed28/vendor/pr1369/DEPENDENCIES.json @@ -0,0 +1,46 @@ +{ + "assignment_seed": 25, + "base_commit": "bce54fb3f895cbe5cd4c0eb477c3afeed100190f", + "method": "Exact DP on all 19 PR1263 eligible helpers with zero static gauge; winning complete replay is L359.", + "pr1259_head": "61367611154266a982fe25e1a6243a8aad77227d", + "pr1263_head": "5fbaca13028846bddbb001e8e07addc2ab8e5816", + "related_concurrent_pr1310": { + "base": "bce54fb3f895cbe5cd4c0eb477c3afeed100190f", + "head": "b9ca10f02fca37c8214d880c244ac14ead6bae7a", + "scope": "two-coordinate constant gauges; not an executable dependency" + }, + "related_temporal_pr1350": { + "base": "bce54fb3f895cbe5cd4c0eb477c3afeed100190f", + "head": "64b8a55c6933ffb6d9e30fa19f85d05b572d4aa5", + "scope": "time-varying L253 on PR1263 nonzero-static support; separate result" + }, + "related_temporal_pr1353": { + "base": "bce54fb3f895cbe5cd4c0eb477c3afeed100190f", + "head": "efc6bfc3302a966ac0e1f5f4656e94b4cabeb9ca", + "scope": "time-varying L248 on PR1263 nonzero-static support; separate result" + }, + "schema_version": 1, + "source_git_blobs": { + "vendor/pr1259/search.py": "6d9f53c62fe16db66c8bcce6f21a89dabbf4384f", + "vendor/pr1263/GAUGES.json": "6bd3ef7e0e2c4ea56d7fa2725d2b09f1f3fc0085", + "vendor/pr1263/PREDECESSORS.json": "19d2de16693eee2df760172982a48c547243dfbe", + "vendor/pr1263/vendor/pr1161/BASE-SELECTED.json": "74e4acfe7347dfbb4f8ebab3615b5a282023eff3", + "vendor/pr1263/vendor/pr1161/PROOF.md": "d2925051c50ae193c1fc922474d6f14a0bf49977", + "vendor/pr1263/vendor/pr1161/PROVENANCE.md": "6ee8cde472014483ef51daf2299784d08ae8c2c1", + "vendor/pr1263/vendor/pr1161/SOURCES.json": "841bf21533d4e6bcdca4f320d0f5a3ae500e999e", + "vendor/pr1263/vendor/pr1161/engine.py": "33c0db7fe7f51c64565d9500709aaf90926d0d60", + "vendor/pr1263/verify.py": "c688f7243562d32d1c6666bdee6ca4ffc59bc5b8" + }, + "task_id": "k8-zero-static-temporal-seed25", + "vendored_sha256": { + "vendor/pr1259/search.py": "e096c811109b02284abdd1e5117df0a0caa3f0f379aa6975e75fc202f73c7cf2", + "vendor/pr1263/GAUGES.json": "9bdfdb3be598e2df4d4102402d0cd8cba4159a28d939ba51bc668d6f3be314c3", + "vendor/pr1263/PREDECESSORS.json": "13f3e91e0625039284da4bbe82bf31ec2d303e59e3a54a9dafb5b367f07cc272", + "vendor/pr1263/vendor/pr1161/BASE-SELECTED.json": "c49e308d209dfbaba184a0d41dbc03cb424663f7ad8136d56aba088bba7f5723", + "vendor/pr1263/vendor/pr1161/PROOF.md": "89cbba31b4d95b9c7c69e3bbccd9858e45cd43e1968c39472af7e03fea0e3e54", + "vendor/pr1263/vendor/pr1161/PROVENANCE.md": "76dca2049e8c008da0398fd722745e421be92c66dac876cf8463295f6cb18518", + "vendor/pr1263/vendor/pr1161/SOURCES.json": "45f24dbd27239e499600e497e3d86cf812f3b45122088ad083a836e8d646b320", + "vendor/pr1263/vendor/pr1161/engine.py": "997b34533aea200c339263a96dd6f76facf21bf54b1627ab244e2ae72d348400", + "vendor/pr1263/verify.py": "1e7b91aef01b431ab74efe5e3bab6cd2180802298f43d9f216cca6e4de422440" + } +} diff --git a/research/complex-temporal-pair-seed28/vendor/pr1369/NOTICE.md b/research/complex-temporal-pair-seed28/vendor/pr1369/NOTICE.md new file mode 100644 index 0000000000..db9f141479 --- /dev/null +++ b/research/complex-temporal-pair-seed28/vendor/pr1369/NOTICE.md @@ -0,0 +1,9 @@ +# Notices + +New work in this package is offered under the repository's Apache-2.0 license. + +The files under `vendor/pr1263/` and `vendor/pr1259/` are retained verbatim from the pinned predecessor work and are identified by exact commit, Git blob, and SHA-256 pins in `DEPENDENCIES.json`. Do not remove their original attribution or license notices when reusing them. + +This contribution builds on Philipp / @mightyOil's PR1263 218-helper construction; Sagar Thakrar's PR1259 temporal-gauge search and PR696 copy-initialization lowerer; and the selected PR1094 supplier lineage. Concurrent PR1350 (L253) and PR1353 (L248) study nonzero-static coordinates; they are complementary scope and are not computational dependencies here. + +Prepared by Cinna Davis / @1337isnot1337 with substantial OpenAI Codex assistance. No independent human review is claimed. diff --git a/research/complex-temporal-pair-seed28/vendor/pr1369/PR1369-README.md b/research/complex-temporal-pair-seed28/vendor/pr1369/PR1369-README.md new file mode 100644 index 0000000000..437d744ac5 --- /dev/null +++ b/research/complex-temporal-pair-seed28/vendor/pr1369/PR1369-README.md @@ -0,0 +1,80 @@ +# Exact temporal-gauge census on PR1263 zero-static helpers + +**Finite scalar construction; no new κ.** On the frozen 218-helper scalar word from [PR1263](https://github.com/CrocSwap/integer-mult-bounds/pull/1263), an exact one-coordinate temporal gauge on L359 saves **484 complex scalar primitives per invocation** over PR1263 in each orientation. L359 was one of the 19 eligible helpers whose static exponent was zero. The search checked every one of those 19 helpers in both orientations; it did not compose independent coordinate minima. + +| Complex scalar word | Forward | Backward | +|---|---:|---:| +| Original PR1094 word | 149,002 | 149,018 | +| PR1263 218-helper static word | 136,002 | 136,018 | +| L359 temporal word | 135,518 | 135,534 | +| Additional saving over PR1263 | 484 | 484 | +| Total saving over original | 13,484 | 13,484 | + +The selected conditional κ at the exact base `bce54fb3f895cbe5cd4c0eb477c3afeed100190f` remains `836330098538459/500000000000000000` (`0.001672660197076918`). The paid recursive profile is unchanged. This result does not claim a new supplier admission, hosted improvement, or κ. + +## Exact price and schedule + +For one helper `h` and one orientation, list its incident ADDs in chronological order. At ADD `i`, let `q_i = p_i 2^{e_i}` with `p_i` positive odd, and let `s_i` be `+1` if `h` is the target and `-1` if it is the source. The integer exponent `d_i` changes the coefficient to `q_i 2^{s_i d_i}`. PR1263's other 218 exponents remain fixed; all existing non-incident events remain as recorded. + +With the exact PR696 copy-initialization price + +```text +P(p 2^e) = 1 + bit_length(p) + popcount(p) + |e| + - 1[p = 1 and e = 0], +``` + +the complete real-component change is + +```text +Δ(d) = Σ_i (P(q_i 2^(s_i d_i)) − P(q_i)) + + |d_1| + Σ_(i>1) |d_i − d_(i−1)| + |d_m|. +``` + +The final terms charge the entry pulse from exponent zero, every phase change, and the exit pulse back to zero. No boundary scale is omitted. The exact DP finds `Δ = -242` in each orientation. The schedule changes L359 at 147 incident ADDs and inserts 33 scale macros, with total scale work 62 real primitives. The resulting complete invoice is 135,518 forward and 135,534 backward complex primitives, exactly 484 below PR1263. + +## Search and coverage + +PR1263 identifies 237 eligible cold-entry/FULL-exit, unwrapped, non-center helpers with no incident COPY or clear. Its static gauge support has 218 coordinates. This search took the complementary **19 eligible zero-static coordinates** `{272, 288, 348, 359, 381, 440, 444, 446, 447, 469, 478, 479, 491, 503, 507, 514, 515, 519, 542}`. + +OS seed **25** assigned the complex-supplier track and selected the first scan coordinate as `25 mod 19 = 6`, L444. The finite census then covered all 19 helpers in both orientations, starting at L444 and wrapping once. Each one-coordinate objective was minimized over every integer schedule. The best constant exponent for each of the 19 coordinates has change zero; the unique lowest temporal minimum is L359 at `-242` real primitives in both orientations. The certificate records every helper's incident ADD count, exact finite interval, DP transition count, temporal minimum, and constant-gauge control. + +The finite interval is exact. For each incident coefficient, price changes only through `|e_i + s_i d_i|` and the isolated unit-coefficient discount at `e_i + s_i d_i = 0`. Let `[L,U]` contain zero and every such integer root. Clamping each exponent to `[L,U]` cannot increase the total variation (interval projection is 1-Lipschitz), cannot increase any coefficient's absolute exponent, and retains every possible unit discount point. Therefore an optimum over all integer schedules lies in this interval. For L359, the forward interval is `[-3,7]` and the backward interval is `[-7,3]`; each DP has 11 exponent states and 17,677 exact edge evaluations, followed by an 11-state terminal scan. + +This is a one-coordinate result. Shared ADDs mean the 19 separate minima cannot be added to claim a combined saving. The finite replay checks the candidate against all 712 source/helper/center input columns, confirms the paid profile and non-scalar event stream, and checks the inherited 192-bit local charge. That replay is evidence for this construction, not a formal proof of the full multiplication theorem. + +## Open next questions + +Can this L359 schedule be emitted by the native supplier and admitted by the full hosted recursive construction? The next step is to add the exact phase schedule to the source-bound native provider and replay both orientations with the existing hosted cost model. This package does not resolve that admission step. + +## Reproduction + +With Python 3.11 or newer and the repository's pinned source files: + +```sh +python3 -I -O -B research/k8-zero-static-temporal-seed25/verify.py +``` + +Expected final lines: + +```text +PASS_ZERO_STATIC_TEMPORAL_CENSUS +forward helpers 19 winner 359 delta_real -242 complex 135518 saved_vs_PR1263 484 columns 712 +backward helpers 19 winner 359 delta_real -242 complex 135534 saved_vs_PR1263 484 columns 712 +``` + +The independent small controls are: + +```sh +python3 -I -O -B research/k8-zero-static-temporal-seed25/test_package.py +``` + +Expected: `PASS_TEMPORAL_DP_CONTROLS exhaustive=27 zero_identity=1 incomplete_schedule_rejected=1`. +The registered repository replay is `python3.12 scripts/research_package.py --package research/k8-zero-static-temporal-seed25`. + +## Pins, scope, and credit + +The base, selected certificate hash, PR1263 head `5fbaca13028846bddbb001e8e07addc2ab8e5816`, temporal-gauge method head PR1259 `61367611154266a982fe25e1a6243a8aad77227d`, source Git blobs, and vendored SHA-256 values are recorded in `DEPENDENCIES.json` and `SOURCES.json`. Related concurrent work varies nonzero-static coordinates: PR1350 head `64b8a55c6933ffb6d9e30fa19f85d05b572d4aa5` studies L253, and PR1353 head `efc6bfc3302a966ac0e1f5f4656e94b4cabeb9ca` studies L248. This result adds a complete census of the 19 eligible zero-static coordinates, including the independently checked L359 schedule; it does not compose the other temporal results. + +The inherited all-size/compiler, native realization, hosting, precision/tape, analytic, and bit-interface assumptions remain. No runtime or whole-hosted result is claimed. + +Prepared by **Cinna Davis / @1337isnot1337** with substantial **OpenAI Codex** assistance in research, exact cost analysis, implementation, verification, and writing. No independent human review is claimed. Credit Philipp / @mightyOil's PR1263 many-helper construction; Sagar Thakrar's PR1259 temporal-gauge method and PR696 lowerer; and the retained PR1094 supplier lineage. Apache-2.0; predecessor notices and source pins are retained. diff --git a/research/complex-temporal-pair-seed28/vendor/pr1369/SOURCES.json b/research/complex-temporal-pair-seed28/vendor/pr1369/SOURCES.json new file mode 100644 index 0000000000..baf6c33668 --- /dev/null +++ b/research/complex-temporal-pair-seed28/vendor/pr1369/SOURCES.json @@ -0,0 +1,178 @@ +{ + "base_commit": "bce54fb3f895cbe5cd4c0eb477c3afeed100190f", + "files": [ + { + "git_blob": "e51435543687f1bd88ab22248082dc689ce8b853", + "path": "CONTRIBUTING.md", + "sha256": "df5b5646602f42cb5da5844f04ac925182ddcd0f627b9de1c96a5095bb7a277a", + "usage": "provenance" + }, + { + "git_blob": "810611c11a759defe50dd0060bbd96b5177bb067", + "path": "autoresearch.md", + "sha256": "eaedfc39c7e413c460a512ebf25d2bf6175f220183c1da188b1a12a11444c34c", + "usage": "provenance" + }, + { + "git_blob": "ae6a99f28aa468649eb66a361e764d769363bf11", + "path": "certificates/selected-result.json", + "sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32", + "usage": "input" + }, + { + "git_blob": "c05fafaa25ba95b2d5af86b1800427198e3d20eb", + "path": "docs/research/agent-task-catalog.json", + "sha256": "89b5928bc92c81e2647b6d702a7ad85a6795b8f44e2eb267b2ff3145d8f2b2ce", + "usage": "input" + }, + { + "git_blob": "6cb6ec061a071a06a2d18cd4dc3e9a2b05d28099", + "path": "docs/research/community-batch1099-review.md", + "sha256": "7e76d2c38e5fce30587835b7251df1430488ae4dd372611ef69a3f03f476b6cb", + "usage": "input" + }, + { + "git_blob": "aa3cf49715cd367ad8c4e63ab28856fc0d19794f", + "path": "docs/research/current-status.md", + "sha256": "1f59d648763c77d574d18dc59ea8bf62d2ee74aaed3c202c9c8cfa4f901badbd", + "usage": "provenance" + }, + { + "git_blob": "4331ba3175b3418f70fb5cf7ee9689b3505c0678", + "path": "docs/research/pr-ledger.md", + "sha256": "8030b58f708e40aee4e40f950a20a0b0ccef3f92b08e6e089fe35db82ec027e6", + "usage": "provenance" + }, + { + "git_blob": "8182d0818c0cbda7e52c10120f15b2c3a2c8f933", + "path": "research/community-frontier1042-audit/RESULT.json", + "sha256": "bf12c6ed3b412539638b76addb40591a631609b2ab9e5ee0db1f6bbe067d0ec0", + "usage": "input" + }, + { + "git_blob": "6f4dc6fe7631d8aacf8081fcaecf32197181685b", + "path": "research/community-frontier1042-audit/selected-replay.tar.gz", + "sha256": "22c3f4dce4b897a1d423d1388801933e288b6a6b1906cb15e1b16a5eb68db754", + "usage": "input" + }, + { + "git_blob": "5fd676df060f3b450782fdf5ff5f6beb63a5eeb0", + "path": "research/community-frontier1094-audit/ASSEMBLY.json", + "sha256": "1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045", + "usage": "input" + }, + { + "git_blob": "131d9c96a54632ae385ced4138fd7f30ad448a3e", + "path": "research/community-frontier1094-audit/RESULT.json", + "sha256": "1e3e47e9ec24bcb6fb5f703b7fce0aab658d84ff72bfae5da3ae429d17b6e752", + "usage": "input" + }, + { + "git_blob": "6a75493790b4eff9c4a98051ef8b01d6aad0d5a8", + "path": "research/community-frontier1094-audit/SELECTED-SOURCE.json", + "sha256": "79b3de5db3dbcb9829789ba58e9e45758926031e2a7d80667a08429d369be53b", + "usage": "provenance" + }, + { + "git_blob": "c24daf067f9c543421d89ca2eeaa4eb78a57fb6f", + "path": "research/community-frontier1094-audit/selected-replay.tar.gz", + "sha256": "f1da80610bf33c58527f18ad63b4350d0b864e1d4486141ee17ac9bed4d529d6", + "usage": "input" + }, + { + "git_blob": "18999b7d252471054af43dea926d81efdf292c2b", + "path": "research/complex-dyadic-lowering/README.md", + "sha256": "798209e9869d1612a2c34412ef2eb87c0eb0dcebcbed9963a45e0fe248326c2f", + "usage": "input" + }, + { + "git_blob": "a2c2889e5be41a0fc30d4dfa5dfcebb03d6d47f8", + "path": "research/complex-dyadic-lowering/lower.py", + "sha256": "eb37d00063dc09323e9aca041d23da749ce17fbd71dade9aaf1c059cab0b9753", + "usage": "input" + }, + { + "git_blob": "b244cd59940659465c07b013ebe3225077496f45", + "path": "research/gauge44-slots/code/invoice_allcold.py", + "sha256": "141bd2fd58bbfb5b8d0fc8f56f61c45586d5608a5af3487c6b883dd987f998ec", + "usage": "input" + }, + { + "git_blob": "4744d8783c25bf7bf5076886169077ca3808309a", + "path": "research/gauge44-slots/independent/audit_local.py", + "sha256": "03afcfc9da428b3f6edac81c1fee7f277ab81b64998efae78380b63498dec6cd", + "usage": "input" + }, + { + "git_blob": "96e6c1386bd052b9bcaf136d934406f3f0c3f777", + "path": "scripts/verify_frontier1094.py", + "sha256": "c7e20f59968ed5736fb859735de4de207de3418083e37012310ebcded946b949", + "usage": "input" + } + ], + "pr1259": { + "head": "61367611154266a982fe25e1a6243a8aad77227d", + "source_git_blobs": "DEPENDENCIES.json", + "vendored_path": "vendor/pr1259/search.py" + }, + "pr1263": { + "base": "dadfea6e8a78ff6ba901705f87532a71c6f5bbb8", + "eligible_helpers": 237, + "head": "5fbaca13028846bddbb001e8e07addc2ab8e5816", + "inherited_source_pin_file": "vendor/pr1263/vendor/pr1161/SOURCES.json", + "inherited_source_pin_sha256": "45f24dbd27239e499600e497e3d86cf812f3b45122088ad083a836e8d646b320", + "inherited_source_pins": { + "archive_members": { + "slots/local/CANONICAL-WORD.json.gz": "16bc0ebb04b4be6c0ade74badc6a0c0cdba4215eda86e4ff9f13abf8ecebd219", + "slots/local/INDEPENDENT-LOCAL-REPLAY.json": "13dd18297162569532983db1a2ab67926b064330cd7edd3587e7b546b2dedf17", + "slots/local/LOCAL-CHECKS.json": "2b8b1891a736598010232bfb26abc31973b265a53a2009a3fcfd9138b5ecadb4", + "slots/local/LOCAL-PROGRAMS.json.gz": "241fde27d4e43f5a9cb6b128f9f76c5131a53d09f0371676163f914d0b0fef3a" + }, + "base": "ce7ad1b6ab09452c3478723a2e96ed5ff212dc08", + "files": { + "docs/research/community-batch1099-review.md": "7e76d2c38e5fce30587835b7251df1430488ae4dd372611ef69a3f03f476b6cb", + "research/community-frontier1042-audit/RESULT.json": "bf12c6ed3b412539638b76addb40591a631609b2ab9e5ee0db1f6bbe067d0ec0", + "research/community-frontier1042-audit/selected-replay.tar.gz": "22c3f4dce4b897a1d423d1388801933e288b6a6b1906cb15e1b16a5eb68db754", + "research/community-frontier1094-audit/ASSEMBLY.json": "1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045", + "research/community-frontier1094-audit/RESULT.json": "1e3e47e9ec24bcb6fb5f703b7fce0aab658d84ff72bfae5da3ae429d17b6e752", + "research/community-frontier1094-audit/selected-replay.tar.gz": "f1da80610bf33c58527f18ad63b4350d0b864e1d4486141ee17ac9bed4d529d6", + "research/complex-dyadic-lowering/README.md": "798209e9869d1612a2c34412ef2eb87c0eb0dcebcbed9963a45e0fe248326c2f", + "research/complex-dyadic-lowering/lower.py": "eb37d00063dc09323e9aca041d23da749ce17fbd71dade9aaf1c059cab0b9753", + "research/gauge44-slots/code/invoice_allcold.py": "141bd2fd58bbfb5b8d0fc8f56f61c45586d5608a5af3487c6b883dd987f998ec", + "research/gauge44-slots/independent/audit_local.py": "03afcfc9da428b3f6edac81c1fee7f277ab81b64998efae78380b63498dec6cd", + "scripts/verify_frontier1094.py": "c7e20f59968ed5736fb859735de4de207de3418083e37012310ebcded946b949" + }, + "format": "exact-inventory-text-lf-binary-exact-sha256-v1", + "selected_snapshot_sha256": "cba7a81945a737a475251e77c6a1da21ffbc22d56ea835f4ee7dfbb813ae796e" + }, + "source_git_blobs": "DEPENDENCIES.json", + "static_gauges": 218 + }, + "raw_record_paths": { + "certificate": "CERTIFICATE.json", + "pr1263_gauges": "vendor/pr1263/GAUGES.json", + "pr1263_predecessors": "vendor/pr1263/PREDECESSORS.json" + }, + "related_temporal_results": [ + { + "head": "64b8a55c6933ffb6d9e30fa19f85d05b572d4aa5", + "pr": 1350, + "scope": "time-varying L253; its static PR1263 exponent is nonzero; not composed" + }, + { + "head": "efc6bfc3302a966ac0e1f5f4656e94b4cabeb9ca", + "pr": 1353, + "scope": "time-varying L248; its static PR1263 exponent is nonzero; not composed" + } + ], + "schema_version": 1, + "selected_result": { + "certificate_path": "research/community-frontier1094-audit/ASSEMBLY.json", + "certificate_sha256": "1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045", + "kappa": "836330098538459/500000000000000000", + "path": "certificates/selected-result.json", + "sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32", + "source_manifest_path": "research/community-frontier1094-audit/SELECTED-SOURCE.json", + "source_manifest_sha256": "79b3de5db3dbcb9829789ba58e9e45758926031e2a7d80667a08429d369be53b" + } +} diff --git a/research/complex-temporal-pair-seed28/vendor/pr1369/independent.py b/research/complex-temporal-pair-seed28/vendor/pr1369/independent.py new file mode 100644 index 0000000000..415083a91a --- /dev/null +++ b/research/complex-temporal-pair-seed28/vendor/pr1369/independent.py @@ -0,0 +1,145 @@ +"""Exact one-coordinate temporal gauge pricing for a frozen scalar word.""" + +from fractions import Fraction + + +def need(ok, message): + if not ok: + raise ValueError(message) + + +def dyadic_parts(value): + value = Fraction(value) + numerator, denominator = abs(value.numerator), value.denominator + need(numerator > 0 and denominator & (denominator - 1) == 0, + "coefficient must be a nonzero dyadic") + trailing = (numerator & -numerator).bit_length() - 1 + return numerator >> trailing, trailing - (denominator.bit_length() - 1) + + +def add_price(value): + odd, exponent = dyadic_parts(value) + return 1 + odd.bit_length() + odd.bit_count() + abs(exponent) - int(odd == 1 and exponent == 0) + + +def two_power(exponent): + return Fraction(2 ** exponent, 1) if exponent >= 0 else Fraction(1, 2 ** -exponent) + + +def incident_adds(events, helper): + found = [] + for index, event in enumerate(events): + if event[0] != "scalar" or event[1][0] != "add": + continue + op = event[1] + sign = int(op[1] == ["L", helper]) - int(op[2] == ["L", helper]) + if sign: + found.append((index, Fraction(op[3], op[4]), sign)) + need(bool(found), "eligible helper has no incident ADD") + return found + + +def objective(terms, schedule): + need(len(terms) == len(schedule), "complete schedule length") + previous = 0 + result = 0 + for (_, coefficient, sign), exponent in zip(terms, schedule): + result += abs(exponent - previous) + result += add_price(coefficient * two_power(sign * exponent)) - add_price(coefficient) + previous = exponent + return result + abs(previous) + + +def optimize(terms): + """Minimize over Z^m by exact DP and a proved finite interval clamp.""" + breakpoints = [0] + for _, coefficient, sign in terms: + _, exponent = dyadic_parts(coefficient) + breakpoints.append(-sign * exponent) + low, high = min(breakpoints), max(breakpoints) + domain = range(low, high + 1) + + # State values include deterministic tie breakers after the exact cost. + states = {0: (0, 0, 0, ())} + edge_evaluations = 0 + for _, coefficient, sign in terms: + following = {} + for exponent in domain: + add_delta = add_price(coefficient * two_power(sign * exponent)) - add_price(coefficient) + choices = [] + for previous, value in states.items(): + edge_evaluations += 1 + choices.append((value[0] + abs(exponent - previous) + add_delta, + value[1] + int(exponent != previous), + value[2] + abs(exponent), + value[3] + (exponent,))) + following[exponent] = min(choices) + states = following + + complete = [(value[0] + abs(last), value[1] + int(last != 0), value[2], value[3]) + for last, value in states.items()] + best = min(complete) + constant = min((2 * abs(exponent) + sum( + add_price(coefficient * two_power(sign * exponent)) - add_price(coefficient) + for _, coefficient, sign in terms), int(exponent != 0), abs(exponent), exponent) + for exponent in domain) + + schedule = tuple(best[3]) + need(objective(terms, schedule) == best[0], "DP receipt recomputes") + return { + "domain": [low, high], + "domain_size": high - low + 1, + "incident_adds": len(terms), + "edge_evaluations": edge_evaluations, + "delta_real": best[0], + "transition_scale_macros": best[1], + "schedule_l1": best[2], + "constant_delta_real": constant[0], + "constant_exponent": constant[3], + "schedule": schedule, + } + + +def transform(events, helper, indexed_schedule): + """Insert every gauge transition and conjugate each incident ADD exactly.""" + terms = incident_adds(events, helper) + indices = [index for index, _, _ in terms] + need([index for index, _ in indexed_schedule] == indices, + "schedule covers every chronological incident ADD exactly once") + need(all(type(exponent) is int for _, exponent in indexed_schedule), "integer exponents") + need(events[-1] == ["phase", "done"], "word has terminal cleanup boundary") + + exponent_at = dict(indexed_schedule) + result, previous = [], 0 + inserted = [] + for index, source_event in enumerate(events): + event = [source_event[0], list(source_event[1]), *source_event[2:]] if source_event[0] == "scalar" else list(source_event) + if index in exponent_at: + current = exponent_at[index] + if current != previous: + change = current - previous + scale = two_power(change) + pulse = ["scalar", ["scale", ["L", helper], scale.numerator, scale.denominator], event[2]] + output_index = len(result) + result.append(pulse) + inserted.append([index, change, event[2], output_index]) + op = event[1] + sign = int(op[1] == ["L", helper]) - int(op[2] == ["L", helper]) + coefficient = Fraction(op[3], op[4]) * two_power(sign * current) + op[3], op[4] = coefficient.numerator, coefficient.denominator + previous = current + if index == len(events) - 1 and previous: + scale = two_power(-previous) + pulse = ["scalar", ["scale", ["L", helper], scale.numerator, scale.denominator], 1] + output_index = len(result) + result.append(pulse) + inserted.append([index, -previous, 1, output_index]) + result.append(event) + return result, inserted + + +def exhaustive(terms, low, high): + """Tiny independent control used to compare the DP with direct enumeration.""" + import itertools + return min(objective(terms, schedule) + for schedule in itertools.product(range(low, high + 1), repeat=len(terms))) diff --git a/research/complex-temporal-pair-seed28/vendor/pr1369/vendor/pr1259/search.py b/research/complex-temporal-pair-seed28/vendor/pr1369/vendor/pr1259/search.py new file mode 100644 index 0000000000..6d9f53c62f --- /dev/null +++ b/research/complex-temporal-pair-seed28/vendor/pr1369/vendor/pr1259/search.py @@ -0,0 +1,105 @@ +"""Paid time-varying dyadic gauge. Sagar Thakrar with OpenAI Codex, Apache-2.0.""" +from copy import deepcopy +from fractions import Fraction as Q + + +def require(ok, message): + if not ok: + raise ValueError(message) + + +def power(k): + return Q(2 ** k) if k >= 0 else Q(1, 2 ** -k) + + +def parts(q): + a, d = abs(q.numerator), q.denominator + require(a > 0 and d & (d - 1) == 0, "nonzero dyadic coefficient") + v = (a & -a).bit_length() - 1 + return a >> v, v - (d.bit_length() - 1) + + +def price(q): + # PR696 copy initialization, including its isolated unit-coefficient discount. + p, e = parts(q) + return 1 + p.bit_length() + p.bit_count() + abs(e) - int(p == 1 and e == 0) + + +def eligible(word, programs): + excluded = set(word["centers"]) + for events in programs.values(): + for event in events: + if event[0] == "residual_adapter": + excluded.add(event[2]) + if event[0] == "scalar" and event[1][0] in ("copy", "clear"): + for r in event[1][1:]: + if isinstance(r, list) and r[0] == "L": + excluded.add(r[1]) + return [h for h in range(224, 704) if h not in excluded + and word["start"][h] == 0 and word["final"][h] == 1] + + +def incident(events, helper): + result = [] + for i, event in enumerate(events): + if event[0] == "scalar" and event[1][0] == "add": + g = event[1] + sign = int(g[1] == ["L", helper]) - int(g[2] == ["L", helper]) + if sign: + result.append((i, Q(g[3], g[4]), sign)) + require(bool(result), "helper has no incident ADD") + return result + + +def optimize(terms): + breaks = [0] + [-s * parts(q)[1] for _, q, s in terms] + lo, hi = min(breaks), max(breaks) + # Ties prefer fewer inserted SCALE macros, then smaller exponents. + dp = {0: (0, 0, 0, ())} + for _, q, sign in terms: + next_row = {} + for k in range(lo, hi + 1): + delta = price(q * power(sign * k)) - price(q) + next_row[k] = min((v[0] + abs(k - j) + delta, + v[1] + int(k != j), v[2] + abs(k), v[3] + (k,)) + for j, v in dp.items()) + dp = next_row + best = min((v[0] + abs(k), v[1] + int(k != 0), v[2], v[3]) + for k, v in dp.items()) + constant = min((2 * abs(k) + sum(price(q * power(s * k)) - price(q) + for _, q, s in terms), abs(k), k) + for k in range(lo, hi + 1)) + return {"domain": [lo, hi], "incident_adds": len(terms), + "delta_real": best[0], "scale_macros": best[1], + "constant_delta_real": constant[0], "constant_exponent": constant[2], + "schedule": [[term[0], k] for term, k in zip(terms, best[3])]} + + +def transform(events, word, helper, schedule): + require([i for i, _ in schedule] == [i for i, _, _ in incident(events, helper)], + "schedule covers exactly every incident ADD") + require(all(type(k) is int for _, k in schedule), "integer gauge exponents") + require(word["start"][helper] == 0 and word["final"][helper] == 1, + "cold/FULL helper boundary") + require(events[-1] == ["phase", "done"], "terminal phase") + by_index = dict(schedule) + result, k = [], 0 + for i, original in enumerate(events): + event = deepcopy(original) + if i in by_index: + new_k = by_index[i] + if new_k != k: + q = power(new_k - k) + result.append(["scalar", ["scale", ["L", helper], + q.numerator, q.denominator], event[2]]) + k = new_k + g = event[1] + sign = int(g[1] == ["L", helper]) - int(g[2] == ["L", helper]) + q = Q(g[3], g[4]) * power(sign * k) + g[3:5] = [q.numerator, q.denominator] + if i == len(events) - 1 and k: + q = power(-k) + result.append(["scalar", ["scale", ["L", helper], + q.numerator, q.denominator], 1]) + result.append(event) + return result diff --git a/research/complex-temporal-pair-seed28/vendor/pr1369/vendor/pr1263/GAUGES.json b/research/complex-temporal-pair-seed28/vendor/pr1369/vendor/pr1263/GAUGES.json new file mode 100644 index 0000000000..6bd3ef7e0e --- /dev/null +++ b/research/complex-temporal-pair-seed28/vendor/pr1369/vendor/pr1263/GAUGES.json @@ -0,0 +1,442 @@ +{ + "forward": { + "225": -1, + "226": -1, + "227": -1, + "228": -1, + "229": -1, + "230": -1, + "231": -1, + "232": -1, + "233": -1, + "234": -1, + "235": -1, + "236": -1, + "237": -1, + "238": -1, + "239": -1, + "241": -1, + "242": -1, + "243": -1, + "244": -2, + "245": -1, + "246": -1, + "247": -1, + "248": -2, + "249": -1, + "250": -1, + "251": -2, + "252": -1, + "253": -1, + "254": -1, + "255": -1, + "257": -1, + "258": -1, + "259": -1, + "260": -2, + "261": -2, + "262": -2, + "263": -2, + "264": -2, + "265": -2, + "266": -2, + "267": -1, + "268": -2, + "269": -2, + "270": -2, + "271": -1, + "274": -2, + "276": -2, + "278": -2, + "279": -2, + "280": -1, + "281": -1, + "283": -1, + "284": -2, + "285": -1, + "286": -1, + "287": -1, + "290": -2, + "292": -2, + "294": -2, + "295": -2, + "296": -1, + "297": -1, + "299": -1, + "300": -2, + "301": -1, + "302": -1, + "303": -1, + "304": -1, + "306": -2, + "308": -2, + "310": -2, + "312": -2, + "313": -1, + "315": -1, + "316": -2, + "317": -1, + "318": -2, + "319": -1, + "320": -2, + "322": -2, + "324": -2, + "326": -2, + "328": -1, + "329": -1, + "331": -1, + "332": -2, + "333": -1, + "334": -1, + "335": -1, + "336": -2, + "338": -2, + "340": -2, + "342": -1, + "343": -1, + "344": -1, + "345": -1, + "347": -1, + "349": -1, + "350": -1, + "351": -1, + "352": -2, + "354": -1, + "356": -2, + "358": -2, + "360": -1, + "361": -1, + "363": -1, + "364": -2, + "365": -1, + "366": -1, + "367": -1, + "368": -2, + "370": -2, + "372": -2, + "374": -2, + "375": -2, + "376": -1, + "377": -1, + "379": -1, + "380": -2, + "382": -1, + "383": -1, + "384": -2, + "386": -2, + "388": -2, + "390": -2, + "391": -2, + "392": -1, + "393": -1, + "395": -1, + "396": -2, + "397": -1, + "398": -2, + "399": -1, + "400": -1, + "401": -2, + "402": -2, + "403": -2, + "404": -2, + "405": -2, + "406": -2, + "407": -2, + "408": -2, + "409": -1, + "410": -2, + "411": -2, + "412": -2, + "413": -2, + "414": -1, + "415": -1, + "416": -1, + "417": -2, + "418": -2, + "419": -2, + "420": -2, + "421": -2, + "422": -2, + "423": -2, + "424": -2, + "425": -1, + "426": -2, + "427": -2, + "428": -2, + "429": -2, + "430": -2, + "431": -1, + "432": -1, + "433": -1, + "434": -1, + "435": -1, + "436": -1, + "437": -1, + "438": -1, + "439": -1, + "441": -1, + "442": -1, + "443": -1, + "445": -1, + "456": -2, + "457": -2, + "458": -2, + "459": -2, + "460": -1, + "461": -1, + "462": -1, + "463": -1, + "464": -2, + "465": -2, + "466": -2, + "467": -2, + "468": -1, + "470": -1, + "471": -1, + "480": -1, + "481": -1, + "482": -1, + "483": -1, + "490": -1, + "492": -1, + "493": -1, + "494": -1, + "495": -1, + "499": -2, + "502": -1, + "504": -1, + "505": -1, + "511": -2, + "516": -1, + "517": -1, + "530": -1, + "546": -2, + "547": -2, + "548": -2, + "549": -2, + "558": -2, + "560": -2, + "568": -2, + "570": -2 + }, + "backward": { + "225": 1, + "226": 1, + "227": 1, + "228": 1, + "229": 1, + "230": 1, + "231": 1, + "232": 1, + "233": 1, + "234": 1, + "235": 1, + "236": 1, + "237": 1, + "238": 1, + "239": 1, + "241": 1, + "242": 1, + "243": 1, + "244": 2, + "245": 1, + "246": 1, + "247": 1, + "248": 2, + "249": 1, + "250": 1, + "251": 2, + "252": 1, + "253": 1, + "254": 1, + "255": 1, + "257": 1, + "258": 1, + "259": 1, + "260": 2, + "261": 2, + "262": 2, + "263": 2, + "264": 2, + "265": 2, + "266": 2, + "267": 1, + "268": 2, + "269": 2, + "270": 2, + "271": 1, + "274": 2, + "276": 2, + "278": 2, + "279": 2, + "280": 1, + "281": 1, + "283": 1, + "284": 2, + "285": 1, + "286": 1, + "287": 1, + "290": 2, + "292": 2, + "294": 2, + "295": 2, + "296": 1, + "297": 1, + "299": 1, + "300": 2, + "301": 1, + "302": 1, + "303": 1, + "304": 1, + "306": 2, + "308": 2, + "310": 2, + "312": 2, + "313": 1, + "315": 1, + "316": 2, + "317": 1, + "318": 2, + "319": 1, + "320": 2, + "322": 2, + "324": 2, + "326": 2, + "328": 1, + "329": 1, + "331": 1, + "332": 2, + "333": 1, + "334": 1, + "335": 1, + "336": 2, + "338": 2, + "340": 2, + "342": 1, + "343": 1, + "344": 1, + "345": 1, + "347": 1, + "349": 1, + "350": 1, + "351": 1, + "352": 2, + "354": 1, + "356": 2, + "358": 2, + "360": 1, + "361": 1, + "363": 1, + "364": 2, + "365": 1, + "366": 1, + "367": 1, + "368": 2, + "370": 2, + "372": 2, + "374": 2, + "375": 2, + "376": 1, + "377": 1, + "379": 1, + "380": 2, + "382": 1, + "383": 1, + "384": 2, + "386": 2, + "388": 2, + "390": 2, + "391": 2, + "392": 1, + "393": 1, + "395": 1, + "396": 2, + "397": 1, + "398": 2, + "399": 1, + "400": 1, + "401": 2, + "402": 2, + "403": 2, + "404": 2, + "405": 2, + "406": 2, + "407": 2, + "408": 2, + "409": 1, + "410": 2, + "411": 2, + "412": 2, + "413": 2, + "414": 1, + "415": 1, + "416": 1, + "417": 2, + "418": 2, + "419": 2, + "420": 2, + "421": 2, + "422": 2, + "423": 2, + "424": 2, + "425": 1, + "426": 2, + "427": 2, + "428": 2, + "429": 2, + "430": 2, + "431": 1, + "432": 1, + "433": 1, + "434": 1, + "435": 1, + "436": 1, + "437": 1, + "438": 1, + "439": 1, + "441": 1, + "442": 1, + "443": 1, + "445": 1, + "456": 2, + "457": 2, + "458": 2, + "459": 2, + "460": 1, + "461": 1, + "462": 1, + "463": 1, + "464": 2, + "465": 2, + "466": 2, + "467": 2, + "468": 1, + "470": 1, + "471": 1, + "480": 1, + "481": 1, + "482": 1, + "483": 1, + "490": 1, + "492": 1, + "493": 1, + "494": 1, + "495": 1, + "499": 2, + "502": 1, + "504": 1, + "505": 1, + "511": 2, + "516": 1, + "517": 1, + "530": 1, + "546": 2, + "547": 2, + "548": 2, + "549": 2, + "558": 2, + "560": 2, + "568": 2, + "570": 2 + } +} diff --git a/research/complex-temporal-pair-seed28/vendor/pr1369/vendor/pr1263/PREDECESSORS.json b/research/complex-temporal-pair-seed28/vendor/pr1369/vendor/pr1263/PREDECESSORS.json new file mode 100644 index 0000000000..19d2de1669 --- /dev/null +++ b/research/complex-temporal-pair-seed28/vendor/pr1369/vendor/pr1263/PREDECESSORS.json @@ -0,0 +1,11 @@ +{ + "pr1161_head": "d210969d3158a1e6c505e41f67dd84e555c88564", + "pr1214_head": "26162c56ec9c50a80e49949f36d4dd9a137a76a6", + "vendor": { + "vendor/pr1161/BASE-SELECTED.json": "c49e308d209dfbaba184a0d41dbc03cb424663f7ad8136d56aba088bba7f5723", + "vendor/pr1161/PROOF.md": "89cbba31b4d95b9c7c69e3bbccd9858e45cd43e1968c39472af7e03fea0e3e54", + "vendor/pr1161/PROVENANCE.md": "76dca2049e8c008da0398fd722745e421be92c66dac876cf8463295f6cb18518", + "vendor/pr1161/SOURCES.json": "45f24dbd27239e499600e497e3d86cf812f3b45122088ad083a836e8d646b320", + "vendor/pr1161/engine.py": "997b34533aea200c339263a96dd6f76facf21bf54b1627ab244e2ae72d348400" + } +} diff --git a/research/complex-temporal-pair-seed28/vendor/pr1369/vendor/pr1263/vendor/pr1161/BASE-SELECTED.json b/research/complex-temporal-pair-seed28/vendor/pr1369/vendor/pr1263/vendor/pr1161/BASE-SELECTED.json new file mode 100644 index 0000000000..74e4acfe73 --- /dev/null +++ b/research/complex-temporal-pair-seed28/vendor/pr1369/vendor/pr1263/vendor/pr1161/BASE-SELECTED.json @@ -0,0 +1 @@ +{"audited_source_head":"0fc329d0bec93ca7cd288eaea1295172e8789810","certificate":"research/community-frontier1094-audit/ASSEMBLY.json","certificate_sha256":"1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045","decimal":"0.001672660197076918","kappa":"836330098538459/500000000000000000","previous_kappa":"1672188119205421/1000000000000000000","previous_record":"certificates/checkpoints/frontier1042.json","proof":"docs/research/community-batch1099-review.md","proof_supplements":{".github/workflows/t37-owners.yml":"c13acc2902c007237103072b7ec10caf5ca21c1b319d27934f194af2f7d87026","certificates/replay-coverage/pr741-sw4-v1.json":"7acd5033bc78e3f473718269edaa267c2785d84fbe95ccf6815a33dcf58c2756","docs/research/community-batch1047-review.md":"a6271faf5db0afe3ff7d24a34a3be7a959cdc33ee37784572fba014ee5358787","docs/research/community-batch1099-review.md":"7e76d2c38e5fce30587835b7251df1430488ae4dd372611ef69a3f03f476b6cb","docs/research/community-batch952-review.md":"04db59dfc2c31453229b6061bbf59547e71ce3abdc0ce0f6779144bb0dde127b","docs/research/community-cold617-review.md":"b3f2bcbae1249f1f651032022ce1e6e2bfb3f563ce580bf53671f50a074d7046","docs/research/community-frontier741-review.md":"4634694fa75ea9e749ecf19d3db3e4d82effe3b61a2efdf08ac5a97275fb676a","docs/research/community-frontier799-review.md":"bd91c10c67f2a873fd456b95cbb43f715a43dac0e0a66938737d591c6b754052","docs/research/community-frontier890-review.md":"cd03b7c2c6c09db2cfa89ae40133ae44e1deb6e32ec5ddd23aacecc9c50f2fea","docs/research/community-hyperplane599-review.md":"3298cd0d451541508af232cac72efbd7c10580e6c6ad493a855ab0faa01ade8c","docs/research/community-k492-review.md":"3b731d30e80010b15408a289b0b32192700885474c8b36d48ee3320a7a8c5c47","research/community-batch1099-audit/check_frontier1094.py":"2608ef213260a43d09a40b3429742f7a5f280861b54acae66400a7c29a123f51","research/complex-571-cold14-b3/PROOF-NOTE.md":"1cf592cbc8ab8e21d2dd8c1e945a5c64c6d5cde1216fb06e05a36c1c6ec6613d","research/complex-571-cold14-b3/README.md":"1945785785c153c7d0e8d4c071adabe626c1091b71721ff85d2d67191b376b96","research/complex-571-free4fc8/NOTICE.md":"a4c084abdc1c7a9ac683eeb11124335d51cff8a6deba6ee92ba5a12bceaa2c97","research/complex-571-hpeq5/README.md":"4000b37f6c07c09d971dc4010ceb137c13340f3a8809d3272046ccaf746c3e2b","research/complex-double-replica-owners/PROOF.md":"db99599e3966bec253c577c23915e2a2899c4c4e8568044efc11c7918b137bbc","research/complex-joint-prefix/proof/CONSTRUCTION.md":"a92e610e7a598d99c612d1b63d1a03a49c0cd1e15ddd29fa55c465ddd8c18105","research/complex-k492-owner-repair/PROOF-NOTE-R.md":"22312bb347bdf159e6a01a45c47675e6170d33b258e2fd9ed52aee88fb92c0ed","research/complex-k492-owner-repair/PROOF-NOTE.md":"337d70fe7abd9afca1d90954c23bde87f4dc27888cc1a6b4bb80506fd6fbf8c5","research/complex-k492-owner-repair/README.md":"ee5a1ace4828f7a073be97e95c2d931988774dd3a29a877e65abdf429aeec902","research/complex-multicold/proof/CONSTRUCTION.md":"27ece5e1c11b90d97a808b56eff897b998c10e61016db95867f84e6e6aef132f","research/complex-multicold/vendor/pr559/PROOF.md":"d5d498edc56fdef8c5798af7f5ec66948bd2f66c553b9efe366cdaab01bd3453","research/complex-sw4-frame8/PROVENANCE.md":"c7648719b01dd93af2c3a2c6e951a54711d13892dc4bd4339d16edb4c37c9bf0","research/complex-t21-owner-bound/PROOF.md":"2aa0aa6ec1d87402138564c38749b5ca0f058c16817efdf58a2685d2d90cb417","research/complex-t21-owners/PROOF.md":"78721b32fceb34b21b8e77c95381c38c60276e72e6d9c2e9c6262cb347457def","research/complex-t37-owners/ALL-T-PROOF.md":"4c0c71ccd0afb850538af1b467e5208b7eb3edd0260fded84e02a8c01dfc868b","research/complex-t37-owners/PROOF.md":"09b39ad0d5f1f59f54dcff15c16640f7a7acf27e6597660acaf957b95c7e8510","research/e8-bit-p111-tuned/tune/README.md":"46c7917fb252949f38b7bcd88cf568efc282e3ea065b61d11e457e41673d0b2d","research/e8-bit-r420/README.md":"9807be57c6adf26b30e4f54e2f8160075bbc05091f1a6d157e43d2a4620c1c9f","research/gauge44-barch/PROOF-NOTE-BARCH.md":"c24f211b09358b25d6cf47dd18e4bbd8bcf4ecf279e6f1c6c90613cfa230818d","research/gauge44-frames-x/PROOF-NOTE-FRAMES-X4.md":"39c50420ebb6e8813706a49b2cf759f277c4afac9f6780fc0a7ac6a5fb86e036","research/hyperplane-end-lean/HyperplaneEnd/Exact.lean":"eebf3a3982af7ab9be45777b272a6aaa523206fa7667ceb6df63ad6589fd8183","research/hyperplane-end-lean/PROOF.md":"1cbce5cf0ff0152f71e8ae7bef25841d1ce13010af248ff7209182d2328c21c9","research/kernel-frame-coalescing/PROOF.md":"fa8b2f36b9590ee80ff45d3f7724f8c7de8ad29a29f366d5133010c77e41fe1b","research/structural-gain/frontier-composition/README.md":"70f0f791cbe3b2603f85d85bb9055aa0ee1df6dc06ba82fc1921356948312887","scripts/verify_cold617_interface.py":"95d7a9094c05ad975fb72f5ab7605593003245a503c8456764987e512028fa6a","scripts/verify_frontier1042.py":"700fdcaeb6e8f57f6e63c71c2dd1652fc5b183e8d706cd092779bdc0d271e854","scripts/verify_frontier1094.py":"c7e20f59968ed5736fb859735de4de207de3418083e37012310ebcded946b949","scripts/verify_frontier588_bindings.py":"6d1932eea7b1936598118ea8e607b09c29b6e31b749ec41bbe0744ea4f0b606d","scripts/verify_frontier626.py":"2207bd0ef04a19ef276869085afdedad80a0938fa75db5e1aa7ab73fd3429444","scripts/verify_frontier626_bindings.py":"cda63ff41c6d6e2e352c7bf75b84e690c0ce57e4ec6c0355573bb5d9b1f98280","scripts/verify_frontier741.py":"215ee6a12de8dc2392e6811a1b8f2140035f6b2d2a0d2100ff4bd2fdcb8bb39b","scripts/verify_frontier741_bindings.py":"eff455167e2fd0bc9a67d35241d0e69d8edc58f3a23e776dcfe8f500ca8e8d67","scripts/verify_frontier741_bridge_coverage.py":"9a14f26762b6126eb54ed43db90371773374fe98733ada80ee871a74afa3b836","scripts/verify_frontier799.py":"19fe1b32079095160dc00fe2f7df75e0fcbc82cff37f7159b755c8a63bd5ce99","scripts/verify_frontier799_bindings.py":"43897b3c99212d6134870898a1840f32898aa1b3679b299e654901568ad7e19b","scripts/verify_frontier890.py":"88ea38dbef62dd7c0dd46e212618520cc89213edddb2032800e5509993958175","scripts/verify_frontier942.py":"27c6713532d9f53f55dfff4884d55a2d9ae74b68156e37a44596c0418fbed5b7","scripts/verify_hpe_lean_binding.py":"52aa1d23641e4c716b43c98f6b883ad042087dd03a9d01369e8e6a735b07aa03","scripts/verify_replay_coverage.py":"babe5941d7e6dac4248613ef01f950ee7bb6199e7355021aea4cf854fd1b91c5"},"reproduce":"make frontier1094-verify","review":"docs/research/community-batch1099-review.md","reviewed_dependency_heads":{"1004":"1974578f82a30158dd5fcdcdf226b83df8e7196f","1005":"779e80aef469bc3a28b19f1adde199871a9a22e3","1018":"eac7547cb191f875d5f5ea5f9bbb1d2b8c51c4ef","1022":"58618bcbfe88a252467755fc283c04c3db5ca4fd","1028":"be4bd89cb4483dcee43257200cd27601f938f13d","1031":"e900534f0beda892c726723524203b97471fb9a3","1042":"7e8ef087c02a77038a28a337a7ee3a77039cac0d","1050":"c87242f846cfab8c0b97fd889b5fecb0eacef939","1053":"6f92ce8884929c9fd4730c86a28e2e3735de02af","1055":"a8ea308976f1709eef0a328463f010cf51469277","1056":"d0201efbd68c4acc9832b84bcc986c8781b83c4f","1061":"223f581afb1d63d5f8476a69040617e11bcd50e4","1063":"d9377d32e0c97e41338e704c3960fd6f2fa73806","1065":"387d935e354a931d636e2c5e6ee63a6910f78a1b","1068":"cc71375eae4e8754da0f5d940cb519d66625fb2e","1074":"052afc128954f7b6a2b3c409eb4d72248e4020f2","1082":"0c2e294ec204e83846d27344f829d15ed9ee7cc6","1087":"589d1cedf5ef5f231182f4ec86408616311a8af0","1094":"0fc329d0bec93ca7cd288eaea1295172e8789810","543":"2065fe4f72a914d907f1046603f5a36f17018535","568":"71c99ac935a33bb7b59a1b4a7af8725a939b0b90","569":"1424da81263a5305b35e4cf74ef686c275f03f3f","571":"b7bdc5a8de18fcf418cfb9c7d83a2b1097a5e4a3","575":"eac6f7e378ab622dac50a2fd4b7ef6eab014de44","583":"89be768f0157f5a3d8e4db69cf1748768605eac9","586":"4846fee5b06af770e9b3a10c36200f673d656725","588":"6d0e53b66c29abd17981881a09eaff41ac862d85","589":"a5afc8c6169ea61ba7c51dfd3cade02cc7b13b46","591":"f622547244bf6d895a571a7b035142ba66279806","592":"1f471c445c06a45a32e2c47e8d74c8264b68356b","593":"fdb6dcc6d7bc29764c5b6b4d32b7fa050acf74a4","596":"7732dd5e46863ff294b5e443661cb9d99abf4e01","599":"bc13c8a3e000442606bd2dbe8583a17649ba6c32","601":"529ab7dcb59d5ea7a5798e9e06cf5b3aee8a1550","604":"1b795c5d7dea746ba310572585c0ef067574b4a6","615":"bf8a49a34350599763cced8592db81dc62c2c1c0","617":"904d62855723c00f8acef9a287a10768598fdeb2","622":"f69477f4f6d3c7eb1f740b166881bffed4ffa9f6","623":"e39a615ca601ce5d62abeb24f3fcdb8644ca1005","626":"660de893d27bb7abd1d5b01b1640207528a5c851","741":"e516b1463606840a15f80aac1995d64ce0092e89","799":"80e6463157cfc80b85af09e7e2f14748fe2dac60","858":"ae2e25fee91540c83ceee5a60e3b07422ce21c7d","869":"73e86f69bf9a391e3c334999f7bbe3825dc42759","870":"b734850dc348800942f0ffd1f0723fdec7539b2b","890":"4b3bd8cbe8e3e81c44161017c9b72c905a8040a8","942":"1960cfa919a0945d0ca4cb14ea96237000037903","987":"5142511af0437572aca71b35d1987cd2b47bb5e3"},"scope":"Finite composition under inherited all-size/compiler, common-label/mutable-source, whole-call hosting, precision/tape, analytic and bit H1-H5 assumptions. Not a full Lean multiplication theorem.","source_manifest":"research/community-frontier1094-audit/SELECTED-SOURCE.json","source_prs":[1094,1087,1082,1074,1068,1065,1063,1061,1056,1055,1053,1050,1042,1031,1028,1022,1018,1005,1004,987,942,890,870,869,858,799,741,699,685,676,664,660,659,656,655,653,658,649,645,635,589,555,545,626,623,622,620,617,615,604,601,596,592,591,593,599,588,543,584,586,583,582,579,576,575,574,571,569,568,567,564,562,561,559,558,552,550,548,541,535,510,503,531,523,493,514,507,484,496,505,522,520,472,458,445,442,425,433,370,361,315],"status":"Maintainer-reviewed conditional finite construction; see the integration receipt for publication and PR resolution status","validation":"docs/research/community-batch1099-integration.json"} diff --git a/research/complex-temporal-pair-seed28/vendor/pr1369/vendor/pr1263/vendor/pr1161/PROOF.md b/research/complex-temporal-pair-seed28/vendor/pr1369/vendor/pr1263/vendor/pr1161/PROOF.md new file mode 100644 index 0000000000..d2925051c5 --- /dev/null +++ b/research/complex-temporal-pair-seed28/vendor/pr1369/vendor/pr1263/vendor/pr1161/PROOF.md @@ -0,0 +1,106 @@ +# Scope and exact algebra + +Fix one non-center helper h and k in Z. Let D multiply its entire scalar register +by2^k and leave every other data, helper and center coordinate fixed. An ADD +`t += q*s` becomes `t += (q*2^(k_t-k_s))*s`, where k_h=k and all other k_i=0. +Each existing SCALE commutes with D and is left literally unchanged. Clear/COPY +events have no incidence with h by the definition of the477-helper domain. + +For chronological original operations A1,...,Am, the new chronological word is +D, DA1D^-1,...,DAmD^-1,D^-1. Its matrix is + +```text +D^-1 (DAmD^-1) ... (DA1D^-1) D = Am ... A1. +``` + +This equality holds on all input vectors, including arbitrary helper dirt. It +does not assume a helper is initially zero. The stored backward program is +checked independently; the inverse-transpose coefficient rule changes the +chosen basis to D^-1 (k=+2), in the same chronological direction, rather than +naively reusing k=-2. Both candidate and original forward transfer are +`Y += X`, and both backward transfers are `X -= Y`, preserving480 helpers and +clearing8 centers. The sparse rational replay includes each center's initial +dirty column, not merely zero center initialization. + +All unchanged non-scalar operations act linearly on an individual register; +uniform scalar multiplication commutes with them. Center operations act on the +separate C registers. Excluding helper COPY sources ensures they commute too. +The selected candidate h427 starts in frame0 and ends in FULL frame1, and has +no residual wrapper. Its entry scale is after the zero-precondition phase +marker; the exit is after full-frame cleanup, before the done marker. This is +why the concrete stream requires no new frame climb or wrapper. Coefficient +changes use the original operands and frame labels. Native type/admission +replay and the complete hosted/compiler invoice remain separate obligations. + +# Actual retained cost, including the unit discontinuity + +For reduced q with |q|=p*2^e and positive odd p, Sagar Thakrar's retained +copy-init lowerer emits + +```text +c(p,e) = 2 + floor(log2(p)) + popcount(p) + |e| - 1[p=1 and e=0]. +``` + +The shortcut at q=+1 or-1 costs2: signed direct ADD followed by work clear. +Otherwise COPY initializes work from the source; numerator Horner steps, any +denominator halvings, signed accumulation and final clear are all charged. +The old Horner formula is `3+floor(log2(p))+popcount(p)+|e|`. +SCALE by a signed power of two costs `|e|+1[q<0]`. New boundary scales are +positive and cost2|k| in total, per real component. Real and imaginary words +each incur this complete cost. + +For each ADD incident with h, set s=+1 when h is its target and s=-1 when h is +its source. The exact change is + +```text +Delta_h(k) = 2|k| + sum_g ( c(p_g,e_g+s_g*k) - c(p_g,e_g) ). +``` + +No unchanged SCALE or disjoint ADD contributes a delta. Complete invoices +nevertheless recount them, and also count all clears/COPYs. The coefficient +work is arbitrary on entry: non-unit COPY overwrites it; unit direct ADD does +not read it; every macro clears it on exit. The independent checker executes +the predecessor's literal primitive words, including that work register. + +# Why finitely many exponents certify an unbounded optimum + +Let B={0} union {-s_g*e_g}. All absolute-value slope changes and all negative +unit discounts occur at integer points of B. Between consecutive points the +undiscounted objective is affine and there are no discounts. An affine function +attains its minimum at an endpoint (or is constant); the possible negative +discounts at endpoints only strengthen this conclusion. Outside the extreme +points every absolute-value term has the same outward slope, so the objective +increases with slope `2 + number_of_incident_ADDs`. Therefore at least one global +integer minimizer is in B. The method does not assume convexity of the discounted +function and is not simply a weighted-median argument. + +The certificate prices every B point for all477 helpers, including k=0, in both +orientations. It uses (cost,|k|,k) to resolve per-helper ties and then helper index +for global ties. The independent method enumerates *every* integer from two +below to two above the extreme valuations and derives the outward slope using +the actual lowerer's lengths. It agrees with every per-helper certificate row. +The unique global winner in each orientation is h427, with123 incident ADDs; +forward costs at k=-4,-3,-2,-1,0,1 are75,-46,-166,-128,0,132 relative to baseline. +The backward list is reflected. No exponent cutoff assumption is used. + +The pure unit-discount control has two incident coefficients1/2: the continuous +absolute-value objective is constant between k=0 and1, so the lower weighted +median is0; the correct discounted price strictly prefers1 by2 primitives. + +# Prefix and admission boundary + +For the source-bound positive scalar envelope, each original L/C register starts +with majorant1, clears set it to0, COPY copies it, SCALE multiplies by|q|, and +ADD replaces the target majorant by target+|q|*source. During non-unit numerator +Horner construction, the work majorant is at most |numerator(q)|*source before +denominator halvings. Unit direct ADD does not touch work until it clears. +Starting coefficient work at arbitrary unit majorant1 covers its dirty entry. +This exact rational recurrence accounts for every emitted primitive's absolute +coefficient majorant. Its complete maximum is unchanged at52/68bits, below192. + +These are scalar-majorant and exact map certificates for one finite provider +word, with actual retained lowering. They are not a rerun of the native checker, +global512-bit accounting, row inventory/packing admission, or the outer root. +The477-helper cost optimum fixes all other coordinate scales; joint scaling, +center normalization, phase-varying diagonals, stage retiming and coefficient +work persistence lie outside the class. The current selected result is retained. diff --git a/research/complex-temporal-pair-seed28/vendor/pr1369/vendor/pr1263/vendor/pr1161/PROVENANCE.md b/research/complex-temporal-pair-seed28/vendor/pr1369/vendor/pr1263/vendor/pr1161/PROVENANCE.md new file mode 100644 index 0000000000..6ee8cde472 --- /dev/null +++ b/research/complex-temporal-pair-seed28/vendor/pr1369/vendor/pr1263/vendor/pr1161/PROVENANCE.md @@ -0,0 +1,46 @@ +# Attribution and scope selection + +Prepared by @woklerx with substantial OpenAI Codex assistance, Apache-2.0. +No independent human review is claimed. Original source notices are retained. + +The current frozen construction is Rohan Arun's PR1094 rare-pattern exchange +placement on Jeremy Kothe's checked k8/T16 supplier, following PR1042. Its actual +archived gauge44 provider is byte-identical to the pinned slots/local provider +in the PR1042 archive. Douglas Colkitt's review, selected-source and complete +assembly receipts establish the inherited lineage; this package does not claim +to authenticate or repeat those native/global executions. The scalar program +and exact local invoice are from the credited icekylinx/PR425/433/531, +Jeremy Kothe/PR622 and gauge44-slots construction lineage. The stronger lowering +is Sagar Thakrar's `research/complex-dyadic-lowering/lower.py`, whose retained +source is imported by the independent checker. The optimum accounts for its +unit shortcut and does not claim an old-Horner gain that disappears there. + +Seed32 is the assigned complex-supplier track at fixed base +`ce7ad1b6ab09452c3478723a2e96ed5ff212dc08`. Three candidates considered: + +1. Uniform dyadic basis change on one complete-program helper (chosen). +2. Further coefficient-work sharing/rescaling (rejected as close to PR739/811, + PR984 and previous sprint round7/PR1032). +3. Frame-transition retiming (rejected as close to rounds26/29). + +Targeted live Curiosity Bot GitHub provider queries covered dyadic conjugation, +diagonal gauge, rescaling, scalar and helper work. PR739 was inspected directly: +it keeps private coefficient work across successive magnitude blocks, not a +uniform helper coordinate change through the full scalar word. PR836 concerns +unitary register mixing; PR426/401 concern other chronological/response gauges. +PR947 prices constant-row center shears; PR1081 fixes CK helper matching. +None supplies this one-helper unbounded valuation/discount certificate. + +Concurrent round31 was coordinated explicitly: it carries *existing* SCALEs +through stage A/B with a time-varying diagonal and consolidates them at stage +boundaries. This package fixes every existing SCALE and inserts two new inverse +boundary scales for one helper across all phases. Neither result asserts that +the two savings compose. Earlier rounds22 butterflies,23 cell minimum,25 dirt +span coverage,26 commuting frame barrier and29 Clifford transition rank have +different mechanisms and obligations. + +The exact mandatory source inventory uses LF-normalized text hashes and exact +binary/archive bytes. Archive member hashes bind original gzip containers, not +recompressed equivalents. Candidate hashes use sorted-key canonical JSON with +integer/list schema. Frozen selection and exact base are context; verification +does not require the mutable selected-result pointer still to select PR1094. diff --git a/research/complex-temporal-pair-seed28/vendor/pr1369/vendor/pr1263/vendor/pr1161/SOURCES.json b/research/complex-temporal-pair-seed28/vendor/pr1369/vendor/pr1263/vendor/pr1161/SOURCES.json new file mode 100644 index 0000000000..841bf21533 --- /dev/null +++ b/research/complex-temporal-pair-seed28/vendor/pr1369/vendor/pr1263/vendor/pr1161/SOURCES.json @@ -0,0 +1 @@ +{"archive_members":{"slots/local/CANONICAL-WORD.json.gz":"16bc0ebb04b4be6c0ade74badc6a0c0cdba4215eda86e4ff9f13abf8ecebd219","slots/local/INDEPENDENT-LOCAL-REPLAY.json":"13dd18297162569532983db1a2ab67926b064330cd7edd3587e7b546b2dedf17","slots/local/LOCAL-CHECKS.json":"2b8b1891a736598010232bfb26abc31973b265a53a2009a3fcfd9138b5ecadb4","slots/local/LOCAL-PROGRAMS.json.gz":"241fde27d4e43f5a9cb6b128f9f76c5131a53d09f0371676163f914d0b0fef3a"},"base":"ce7ad1b6ab09452c3478723a2e96ed5ff212dc08","files":{"docs/research/community-batch1099-review.md":"7e76d2c38e5fce30587835b7251df1430488ae4dd372611ef69a3f03f476b6cb","research/community-frontier1042-audit/RESULT.json":"bf12c6ed3b412539638b76addb40591a631609b2ab9e5ee0db1f6bbe067d0ec0","research/community-frontier1042-audit/selected-replay.tar.gz":"22c3f4dce4b897a1d423d1388801933e288b6a6b1906cb15e1b16a5eb68db754","research/community-frontier1094-audit/ASSEMBLY.json":"1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045","research/community-frontier1094-audit/RESULT.json":"1e3e47e9ec24bcb6fb5f703b7fce0aab658d84ff72bfae5da3ae429d17b6e752","research/community-frontier1094-audit/selected-replay.tar.gz":"f1da80610bf33c58527f18ad63b4350d0b864e1d4486141ee17ac9bed4d529d6","research/complex-dyadic-lowering/README.md":"798209e9869d1612a2c34412ef2eb87c0eb0dcebcbed9963a45e0fe248326c2f","research/complex-dyadic-lowering/lower.py":"eb37d00063dc09323e9aca041d23da749ce17fbd71dade9aaf1c059cab0b9753","research/gauge44-slots/code/invoice_allcold.py":"141bd2fd58bbfb5b8d0fc8f56f61c45586d5608a5af3487c6b883dd987f998ec","research/gauge44-slots/independent/audit_local.py":"03afcfc9da428b3f6edac81c1fee7f277ab81b64998efae78380b63498dec6cd","scripts/verify_frontier1094.py":"c7e20f59968ed5736fb859735de4de207de3418083e37012310ebcded946b949"},"format":"exact-inventory-text-lf-binary-exact-sha256-v1","selected_snapshot_sha256":"cba7a81945a737a475251e77c6a1da21ffbc22d56ea835f4ee7dfbb813ae796e"} diff --git a/research/complex-temporal-pair-seed28/vendor/pr1369/vendor/pr1263/vendor/pr1161/engine.py b/research/complex-temporal-pair-seed28/vendor/pr1369/vendor/pr1263/vendor/pr1161/engine.py new file mode 100644 index 0000000000..33c0db7fe7 --- /dev/null +++ b/research/complex-temporal-pair-seed28/vendor/pr1369/vendor/pr1263/vendor/pr1161/engine.py @@ -0,0 +1,209 @@ +"""One-helper dyadic basis search. @woklerx with OpenAI Codex, Apache-2.0. + +Retained copy-init lowering: Sagar Thakrar's complex-dyadic-lowering/lower.py; +original Horner vocabulary: icekylinx PR425/433/531, Jeremy Kothe PR622. +""" +from collections import Counter, defaultdict +from fractions import Fraction as Q +import copy, gzip, hashlib, json, tarfile +from pathlib import Path + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] +BASE = 'ce7ad1b6ab09452c3478723a2e96ed5ff212dc08' +ARCHIVE = 'research/community-frontier1042-audit/selected-replay.tar.gz' +REQUIRED = frozenset([ + ARCHIVE, 'research/community-frontier1042-audit/RESULT.json', + 'research/community-frontier1094-audit/selected-replay.tar.gz', + 'research/community-frontier1094-audit/RESULT.json', + 'research/community-frontier1094-audit/ASSEMBLY.json', + 'docs/research/community-batch1099-review.md', + 'scripts/verify_frontier1094.py', + 'research/complex-dyadic-lowering/lower.py', + 'research/complex-dyadic-lowering/README.md', + 'research/gauge44-slots/code/invoice_allcold.py', + 'research/gauge44-slots/independent/audit_local.py']) +MEMBERS = ('CANONICAL-WORD.json.gz','LOCAL-PROGRAMS.json.gz', + 'INDEPENDENT-LOCAL-REPLAY.json','LOCAL-CHECKS.json') + +def require(value, message): + if not value: raise ValueError(message) + +def canonical(value): + return json.dumps(json.loads(json.dumps(value)), sort_keys=True, + separators=(',', ':'), allow_nan=False).encode() + +def digest(data): return hashlib.sha256(data).hexdigest() +def pin(path): + b = path.read_bytes() + return digest(b if path.name.endswith('.gz') else b.replace(b'\r\n',b'\n')) + +def check_sources(manifest=None): + m = manifest if manifest is not None else json.loads((HERE/'SOURCES.json').read_bytes()) + require(m['base'] == BASE and set(m['files']) == REQUIRED, 'source inventory') + require(set(m['archive_members'])=={'slots/local/'+n for n in MEMBERS},'archive member inventory') + for p,d in m['files'].items(): require(pin(ROOT/p)==d, 'source pin '+p) + selected=json.loads((HERE/'BASE-SELECTED.json').read_bytes()) + require(digest(canonical(selected))==m['selected_snapshot_sha256'],'selected snapshot') + require(selected['kappa']=='836330098538459/500000000000000000','selected kappa') + old=json.loads((ROOT/'research/community-frontier1042-audit/RESULT.json').read_bytes()) + current=json.loads((ROOT/'research/community-frontier1094-audit/RESULT.json').read_bytes()) + require(current['baseline_receipt_sha256']==digest((ROOT/'research/community-frontier1042-audit/RESULT.json').read_bytes()),'selected baseline receipt') + require(old['status']=='PASS_COMPLETE_PR1042_COMPOSITION' and current['status']=='PASS_COMPLETE_PR1094_COMPOSITION','selected receipt statuses') + return m + +def load(): + m=check_sources(); objs={} + with tarfile.open(ROOT/ARCHIVE) as t: + for n in MEMBERS: + name='slots/local/'+n; raw=t.extractfile(name).read() + require(digest(raw)==m['archive_members'][name], 'archive member '+name) + objs[n]=json.loads(gzip.decompress(raw) if n.endswith('.gz') else raw) + w=objs[MEMBERS[0]]; programs=objs[MEMBERS[1]]; receipt=objs[MEMBERS[2]] + require(set(m['archive_members'])=={'slots/local/'+n for n in MEMBERS},'archive member inventory') + with tarfile.open(ROOT/'research/community-frontier1094-audit/selected-replay.tar.gz') as t: + for n in MEMBERS: + raw=t.extractfile('candidate/strict/global8/base/providers/gauge44/'+n).read() + require(digest(raw)==m['archive_members']['slots/local/'+n],'selected1094 provider alias '+n) + require((w['v'],w['h'],w['R'])==(112,9,480),'source dimensions') + require(receipt['canonical_word_sha256']==m['archive_members']['slots/local/'+MEMBERS[0]] and receipt['local_programs_sha256']==m['archive_members']['slots/local/'+MEMBERS[1]],'native receipt artifact binding') + require(set(programs)=={'forward','backward'},'orientations') + return w,programs,receipt,objs[MEMBERS[3]] + +def power(k): return Q(2**k) if k>=0 else Q(1,2**-k) + +def parts(q): + a=abs(q.numerator);d=q.denominator + require(a and d&(d-1)==0,'nonzero dyadic') + v=(a&-a).bit_length()-1 + return a>>v, v-(d.bit_length()-1) + +def price(q, mode='copy-init'): + p,e=parts(q) + return 3+(p.bit_length()-1)+p.bit_count()+abs(e) if mode=='horner' else 2+(p.bit_length()-1)+p.bit_count()+abs(e)-int(p==1 and e==0) + +def cost(g,mode='copy-init'): + if g[0]=='add':return price(Q(g[3],g[4]),mode) + if g[0] in ('copy','clear'):return 1 + require(g[0]=='scale','scalar opcode') + q=Q(g[2],g[3]);p,e=parts(q);require(p==1,'power of two scale') + return abs(e)+int(q<0) + +def domain(w,programs): + excluded=set(w['centers']) & set(range(224,704)) + for events in programs.values(): + for ev in events: + if ev[0]=='scalar' and ev[1][0] in ('copy','clear'): + for r in ev[1][1:]: + if isinstance(r,list) and r[0]=='L' and 224<=r[1]<704:excluded.add(r[1]) + return sorted(set(range(224,704))-excluded),sorted(excluded) + +def search(events,helpers,mode='copy-init'): + terms=defaultdict(list) + for ev in events: + if ev[0]=='scalar' and ev[1][0]=='add': + g=ev[1];p,e=parts(Q(g[3],g[4])) + for r,s in ((g[1],1),(g[2],-1)): + if r[0]=='L':terms[r[1]].append((p,e,s)) + rows=[] + for h in helpers: + ts=terms[h]; points=sorted({0}|{-s*e for p,e,s in ts}) + def delta(k): + return 2*abs(k)+sum(abs(e+s*k)-abs(e) - (int(p==1 and e+s*k==0)-int(p==1 and e==0) if mode=='copy-init' else 0) for p,e,s in ts) + values=[[k,delta(k)] for k in points] + best=min(values,key=lambda kv:(kv[1],abs(kv[0]),kv[0])) + rows.append(dict(helper=h,incident_adds=len(ts),candidates=values,best_k=best[0],delta=best[1],tail_slope=2+len(ts))) + return rows + +def transform(events,w,h,k): + require(224<=h<704 and h not in w['centers'],'non-center helper only') + result=copy.deepcopy(events) + for ev in result: + if ev[0]!='scalar':continue + g=ev[1] + if g[0]=='add': + shift=k*(int(g[1]==['L',h])-int(g[2]==['L',h])) + q=Q(g[3],g[4])*power(shift);g[3:5]=[q.numerator,q.denominator] + elif g[0] in ('copy','clear'): + require(['L',h] not in g[1:],'copy/clear carrier excluded') + q=power(k); entry=['scalar',['scale',['L',h],q.numerator,q.denominator],w['start'][h]] + q=1/q; leave=['scalar',['scale',['L',h],q.numerator,q.denominator],w['final'][h]] + # The materialized winner is cold/FULL and has no residual wrapper. The + # exit scale follows full-frame cleanup, in the retained FULL coordinate. + require(w['start'][h]==0 and w['final'][h]==1,'materialized cold/FULL helper') + require(not any(e[0]=='residual_adapter' and e[2]==h for e in result),'unwrapped helper') + require(result[0]==['phase','zero_frame_precondition'] and result[-1]==['phase','done'],'boundary phases') + result.insert(len(result)-1,leave);result.insert(1,entry) + require([e for e in result if e[0]!='scalar']==[e for e in events if e[0]!='scalar'],'nonscalar stream preserved') + return result + +def replay(events,orientation): + # Independent formal variables for all 704 data/helper and 8 centre registers. + rows={('L',i):{i:Q(1)} for i in range(704)} + rows.update({('C',i):{704+i:Q(1)} for i in range(8)}) + for ev in events: + if ev[0]!='scalar':continue + g=ev[1];t=tuple(g[1]);tag=g[0] + if tag=='clear':rows[t]={} + elif tag=='copy':rows[t]=dict(rows[tuple(g[2])]) + elif tag=='scale':rows[t]={i:a*Q(g[2],g[3]) for i,a in rows[t].items()} + elif tag=='add': + s=tuple(g[2]);q=Q(g[3],g[4]);require(t!=s,'distinct add operands') + for i,a in rows[s].items(): + v=rows[t].get(i,Q(0))+q*a + if v:rows[t][i]=v + else:rows[t].pop(i,None) + else:raise ValueError('scalar opcode') + for i in range(704): + expected={i:Q(1)} + if orientation=='forward' and 112<=i<224:expected[i-112]=Q(1) + if orientation=='backward' and i<112:expected[i+112]=Q(-1) + require(rows['L',i]==expected,'all-column endpoint '+str((orientation,i))) + require(all(not rows['C',i] for i in range(8)),'private centre erased') + return dict(formal_input_columns=712,data_helper_columns=704,dirty_helper_columns=480,centre_columns=8,all_restored=True) + +def invoice(events,mode): + env={('L',i):Q(1) for i in range(704)} + env.update({('C',i):Q(1) for i in range(8)}) + peak=Q(1);count=0;paid=Counter() + for ev in events: + if ev[0]=='climb':paid[ev[5]]+=1 + elif ev[0]=='center':paid[ev[4]]+=1 + if ev[0]!='scalar':continue + g=ev[1];tag=g[0];t=tuple(g[1]);count+=cost(g,mode) + if tag=='clear':env[t]=Q(0) + elif tag=='copy':env[t]=env[tuple(g[2])] + elif tag=='scale': + q=Q(g[2],g[3]);env[t]*=abs(q) + else: + s=tuple(g[2]);q=Q(g[3],g[4]);a=abs(q.numerator) + # Integer Horner work grows to |numerator| times source before halving. + # Copy-init has the same bound; unit direct-add does not touch W until clear. + if mode=='horner' or abs(q)!=1:peak=max(peak,a*env[s]) + env[t]+=abs(q)*env[s] + peak=max(peak,env[t]) + bits=peak.numerator.bit_length()-peak.denominator.bit_length()+1 + require(peak<2**192,'local 192-bit payload cap') + return dict(real_primitives=count,complex_primitives=2*count,prefix_l1=str(peak),prefix_bits=bits,charged_payload_bits=192,paid_profile=dict(sorted(paid.items()))) + +def compute(): + w,programs,receipt,checks=load();helpers,excluded=domain(w,programs) + result=dict(base=BASE,geometry=dict(v=112,h=9,R=480),helpers=helpers,excluded_center_or_copy_helpers=excluded,orientations={}) + candidates={} + for orientation in ('forward','backward'): + events=programs[orientation];rows=search(events,helpers) + winner=min(rows,key=lambda row:(row['delta'],row['helper'],abs(row['best_k']),row['best_k'])) + h,k=winner['helper'],winner['best_k'];candidate=transform(events,w,h,k);candidates[orientation]=candidate + entry={ 'optima':rows,'winner':winner,'candidate_sha256':digest(canonical(candidate)), + 'boundary_frames':[w['start'][h],w['final'][h]],'baseline_endpoint':replay(events,orientation),'candidate_endpoint':replay(candidate,orientation),'prices':{}} + for mode in ('horner','copy-init'): + before=invoice(events,mode);after=invoice(candidate,mode) + require(before['paid_profile']==after['paid_profile'],'paid children unchanged') + if mode=='horner': + require(before['prefix_l1']==receipt['local'][orientation]['prefix_l1_upper'],'source prefix invoice') + require(before['complex_primitives']==checks[orientation]['real_component_primitive_bound'],'source primitive invoice') + else:require(after['real_primitives']-before['real_primitives']==winner['delta'],'search vs whole stream cost') + entry['prices'][mode]=dict(before=before,after=after,saving_real=before['real_primitives']-after['real_primitives'],saving_complex=before['complex_primitives']-after['complex_primitives']) + result['orientations'][orientation]=entry + result['status']='PASS_EXACT_UNBOUNDED_SINGLE_NONCENTER_HELPER_DYADIC_GAUGE' + return result,candidates diff --git a/research/complex-temporal-pair-seed28/vendor/pr1369/vendor/pr1263/verify.py b/research/complex-temporal-pair-seed28/vendor/pr1369/vendor/pr1263/verify.py new file mode 100644 index 0000000000..c688f72435 --- /dev/null +++ b/research/complex-temporal-pair-seed28/vendor/pr1369/vendor/pr1263/verify.py @@ -0,0 +1,207 @@ +"""Many-coordinate k8 diagonal gauges; Philipp / GPT-6 Astra, Apache-2.0. + +Reuses the byte-identical attributed PR1161 loader, scalar replay and invoice. +The joint objective and bounded discovery are new; no global optimum is claimed. +""" +import copy +import hashlib +import importlib.util +import json +from pathlib import Path +import random +import sys + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] + + +def need(value, message): + if not value: + raise ValueError(message) + + +def canonical(value): + return json.dumps(value, sort_keys=True, separators=(',', ':'), allow_nan=False).encode() + + +def sha(data): + return hashlib.sha256(data).hexdigest() + + +def engine(): + pins = json.loads((HERE / 'PREDECESSORS.json').read_bytes()) + expected_vendor = {'engine.py', 'SOURCES.json', 'BASE-SELECTED.json', 'PROVENANCE.md', 'PROOF.md'} + need(set(pins['vendor']) == {'vendor/pr1161/' + name for name in expected_vendor}, 'complete vendor inventory') + need(pins['pr1161_head'] == 'd210969d3158a1e6c505e41f67dd84e555c88564', 'PR1161 head') + need(pins['pr1214_head'] == '26162c56ec9c50a80e49949f36d4dd9a137a76a6', 'PR1214 head') + for path, digest in pins['vendor'].items(): + need(sha((HERE / path).read_bytes()) == digest, 'vendor pin ' + path) + spec = importlib.util.spec_from_file_location('credited_pr1161', HERE / 'vendor/pr1161/engine.py') + lib = importlib.util.module_from_spec(spec) + spec.loader.exec_module(lib) + lib.ROOT = ROOT + return lib + + +def domain(lib, word, programs): + helpers, _ = lib.domain(word, programs) + wrapped = {event[2] for stream in programs.values() for event in stream + if event[0] == 'residual_adapter'} + result = [h for h in helpers if word['start'][h] == 0 and word['final'][h] == 1 + and h not in wrapped] + need(len(result) == 237, '237 eligible helpers') + return result + + +def terms_from(lib, events, helpers): + allowed = set(helpers) + terms = [] + for event in events: + if event[0] != 'scalar' or event[1][0] != 'add': + continue + gate = event[1] + p, exponent = lib.parts(lib.Q(gate[3], gate[4])) + target, source = [r[1] if r[0] == 'L' and r[1] in allowed else -1 for r in gate[1:3]] + if target != -1 or source != -1: + need(target != source, 'distinct eligible ADD operands') + terms.append((p == 1, exponent, target, source)) + return terms + + +def f(unit, exponent): + return abs(exponent) - int(unit and exponent == 0) + + +def objective(terms, gauges): + return 2 * sum(abs(k) for k in gauges.values()) + sum( + f(u, e + gauges.get(t, 0) - gauges.get(s, 0)) - f(u, e) for u, e, t, s in terms) + + +def coordinate_candidates(terms, gauges, helper): + incident = [term for term in terms if helper in term[2:]] + points = {0, gauges.get(helper, 0)} | { + gauges.get(s, 0) - e if t == helper else gauges.get(t, 0) + e + for _, e, t, s in incident} + + def cost(value): + return 2 * abs(value) + sum(f(u, e + (value if t == helper else gauges.get(t, 0)) + - (value if s == helper else gauges.get(s, 0))) + for u, e, t, s in incident) + return sorted((k, cost(k)) for k in points) + + +def discover(terms, helpers): + """Four deterministic restarts, at most 50 complete sweeps per restart.""" + rng = random.Random(29) + incident = {h: [term for term in terms if h in term[2:]] for h in helpers} + records = [] + best = None + for restart in range(4): + gauges = {h: 0 if restart == 0 else rng.randint(-2, 2) for h in helpers} + trace = [] + for sweep in range(50): + order = helpers.copy() + rng.shuffle(order) + changes = 0 + for helper in order: + points = coordinate_candidates(incident[helper], gauges, helper) + chosen, value = min(points, key=lambda row: (row[1], abs(row[0]), row[0])) + old = dict(points)[gauges[helper]] + if value < old: + gauges[helper] = chosen + changes += 1 + trace.append([sweep, changes, objective(terms, gauges)]) + if changes == 0: + break + need(trace[-1][1] == 0, 'discovery completed before stopping cap') + record = {'restart': restart, 'delta_real': objective(terms, gauges), 'trace': trace, + 'gauges': {str(h): k for h, k in gauges.items() if k}} + records.append(record) + if best is None or record['delta_real'] < best['delta_real']: + best = record + return {'seed': 29, 'restarts': records, 'chosen_restart': best['restart']}, best['gauges'] + + +def transform(lib, word, events, gauges): + result = copy.deepcopy(events) + for event in result: + if event[0] != 'scalar': + continue + gate = event[1] + if gate[0] == 'add': + shift = sum(sign * gauges.get(r[1], 0) for sign, r in zip((1, -1), gate[1:3]) if r[0] == 'L') + q = lib.Q(gate[3], gate[4]) * lib.power(shift) + gate[3:5] = [q.numerator, q.denominator] + elif gate[0] in ('copy', 'clear'): + need(not any(isinstance(r, list) and r[0] == 'L' and r[1] in gauges for r in gate[1:]), + 'no gauge on COPY/clear register') + entry, exit_events = [], [] + for helper, k in sorted(gauges.items()): + need(224 <= helper < 704 and helper not in word['centers'], 'helper domain') + need(word['start'][helper] == 0 and word['final'][helper] == 1, 'cold/FULL helper') + need(not any(e[0] == 'residual_adapter' and e[2] == helper for e in events), 'unwrapped helper') + q = lib.power(k) + entry.append(['scalar', ['scale', ['L', helper], q.numerator, q.denominator], 0]) + exit_events.append(['scalar', ['scale', ['L', helper], q.denominator, q.numerator], 1]) + need(result[0] == ['phase', 'zero_frame_precondition'] and result[-1] == ['phase', 'done'], 'phases') + return result[:1] + entry + result[1:-1] + exit_events + result[-1:] + + +def compute(): + lib = engine() + word, programs, _, _ = lib.load() + helpers = domain(lib, word, programs) + gauges_raw = json.loads((HERE / 'GAUGES.json').read_bytes()) + need(set(gauges_raw) == {'forward', 'backward'}, 'gauge orientations') + forward_terms = terms_from(lib, programs['forward'], helpers) + discovery, discovered = discover(forward_terms, helpers) + need(discovered == gauges_raw['forward'], 'frozen forward gauges match bounded discovery') + need({h: -k for h, k in discovered.items()} == gauges_raw['backward'], 'inverse gauges') + certificate = {'seed': 29, 'base': 'dadfea6e8a78ff6ba901705f87532a71c6f5bbb8', + 'eligible_helpers': helpers, 'discovery': discovery, 'orientations': {}} + candidates = {} + for orientation in ('forward', 'backward'): + events = programs[orientation] + gauges = {int(h): k for h, k in gauges_raw[orientation].items()} + need(set(gauges) <= set(helpers) and all(type(k) is int and k != 0 for k in gauges.values()), 'gauge domain') + candidate = transform(lib, word, events, gauges) + need([e for e in events if e[0] != 'scalar'] == [e for e in candidate if e[0] != 'scalar'], 'paid event identity') + terms = terms_from(lib, events, helpers) + rows = [] + for h in helpers: + points = coordinate_candidates(terms, gauges, h) + old = dict(points)[gauges.get(h, 0)] + need(min(value for _, value in points) == old, 'coordinate stationary') + rows.append([h, points]) + before = lib.invoice(events, 'copy-init') + after = lib.invoice(candidate, 'copy-init') + need(after['real_primitives'] - before['real_primitives'] == objective(terms, gauges), 'complete invoice delta') + need(before['paid_profile'] == after['paid_profile'], 'paid profile equality') + certificate['orientations'][orientation] = { + 'support': len(gauges), 'boundary_real_primitives': 2 * sum(abs(k) for k in gauges.values()), + 'delta_real': objective(terms, gauges), 'baseline': before, 'candidate': after, + 'saving_complex': before['complex_primitives'] - after['complex_primitives'], + 'candidate_sha256': sha(canonical(candidate)), 'coordinate_checks': rows, + 'baseline_endpoint': lib.replay(events, orientation), 'candidate_endpoint': lib.replay(candidate, orientation), + 'horner_saving_complex': lib.invoice(events, 'horner')['complex_primitives'] - lib.invoice(candidate, 'horner')['complex_primitives']} + candidates[orientation] = candidate + certificate['status'] = 'PASS_MANY_HELPER_DYADIC_CONSTRUCTION' + return certificate, candidates + + +def main(): + result, _ = compute() + path = HERE / 'CERTIFICATE.json' + if '--write' in sys.argv: + need(not path.exists(), 'refusing to overwrite certificate') + path.write_bytes(canonical(result) + b'\n') + else: + need(canonical(result) == canonical(json.loads(path.read_bytes())), 'complete certificate equality') + print(result['status']) + for orientation, row in result['orientations'].items(): + print(orientation, 'support', row['support'], 'saving_complex', row['saving_complex'], + 'before', row['baseline']['complex_primitives'], 'after', row['candidate']['complex_primitives']) + + +if __name__ == '__main__': + main() diff --git a/research/complex-temporal-pair-seed28/vendor/pr1369/verify.py b/research/complex-temporal-pair-seed28/vendor/pr1369/verify.py new file mode 100644 index 0000000000..805b34f7c8 --- /dev/null +++ b/research/complex-temporal-pair-seed28/vendor/pr1369/verify.py @@ -0,0 +1,257 @@ +"""Recompute the seed-25 exact temporal census and full L359 candidate invoice.""" + +import hashlib +import importlib.util +import json +from pathlib import Path +import re +import sys + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] +BASE = "bce54fb3f895cbe5cd4c0eb477c3afeed100190f" +PR1263 = "5fbaca13028846bddbb001e8e07addc2ab8e5816" +PR1259 = "61367611154266a982fe25e1a6243a8aad77227d" +SEED = 25 +EXPECTED_ZERO = [272, 288, 348, 359, 381, 440, 444, 446, 447, 469, + 478, 479, 491, 503, 507, 514, 515, 519, 542] +SELECTED_KAPPA = "836330098538459/500000000000000000" + + +def need(ok, message): + if not ok: + raise ValueError(message) + + +def canonical(value): + return json.dumps(value, sort_keys=True, separators=(",", ":"), allow_nan=False).encode() + + +def sha(data): + return hashlib.sha256(data).hexdigest() + + +def module(name, path): + spec = importlib.util.spec_from_file_location(name, path) + need(spec is not None and spec.loader is not None, "load " + name) + value = importlib.util.module_from_spec(spec) + spec.loader.exec_module(value) + return value + + +independent = module("seed25_independent", HERE / "independent.py") +incident_adds = independent.incident_adds +optimize = independent.optimize +transform = independent.transform + + +def check_dependencies(): + deps = json.loads((HERE / "DEPENDENCIES.json").read_bytes()) + need(deps["schema_version"] == 1 and deps["base_commit"] == BASE, + "pinned base and dependency schema") + need(deps["pr1263_head"] == PR1263 and deps["pr1259_head"] == PR1259, + "pinned predecessor heads") + need(set(deps["vendored_sha256"]) == set(deps["source_git_blobs"]), + "complete source blob inventory") + for rel, expected in deps["vendored_sha256"].items(): + raw = (HERE / rel).read_bytes() + need(sha(raw) == expected, "vendored SHA-256 " + rel) + blob_id = hashlib.sha1(b"blob " + str(len(raw)).encode() + b"\0" + raw).hexdigest() + need(re.fullmatch(r"[0-9a-f]{40}", deps["source_git_blobs"][rel]) + and blob_id == deps["source_git_blobs"][rel], "source Git blob pin " + rel) + return deps + + +def compute(): + deps = check_dependencies() + selected = json.loads((ROOT / "certificates/selected-result.json").read_bytes()) + need(selected["kappa"] == SELECTED_KAPPA, "selected result at the pinned base") + selected_cert = ROOT / selected["certificate"] + need(sha(selected_cert.read_bytes()) == selected["certificate_sha256"], + "selected certificate hash") + source_pins = json.loads((HERE / "SOURCES.json").read_bytes()) + selected_pins = source_pins["selected_result"] + need(source_pins["base_commit"] == BASE + and sha((ROOT / selected_pins["path"]).read_bytes()) == selected_pins["sha256"], + "selected-result source pin") + need(selected_pins["certificate_path"] == selected["certificate"] + and selected_pins["certificate_sha256"] == selected["certificate_sha256"], + "selected-certificate source pin") + need(sha((ROOT / selected_pins["source_manifest_path"]).read_bytes()) + == selected_pins["source_manifest_sha256"], "selected source manifest pin") + inherited_pin = HERE / source_pins["pr1263"]["inherited_source_pin_file"] + need(sha(inherited_pin.read_bytes()) == source_pins["pr1263"]["inherited_source_pin_sha256"], + "inherited PR1263 source-pin manifest") + + parent = module("seed25_pinned_pr1263", HERE / "vendor/pr1263/verify.py") + parent.ROOT = ROOT + parent_result, static_words = parent.compute() + need(parent_result["status"] == "PASS_MANY_HELPER_DYADIC_CONSTRUCTION", + "PR1263 frozen source replay") + need(parent_result["base"] == "dadfea6e8a78ff6ba901705f87532a71c6f5bbb8", + "PR1263 historical source base") + need(all(v["support"] == 218 and v["saving_complex"] == 13000 + for v in parent_result["orientations"].values()), "PR1263 218-helper word") + + gauges = json.loads((HERE / "vendor/pr1263/GAUGES.json").read_bytes()) + forward_support = set(map(int, gauges["forward"])) + backward_support = set(map(int, gauges["backward"])) + eligible = set(parent_result["eligible_helpers"]) + zero_helpers = sorted(eligible - forward_support) + need(zero_helpers == EXPECTED_ZERO and forward_support == backward_support, + "exact PR1263 zero-static eligible helper domain") + need(SEED % len(zero_helpers) == 6 and zero_helpers[6] == 444, + "seed-indexed first helper") + scan_order = zero_helpers[SEED % len(zero_helpers):] + zero_helpers[:SEED % len(zero_helpers)] + + lib = parent.engine() + word, originals, _, _ = lib.load() + result = { + "status": "PASS_ZERO_STATIC_TEMPORAL_CENSUS", + "assignment_seed": SEED, + "track": "complex supplier", + "base_commit": BASE, + "selected_kappa": SELECTED_KAPPA, + "selected_certificate_sha256": selected["certificate_sha256"], + "predecessors": {"pr1263_head": PR1263, "pr1259_head": PR1259}, + "domain": { + "eligible_helpers": len(eligible), + "static_gauged_helpers": len(forward_support), + "zero_static_helpers": zero_helpers, + "scan_order": scan_order, + "orientation": ["forward", "backward"], + "schedule_values": "all integers, reduced to the exact breakpoint interval", + }, + "orientations": {}, + } + winner_candidates = {} + all_rows = {} + for orientation in ("forward", "backward"): + rows = [] + optimized = {} + for helper in scan_order: + need(word["start"][helper] == 0 and word["final"][helper] == 1, + orientation + " cold/FULL helper boundary") + need(not any(event[0] == "residual_adapter" and event[2] == helper + for event in originals[orientation]), orientation + " no residual adapter") + need(not any(event[0] == "scalar" and event[1][0] in ("copy", "clear") + and ["L", helper] in event[1][1:] + for event in originals[orientation]), orientation + " no incident COPY/clear") + terms = incident_adds(static_words[orientation], helper) + opt = optimize(terms) + optimized[helper] = (terms, opt) + rows.append({ + "helper": helper, + "incident_adds": opt["incident_adds"], + "domain": opt["domain"], + "edge_evaluations": opt["edge_evaluations"], + "best_delta_real": opt["delta_real"], + "best_constant_delta_real": opt["constant_delta_real"], + "best_constant_exponent": opt["constant_exponent"], + "transition_scale_macros": opt["transition_scale_macros"], + }) + + best_helper = min(scan_order, key=lambda helper: (optimized[helper][1]["delta_real"], helper)) + need(best_helper == 359, orientation + " exact best zero-static temporal helper") + terms, optimum = optimized[best_helper] + schedule = [[index, exponent] for (index, _, _), exponent + in zip(terms, optimum["schedule"])] + candidate, pulses = transform(static_words[orientation], best_helper, schedule) + before = lib.invoice(static_words[orientation], "copy-init") + after = lib.invoice(candidate, "copy-init") + base_invoice = parent_result["orientations"][orientation]["baseline"] + need(after["real_primitives"] - before["real_primitives"] == optimum["delta_real"], + orientation + " DP agrees with full lowerer invoice") + need(optimum["delta_real"] == -242 and optimum["constant_delta_real"] == 0, + orientation + " exact temporal improvement over every constant exponent") + need(after["complex_primitives"] == base_invoice["complex_primitives"] - 13484, + orientation + " full-word invoice vs original PR1094 word") + need(after["complex_primitives"] == before["complex_primitives"] - 484, + orientation + " complete 484-primitive improvement over PR1263") + need(after["charged_payload_bits"] == 192 and after["prefix_bits"] <= 192, + orientation + " inherited local precision ceiling") + need(before["paid_profile"] == after["paid_profile"], + orientation + " paid recursive profile unchanged") + need(lib.replay(candidate, orientation) == lib.replay(originals[orientation], orientation), + orientation + " all formal source columns") + need([event for event in candidate if event[0] != "scalar"] + == [event for event in static_words[orientation] if event[0] != "scalar"], + orientation + " frame, source, and paid event sequence unchanged") + need(len(pulses) == optimum["transition_scale_macros"] == 33, + orientation + " transition scale macro count") + scale_work = sum(abs(pulse[1]) for pulse in pulses) + previous = 0 + schedule_work = 0 + for exponent in optimum["schedule"]: + schedule_work += abs(exponent - previous) + previous = exponent + schedule_work += abs(previous) + need(scale_work == schedule_work, orientation + " full entry/transition/exit scale work") + + # A zero schedule is an exact identity control; the best constant schedule + # has zero delta, so the reported gain requires time variation. + identity, identity_pulses = transform(static_words[orientation], best_helper, + [[index, 0] for index, _, _ in terms]) + need(identity == static_words[orientation] and not identity_pulses, + orientation + " zero schedule identity control") + malformed = [list(event) for event in candidate] + malformed.pop(pulses[0][3]) + try: + omitted_pulse_matches = (lib.replay(malformed, orientation) + == lib.replay(originals[orientation], orientation)) + except Exception: + omitted_pulse_matches = False + need(not omitted_pulse_matches, orientation + " omitted-transition-scale control rejected") + rows_by_helper = {row["helper"]: row for row in rows} + need(all(row["best_constant_delta_real"] == 0 for row in rows), + orientation + " all 19 static zero-coordinate controls") + + result["orientations"][orientation] = { + "helpers_checked": len(rows), + "helpers": rows, + "winner": best_helper, + "winner_incident_adds": len(terms), + "winner_domain": optimum["domain"], + "winner_edge_evaluations": optimum["edge_evaluations"], + "winner_delta_real": optimum["delta_real"], + "winner_transition_scale_macros": len(pulses), + "winner_transition_scale_work": scale_work, + "winner_schedule": schedule, + "baseline_static_invoice": before, + "candidate_invoice": after, + "omitted_transition_scale_rejected": True, + "saving_complex_vs_pr1263": before["complex_primitives"] - after["complex_primitives"], + "saving_complex_vs_original": base_invoice["complex_primitives"] - after["complex_primitives"], + "formal_endpoint": lib.replay(candidate, orientation), + "candidate_sha256": sha(canonical(candidate)), + } + winner_candidates[orientation] = candidate + all_rows[orientation] = rows_by_helper + + # The selected winner is a single-coordinate result; do not sum independent + # savings across shared ADDs or infer a composed multi-coordinate optimum. + need(result["orientations"]["forward"]["winner"] == result["orientations"]["backward"]["winner"], + "same winning helper in both orientations") + return result + + +def main(): + result = compute() + cert_path = HERE / "CERTIFICATE.json" + if "--write" in sys.argv: + need(not cert_path.exists(), "refuse to overwrite frozen certificate") + cert_path.write_bytes(canonical(result) + b"\n") + else: + frozen = json.loads(cert_path.read_bytes()) + need(canonical(result) == canonical(frozen), "frozen exact certificate") + print(result["status"]) + for orientation, row in result["orientations"].items(): + print(orientation, "helpers", row["helpers_checked"], "winner", row["winner"], + "delta_real", row["winner_delta_real"], + "complex", row["candidate_invoice"]["complex_primitives"], + "saved_vs_PR1263", row["saving_complex_vs_pr1263"], + "columns", row["formal_endpoint"].get("formal_input_columns")) + + +if __name__ == "__main__": + main() diff --git a/research/complex-temporal-pair-seed28/verify.py b/research/complex-temporal-pair-seed28/verify.py new file mode 100644 index 0000000000..f2755ed6a1 --- /dev/null +++ b/research/complex-temporal-pair-seed28/verify.py @@ -0,0 +1,404 @@ +#!/usr/bin/env python3 +"""Compose a seed-selected pair of exact temporal gauges on one shared ADD.""" +import copy +import gzip +import hashlib +import importlib.util +import itertools +import json +from fractions import Fraction as Q +from pathlib import Path +import sys + +PACKAGE = Path(__file__).resolve().parent +ROOT = PACKAGE.parents[1] +LEGACY = PACKAGE / "vendor/pr1369" +REPORT = PACKAGE / "RESULT.json" +SOURCES = PACKAGE / "SOURCES.json" +BASE = "bce54fb3f895cbe5cd4c0eb477c3afeed100190f" +PR1369 = "f28e1c460cd910886f9b06835abd6b1c96d2992f" +SEED = 28 +ZERO_HELPERS = [272, 288, 348, 359, 381, 440, 444, 446, 447, 469, + 478, 479, 491, 503, 507, 514, 515, 519, 542] +EXPECTED_PAIR_POOL = [[348, 359], [479, 515]] +EXPECTED_PAIR = (348, 359) +EXPECTED_SHARED_ADD = 24336 +SELECTED_KAPPA = "836330098538459/500000000000000000" + + +def need(condition, message): + if not condition: + raise ValueError(message) + + +def canonical(value): + return json.dumps(value, sort_keys=True, separators=(",", ":"), + allow_nan=False).encode() + + +def sha(raw): + return hashlib.sha256(raw).hexdigest() + + +def blob(raw): + return hashlib.sha1(b"blob " + str(len(raw)).encode() + b"\0" + raw).hexdigest() + + +def import_file(name, path): + spec = importlib.util.spec_from_file_location(name, path) + need(spec is not None and spec.loader is not None, "load " + name) + result = importlib.util.module_from_spec(spec) + spec.loader.exec_module(result) + return result + + +def check_source_pins(sources): + need(sources["schema_version"] == 1 and sources["base_commit"] == BASE, + "base source manifest") + for row in sources["base_files"]: + raw = (ROOT / row["path"]).read_bytes() + need(sha(raw) == row["sha256"], "base input SHA-256: " + row["path"]) + need(blob(raw) == row["git_blob"], "base input Git blob: " + row["path"]) + need(len(sources["vendored_files"]) == 16, "complete PR1369 source snapshot") + for row in sources["vendored_files"]: + raw = (PACKAGE / row["path"]).read_bytes() + need(sha(raw) == row["sha256"], "vendored SHA-256: " + row["path"]) + need(blob(raw) == row["git_blob"], "vendored source Git blob: " + row["path"]) + pred = sources["predecessors"] + need(pred["pr1369"]["head"] == PR1369, "PR1369 exact head") + need(pred["pr1263"]["head"] == + "5fbaca13028846bddbb001e8e07addc2ab8e5816", "PR1263 exact head") + need(pred["pr1259"]["head"] == + "61367611154266a982fe25e1a6243a8aad77227d", "PR1259 exact head") + need(pred["pr1310"]["head"] == + "b9ca10f02fca37c8214d880c244ac14ead6bae7a", "PR1310 scope pin") + need(pred["pr1376"]["head"] == + "49f112ac76e95415fcea8969de28f74c8928b2b1", "PR1376 overlap pin") + need(pred["pr1380"]["head"] == + "c2bc6848cffb2e2203095d4c4bbc45b0848c22e7", "PR1380 overlap pin") + + +def load_predecessor(sources): + legacy = import_file("seed28_pinned_pr1369", LEGACY / "verify.py") + legacy.ROOT = ROOT + captured = {} + original_loader = legacy.module + + def capture_parent(name, path): + module = original_loader(name, path) + if name == "seed25_pinned_pr1263": + original_compute = module.compute + + def compute_and_capture(): + result, static_words = original_compute() + captured["parent_result"] = result + captured["static_words"] = static_words + captured["parent_module"] = module + return result, static_words + + module.compute = compute_and_capture + return module + + legacy.module = capture_parent + result = legacy.compute() + certificate_path = LEGACY / "CERTIFICATE.json" + certificate = json.loads(certificate_path.read_bytes()) + need(canonical(result) == canonical(certificate), + "recomputed PR1369 certificate equality") + need(result["status"] == "PASS_ZERO_STATIC_TEMPORAL_CENSUS", + "PR1369 single-coordinate census") + need(result["base_commit"] == BASE and + result["selected_kappa"] == SELECTED_KAPPA, "PR1369 selected source") + need(captured.get("static_words") is not None, "recover pinned PR1263 word") + return legacy, result, captured["parent_result"], captured["static_words"], captured["parent_module"] + + +def scale_word(events, helper_a, optimum_a, helper_b, optimum_b, independent): + terms_a = independent.incident_adds(events, helper_a) + terms_b = independent.incident_adds(events, helper_b) + need(len(terms_a) == len(optimum_a["schedule"]), "L348 complete schedule") + need(len(terms_b) == len(optimum_b["schedule"]), "L359 complete schedule") + schedule_a = {term[0]: exponent for term, exponent + in zip(terms_a, optimum_a["schedule"])} + schedule_b = {term[0]: exponent for term, exponent + in zip(terms_b, optimum_b["schedule"])} + current = {helper_a: 0, helper_b: 0} + inserted = [] + result = [] + for index, source_event in enumerate(events): + event = copy.deepcopy(source_event) + for helper, schedule in ((helper_a, schedule_a), (helper_b, schedule_b)): + if index in schedule: + exponent = schedule[index] + change = exponent - current[helper] + if change: + scale = independent.two_power(change) + output_index = len(result) + result.append(["scalar", ["scale", ["L", helper], + scale.numerator, scale.denominator], event[2]]) + inserted.append([helper, index, change, event[2], output_index]) + current[helper] = exponent + if index == len(events) - 1: + need(source_event == ["phase", "done"], "terminal restoration boundary") + for helper in (helper_a, helper_b): + if current[helper]: + scale = independent.two_power(-current[helper]) + output_index = len(result) + result.append(["scalar", ["scale", ["L", helper], + scale.numerator, scale.denominator], 1]) + inserted.append([helper, index, -current[helper], 1, output_index]) + if event[0] == "scalar" and event[1][0] == "add": + gate = event[1] + sign_a = int(gate[1] == ["L", helper_a]) - int(gate[2] == ["L", helper_a]) + sign_b = int(gate[1] == ["L", helper_b]) - int(gate[2] == ["L", helper_b]) + coefficient = Q(gate[3], gate[4]) * independent.two_power( + sign_a * current[helper_a] + sign_b * current[helper_b]) + gate[3], gate[4] = coefficient.numerator, coefficient.denominator + result.append(event) + need(len(result) == len(events) + len(inserted), "inserted scale census") + return result, inserted, schedule_a, schedule_b, terms_a, terms_b + + +def replay_equal(lib, candidate, original, orientation): + try: + return lib.replay(candidate, orientation) == lib.replay(original, orientation) + except Exception: + return False + + +def invoice_view(row): + fields = ("real_primitives", "complex_primitives", "charged_payload_bits", "prefix_bits") + return {key: row[key] for key in fields if key in row} + + +def verify(): + sources = json.loads(SOURCES.read_bytes()) + check_source_pins(sources) + selected = json.loads((ROOT / "certificates/selected-result.json").read_bytes()) + need(selected["kappa"] == SELECTED_KAPPA and 1094 in selected["source_prs"], + "selected conditional result") + assembly = json.loads((ROOT / "research/community-frontier1094-audit/ASSEMBLY.json").read_bytes()) + need(assembly.get("selected_kappa") == SELECTED_KAPPA or + assembly.get("kappa") == SELECTED_KAPPA, "selected assembly kappa") + + legacy, legacy_result, parent_result, static_words, parent = load_predecessor(sources) + gauges = json.loads((LEGACY / "vendor/pr1263/GAUGES.json").read_bytes()) + forward_static = set(map(int, gauges["forward"])) + backward_static = set(map(int, gauges["backward"])) + eligible = set(map(int, parent_result["eligible_helpers"])) + zero = sorted(eligible - forward_static) + need(zero == ZERO_HELPERS and forward_static == backward_static, + "complete zero-static helper inventory") + need(len(eligible) == 237 and len(forward_static) == 218, + "PR1263 237/218 helper inventory") + + lib = parent.engine() + word, original_words, _, _ = lib.load() + orientation_results = {} + pair_lists = [] + candidate_words = {} + for orientation in ("forward", "backward"): + events = static_words[orientation] + helper_terms = {helper: legacy.independent.incident_adds(events, helper) + for helper in zero} + helper_opts = {helper: legacy.independent.optimize(helper_terms[helper]) + for helper in zero} + predecessor_rows = {row["helper"]: row for row in + legacy_result["orientations"][orientation]["helpers"]} + need(set(predecessor_rows) == set(zero), orientation + " all 19 predecessor rows") + for helper in zero: + opt = helper_opts[helper] + row = predecessor_rows[helper] + need(opt["incident_adds"] == row["incident_adds"] and + opt["domain"] == row["domain"] and + opt["edge_evaluations"] == row["edge_evaluations"] and + opt["delta_real"] == row["best_delta_real"] and + opt["constant_delta_real"] == row["best_constant_delta_real"], + orientation + " PR1369 exact DP row " + str(helper)) + + schedules = {helper: {term[0]: exponent for term, exponent in + zip(helper_terms[helper], helper_opts[helper]["schedule"])} + for helper in zero} + pair_pool = [] + for helper_a, helper_b in itertools.combinations(zero, 2): + shared_active = sorted(index for index in + set(schedules[helper_a]) & set(schedules[helper_b]) + if schedules[helper_a][index] != 0 and + schedules[helper_b][index] != 0) + if (shared_active and helper_opts[helper_a]["delta_real"] < 0 and + helper_opts[helper_b]["delta_real"] < 0): + pair_pool.append((helper_a, helper_b, shared_active)) + pair_lists.append([[a, b, shared] for a, b, shared in pair_pool]) + need([[a, b] for a, b, _ in pair_pool] == EXPECTED_PAIR_POOL, + orientation + " seed-selected interacting pair domain") + pair_index = SEED % len(pair_pool) + helper_a, helper_b, shared = pair_pool[pair_index] + need((helper_a, helper_b) == EXPECTED_PAIR and shared == [EXPECTED_SHARED_ADD], + orientation + " seed-selected pair and shared ADD") + + opt_a, opt_b = helper_opts[helper_a], helper_opts[helper_b] + before = lib.invoice(events, "copy-init") + need(before["paid_profile"] == parent_result["orientations"][orientation]["baseline"]["paid_profile"], + orientation + " PR1263 paid profile") + individual = {} + for helper, opt, terms in ((helper_a, opt_a, helper_terms[helper_a]), + (helper_b, opt_b, helper_terms[helper_b])): + single, pulses = legacy.independent.transform( + events, helper, [[term[0], exponent] + for term, exponent in zip(terms, opt["schedule"])]) + single_invoice = lib.invoice(single, "copy-init") + need(single_invoice["real_primitives"] - before["real_primitives"] == opt["delta_real"], + orientation + " single coordinate full invoice") + need(single_invoice["paid_profile"] == before["paid_profile"], + orientation + " single coordinate profile") + need(lib.replay(single, orientation) == lib.replay(events, orientation), + orientation + " single coordinate complete map") + individual[str(helper)] = invoice_view(single_invoice) + + candidate, inserted, schedule_a, schedule_b, terms_a, terms_b = scale_word( + events, helper_a, opt_a, helper_b, opt_b, legacy.independent) + after = lib.invoice(candidate, "copy-init") + need(len(inserted) == opt_a["transition_scale_macros"] + + opt_b["transition_scale_macros"] == 54, + orientation + " full entry/transition/exit scale census") + need(len(candidate) == len(events) + 54, + orientation + " complete scalar event count") + need(after["paid_profile"] == before["paid_profile"], + orientation + " complete paid-profile equality") + need(after["charged_payload_bits"] == 192 and after["prefix_bits"] <= 192, + orientation + " inherited precision charge") + need(after["prefix_bits"] == (52 if orientation == "forward" else 68), + orientation + " local prefix ceiling") + need([e for e in candidate if e[0] != "scalar"] == + [e for e in events if e[0] != "scalar"], + orientation + " all frame and paid events unchanged") + endpoint = lib.replay(candidate, orientation) + need(endpoint == lib.replay(events, orientation), + orientation + " all 712 formal columns") + + term_a = next(term for term in terms_a if term[0] == shared[0]) + term_b = next(term for term in terms_b if term[0] == shared[0]) + need(term_a[1] == term_b[1], orientation + " shared original ADD coefficient") + exponent_a, exponent_b = schedule_a[shared[0]], schedule_b[shared[0]] + delta_a = legacy.independent.add_price( + term_a[1] * legacy.independent.two_power(term_a[2] * exponent_a)) - legacy.independent.add_price(term_a[1]) + delta_b = legacy.independent.add_price( + term_b[1] * legacy.independent.two_power(term_b[2] * exponent_b)) - legacy.independent.add_price(term_b[1]) + delta_joint = legacy.independent.add_price( + term_a[1] * legacy.independent.two_power(term_a[2] * exponent_a + + term_b[2] * exponent_b)) - legacy.independent.add_price(term_a[1]) + cross = delta_joint - delta_a - delta_b + joint_delta = after["real_primitives"] - before["real_primitives"] + need((delta_a, delta_b, delta_joint, cross) == (-1, -4, -2, 3), + orientation + " exact shared-ADD correction") + need(joint_delta == opt_a["delta_real"] + opt_b["delta_real"] + cross == -400, + orientation + " exact complete composition price") + need(before["complex_primitives"] - after["complex_primitives"] == 800, + orientation + " complete complex invoice saving") + + original_invoice = parent_result["orientations"][orientation]["baseline"] + need(original_invoice["complex_primitives"] - after["complex_primitives"] == 13800, + orientation + " total saving over PR1094 original") + + # Positive identity control: both all-zero schedules leave the word byte-identical. + zero_a = {term[0]: 0 for term in terms_a} + zero_b = {term[0]: 0 for term in terms_b} + zero_candidate, zero_pulses, _, _, _, _ = scale_word( + events, helper_a, {"schedule": tuple(zero_a[i] for i, _, _ in terms_a)}, + helper_b, {"schedule": tuple(zero_b[i] for i, _, _ in terms_b)}, + legacy.independent) + need(zero_candidate == events and not zero_pulses, + orientation + " all-zero schedule identity") + + # Negative control: remove a charged L348 entry/transition/restore scale. + helper_a_scales = [row for row in inserted if row[0] == helper_a] + need(bool(helper_a_scales), orientation + " L348 scale exists") + missing_scale = copy.deepcopy(candidate) + missing_scale.pop(helper_a_scales[0][4]) + need(not replay_equal(lib, missing_scale, events, orientation), + orientation + " omitted L348 scale rejected") + + # Negative control: omit L359's contribution at the one shared ADD. + wrong_shared = copy.deepcopy(candidate) + found_shared = [] + for row in wrong_shared: + if row[0] == "scalar" and row[1][0] == "add" and \ + ["L", helper_a] in row[1][1:3] and ["L", helper_b] in row[1][1:3]: + found_shared.append(row) + need(len(found_shared) == 1, orientation + " unique shared ADD") + shared_gate = found_shared[0][1] + coefficient_without_b = term_a[1] * legacy.independent.two_power(term_a[2] * exponent_a) + shared_gate[3], shared_gate[4] = coefficient_without_b.numerator, coefficient_without_b.denominator + need(not replay_equal(lib, wrong_shared, events, orientation), + orientation + " omitted shared coordinate rejected") + + orientation_results[orientation] = { + "helpers": [helper_a, helper_b], + "helper_schedules": { + str(helper_a): {"domain": opt_a["domain"], "schedule": list(opt_a["schedule"]), + "delta_real": opt_a["delta_real"], + "transition_scale_macros": opt_a["transition_scale_macros"]}, + str(helper_b): {"domain": opt_b["domain"], "schedule": list(opt_b["schedule"]), + "delta_real": opt_b["delta_real"], + "transition_scale_macros": opt_b["transition_scale_macros"]}}, + "single_candidate_invoices": individual, + "shared_add": {"index": shared[0], "coefficient": + [term_a[1].numerator, term_a[1].denominator], + "signs": [term_a[2], term_b[2]], + "exponents": [exponent_a, exponent_b], + "separate_real_add_deltas": [delta_a, delta_b], + "combined_real_add_delta": delta_joint, + "cross_correction_real": cross}, + "static_invoice": invoice_view(before), + "candidate_invoice": invoice_view(after), + "joint_real_delta": joint_delta, + "complex_saving_vs_PR1263": before["complex_primitives"] - after["complex_primitives"], + "complex_saving_vs_PR1094": original_invoice["complex_primitives"] - after["complex_primitives"], + "scale_macros": len(inserted), + "input_event_count": len(events), + "candidate_event_count": len(candidate), + "non_scalar_events_unchanged": True, + "all_712_columns_equal": True, + "candidate_sha256": sha(canonical(candidate)), + "endpoint_sha256": sha(canonical(endpoint)), + "controls": {"zero_schedule_identity": "passed", + "missing_L348_transition_scale": "rejected", + "missing_L359_shared_coefficient": "rejected"}} + candidate_words[orientation] = candidate + + need(pair_lists[0] == pair_lists[1], "same seed-selected pair pool both ways") + selected_certificate = json.loads((ROOT / "certificates/selected-result.json").read_bytes()) + return { + "status": "PASS_COMPLEX_TEMPORAL_PAIR", + "assignment_seed": SEED, + "base_commit": BASE, + "selected_kappa_unchanged": selected_certificate["kappa"], + "predecessor_pr1369_head": PR1369, + "zero_static_helper_count": len(zero), + "pair_search_domain": "all 171 unordered pairs of the 19 zero-static helpers; retain improving solo DPs active together on a shared ADD", + "qualifying_pairs_both_orientations": pair_lists[0], + "seed_index": SEED % len(pair_lists[0]), + "selected_pair": list(EXPECTED_PAIR), + "orientations": orientation_results, + "no_joint_optimality_claim": True, + "no_new_kappa": True, + "scope": "Feasible composition of two exact single-coordinate minima on a pinned shared-ADD pair; no two-coordinate optimum, supplier admission, or paid-profile change." + } + + +def main(): + write = len(sys.argv) == 2 and sys.argv[1] == "--write" + need(len(sys.argv) == 1 or write, "usage: verify.py [--write]") + result = verify() + if write: + need(not REPORT.exists(), "refusing to overwrite RESULT.json") + REPORT.write_text(json.dumps(result, indent=2) + "\n") + print("WROTE_RESULT " + str(REPORT.relative_to(ROOT))) + return + expected = json.loads(REPORT.read_text()) + need(canonical(result) == canonical(expected), "stored RESULT.json differs from exact replay") + print("PASS_COMPLEX_TEMPORAL_PAIR seed=28 helpers=348,359 shared_add=24336 cross=+3real saving=800complex/orientation controls=3 no_new_kappa") + + +if __name__ == "__main__": + main() diff --git a/research/seed28-complex-reroll-20261013/ASSIGNMENT.json b/research/seed28-complex-reroll-20261013/ASSIGNMENT.json new file mode 100644 index 0000000000..bfad44236a --- /dev/null +++ b/research/seed28-complex-reroll-20261013/ASSIGNMENT.json @@ -0,0 +1,75 @@ +{ + "assignment_seed_os_random": 28, + "track": "Complex supplier", + "draw_source": "Python secrets backed by OS randomness", + "started_at_utc": "2026-10-13T23:37:47Z", + "base_commit": "bce54fb3f895cbe5cd4c0eb477c3afeed100190f", + "status": "submitted as PR #1388; one distinct-pair certificate; selected kappa unchanged", + "selected_record": { + "kappa": "836330098538459/500000000000000000", + "certificate": "research/community-frontier1094-audit/ASSEMBLY.json", + "review": "docs/research/community-batch1099-review.md", + "complex_local_lineage": "PR1094 selected complex word; PR1263 static 218-helper gauge word" + }, + "candidate_screen": [ + { + "object": "Compose two exact time-varying gauges on a PR1263 pair sharing an ADD", + "claims_checked": "PR1369 single-coordinate census; PR1310 all two-coordinate constant-gauge stationarity; PR1350/L253 and PR1353/L248 separate nonzero-static one-coordinate constructions", + "decision": "selected as new obligation: dynamic pair composition at a shared coefficient is explicitly outside both one-coordinate census and constant-pair stationarity" + }, + { + "object": "One finite masked/overcomplete complex decoder support class", + "claims_checked": "PR1212, PR1213, PR1224, PR1226, PR1236, PR1304, PR1320; active Discussions 1267, 1275, 1316, 1360", + "decision": "crowded; avoid repeating active masked/rank-shape classes" + }, + { + "object": "Changed complex helper inventory or coverage-law relaxation", + "claims_checked": "PR1240/1348 and Discussion 1328, plus selected helper-inventory claims", + "decision": "occupied; do not re-price claimed coverage-law thresholds" + } + ], + "seed_diversification": { + "universe": "19 PR1369 zero-static helpers; 171 unordered pairs", + "filter": "both single-coordinate all-integer minima strictly improve and their active schedules meet on at least one ADD, in both orientations", + "qualifying_pairs": 2, + "seed_rule": "seed 28 modulo 2 selects index 0", + "selected_pair": [ + 348, + 359 + ], + "shared_add_index": 24336, + "pivot": "The first raw lexicographic pair for seed 28 was (288,491) but their ADD supports were disjoint, so pivot once to the shared-ADD candidate universe to test a genuine coefficient interaction." + }, + "scope_claimed": "Compose the exact single-helper optima for L348 and L359 simultaneously on the selected PR1263 static word. Reprice the combined word and complete invoice, replay all formal columns both ways, and measure the shared-ADD correction. No joint optimum or new kappa claim.", + "expected_deliverable": "Source-pinned finite circuit package with exact solo schedules, pair composition, full invoices, shared-ADD correction, 712-column replay, and negative controls.", + "expected_finish_utc": "2026-10-13T23:58:00Z", + "coordination": "No pinned sprint coordination issue found by open-issue search; local claim is in research/complex-temporal-pair-seed28/CLAIM.md.", + "final_overlap_refresh": { + "searched_at_utc": "2026-10-13T23:55:32Z", + "open_pr_searches": [ + "temporal gauge pair shared ADD", + "phase varying gauge composition" + ], + "exact_pr1376_head": "49f112ac76e95415fcea8969de28f74c8928b2b1", + "exact_pr1380_head": "c2bc6848cffb2e2203095d4c4bbc45b0848c22e7", + "pr1376_scope": "L248/L253 temporal composition with disjoint ADD supports", + "pr1380_scope": "16 paired temporal schedules, all tested pairs contain L225; exact certificate pair set excludes L348/L359", + "distinct_result": "seed-selected L348/L359 is a different pair from every pair in PR1380 certificate; this package independently composes PR1369 exact one-coordinate minima and prices the +3-real shared ADD correction" + }, + "final_result": { + "package": "research/complex-temporal-pair-seed28/", + "selected_pair": [ + 348, + 359 + ], + "shared_add_index": 24336, + "joint_real_delta_per_orientation": -400, + "shared_add_cross_correction_real": 3, + "complex_saving_vs_PR1263_per_orientation": 800, + "formal_columns_replayed_per_orientation": 712, + "paid_profile_changed": false, + "new_kappa_claim": false, + "verifier": "PASS_COMPLEX_TEMPORAL_PAIR seed=28 helpers=348,359 shared_add=24336 cross=+3real saving=800complex/orientation controls=3 no_new_kappa" + }, + "pr_url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1388" +}