diff --git a/research/p104-final-helper-audit/CREDITS.md b/research/p104-final-helper-audit/CREDITS.md new file mode 100644 index 0000000000..25a8492e38 --- /dev/null +++ b/research/p104-final-helper-audit/CREDITS.md @@ -0,0 +1,29 @@ +# Sources and attribution + +Clear1nsight supplied the final split, literal carrier, overlay and +construction journal in +[PR #7781](https://github.com/CrocSwap/integer-mult-bounds/pull/7781). +The source [notice](https://github.com/Clear1nsight/integer-mult-bounds/blob/913fb6febe28cc3ccad1c16de8e45b8bce0da063/research/p104-subdivided-helper-births/NOTICE) +credits that work and its predecessors. The retained overlay is executed +unchanged. The source proof and replay describe the intended boundary. + +Ali Romman supplied the calibrated split algebra and dual carrier in +[PR #7776](https://github.com/CrocSwap/integer-mult-bounds/pull/7776). +The [split routine](https://github.com/aliromman/integer-mult-bounds/blob/4f7c67ae387cc91580f469aeda4d508b372b9ec1/research/p104-dual-supplier-lift/complex/birth_event.py) +is retained unchanged for a forward round-trip check. The exact rational +expander and chart checks come from Ali Romman's +[PR #7777](https://github.com/CrocSwap/integer-mult-bounds/pull/7777), in its +[checker](https://github.com/aliromman/integer-mult-bounds/blob/0288431ab2ad0cccfbede0b57cd3edfb2679e0f6/research/p104-first-relay-repair/verify.py). +Only those generic functions run here; its earlier repair experiment does +not run. + +Jerry Chen (CubeJerry), DreamingOfClouds, zxv, SYLforge, Rohan Arun, +Cinna Davis, Douglas Colkitt and the retained authors supplied earlier +application, caller, native, physical and analytic work. Their source +notices remain byte-exact. SOURCE-PINS.json identifies each retained file. + +Ali Romman prepared this audit with substantial OpenAI Codex assistance +in research, implementation, verification and writing. The new inverse +reconstruction, pulse-weight classification and controls are source-aware +checks. No independent human or proof-kernel review is claimed. +Apache-2.0. diff --git a/research/p104-final-helper-audit/LICENSE b/research/p104-final-helper-audit/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/p104-final-helper-audit/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/p104-final-helper-audit/PROOF.md b/research/p104-final-helper-audit/PROOF.md new file mode 100644 index 0000000000..201bd87a35 --- /dev/null +++ b/research/p104-final-helper-audit/PROOF.md @@ -0,0 +1,156 @@ +# Exact final helper return and pulse weights + +This is a scoped audit of the final split in +[PR #7781](https://github.com/CrocSwap/integer-mult-bounds/pull/7781). +It confirms the rational public map and determines all valid weights on +the three fixed pulse sends. It gives no new kappa and no complete supplier +admission. The source is +[the exact final journal](https://github.com/Clear1nsight/integer-mult-bounds/blob/913fb6febe28cc3ccad1c16de8e45b8bce0da063/research/p104-subdivided-helper-births/complex/FINAL-BIRTH.json). + +## Boundary and exact reconstruction + +The old helper has role 1164, label 1307, and charts 3 to 517. +The split returns that input at chart 232. A new independent input at +chart 232 has role 1278, label 1531, and returns at chart 517. +Every other owner keeps its source and return chart. The 5,714 paid MOVEs +are identical. The chart spans satisfy strict inclusions +`3 < 232 < 517`, with dimensions that differ by four on each side. +Here the inequality denotes subspace inclusion, not integer order. + +The deposited WORD is the carrier before the overlay. The checker applies +the retained overlay and checks its published digest. It then constructs +the split from the stated equations, recovers the old graph in reverse, +and compares both canonical objects with the journal: + +| Graph | SHA-256 | +| --- | --- | +| Before final split | `6eba6bb65015df98cf103ce6d12fdd982ba4dcd24a69000bcc58e05477b17c19` | +| After final split | `03ef8f6cc9ebb7394b5c7f8da70d44df965659ae4ff361bbc8d32c7a12121445` | + +Let h=1164, j=1166 and f=1278. The source and return direction is +`d = -2 e_h - 8 e_j`. Write p for the full source covector in the journal. +Its h coordinate is 3030720, its j coordinate is zero, and +`p d = -6061440`. If u has zero h coordinate, the source substitution is + +```text +u' = u + d (x - p u)/(p d). +``` + +The inverse substitution is explicit: recover x as `p u'`; recover u_j +as `u'_j - 4 u'_h`; retain every other coordinate except the removed +h coordinate. Thus this input change is invertible on the old public +inputs. The local readout at chart 232 equals x. + +Let z denote the terminal rows after the source substitution and pulse, +but before the final terminal edit. The return covector is `-e_j`. +The new f row is `-z_j`, and the new j row is `z_j - 4 z_h`. +Their inverse is + +```text +z_j = -new_f, +z_h = -(new_f + new_j)/4. +``` + +After this terminal inverse, remove the pulse at each of the three sends. +Then apply the inverse source substitution. The recovered graph has the +exact pre-split digest above. The 48 changed rows also match the journal's +complete delta digest. As a cross-check, the retained source split routine +maps this recovered graph back to the same final rows and chart lists. + +## Arbitrary inputs and the adjoint + +The checker expands every graph row as a rational form in independent +public inputs. It uses integer numerators and one reduced denominator per +row. It checks local chart access and acyclic dependencies before each +expansion. It compares the old 1278-square map and new 1279-square map +with the exact prescribed main blocks and independent helper identities. +It separately reverses all graph edges and all paid routes, exchanges +input and output charts, and expands that adjoint. The result is the +transpose of the prescribed map. + +These checks cover 4,904,966 coefficient positions and perform 46,466,187 +scalar coefficient products. These are verification counts, not physical +gate or work counts. The full new public operator has rank 1279: each +helper block is the identity and each main block is invertible. + +## Complete pulse-weight error law + +The pulse sends, in order, are 92740, 98411 and 98796. Their source +coefficients are -5, -2 and -2. The return normalization is eight. +Let C be the local calibration form after the source substitution, and +let y be the fresh input. The exact calibration is + +```text +C = -u_j - (x - p u)/757680. +``` + +The checker verifies this identity on all public input coefficients. +It also checks that each individual pulse has zero response on both C +and the old-input readout. Thus each pulse can vary without changing +either local probe. The common excitation is `y-C`. + +Define R_i as the final output response to an additive pulse of the +stated coefficient divided by eight at send i. The full columns are in +RESULT.json. Their sum is `e_f`. Their rows at outputs 17, 38 and f are + +```text + 92740 98411 98796 +17 -5/2 0 5/2 +38 5/2 -5/2 0 +1278 0 1/2 1/2 +``` + +This minor has determinant 25/4. The three response columns are linearly +independent over the rationals. + +Keep the source substitution, terminal edit and three send locations +fixed. Multiply their complete pulse additions by arbitrary rational +weights lambda_i. Linearity and the probe identities give the full error + +```text +error = (y-C) sum_i (lambda_i-1) R_i. +``` + +The form `y-C` is nonzero because y is independent and C has zero y +coefficient. Therefore the full public map is correct if and only if +all three weights are one. This is an exact classification within this +three-send family. It does not optimize different send locations, new +local forms, added paid transfers or another graph. + +If only the fresh-input terms are weighted, the same law holds with y +in place of `y-C`. All old input columns stay unchanged. All eight +include-or-omit subsets are checked. Omitting all three gives exactly +`-y e_f`. Every nonempty proper subset also introduces a wrong old-owner +output coefficient. Twelve direct rational controls check the complete +pulse law on four input assignments, including old and fresh inputs. + +## Signed ranks and limits + +The split replaces one rank-eight productive target with two rank-four +targets. The native paid rank histogram is identical. Under the retained +48-call multiplicity, its contribution to the signed margin is + +```text +48 (2 * 4^(1-kappa) - 8^(1-kappa)). +``` + +This is positive for `0 < kappa < 1`, because +`2 * 4^t > 8^t` for `0 < t < 1`. The calculation is a local signed-rank +delta. It does not reprice the increased ordinary work or establish a +new finite bound. + +The overlay is retained source code; the final constructor, inverse, +adjoint and pulse controls are source-aware checks. The exact row +expander comes from the separately published audit in +[PR #7777](https://github.com/CrocSwap/integer-mult-bounds/pull/7777). +This is computational and algebraic corroboration, not independent human +or proof-kernel acceptance. The earlier fourteen births, full physical +word, caller stream, binary service, ordinary costs, stock and compiler +are not replayed here. The five inherited assumptions remain. + +## Open next questions + +Does the complete finite application preserve this exact owner boundary +with its stated ordinary allowance? Inspect the published application +and its owner and cost obligations. This audit supplies the exact scalar +map and local rank delta for that review; it does not discharge it. diff --git a/research/p104-final-helper-audit/README.md b/research/p104-final-helper-audit/README.md new file mode 100644 index 0000000000..32f962b81b --- /dev/null +++ b/research/p104-final-helper-audit/README.md @@ -0,0 +1,36 @@ +# Final P104 helper audit + +The final split in PR #7781 preserves every prescribed public coefficient +and adds one independent helper without a new paid MOVE. All three fixed +pulse weights are uniquely required over the rationals. No new kappa is +claimed. Read [the proof](PROOF.md), [certificate](RESULT.json), +[source pins](SOURCE-PINS.json) and [credits](CREDITS.md). + +Use Python 3.12 and the standard library from the repository root: + +```sh +python3.12 -B scripts/research_package.py --package research/p104-final-helper-audit +``` + +Both modes print this prefix and elapsed seconds: + +```text +PASS_P104_FINAL_HELPER_AUDIT 1279 owners 3 pulse rank +``` + +The package has no network or Git dependency at replay. It checks 19 +retained files, both graph hashes, all 48 changed rows, 4,904,966 rational +coefficient positions, the rank-three pulse minor, all eight fresh-term +omission subsets and twelve rational pulse controls. It also checks +causal chart access, every public chart and the exact native invoice. + +The full physical application and its ordinary costs remain outside this +audit. All five framework assumptions remain. The proof gives the open +next question. The selected frontier is unchanged. + +## Open next questions + +Does the full caller preserve this exact owner boundary with its stated +ordinary allowance? Inspect the published application and its owner and +cost obligations. The present audit supplies the scalar map and local +rank delta for that check. diff --git a/research/p104-final-helper-audit/RESULT.json b/research/p104-final-helper-audit/RESULT.json new file mode 100644 index 0000000000..bd9ac05930 --- /dev/null +++ b/research/p104-final-helper-audit/RESULT.json @@ -0,0 +1,2971 @@ +{ + "both_probes_blind_to_each_pulse": true, + "calibration_row": [ + [ + 3, + "-3/10" + ], + [ + 21, + "4/5" + ], + [ + 129, + "2/5" + ], + [ + 133, + "-1/10" + ], + [ + 150, + "-2/5" + ], + [ + 159, + "2/5" + ], + [ + 164, + "-2/5" + ], + [ + 172, + "-2/5" + ], + [ + 173, + "372/55" + ], + [ + 188, + "-3/20" + ], + [ + 205, + "1/5" + ], + [ + 226, + "-11/20" + ], + [ + 228, + "-64/55" + ], + [ + 230, + "-2" + ], + [ + 231, + "-3/20" + ], + [ + 235, + "6/5" + ], + [ + 239, + "2/5" + ], + [ + 240, + "-4/5" + ], + [ + 245, + "1/10" + ], + [ + 246, + "-27/820" + ], + [ + 247, + "-3/20" + ], + [ + 249, + "-3/20" + ], + [ + 252, + "-2/11" + ], + [ + 254, + "4/5" + ], + [ + 260, + "-3/40" + ], + [ + 262, + "32/5" + ], + [ + 263, + "-1/5" + ], + [ + 266, + "-14/5" + ], + [ + 270, + "2/5" + ], + [ + 273, + "-8/5" + ], + [ + 274, + "-8/5" + ], + [ + 277, + "6/5" + ], + [ + 283, + "-36/287" + ], + [ + 288, + "401/2870" + ], + [ + 289, + "311/2870" + ], + [ + 292, + "-180/287" + ], + [ + 299, + "-1/5" + ], + [ + 302, + "-4/5" + ], + [ + 304, + "-8/5" + ], + [ + 307, + "-3/5" + ], + [ + 309, + "4/5" + ], + [ + 310, + "-2/5" + ], + [ + 315, + "1/20" + ], + [ + 317, + "1/20" + ], + [ + 320, + "1/10" + ], + [ + 322, + "-6/5" + ], + [ + 328, + "2/5" + ], + [ + 329, + "-1/10" + ], + [ + 335, + "2/5" + ], + [ + 336, + "-1/5" + ], + [ + 338, + "1/10" + ], + [ + 340, + "-1/5" + ], + [ + 344, + "6/5" + ], + [ + 347, + "-16/5" + ], + [ + 348, + "2/5" + ], + [ + 349, + "-2/5" + ], + [ + 350, + "-8/5" + ], + [ + 356, + "-2/5" + ], + [ + 359, + "4/5" + ], + [ + 361, + "76/55" + ], + [ + 362, + "2/5" + ], + [ + 365, + "-2" + ], + [ + 368, + "-1/5" + ], + [ + 370, + "1/10" + ], + [ + 376, + "-3/5" + ], + [ + 381, + "-2/5" + ], + [ + 383, + "-2" + ], + [ + 384, + "2/5" + ], + [ + 388, + "-4/5" + ], + [ + 390, + "6/5" + ], + [ + 391, + "8/5" + ], + [ + 392, + "-1/5" + ], + [ + 401, + "-2/5" + ], + [ + 402, + "32/5" + ], + [ + 404, + "-253/2870" + ], + [ + 406, + "-4/5" + ], + [ + 409, + "32/55" + ], + [ + 410, + "1/5" + ], + [ + 411, + "1" + ], + [ + 413, + "-8/5" + ], + [ + 414, + "2/5" + ], + [ + 420, + "-4/5" + ], + [ + 421, + "-32/5" + ], + [ + 427, + "2" + ], + [ + 428, + "12/5" + ], + [ + 429, + "-6/5" + ], + [ + 433, + "-8/5" + ], + [ + 434, + "8/5" + ], + [ + 443, + "-16/5" + ], + [ + 448, + "7/5" + ], + [ + 452, + "4/5" + ], + [ + 453, + "-8/5" + ], + [ + 454, + "7/10" + ], + [ + 455, + "-4/5" + ], + [ + 457, + "4/5" + ], + [ + 458, + "2/5" + ], + [ + 459, + "-1/5" + ], + [ + 460, + "-2/5" + ], + [ + 463, + "-2/5" + ], + [ + 464, + "-8/5" + ], + [ + 468, + "4" + ], + [ + 469, + "-12/5" + ], + [ + 470, + "-12/5" + ], + [ + 471, + "8/5" + ], + [ + 472, + "2/5" + ], + [ + 474, + "-8/5" + ], + [ + 475, + "-24/5" + ], + [ + 476, + "24/5" + ], + [ + 479, + "-186/55" + ], + [ + 481, + "12/5" + ], + [ + 483, + "-4/5" + ], + [ + 484, + "-2/5" + ], + [ + 486, + "-4/5" + ], + [ + 487, + "-8/5" + ], + [ + 488, + "2/5" + ], + [ + 490, + "-16/5" + ], + [ + 492, + "-1" + ], + [ + 493, + "2" + ], + [ + 495, + "2/5" + ], + [ + 496, + "-4/5" + ], + [ + 497, + "-4/5" + ], + [ + 498, + "-48/5" + ], + [ + 500, + "8/5" + ], + [ + 501, + "-3/20" + ], + [ + 502, + "-1" + ], + [ + 503, + "2/5" + ], + [ + 508, + "-24/5" + ], + [ + 509, + "24/5" + ], + [ + 510, + "-6/5" + ], + [ + 511, + "2/5" + ], + [ + 512, + "4/5" + ], + [ + 513, + "-2/5" + ], + [ + 514, + "-1" + ], + [ + 516, + "-2" + ], + [ + 517, + "-2/5" + ], + [ + 519, + "-1/10" + ], + [ + 522, + "1/5" + ], + [ + 527, + "-1" + ], + [ + 529, + "1/5" + ], + [ + 530, + "-1/5" + ], + [ + 531, + "1/5" + ], + [ + 537, + "8/5" + ], + [ + 538, + "-2/5" + ], + [ + 540, + "6/5" + ], + [ + 546, + "-2/5" + ], + [ + 547, + "-16/5" + ], + [ + 552, + "-1/5" + ], + [ + 553, + "3/5" + ], + [ + 555, + "-2" + ], + [ + 565, + "-2/5" + ], + [ + 574, + "-2/5" + ], + [ + 578, + "-1/10" + ], + [ + 579, + "-1/5" + ], + [ + 581, + "-2/5" + ], + [ + 588, + "-1/5" + ], + [ + 590, + "4/5" + ], + [ + 595, + "4/5" + ], + [ + 608, + "6/5" + ], + [ + 616, + "1" + ], + [ + 624, + "-1/5" + ], + [ + 630, + "-1/5" + ], + [ + 633, + "-1/10" + ], + [ + 634, + "-2/5" + ], + [ + 645, + "4/5" + ], + [ + 649, + "-32/5" + ], + [ + 651, + "-38/55" + ], + [ + 652, + "8/5" + ], + [ + 655, + "-12/5" + ], + [ + 666, + "-2" + ], + [ + 679, + "4/5" + ], + [ + 683, + "-1/757680" + ], + [ + 696, + "-6/5" + ], + [ + 700, + "1/5" + ], + [ + 770, + "8/5" + ], + [ + 771, + "8/5" + ], + [ + 772, + "8/5" + ], + [ + 773, + "4/5" + ], + [ + 774, + "4/5" + ], + [ + 775, + "4/5" + ], + [ + 776, + "-4/5" + ], + [ + 777, + "4/5" + ], + [ + 778, + "-4/5" + ], + [ + 781, + "4/5" + ], + [ + 782, + "4/5" + ], + [ + 783, + "-4/5" + ], + [ + 785, + "4/5" + ], + [ + 791, + "4/5" + ], + [ + 792, + "4/5" + ], + [ + 793, + "4/5" + ], + [ + 794, + "4/5" + ], + [ + 795, + "4/5" + ], + [ + 797, + "4/5" + ], + [ + 798, + "4/5" + ], + [ + 800, + "1/5" + ], + [ + 801, + "4/5" + ], + [ + 804, + "1/10" + ], + [ + 807, + "4/5" + ], + [ + 810, + "-4/5" + ], + [ + 811, + "1/5" + ], + [ + 813, + "4/5" + ], + [ + 814, + "4/5" + ], + [ + 816, + "-4/5" + ], + [ + 817, + "4/5" + ], + [ + 818, + "4/5" + ], + [ + 819, + "4/5" + ], + [ + 820, + "8/5" + ], + [ + 823, + "4/5" + ], + [ + 824, + "-4/5" + ], + [ + 825, + "-4/5" + ], + [ + 826, + "4/5" + ], + [ + 827, + "4/5" + ], + [ + 828, + "8/5" + ], + [ + 830, + "4/5" + ], + [ + 831, + "4/5" + ], + [ + 832, + "4/5" + ], + [ + 833, + "4/5" + ], + [ + 834, + "8/5" + ], + [ + 835, + "4/5" + ], + [ + 836, + "4/5" + ], + [ + 837, + "8/5" + ], + [ + 840, + "4/5" + ], + [ + 841, + "-4/5" + ], + [ + 842, + "4/5" + ], + [ + 843, + "-4/5" + ], + [ + 844, + "4/5" + ], + [ + 845, + "8/5" + ], + [ + 846, + "8/5" + ], + [ + 847, + "4/5" + ], + [ + 848, + "4/5" + ], + [ + 849, + "4/5" + ], + [ + 850, + "4/5" + ], + [ + 851, + "4/5" + ], + [ + 852, + "8/5" + ], + [ + 853, + "8/5" + ], + [ + 858, + "4/5" + ], + [ + 859, + "4/5" + ], + [ + 863, + "4/5" + ], + [ + 864, + "4/5" + ], + [ + 867, + "4/5" + ], + [ + 868, + "4/5" + ], + [ + 870, + "4/5" + ], + [ + 871, + "4/5" + ], + [ + 872, + "-4/5" + ], + [ + 873, + "-4/5" + ], + [ + 874, + "2/5" + ], + [ + 877, + "4/5" + ], + [ + 879, + "-48/5" + ], + [ + 884, + "6/5" + ], + [ + 887, + "4/5" + ], + [ + 890, + "4/5" + ], + [ + 891, + "-1/5" + ], + [ + 892, + "1/757680" + ], + [ + 894, + "-24/5" + ], + [ + 896, + "2/5" + ], + [ + 898, + "8/5" + ], + [ + 899, + "2/5" + ], + [ + 902, + "2/5" + ], + [ + 904, + "8/5" + ], + [ + 906, + "-8/5" + ], + [ + 907, + "4/5" + ], + [ + 916, + "-12/5" + ], + [ + 917, + "8/5" + ], + [ + 918, + "-4/5" + ], + [ + 919, + "-8/5" + ], + [ + 923, + "-8/5" + ], + [ + 924, + "-4/5" + ], + [ + 927, + "-4/5" + ], + [ + 929, + "-2/5" + ], + [ + 931, + "-6/5" + ], + [ + 935, + "-2/5" + ], + [ + 937, + "2/5" + ], + [ + 939, + "-6/5" + ], + [ + 943, + "-2/5" + ], + [ + 944, + "-4/5" + ], + [ + 946, + "8/5" + ], + [ + 947, + "2/5" + ], + [ + 948, + "-1/2" + ], + [ + 949, + "-2/5" + ], + [ + 950, + "-4/5" + ], + [ + 956, + "4/5" + ], + [ + 961, + "6/5" + ], + [ + 964, + "1/5" + ], + [ + 965, + "8/5" + ], + [ + 968, + "1/5" + ], + [ + 973, + "2/5" + ], + [ + 978, + "2/5" + ], + [ + 981, + "1" + ], + [ + 988, + "4/5" + ], + [ + 992, + "-24/5" + ], + [ + 994, + "-4/5" + ], + [ + 995, + "-4/5" + ], + [ + 996, + "-24/5" + ], + [ + 999, + "4/5" + ], + [ + 1001, + "-4/5" + ], + [ + 1003, + "4/5" + ], + [ + 1005, + "2/5" + ], + [ + 1009, + "-4/5" + ], + [ + 1010, + "4/5" + ], + [ + 1011, + "8/5" + ], + [ + 1024, + "-4/5" + ], + [ + 1025, + "2/5" + ], + [ + 1029, + "-16/5" + ], + [ + 1033, + "8/5" + ], + [ + 1037, + "-4/5" + ], + [ + 1038, + "12/5" + ], + [ + 1040, + "-4/5" + ], + [ + 1043, + "-4/5" + ], + [ + 1044, + "-8/5" + ], + [ + 1045, + "-2/5" + ], + [ + 1047, + "-4/5" + ], + [ + 1049, + "2/5" + ], + [ + 1052, + "2/5" + ], + [ + 1053, + "-2/5" + ], + [ + 1054, + "-4/5" + ], + [ + 1057, + "-4/5" + ], + [ + 1060, + "-8/5" + ], + [ + 1061, + "-6/5" + ], + [ + 1063, + "-1/5" + ], + [ + 1064, + "4/5" + ], + [ + 1065, + "4/5" + ], + [ + 1067, + "4/5" + ], + [ + 1069, + "-2/5" + ], + [ + 1070, + "4/5" + ], + [ + 1071, + "4/5" + ], + [ + 1073, + "4/5" + ], + [ + 1074, + "1/5" + ], + [ + 1076, + "1/5" + ], + [ + 1077, + "4/5" + ], + [ + 1079, + "12/5" + ], + [ + 1080, + "-7/5" + ], + [ + 1081, + "-4/5" + ], + [ + 1084, + "1/5" + ], + [ + 1086, + "-4/5" + ], + [ + 1088, + "-8/5" + ], + [ + 1089, + "12/5" + ], + [ + 1090, + "4/5" + ], + [ + 1092, + "4/5" + ], + [ + 1094, + "-6/5" + ], + [ + 1095, + "-2/5" + ], + [ + 1097, + "-6/5" + ], + [ + 1100, + "-2/5" + ], + [ + 1102, + "6/5" + ], + [ + 1103, + "1/5" + ], + [ + 1104, + "-24/5" + ], + [ + 1105, + "-2/5" + ], + [ + 1106, + "-1/10" + ], + [ + 1111, + "-24/5" + ], + [ + 1112, + "-4" + ], + [ + 1115, + "-8/5" + ], + [ + 1116, + "-4/5" + ], + [ + 1117, + "6/5" + ], + [ + 1118, + "-2/5" + ], + [ + 1119, + "-3/20" + ], + [ + 1121, + "-8/5" + ], + [ + 1122, + "16/15" + ], + [ + 1123, + "-37/5" + ], + [ + 1124, + "-22/5" + ], + [ + 1125, + "7/5" + ], + [ + 1126, + "12/5" + ], + [ + 1127, + "2/5" + ], + [ + 1132, + "4/5" + ], + [ + 1138, + "-4/5" + ], + [ + 1139, + "-8/5" + ], + [ + 1140, + "-8/5" + ], + [ + 1144, + "2" + ], + [ + 1145, + "-16/5" + ], + [ + 1147, + "-2/5" + ], + [ + 1164, + "-1/757680" + ], + [ + 1166, + "-1" + ], + [ + 1173, + "-3/5" + ], + [ + 1242, + "-2/5" + ] + ], + "changed_rows": 48, + "coefficient_positions": 4904966, + "exact_scalar_products": 46466187, + "final_graph": "03ef8f6cc9ebb7394b5c7f8da70d44df965659ae4ff361bbc8d32c7a12121445", + "native_delta": { + "paid": {}, + "targets": { + "4": 2, + "8": -1 + } + }, + "omission_controls": [ + { + "errors": [ + [ + 1278, + "-1" + ] + ], + "mask": 0 + }, + { + "errors": [ + [ + 17, + "-5/2" + ], + [ + 38, + "5/2" + ], + [ + 39, + "-1" + ], + [ + 308, + "-1" + ], + [ + 362, + "5/4" + ], + [ + 364, + "-5/4" + ], + [ + 461, + "5/2" + ], + [ + 603, + "-5" + ], + [ + 608, + "5" + ], + [ + 675, + "-5/8" + ], + [ + 693, + "5/8" + ], + [ + 716, + "-5/8" + ], + [ + 735, + "5/8" + ], + [ + 758, + "5/8" + ], + [ + 761, + "-5/8" + ], + [ + 876, + "5/8" + ], + [ + 958, + "5/8" + ], + [ + 1038, + "-5/2" + ], + [ + 1045, + "5/4" + ], + [ + 1100, + "5/2" + ], + [ + 1166, + "1" + ], + [ + 1278, + "-1" + ] + ], + "mask": 1 + }, + { + "errors": [ + [ + 38, + "-5/2" + ], + [ + 39, + "1/2" + ], + [ + 308, + "1/2" + ], + [ + 328, + "5/8" + ], + [ + 362, + "-5/4" + ], + [ + 401, + "5/8" + ], + [ + 461, + "-5/4" + ], + [ + 603, + "5/2" + ], + [ + 608, + "-5/2" + ], + [ + 693, + "-5/8" + ], + [ + 758, + "-5/8" + ], + [ + 761, + "5/8" + ], + [ + 876, + "-5/16" + ], + [ + 958, + "-5/16" + ], + [ + 1025, + "-5/8" + ], + [ + 1038, + "5/4" + ], + [ + 1052, + "5/8" + ], + [ + 1100, + "-5/2" + ], + [ + 1166, + "-1/2" + ], + [ + 1278, + "-1/2" + ] + ], + "mask": 2 + }, + { + "errors": [ + [ + 17, + "-5/2" + ], + [ + 39, + "-1/2" + ], + [ + 308, + "-1/2" + ], + [ + 328, + "5/8" + ], + [ + 364, + "-5/4" + ], + [ + 401, + "5/8" + ], + [ + 461, + "5/4" + ], + [ + 603, + "-5/2" + ], + [ + 608, + "5/2" + ], + [ + 675, + "-5/8" + ], + [ + 716, + "-5/8" + ], + [ + 735, + "5/8" + ], + [ + 876, + "5/16" + ], + [ + 958, + "5/16" + ], + [ + 1025, + "-5/8" + ], + [ + 1038, + "-5/4" + ], + [ + 1045, + "5/4" + ], + [ + 1052, + "5/8" + ], + [ + 1166, + "1/2" + ], + [ + 1278, + "-1/2" + ] + ], + "mask": 3 + }, + { + "errors": [ + [ + 17, + "5/2" + ], + [ + 39, + "1/2" + ], + [ + 308, + "1/2" + ], + [ + 328, + "-5/8" + ], + [ + 364, + "5/4" + ], + [ + 401, + "-5/8" + ], + [ + 461, + "-5/4" + ], + [ + 603, + "5/2" + ], + [ + 608, + "-5/2" + ], + [ + 675, + "5/8" + ], + [ + 716, + "5/8" + ], + [ + 735, + "-5/8" + ], + [ + 876, + "-5/16" + ], + [ + 958, + "-5/16" + ], + [ + 1025, + "5/8" + ], + [ + 1038, + "5/4" + ], + [ + 1045, + "-5/4" + ], + [ + 1052, + "-5/8" + ], + [ + 1166, + "-1/2" + ], + [ + 1278, + "-1/2" + ] + ], + "mask": 4 + }, + { + "errors": [ + [ + 38, + "5/2" + ], + [ + 39, + "-1/2" + ], + [ + 308, + "-1/2" + ], + [ + 328, + "-5/8" + ], + [ + 362, + "5/4" + ], + [ + 401, + "-5/8" + ], + [ + 461, + "5/4" + ], + [ + 603, + "-5/2" + ], + [ + 608, + "5/2" + ], + [ + 693, + "5/8" + ], + [ + 758, + "5/8" + ], + [ + 761, + "-5/8" + ], + [ + 876, + "5/16" + ], + [ + 958, + "5/16" + ], + [ + 1025, + "5/8" + ], + [ + 1038, + "-5/4" + ], + [ + 1052, + "-5/8" + ], + [ + 1100, + "5/2" + ], + [ + 1166, + "1/2" + ], + [ + 1278, + "-1/2" + ] + ], + "mask": 5 + }, + { + "errors": [ + [ + 17, + "5/2" + ], + [ + 38, + "-5/2" + ], + [ + 39, + "1" + ], + [ + 308, + "1" + ], + [ + 362, + "-5/4" + ], + [ + 364, + "5/4" + ], + [ + 461, + "-5/2" + ], + [ + 603, + "5" + ], + [ + 608, + "-5" + ], + [ + 675, + "5/8" + ], + [ + 693, + "-5/8" + ], + [ + 716, + "5/8" + ], + [ + 735, + "-5/8" + ], + [ + 758, + "-5/8" + ], + [ + 761, + "5/8" + ], + [ + 876, + "-5/8" + ], + [ + 958, + "-5/8" + ], + [ + 1038, + "5/2" + ], + [ + 1045, + "-5/4" + ], + [ + 1100, + "-5/2" + ], + [ + 1166, + "-1" + ] + ], + "mask": 6 + }, + { + "errors": [], + "mask": 7 + } + ], + "paid": { + "1": 3850, + "2": 795, + "3": 489, + "4": 222, + "5": 307, + "6": 45, + "7": 4, + "8": 2 + }, + "paid_moves": 5714, + "public_owners": 1279, + "pulse_ids": [ + 92740, + 98411, + 98796 + ], + "pulse_response_columns": [ + [ + [ + 17, + "-5/2" + ], + [ + 38, + "5/2" + ], + [ + 39, + "-1" + ], + [ + 308, + "-1" + ], + [ + 362, + "5/4" + ], + [ + 364, + "-5/4" + ], + [ + 461, + "5/2" + ], + [ + 603, + "-5" + ], + [ + 608, + "5" + ], + [ + 675, + "-5/8" + ], + [ + 693, + "5/8" + ], + [ + 716, + "-5/8" + ], + [ + 735, + "5/8" + ], + [ + 758, + "5/8" + ], + [ + 761, + "-5/8" + ], + [ + 876, + "5/8" + ], + [ + 958, + "5/8" + ], + [ + 1038, + "-5/2" + ], + [ + 1045, + "5/4" + ], + [ + 1100, + "5/2" + ], + [ + 1166, + "1" + ] + ], + [ + [ + 38, + "-5/2" + ], + [ + 39, + "1/2" + ], + [ + 308, + "1/2" + ], + [ + 328, + "5/8" + ], + [ + 362, + "-5/4" + ], + [ + 401, + "5/8" + ], + [ + 461, + "-5/4" + ], + [ + 603, + "5/2" + ], + [ + 608, + "-5/2" + ], + [ + 693, + "-5/8" + ], + [ + 758, + "-5/8" + ], + [ + 761, + "5/8" + ], + [ + 876, + "-5/16" + ], + [ + 958, + "-5/16" + ], + [ + 1025, + "-5/8" + ], + [ + 1038, + "5/4" + ], + [ + 1052, + "5/8" + ], + [ + 1100, + "-5/2" + ], + [ + 1166, + "-1/2" + ], + [ + 1278, + "1/2" + ] + ], + [ + [ + 17, + "5/2" + ], + [ + 39, + "1/2" + ], + [ + 308, + "1/2" + ], + [ + 328, + "-5/8" + ], + [ + 364, + "5/4" + ], + [ + 401, + "-5/8" + ], + [ + 461, + "-5/4" + ], + [ + 603, + "5/2" + ], + [ + 608, + "-5/2" + ], + [ + 675, + "5/8" + ], + [ + 716, + "5/8" + ], + [ + 735, + "-5/8" + ], + [ + 876, + "-5/16" + ], + [ + 958, + "-5/16" + ], + [ + 1025, + "5/8" + ], + [ + 1038, + "5/4" + ], + [ + 1045, + "-5/4" + ], + [ + 1052, + "-5/8" + ], + [ + 1166, + "-1/2" + ], + [ + 1278, + "1/2" + ] + ] + ], + "pulse_response_rank": 3, + "rational_controls": [ + { + "error": [ + [ + 1278, + "-1" + ] + ], + "input": [ + [ + 1278, + "1" + ] + ], + "weights": [ + "0", + "0", + "0" + ] + }, + { + "error": [ + [ + 17, + "9/4" + ], + [ + 38, + "35/12" + ], + [ + 39, + "-2/15" + ], + [ + 308, + "-2/15" + ], + [ + 328, + "-31/24" + ], + [ + 362, + "35/24" + ], + [ + 364, + "9/8" + ], + [ + 401, + "-31/24" + ], + [ + 461, + "1/3" + ], + [ + 603, + "-2/3" + ], + [ + 608, + "2/3" + ], + [ + 675, + "9/16" + ], + [ + 693, + "35/48" + ], + [ + 716, + "9/16" + ], + [ + 735, + "-9/16" + ], + [ + 758, + "35/48" + ], + [ + 761, + "-35/48" + ], + [ + 876, + "1/12" + ], + [ + 958, + "1/12" + ], + [ + 1025, + "31/24" + ], + [ + 1038, + "-1/3" + ], + [ + 1045, + "-9/8" + ], + [ + 1052, + "-31/24" + ], + [ + 1100, + "35/12" + ], + [ + 1166, + "2/15" + ], + [ + 1278, + "-19/30" + ] + ], + "input": [ + [ + 1278, + "1" + ] + ], + "weights": [ + "1/2", + "-2/3", + "7/5" + ] + }, + { + "error": [], + "input": [ + [ + 1278, + "1" + ] + ], + "weights": [ + "1", + "1", + "1" + ] + }, + { + "error": [ + [ + 1278, + "-1/757680" + ] + ], + "input": [ + [ + 1164, + "1" + ] + ], + "weights": [ + "0", + "0", + "0" + ] + }, + { + "error": [ + [ + 17, + "3/1010240" + ], + [ + 38, + "1/259776" + ], + [ + 39, + "-1/5682600" + ], + [ + 308, + "-1/5682600" + ], + [ + 328, + "-31/18184320" + ], + [ + 362, + "1/519552" + ], + [ + 364, + "3/2020480" + ], + [ + 401, + "-31/18184320" + ], + [ + 461, + "1/2273040" + ], + [ + 603, + "-1/1136520" + ], + [ + 608, + "1/1136520" + ], + [ + 675, + "3/4040960" + ], + [ + 693, + "1/1039104" + ], + [ + 716, + "3/4040960" + ], + [ + 735, + "-3/4040960" + ], + [ + 758, + "1/1039104" + ], + [ + 761, + "-1/1039104" + ], + [ + 876, + "1/9092160" + ], + [ + 958, + "1/9092160" + ], + [ + 1025, + "31/18184320" + ], + [ + 1038, + "-1/2273040" + ], + [ + 1045, + "-3/2020480" + ], + [ + 1052, + "-31/18184320" + ], + [ + 1100, + "1/259776" + ], + [ + 1166, + "1/5682600" + ], + [ + 1278, + "-19/22730400" + ] + ], + "input": [ + [ + 1164, + "1" + ] + ], + "weights": [ + "1/2", + "-2/3", + "7/5" + ] + }, + { + "error": [], + "input": [ + [ + 1164, + "1" + ] + ], + "weights": [ + "1", + "1", + "1" + ] + }, + { + "error": [ + [ + 1278, + "-1" + ] + ], + "input": [ + [ + 1166, + "1" + ] + ], + "weights": [ + "0", + "0", + "0" + ] + }, + { + "error": [ + [ + 17, + "9/4" + ], + [ + 38, + "35/12" + ], + [ + 39, + "-2/15" + ], + [ + 308, + "-2/15" + ], + [ + 328, + "-31/24" + ], + [ + 362, + "35/24" + ], + [ + 364, + "9/8" + ], + [ + 401, + "-31/24" + ], + [ + 461, + "1/3" + ], + [ + 603, + "-2/3" + ], + [ + 608, + "2/3" + ], + [ + 675, + "9/16" + ], + [ + 693, + "35/48" + ], + [ + 716, + "9/16" + ], + [ + 735, + "-9/16" + ], + [ + 758, + "35/48" + ], + [ + 761, + "-35/48" + ], + [ + 876, + "1/12" + ], + [ + 958, + "1/12" + ], + [ + 1025, + "31/24" + ], + [ + 1038, + "-1/3" + ], + [ + 1045, + "-9/8" + ], + [ + 1052, + "-31/24" + ], + [ + 1100, + "35/12" + ], + [ + 1166, + "2/15" + ], + [ + 1278, + "-19/30" + ] + ], + "input": [ + [ + 1166, + "1" + ] + ], + "weights": [ + "1/2", + "-2/3", + "7/5" + ] + }, + { + "error": [], + "input": [ + [ + 1166, + "1" + ] + ], + "weights": [ + "1", + "1", + "1" + ] + }, + { + "error": [ + [ + 1278, + "-1250171/378840" + ] + ], + "input": [ + [ + 3, + "1" + ], + [ + 683, + "-2" + ], + [ + 1278, + "3" + ] + ], + "weights": [ + "0", + "0", + "0" + ] + }, + { + "error": [ + [ + 17, + "3750513/505120" + ], + [ + 38, + "1250171/129888" + ], + [ + 39, + "-1250171/2841300" + ], + [ + 308, + "-1250171/2841300" + ], + [ + 328, + "-38755301/9092160" + ], + [ + 362, + "1250171/259776" + ], + [ + 364, + "3750513/1010240" + ], + [ + 401, + "-38755301/9092160" + ], + [ + 461, + "1250171/1136520" + ], + [ + 603, + "-1250171/568260" + ], + [ + 608, + "1250171/568260" + ], + [ + 675, + "3750513/2020480" + ], + [ + 693, + "1250171/519552" + ], + [ + 716, + "3750513/2020480" + ], + [ + 735, + "-3750513/2020480" + ], + [ + 758, + "1250171/519552" + ], + [ + 761, + "-1250171/519552" + ], + [ + 876, + "1250171/4546080" + ], + [ + 958, + "1250171/4546080" + ], + [ + 1025, + "38755301/9092160" + ], + [ + 1038, + "-1250171/1136520" + ], + [ + 1045, + "-3750513/1010240" + ], + [ + 1052, + "-38755301/9092160" + ], + [ + 1100, + "1250171/129888" + ], + [ + 1166, + "1250171/2841300" + ], + [ + 1278, + "-23753249/11365200" + ] + ], + "input": [ + [ + 3, + "1" + ], + [ + 683, + "-2" + ], + [ + 1278, + "3" + ] + ], + "weights": [ + "1/2", + "-2/3", + "7/5" + ] + }, + { + "error": [], + "input": [ + [ + 3, + "1" + ], + [ + 683, + "-2" + ], + [ + 1278, + "3" + ] + ], + "weights": [ + "1", + "1", + "1" + ] + } + ], + "response_minor": [ + [ + "-5/2", + "0", + "5/2" + ], + [ + "5/2", + "-5/2", + "0" + ], + [ + "0", + "1/2", + "1/2" + ] + ], + "response_minor_determinant": "25/4", + "source_files": 19, + "source_graph": "6eba6bb65015df98cf103ce6d12fdd982ba4dcd24a69000bcc58e05477b17c19", + "targets": { + "1": 18, + "2": 7, + "3": 8, + "4": 235, + "5": 25, + "7": 15, + "8": 33, + "9": 538 + } +} diff --git a/research/p104-final-helper-audit/SOURCE-PINS.json b/research/p104-final-helper-audit/SOURCE-PINS.json new file mode 100644 index 0000000000..51c5030790 --- /dev/null +++ b/research/p104-final-helper-audit/SOURCE-PINS.json @@ -0,0 +1,157 @@ +{ + "schema_version": 1, + "sources": [ + { + "repository": "Clear1nsight/integer-mult-bounds", + "commit": "913fb6febe28cc3ccad1c16de8e45b8bce0da063", + "path": "research/p104-subdivided-helper-births/complex/WORD.json.gz", + "retained": "retained/source7781/complex/WORD.json.gz", + "sha256": "9b738021d71f4b9ff8c44f42c46453e5ae14846ad930a599d69546be01b1dd31", + "git_blob": "f4368731b6eef493fd7019bdfe5fa62c85c2518a" + }, + { + "repository": "Clear1nsight/integer-mult-bounds", + "commit": "913fb6febe28cc3ccad1c16de8e45b8bce0da063", + "path": "research/p104-subdivided-helper-births/complex/LAYOUT.json.gz", + "retained": "retained/source7781/complex/LAYOUT.json.gz", + "sha256": "5f44174899e3179ae27a4801c81177ddcdb049f8fd20b40e52773fdb35bf59dc", + "git_blob": "b35dc96caad38700e4019d6914f8b10b575f4c17" + }, + { + "repository": "Clear1nsight/integer-mult-bounds", + "commit": "913fb6febe28cc3ccad1c16de8e45b8bce0da063", + "path": "research/p104-subdivided-helper-births/complex/FINAL-BIRTH.json", + "retained": "retained/source7781/complex/FINAL-BIRTH.json", + "sha256": "f1fe5e6a2a651d3bbbac308b45418d2bbeb2ad45292a9781431b81a93168af79", + "git_blob": "18d111866bfe25b09acd3cef33ea62f805de811b" + }, + { + "repository": "Clear1nsight/integer-mult-bounds", + "commit": "913fb6febe28cc3ccad1c16de8e45b8bce0da063", + "path": "research/p104-subdivided-helper-births/complex/PROOF.md", + "retained": "retained/source7781/complex/PROOF.md", + "sha256": "e9fadfa8e0add48a1b45293f3e8787722666a938dc1b4df88cc0aa025a3334df", + "git_blob": "3f821272e67b077bfb3c0ad15d3a0ccb42f40e83" + }, + { + "repository": "Clear1nsight/integer-mult-bounds", + "commit": "913fb6febe28cc3ccad1c16de8e45b8bce0da063", + "path": "research/p104-subdivided-helper-births/complex/birth_replay.py", + "retained": "retained/source7781/complex/birth_replay.py", + "sha256": "65976e8e34c9c65b5e10e6c4880fb9ab7cdd9f6433c4056fe0b795eaddf29da8", + "git_blob": "df0f49de32ba9f4c376d538e4ba9a3e13ce79a34" + }, + { + "repository": "Clear1nsight/integer-mult-bounds", + "commit": "913fb6febe28cc3ccad1c16de8e45b8bce0da063", + "path": "research/p104-subdivided-helper-births/complex/final_birth.py", + "retained": "retained/source7781/complex/final_birth.py", + "sha256": "52b717ebf6a2b3d1f4c3806b32dba7c9f7555395d3cba247e693786a36fb7cce", + "git_blob": "85baca8ef2f576706724460f90ab999e420dc156" + }, + { + "repository": "Clear1nsight/integer-mult-bounds", + "commit": "913fb6febe28cc3ccad1c16de8e45b8bce0da063", + "path": "research/p104-subdivided-helper-births/SOURCE-LOCK.json", + "retained": "retained/source7781/SOURCE-LOCK.json", + "sha256": "4fad450ab3a7e237784d2d4b173ca6b33501b1c7f25241765d5bc7a597966093", + "git_blob": "48a781cd9f0f507bec68ec9a400819c186361b63" + }, + { + "repository": "Clear1nsight/integer-mult-bounds", + "commit": "913fb6febe28cc3ccad1c16de8e45b8bce0da063", + "path": "research/p104-subdivided-helper-births/README.md", + "retained": "retained/source7781/README.md", + "sha256": "c577bc08688dcb0a701955d9907454b2178496ba8b70f81c8d6ba2ad946722ee", + "git_blob": "18a5c26c2fd082c73fa7217fb39b12d25820fd32" + }, + { + "repository": "Clear1nsight/integer-mult-bounds", + "commit": "913fb6febe28cc3ccad1c16de8e45b8bce0da063", + "path": "research/p104-subdivided-helper-births/NOTICE", + "retained": "retained/source7781/NOTICE", + "sha256": "5b20e5e7321a62fc765f31114c68aaff3f6c9c8d9f7707ecfe3575ca37aee6b2", + "git_blob": "e47774f92a4984b50075df5baa7f9f885b24a6c6" + }, + { + "repository": "Clear1nsight/integer-mult-bounds", + "commit": "913fb6febe28cc3ccad1c16de8e45b8bce0da063", + "path": "research/p104-subdivided-helper-births/LICENSE", + "retained": "retained/source7781/LICENSE", + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "git_blob": "261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64" + }, + { + "repository": "aliromman/integer-mult-bounds", + "commit": "4f7c67ae387cc91580f469aeda4d508b372b9ec1", + "path": "research/p104-dual-supplier-lift/complex/birth_event.py", + "retained": "retained/algebra7776/birth_event.py", + "sha256": "b64c955e5183b93cc48fe7a1a6149b242d5e3b0e9abcdd0c64bbb4de9361995a", + "git_blob": "7ea89cbb8e12aa780afb8bea5417b7927800c207" + }, + { + "repository": "aliromman/integer-mult-bounds", + "commit": "4f7c67ae387cc91580f469aeda4d508b372b9ec1", + "path": "research/p104-dual-supplier-lift/complex/retained/CREDITS.md", + "retained": "retained/algebra7776/retained/CREDITS.md", + "sha256": "298a542162010686d1306aa9ba46f2b93f2229e383c9e57d5b9a9e816db7fc3e", + "git_blob": "a37cba81c7abca439e30303e38e392b109b68d95" + }, + { + "repository": "aliromman/integer-mult-bounds", + "commit": "4f7c67ae387cc91580f469aeda4d508b372b9ec1", + "path": "research/p104-dual-supplier-lift/complex/retained/NOTICE", + "retained": "retained/algebra7776/retained/NOTICE", + "sha256": "4e79158050dcf11ae2aa3867f15d66f4e5586e774a7167c61c2cb24bda9879b9", + "git_blob": "051d4cba2d47c65d5b2591aec77a17e7c44ed69c" + }, + { + "repository": "aliromman/integer-mult-bounds", + "commit": "4f7c67ae387cc91580f469aeda4d508b372b9ec1", + "path": "research/p104-dual-supplier-lift/complex/retained/LICENSE", + "retained": "retained/algebra7776/retained/LICENSE", + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "git_blob": "261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64" + }, + { + "repository": "aliromman/integer-mult-bounds", + "commit": "0288431ab2ad0cccfbede0b57cd3edfb2679e0f6", + "path": "research/p104-first-relay-repair/verify.py", + "retained": "retained/operator7777/verify.py", + "sha256": "71ee92e8d672d1d228838d94022d03dab1d4a1751908e411b6301a3fd94c689f", + "git_blob": "b48b3b79a752e210a1099dea0dd693bf3c4d3f27" + }, + { + "repository": "aliromman/integer-mult-bounds", + "commit": "0288431ab2ad0cccfbede0b57cd3edfb2679e0f6", + "path": "research/p104-first-relay-repair/CREDITS.md", + "retained": "retained/operator7777/CREDITS.md", + "sha256": "b01c74297e281574308fc1e205a33ddc4e401d56dc127420981abc5763b204e3", + "git_blob": "f7110cfd934ddb670bf946fb2d14cd429663c71f" + }, + { + "repository": "aliromman/integer-mult-bounds", + "commit": "0288431ab2ad0cccfbede0b57cd3edfb2679e0f6", + "path": "research/p104-first-relay-repair/LICENSE", + "retained": "retained/operator7777/LICENSE", + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "git_blob": "261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64" + }, + { + "repository": "Clear1nsight/integer-mult-bounds", + "commit": "913fb6febe28cc3ccad1c16de8e45b8bce0da063", + "path": "research/p104-subdivided-helper-births/complex/overlay.py", + "retained": "retained/source7781/complex/overlay.py", + "sha256": "acdc730d31beb9df8dbc1a8110d9dc38a35bbb1e7f8031d85905a36d2fee04f2", + "git_blob": "7049b0904ad0f1663e1d9e916e854b15a2c26f20" + }, + { + "repository": "Clear1nsight/integer-mult-bounds", + "commit": "913fb6febe28cc3ccad1c16de8e45b8bce0da063", + "path": "research/p104-subdivided-helper-births/complex/OVERLAY.json.gz", + "retained": "retained/source7781/complex/OVERLAY.json.gz", + "sha256": "8468229a087864ddb12ff98f6f5515387058345a728721f0bc5fc0e8c09e2341", + "git_blob": "c3a9132e70e6bde46976078a8606981846abf065" + } + ] +} diff --git a/research/p104-final-helper-audit/SOURCES.json b/research/p104-final-helper-audit/SOURCES.json new file mode 100644 index 0000000000..5335fa97d9 --- /dev/null +++ b/research/p104-final-helper-audit/SOURCES.json @@ -0,0 +1,18 @@ +{ + "schema_version": 1, + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "75d77b328ea02ded535e7f23aee5b1e55d0bb1a8", + "sha256": "154c3d30455d778fd3343b6b4851f0fa4665f0f7625b0adb3675e2bafbbf6bf1" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "3404fbdd5e7529a0674eef26114b5071e4586cec", + "sha256": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81" + } + ] +} diff --git a/research/p104-final-helper-audit/TASK.json b/research/p104-final-helper-audit/TASK.json new file mode 100644 index 0000000000..6251f570bf --- /dev/null +++ b/research/p104-final-helper-audit/TASK.json @@ -0,0 +1,91 @@ +{ + "schema_version": 1, + "task_id": "supplier-boundary-audit", + "priority_revision": 8, + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "original_card": { + "id": "supplier-boundary-audit", + "question": "Does one changed supplier have complete source-bound native, caller, ordinary and outer admission coverage?", + "starting_points": [ + "docs/research/current-priorities.md", + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md" + ], + "methods": [ + "Construct and independently check one source-bound instance of the stated first experiment.", + "Seek an exact counterexample or target-specific complete-budget obstruction to that same proposed change." + ], + "acceptance_gate": "Pin the current sources and one obligation; the historical owner audit is an example, not evidence of a current bug.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_selected_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read revision 8, the selected review and live exact-source handoffs. Then follow this card's bounded first_experiment.", + "scope": "Source-bound orientation only, not a supplier replay or theorem proof." + }, + "first_experiment": "Choose one latest uncovered candidate and build a delta coverage map against the selected review. For P104, #5717 changes owned-lifetime assumptions and #5719 covers exact #5713 causal premises; neither automatically transfers to #5718. For BIT, #5679/#5708 need component admission and compatible outer use. Check controls and exact source identity before reuse; stop with one resolved gap or explicit remaining obligation. A heavy full replay requires a separate serial resource budget.", + "bottleneck_link": "Judge the actual current supplier contract and complete signed target/paid bill; frozen-profile ceilings require an applicability proof.", + "allowed_variations": [ + "One exact source head, helper/cut region or quantified proposition and changed hypothesis; check live handoffs first. Different seeds are not different scopes." + ], + "scope_change_triggers": [ + "Changing source head, helper/cut domain, operation alphabet or caller boundary without recording the new scope.", + "Treating an archived proposal or local numerical pass as complete supplier admission." + ], + "overlap_terms": [ + "supplier admission", + "5717", + "5719", + "5708", + "owned lifetime" + ], + "existing_checks": [ + { + "scope": "PR #4088: author-checked local words, native receipts, owner/phase fill and exact moment.", + "evidence": "research/staged544-mixed-fourth-entry/README.md", + "remaining": "Rebind and validate ordinary/outer admission with all four providers; full mixed release not established.", + "status": "author-checked", + "source_commit": "72d7efc181edb21806a878f174847c96dd410ab0", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #3801: successor scatter-boundary decision package.", + "evidence": "research/scatter-boundary-decision/README.md", + "remaining": "Consult its exact acceptance scope before any new exporter audit; not proof of a selected failure.", + "status": "author-checked", + "source_commit": "911f8800ba7a4b03603ef62c5ffc6240e53cb5fd", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "Selected PR5599: complete helper-subspace construction and independent caller replay; five framework assumptions remain.", + "evidence": "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md", + "remaining": "The next experiment must identify uncovered source-specific work. Successor archive intake does not transfer this admission.", + "status": "reviewed", + "source_commit": "09dd0965711ca7eeb169057a420abab1c9052137", + "selected_record_sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5" + } + ] + }, + "scope_status": "changed", + "actual_scope": "Independent audit of the final rational helper split in PR7781, including the complete three-pulse weight error space and all arbitrary-input and adjoint coefficients.", + "scope_change_reason": "Take the final-split independent-check request on the newly published exact source head.", + "bottleneck_link": "Check whether the zero-new-MOVE helper return preserves all other owners and gives the claimed productive rank change.", + "budget_minutes": 60, + "stop_rule": "Stop after the exact final-split map, pulse error space and local paid/target invoice; do not infer complete supplier admission.", + "outcome": "completed", + "evidence": "PROOF.md gives the inverse reconstruction and exact pulse-weight law. RESULT.json records full coefficient checks and negative controls.", + "author": "Ali Romman", + "ai_assistance": "Substantial OpenAI Codex assistance in research, implementation, verification and writing", + "open_questions": [ + { + "question": "Does the full caller preserve this exact native boundary with the stated finite ordinary allowance?", + "why_it_matters": "The scalar graph and local rank delta do not certify the full finite application.", + "first_step": "Use the published source-bound application and inspect its owner and ordinary-cost obligations.", + "blocked_by": "This audit does not replay the physical compiler or complete caller." + } + ] +} diff --git a/research/p104-final-helper-audit/VERIFY.json b/research/p104-final-helper-audit/VERIFY.json new file mode 100644 index 0000000000..9d34317cd8 --- /dev/null +++ b/research/p104-final-helper-audit/VERIFY.json @@ -0,0 +1,32 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [], + "commands": [ + { + "argv": [ + "{python}", + "-W", + "error", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 180, + "checks": "Check the exact inverse graph, all forward and adjoint coefficients, all pulse omission subsets, rational weight error space, charts and unchanged paid invoice." + }, + { + "argv": [ + "{python}", + "-W", + "error", + "-O", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 180, + "checks": "Check the exact inverse graph, all forward and adjoint coefficients, all pulse omission subsets, rational weight error space, charts and unchanged paid invoice." + } + ] +} diff --git a/research/p104-final-helper-audit/retained/.gitattributes b/research/p104-final-helper-audit/retained/.gitattributes new file mode 100644 index 0000000000..fa1385d99a --- /dev/null +++ b/research/p104-final-helper-audit/retained/.gitattributes @@ -0,0 +1 @@ +* -text diff --git a/research/p104-final-helper-audit/retained/algebra7776/birth_event.py b/research/p104-final-helper-audit/retained/algebra7776/birth_event.py new file mode 100644 index 0000000000..7ea89cbb8e --- /dev/null +++ b/research/p104-final-helper-audit/retained/algebra7776/birth_event.py @@ -0,0 +1,79 @@ +"""Apply one helper split to an oriented scalar communication network.""" + +from fractions import Fraction + + +def linear_combination(destination, source, scale): + for index, coefficient in source.items(): + value = destination.get(index, 0) + scale * coefficient + if value: + destination[index] = value + else: + destination.pop(index, None) + + +def read_row(items): + row = {index: Fraction(text) for index, text in items} + if [[index, str(row[index])] for index in sorted(row)] != items or not all(row.values()): + raise ValueError("noncanonical split row") + return row + + +def apply_split(net, event): + """Use the direction specified in the event before this call.""" + first = net.first_output + role = event["role"] + chart = event["split_chart"] + if (net.initial[role], net.final[role]) != (event["source_chart"], event["return_chart"]): + raise ValueError("helper split boundary") + direction = read_row(event["source_direction"]) + probe = read_row(event["source_covector"]) + readout = read_row(event["readout"]) + response = read_row(event["return_direction"]) + decode = read_row(event["return_covector"]) + calibration = read_row(event["calibration"]) + pulse = read_row(event["pulse"]) + input_scale = sum(probe.get(i, 0) * v for i, v in direction.items()) + output_scale = sum(decode.get(i, 0) * v for i, v in response.items()) + if not input_scale or not output_scale or not response.get(role): + raise ValueError("zero helper split pivot") + if not all(net.initial[i] == net.initial[role] for i in direction.keys() | probe.keys()): + raise ValueError("source vectors use different charts") + if not all(net.final[i] == net.final[role] for i in response.keys() | decode.keys()): + raise ValueError("return vectors use different charts") + fresh = len(net.initial) + # The old input value has coordinate role set to zero before it receives the source direction. + multiplier = {~i: -v / input_scale for i, v in probe.items() if i != role} + multiplier[~role] = 1 / input_scale + + def change_inputs(row): + coefficient = sum(row.get(~i, 0) * value for i, value in direction.items()) + if not coefficient and ~role not in row: + return row + changed = dict(row) + changed.pop(~role, None) + linear_combination(changed, multiplier, coefficient) + return changed + + rows = {k: change_inputs(a) for k, a in net.forms.items()} + observed = change_inputs(readout) + excitation = {~fresh: 1 / output_scale} + linear_combination(excitation, change_inputs(calibration), -1 / output_scale) + for k, coefficient in pulse.items(): + row = dict(rows[k]) + linear_combination(row, excitation, coefficient) + rows[k] = row + returned = {} + for i, coefficient in decode.items(): + linear_combination(returned, rows[first + i], coefficient) + pivot = rows[first + role] + for i, coefficient in response.items(): + if i != role: + row = dict(rows[first + i]) + linear_combination(row, pivot, -coefficient / response[role]) + rows[first + i] = row + rows[first + role] = observed + rows[first + fresh] = returned + final = net.final + [net.final[role]] + final[role] = chart + return type(net)(first, net.initial + [chart], final, dict(net.moves), rows) diff --git a/research/p104-final-helper-audit/retained/algebra7776/retained/CREDITS.md b/research/p104-final-helper-audit/retained/algebra7776/retained/CREDITS.md new file mode 100644 index 0000000000..a37cba81c7 --- /dev/null +++ b/research/p104-final-helper-audit/retained/algebra7776/retained/CREDITS.md @@ -0,0 +1,9 @@ +# Credit and source record + +Ali Romman prepared the new graph, edit journal, mixed caller, exact replays and price comparison with substantial OpenAI Codex assistance in research, implementation, verification and writing. New material uses Apache-2.0. The checks in this package are author verification. [License](LICENSE) · [Original notices](credits) + +PR 7726 supplies the base graph, public labels, scalar operator, signed caller, previous complete invoice, and the starting versions of the native physical and reverse checks. Its scientific commit is `3ba9094c54b61f424d2f98cd2c6ca64c01baf9d3`. The unpacked base graph is the byte-exact output of its construction. The interface export keeps the port assignments and original public labels. The file inventory distinguishes source blobs from generated exports. The source manifest pins the two chart engines and the two comparison scripts in canonical main. [Parent PR](https://github.com/CrocSwap/integer-mult-bounds/pull/7726) · [Parent credit](credits/7726-CREDITS.md) · [File pins](SOURCE-PINS.json) · [Repository inputs](SOURCES.json) + +The new paid basis changes, grouped source and return equations and direct relay extend earlier work. Clear1nsight supplied the causal split, the banked relay and the physical execution engine. DreamingOfClouds supplied literal helper splits and the exploratory banked-circuit toolkit with Claude assistance. Ali Romman supplied earlier scalar restrictions and recodings. SYLforge supplied the source word and signed caller. [Causal split](https://github.com/CrocSwap/integer-mult-bounds/pull/7697) · [Banked relay](https://github.com/CrocSwap/integer-mult-bounds/pull/7704) · [Literal splits](https://github.com/CrocSwap/integer-mult-bounds/pull/7712) · [Toolkit](https://github.com/CrocSwap/integer-mult-bounds/pull/7727) · [Signed word](https://github.com/CrocSwap/integer-mult-bounds/pull/7700) + +Rohan Arun's mirrored caller and DreamingOfClouds's nested caller flags informed the new pair of conjugate streams. Douglas Colkitt supplied the absolute phase and compiler framework. Jerry Chen / CubeJerry supplied the selected complex and BIT application. DreamingOfClouds supplied the signed-curvature interval gate with Claude Opus 5.5 assistance. The retained notices credit mightyOil, unpaidmoon, icekylinx and the other authors of the underlying results. The caller proof gives the source and author for each new caller file. [Caller credit](MIXED-PROOF.md#credit-and-file-sources) · [Original application](https://github.com/CrocSwap/integer-mult-bounds/pull/7000) · [Signed-curvature proof](https://github.com/CrocSwap/integer-mult-bounds/pull/7618) diff --git a/research/p104-final-helper-audit/retained/algebra7776/retained/LICENSE b/research/p104-final-helper-audit/retained/algebra7776/retained/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/p104-final-helper-audit/retained/algebra7776/retained/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/p104-final-helper-audit/retained/algebra7776/retained/NOTICE b/research/p104-final-helper-audit/retained/algebra7776/retained/NOTICE new file mode 100644 index 0000000000..051d4cba2d --- /dev/null +++ b/research/p104-final-helper-audit/retained/algebra7776/retained/NOTICE @@ -0,0 +1,3 @@ +Apache License 2.0. Ali Romman prepared the new P104 construction and verification with substantial OpenAI Codex assistance. + +Retain CREDITS.md, LICENSE, SOURCE-PINS.json, SOURCES.json and the notices in credits/ with this package. They identify the authors, source commits and licenses of the parent, causal split, physical and caller engines, signed-curvature interval gate and chart-operator checks. diff --git a/research/p104-final-helper-audit/retained/operator7777/CREDITS.md b/research/p104-final-helper-audit/retained/operator7777/CREDITS.md new file mode 100644 index 0000000000..f7110cfd93 --- /dev/null +++ b/research/p104-final-helper-audit/retained/operator7777/CREDITS.md @@ -0,0 +1,30 @@ +# Credit and source record + +Ali Romman prepared this audit, exact residual law, bank separation certificate +and checker with substantial OpenAI Codex assistance in research, implementation, +verification and writing. New material is under Apache-2.0. + +Clear1nsight supplied the joint construction, ordered paid edits, graph bridge +and review request in [PR #7774](https://github.com/CrocSwap/integer-mult-bounds/pull/7774). +The retained [source notice](retained/pr7774/NOTICE) states the contribution and +its Codex assistance. The two parent graph differentials and their constructors +come from Clear1nsight's [PR #7767](https://github.com/CrocSwap/integer-mult-bounds/pull/7767). +They are retained without changes. This audit does not claim their construction +as new work. + +Ali Romman supplied the published graph and released supplier. The graph file +comes from the public supplier at +[commit 6b0b2f7d](https://github.com/aliromman/integer-mult-bounds/tree/6b0b2f7de0f068834264fc50b75a39a72c52ea22/research/p104-dual-supplier-lift/complex). +Its parent is the [PR #7756 scientific source](https://github.com/aliromman/integer-mult-bounds/tree/9e051455757d1cc86b822e52e42e1e1c98ead417/research/p104-parallel-bank-punctures). +The parent credit, source manifests, license and original notices are retained +in [donor-notices](retained/donor-notices). + +The notices credit DreamingOfClouds, with Claude assistance, for the hub routes, +banked toolkit and signed-curvature gate; SYLforge for the signed word; +Rohan Arun for the mirrored caller; Douglas Colkitt for the absolute-phase and +compiler framework; Jerry Chen (CubeJerry) for the selected application; and +the earlier engine and geometry contributors. Their physical checks are not +rerun by this rational audit. + +[SOURCE-PINS.json](SOURCE-PINS.json) gives the exact original Git object and +SHA256 for every retained file. The verifier checks both hashes before use. diff --git a/research/p104-final-helper-audit/retained/operator7777/LICENSE b/research/p104-final-helper-audit/retained/operator7777/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/p104-final-helper-audit/retained/operator7777/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/p104-final-helper-audit/retained/operator7777/verify.py b/research/p104-final-helper-audit/retained/operator7777/verify.py new file mode 100644 index 0000000000..b48b3b79a7 --- /dev/null +++ b/research/p104-final-helper-audit/retained/operator7777/verify.py @@ -0,0 +1,267 @@ +"""Check one P104 repair with exact rational operators and a bank separator.""" +from fractions import Fraction as F +from graphlib import TopologicalSorter +from hashlib import sha1, sha256 +from math import gcd, lcm +from pathlib import Path +import argparse +import gzip +import importlib.util +import json +import time + +HERE = Path(__file__).resolve().parent + + +def need(ok, message): + if not ok: + raise ValueError(message) + + +def read(path): + raw = path.read_bytes() + return json.loads(gzip.decompress(raw) if raw[:2] == b'\x1f\x8b' else raw) + + +def encoded(value): + return json.dumps(value, sort_keys=True, separators=(',', ':')).encode() + + +def load(name, path): + spec = importlib.util.spec_from_file_location(name, path) + module = importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + return module + + +def sources(): + pins = read(HERE / 'SOURCE-PINS.json')['sources'] + for pin in pins: + raw = (HERE / pin['retained']).read_bytes() + need(sha256(raw).hexdigest() == pin['sha256'], 'source SHA256') + need(sha1(b'blob '+str(len(raw)).encode()+b'\0'+raw).hexdigest() == pin['git_blob'], 'source Git blob') + return len(pins) + + +def unpack(graph): + return ({k: (a, b) for k, a, b in graph['moves']}, + {k: {j: F(q) for j, q in row} for k, row in graph['forms']}) + + +def span(frame): + values = {0} + for x in frame: + need(x not in values, 'independent chart basis') + values |= {x ^ y for y in values} + return values + + +def order(graph, moves, rows): + first = graph['first_output'] + charts = {~i: c for i, c in enumerate(graph['initial'])} + need(set(rows) == set(moves) | set(range(first, first+len(graph['initial']))), 'complete row inventory') + sequence = list(TopologicalSorter({k: [j for j in row if j >= 0] for k, row in sorted(rows.items())}).static_order()) + spans = [span(f) for f in graph['frames']] + for k in sequence: + chart = moves[k][0] if k in moves else graph['final'][k-first] + need(all(j in charts and charts[j] == chart for j in rows[k]), 'available same-chart donor') + if k in moves: + a, b = moves[k] + need(spans[a] < spans[b] or spans[b] < spans[a], 'strictly nested paid charts') + charts[k] = b + return sequence + + +def edit(moves, rows, delta): + moves, rows = moves.copy(), rows.copy() + for k, before, after in delta['moves']: + need(moves.get(k) == (None if before is None else tuple(before)), 'paid preimage') + if after is None: + del moves[k] + else: + moves[k] = tuple(after) + for k, existed, kept, changes in delta['forms']: + need((k in rows) == existed, 'row presence') + row = rows.get(k, {}).copy() + for j, old, new in changes: + need(row.get(j) == (None if old is None else F(old)), 'coefficient preimage') + if new is None: + del row[j] + else: + row[j] = F(new) + if kept: + rows[k] = row + else: + need(not row, 'empty retired row') + del rows[k] + return moves, rows + + +def expand(graph, moves, rows): + values = {~i: (1, {i: 1}) for i in range(len(graph['initial']))} + products = 0 + for k in order(graph, moves, rows): + parts = [(values[j], q) for j, q in rows[k].items()] + den = lcm(*(d*q.denominator for (d, _), q in parts)) + total = {} + for (d, vector), q in parts: + factor = den//(d*q.denominator)*q.numerator + for j, v in vector.items(): + total[j] = total.get(j, 0)+factor*v + products += 1 + total = {j: v for j, v in total.items() if v} + common = gcd(den, *total.values()) + values[k] = (den//common, {j: v//common for j, v in total.items()}) + return values, products + + +def vector(value): + den, row = value + return {j: F(v, den) for j, v in row.items()} + + +def add(row, other, factor): + for j, v in other.items(): + new = row.get(j, 0)+factor*v + if new: + row[j] = new + else: + row.pop(j, None) + return row + + +def reduced(row, basis): + row = row.copy() + while row: + j = max(row) + if j not in basis: + break + add(row, basis[j], -row[j]) + return row + + +def dot(a, b): + return sum(v*b.get(j, 0) for j, v in a.items()) + + +def terms(row): + return [[j, str(v)] for j, v in sorted(row.items()) if v] + + +def scalar(graph, moves, rows, input_values, pulses=()): + values = {~i: input_values.get(i, F(0)) for i in range(len(graph['initial']))} + for k in order(graph, moves, rows): + values[k] = sum(q*values[j] for j, q in rows[k].items())+dict(pulses).get(k, F(0)) + return values + + +def run(): + pin_count = sources() + retained = HERE / 'retained' + prior = load('prior7767', retained/'pr7767/verify.py') + bridge = load('bridge7774', retained/'pr7774/rebase_pr7767.py') + raw = read(retained/'donor/GRAPH.json.gz') + need(sha256(encoded(raw)).hexdigest() == prior.PARENT_GRAPH, 'published parent graph') + before = prior.apply_stack(prior.apply_delta(raw, read(retained/'pr7767/DELTA.json')), read(retained/'pr7767/STACK-DELTA.json')) + before = json.loads(encoded(before)) + patch = read(retained/'pr7774/PR7767-TO-JOINT.json.gz') + graph = bridge.apply(before, patch) + need(bridge.apply(graph, patch, reverse=True) == before, 'literal reverse bridge') + journal = read(retained/'pr7774/PAID-EDITS.json') + need(sha256(encoded(graph)).hexdigest() == journal['inherited_graph'], 'exact edit input') + moves0, rows0 = unpack(graph) + first_edit = journal['ordered_edits'][0] + need(first_edit['start'] == 99771, 'named first edit') + moves, rows = edit(moves0, rows0, first_edit['delta']) + old, old_products = expand(graph, moves0, rows0) + new, new_products = expand(graph, moves, rows) + first, count = graph['first_output'], len(graph['initial']) + need(count == 1264 and all(old[first+i] == new[first+i] for i in range(count)), 'all input/output rational coefficients') + x = vector(new[53]) + need(x == vector(old[99771]), 'repair is the removed source value') + need(vector(new[96048]) == add(vector(old[96048]), x, -4), 'exact slope-four source substitution') + quotient = add({j:-v for j,v in vector(new[103626]).items()}, vector(new[103736]), F(2)) + difference = add(vector(old[104247]), quotient, F(-1)) + need(difference == {j:2*v for j,v in x.items()}, 'terminal quotient leaves exactly twice the repair') + need(all(53 not in rows[k] for k in moves), 'repair has terminal-only readers') + a = scalar(graph, moves, rows, {}, [(96048, F(1))]) + b = scalar(graph, moves, rows, {}, [(53, F(1))]) + need((a[first+186], b[first+186], a[first+38], b[first+38]) == (F(-1,4), 0, 2, 16), 'nonzero residual minor') + need(x[25] == F(-1,2), 'source witness input') + # Every retained bank is allowed, even if it is too late for a specific terminal. + bank = sorted([k for k, (_, c) in moves.items() if c == 127 and k != 53] + + [~i for i, c in enumerate(graph['initial']) if c == 127]) + basis = {} + for k in bank: + row = reduced(vector(new[k]), basis) + if row: + pivot = max(row) + basis[pivot] = {j: v/row[pivot] for j, v in row.items()} + residual = reduced(x, basis) + need(residual and len(bank) == len(basis) == 907, 'missing repair direction') + free = max(residual) + witness = {free: F(1)} + for pivot in sorted(basis): + value = -dot(basis[pivot], witness) + if value: + witness[pivot] = value + need(all(dot(vector(new[k]), witness) == 0 for k in bank), 'separator annihilates every receiving bank') + separated = dot(x, witness) + need(separated == residual[free] and separated, 'separator detects required value') + # Direct runs check the symbolic law, including an attempted compensation at output 38. + controls = [] + for slope, repair in [(3, 1), (4, 0), (0, F(1,2)), (F(7,3), F(-2,5)), (4, 1)]: + changed = rows.copy() + changed[96048] = add(rows[96048].copy(), rows[53], F(4)-slope) + changed[53] = {j: repair*q for j, q in rows[53].items() if repair*q} + got = scalar(graph, moves, changed, {25: F(1)}) + expected = scalar(graph, moves0, rows0, {25: F(1)}) + errors = {} + for i in range(count): + actual = got[first+i]-expected[first+i] + need(actual == x[25]*((4-slope)*a[first+i]+(repair-1)*b[first+i]), 'two-parameter residual law') + if actual: + errors[i] = actual + need(bool(errors) == ((slope, repair) != (4, 1)), 'mutation outcome') + controls.append(dict(slope=str(slope), repair=str(repair), changed_outputs=len(errors), output186=str(errors.get(186,0)), output38=str(errors.get(38,0)))) + bad_moves = moves.copy();bad_moves[53] = (859,127) + try: + order(graph, bad_moves, rows) + except ValueError: + pass + else: + raise ValueError('wrong source chart accepted') + # Follow the original identifiers through all later edits before checking the final witness. + final_moves, final_rows = moves, rows + for entry in journal['ordered_edits'][1:]: + final_moves, final_rows = edit(final_moves, final_rows, entry['delta']) + sequence = order(graph, final_moves, final_rows) + final_graph = dict(graph, moves=[[k,*v] for k,v in sorted(final_moves.items())], + forms=[[k,terms(row)] for k,row in sorted(final_rows.items())], schedule=sequence) + need(sha256(encoded(final_graph)).hexdigest() == journal['final_graph'], 'complete submitted graph') + final_values = scalar(graph, final_moves, final_rows, {1:F(1)}) + lost = -final_rows[first+19][53]*final_values[53] + need(lost == -8, 'independent final-word omission witness') + omissions = read(retained/'pr7774/evidence/omissions.json') + need(next(w for w in omissions['witnesses'] if w['paid_slot']==53) == dict(input_role=1,output_role=19,paid_slot=53,omitted_minus_qualified_coefficient='-8'), 'source omission agreement') + rank = lambda pair: abs(len(graph['frames'][pair[0]])-len(graph['frames'][pair[1]])) + need([rank(moves0[k]) for k in (99771,104247)] == [2,3] and rank(moves[53]) == 5, 'paid replacement ranks') + return dict(source_files=pin_count,source_graph=journal['inherited_graph'],final_graph=journal['final_graph'], + owners=count,before_paid=len(moves0),after_paid=len(moves),changed_forms=len(first_edit['delta']['forms']), + exact_scalar_products=old_products+new_products,repair=terms(x), + terminal_responses=[[i,str(a[first+i]),str(b[first+i])] for i in range(count) if a[first+i] or b[first+i]], + separator=dict(bank_count=len(bank),rank=len(basis),bank_ids=bank,free_coordinate=free,input=terms(witness),repair_value=str(separated)), + controls=controls,final_omission=dict(input_role=1,output_role=19,coefficient=str(lost)),wrong_chart_rejected=True,terminal_quotient_repair_coefficient='2') + + +if __name__ == '__main__': + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--record', action='store_true') + args = parser.parse_args() + start = time.monotonic() + result = run() + if args.record: + (HERE/'RESULT.json').write_text(json.dumps(result, indent=2)+'\n') + else: + need(result == read(HERE/'RESULT.json'), 'deposited certificate') + print('PASS_P104_FIRST_RELAY_REPAIR', result['owners'], 'owners', len(result['terminal_responses']), 'affected outputs', result['separator']['bank_count'], 'separated banks', round(time.monotonic()-start,2), 'seconds') diff --git a/research/p104-final-helper-audit/retained/source7781/LICENSE b/research/p104-final-helper-audit/retained/source7781/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/p104-final-helper-audit/retained/source7781/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/p104-final-helper-audit/retained/source7781/NOTICE b/research/p104-final-helper-audit/retained/source7781/NOTICE new file mode 100644 index 0000000000..e47774f92a --- /dev/null +++ b/research/p104-final-helper-audit/retained/source7781/NOTICE @@ -0,0 +1,20 @@ +Paid subdivisions on both P104 suppliers + +Clear1nsight prepared the new binary and rational subdivisions, construction journals, +independent checks and compilation with substantial OpenAI Codex assistance. New +material is offered under Apache-2.0. + +Ali Romman supplied the exact dual supplier in PR #7776, including the residual +binary emitter, productive basis operations, paid layouts, caller and common +finite application. Jerry Chen (CubeJerry) supplied the selected #7000/#7001 +ordinary application. DreamingOfClouds supplied the paired caller and shared +native helper framework. The word and compiler descend from zxv and other +contributors to #6726. PR #7774 supplies closed-caller relay journals, exact +product-grid arithmetic and an independent directed price routine. SYLforge, +Rohan Arun, Cinna Davis and Douglas Colkitt contributed earlier caller, carrier +and physical or analytic frameworks. The source preparation helper is adapted +from Clear1nsight's PR #7774 under Apache-2.0. + +The exact upstream sources and retained notices are identified in SOURCE-LOCK.json. +The reproduction commands fetch all cited mathematical program files from the +pinned public source trees and verify their digests. diff --git a/research/p104-final-helper-audit/retained/source7781/README.md b/research/p104-final-helper-audit/retained/source7781/README.md new file mode 100644 index 0000000000..18a5c26c2f --- /dev/null +++ b/research/p104-final-helper-audit/retained/source7781/README.md @@ -0,0 +1,46 @@ +# Paid subdivisions on both suppliers + +**Conditional κ ≥ 0.00386969949992** for a complete multiplication using 36 ordinary binary calls and the closed 48-call P104 complex supplier. The directed gain over the largest submitted predecessor’s joint raw upper endpoint is **0.00001073765744**. The construction starts from Ali Romman’s exact #7776 binary and complex words. [PR #7776](https://github.com/CrocSwap/integer-mult-bounds/pull/7776) + +| Compared construction | Directed endpoint | Excess of the candidate’s finite lower | +| --- | ---: | ---: | +| Submitted dual supplier #7776, joint raw upper | 0.00385896184248 | 0.00001073765744 | +| #7776 complex word given the new binary service, complex raw upper | 0.00385932267588 | 0.00001037682404 | +| Fixed round target | 0.00386380485468 | 0.00000589464524 | + +The original selected result was κ ≥ 0.00363005817 from #7000 when this package was prepared. The predecessor's finite lower is 0.00385896148992. Its unchanged binary word crosses below 0.00385896184248, and its unchanged complex word crosses below 0.00385932267588. Giving that complex word the new ordinary service yields the separate finite checkpoint 0.00385932267579. These comparisons use the same signed rank tariff, caller conventions and five outer assumptions. [First joint checkpoint](evidence/unchanged-complex-application.json) · [Selected result](https://github.com/CrocSwap/integer-mult-bounds/blob/e54523517d0f03e58352e647c403a5af3e525a57/certificates/selected-result.json) + +## Construction and cost + +An existing paid transfer can sometimes be subdivided at an intermediate chart. For each accepted subdivision the construction gives a local readout that retires an original arbitrary input, a calibrated independent input at the new chart, and an impulse that reaches the intended output. The verifier checks the later consumers and the full operator in both directions. It charges the two new paid legs and credits both productive legs in place of their original entries. The numerical saving comes from their different rank distributions under `H(r) = r^(1−κ)`. [Binary derivation](binary/PROOF.md) · [Rational derivation](complex/PROOF.md) + +The binary word uses 21 subdivisions, checks all 672 independent public fields in both directions, and retains 36 caller invocations. The ordinary compiler admits **0.00386969950**. The rational carrier has 14 productive subdivisions on the #7776 word. The final fixed-boundary changes relocate four local scalar banks and replace two paid transfers of ranks 1 and 3 with one rank-4 return. A further same-chart split on owner 1164 creates an independent productive return without another paid transfer. The proof records each of these changes against its immediate parent. + +| Complete bill | Binary | Complex | +| --- | ---: | ---: | +| Native calls | 36 | 48 | +| Paid positions | 107,532 | 283,488 | +| Productive positions | 20,418 | 52,032 | +| Ordinary record allowance used | 933,004,517,520 | 151,885,612,032 | +| Raw crossing | 0.003870038707744–0.003870038707745 | 0.00386981257852–0.00386981257853 | + +The binary construction requires 6,998,328 owned fields. The complex accounting includes 1,288,991,232 scalar services and 142,464 odd conversions. The test covers 1,279 rational public outputs and their adjoints, overwritten sender fields, source-home cleanup, physical adapters, both finite compilers and a common root-envelope depth guard. [Complete signed and ordinary invoices](evidence/application.json) · [Binary finite certificate](binary/FINITE.json) · [Independent rational operator](complex/INDEPENDENT.json) + +## Reproduce + +The source lock binds the public #7776 scientific tree at `4f7c67ae387cc91580f469aeda4d508b372b9ec1` and the #7774 product-grid and directed-root routines at `22fff773f897e70a2c346d09de62515fadb1c445`. All checks use standard-library Python 3.12. From this directory, use fresh source and output directories for these commands. + +```sh +python3 -IB prepare_sources.py /tmp/p104-birth-sources --fetch +for part in binary construction operator application charts-0 charts-1 charts-2; do + python3 -IB verify.py --cache /tmp/p104-birth-sources --out "/tmp/p104-birth-$part" --part "$part" || exit 1 +done +``` + +The pure rational birth journal records every replaced owner, paid sender, local coefficient and necessary return. The final coefficient journal checks each changed literal against its parent and validates the resulting topological order. The binary and complex operator checks mutate a paid read or return and exercise a dirty CLEAR. The physical catalogue checks the signed phases, including the relative maps between charts. [Source pins](SOURCE-LOCK.json) · [Frozen identities](CLAIM.json) · [Rational birth journal](complex/BIRTHS.json) · [Bank and sparse projection derivation](complex/REFINEMENTS.md) · [Final unpaid split](complex/FINAL-BIRTH.json) + +## Open next questions + +The conditional application retains native all-column correctness, owned erasure, the compiler model, precision-tape simulation and analytic recovery. The finite programs establish the listed instances inside that framework. Maintainers determine frontier admission. An independent next check is to pick the first rational birth in the journal, remove its paid return, and compare the affected arbitrary input and adjoint coefficient with the signed bill. A compiler or theorem review can then examine the shared outer and finite parameter inequalities. [Selected framework](https://github.com/CrocSwap/integer-mult-bounds/blob/e54523517d0f03e58352e647c403a5af3e525a57/docs/research/pr-intake-evidence/pr7000-application/PROOF-REVIEW.md) + +Ali Romman supplied the dual construction and its eight binary punctures. Jerry Chen (CubeJerry), DreamingOfClouds, zxv, SYLforge, Rohan Arun, Cinna Davis, Douglas Colkitt, Clear1nsight and the cited predecessors supplied the selected application, callers, physical engines and compiler checks. Clear1nsight prepared this contribution with substantial OpenAI Codex assistance for construction, programming and independent computational review. [PR #7776](https://github.com/CrocSwap/integer-mult-bounds/pull/7776) · [PR #7774](https://github.com/CrocSwap/integer-mult-bounds/pull/7774) · [Notice](NOTICE) diff --git a/research/p104-final-helper-audit/retained/source7781/SOURCE-LOCK.json b/research/p104-final-helper-audit/retained/source7781/SOURCE-LOCK.json new file mode 100644 index 0000000000..48a781cd9f --- /dev/null +++ b/research/p104-final-helper-audit/retained/source7781/SOURCE-LOCK.json @@ -0,0 +1,363 @@ +{ + "schema": 1, + "sources": { + "peer": { + "commit": "22fff773f897e70a2c346d09de62515fadb1c445", + "files": { + "qualification.py": { + "blob": "0a4da90525f56925adee5be214ad8c11a3f52fc5", + "sha256": "281efa4628f088340865d6f3d72c3e416f96f90d1fa881214181cd955071243a" + } + }, + "path": "research/p104-closed-supplier-relays", + "repository": "Clear1nsight/integer-mult-bounds" + }, + "source": { + "commit": "4f7c67ae387cc91580f469aeda4d508b372b9ec1", + "files": { + "certificates/frontier7000/CLAIM.json": { + "blob": "c9b816f8445be9dc19b2259e03e9d8709d18c87a", + "sha256": "3f8add8252adb223b60418ec69351a69b6b5edfe601ec1c6b4b65cd9e2afd9b2" + }, + "research/p104-dual-supplier-lift/BIT-PROOF.md": { + "blob": "ee84300fd31f786b9df4a6977c1b99c8bac051a8", + "sha256": "c87bd698ec5d9bb8741d509bc1d2f7d421d9686a95b515829c5c042a0a71f15b" + }, + "research/p104-dual-supplier-lift/BIT-RESULT.json": { + "blob": "79acadc0d03146c060e09e640534f5d5f4456db8", + "sha256": "907858ba4c6f4c110662c8ea9faa1209acca07a9ae281ba29e9291a41fe8e6e1" + }, + "research/p104-dual-supplier-lift/README.md": { + "blob": "1c7e7583b4b19d0a724b697d2d694c487c6bfd83", + "sha256": "14ed292b5b586b1df8d9ec6207e0df02cbe96789ac06f04f610ec1feb61a0321" + }, + "research/p104-dual-supplier-lift/SOURCES.json": { + "blob": "d89793055ca4a1ff5a5d3c9fce207feb27d01143", + "sha256": "1415841c2af154273b9c1064400842b8a799a6bf29f2779f5cd18d5054917bdd" + }, + "research/p104-dual-supplier-lift/TASK.json": { + "blob": "99847861c26a4fd9efe55a918ca29e3770b5797e", + "sha256": "a1119a911d99b20bb57628d842e4047a0d43e545a889e709b7b1e55c8fb79f24" + }, + "research/p104-dual-supplier-lift/VERIFY.json": { + "blob": "14ac0ae0e89ce8b1621980e44f9f8a99ca5a2f7e", + "sha256": "1d39cea59e93e842b31188a5cc9025141dfdad0299f4fda2dfec8617e4dd8f9e" + }, + "research/p104-dual-supplier-lift/bit_application.py": { + "blob": "2c67be79f56b8c4c29cf74ca3d12b3ca113a6d2d", + "sha256": "fa76543d0aa0d515b48eaa9516f73df2c34a5f482114080fe3bcd6d37c32bbbd" + }, + "research/p104-dual-supplier-lift/bit_native.py": { + "blob": "86d88d7ed25ab24662e82b51dc0180e5af7b3d4f", + "sha256": "4368c62a5d42f81189d6776b8dba8c85a311b6a199b816244b545c6bb7d3dc1e" + }, + "research/p104-dual-supplier-lift/complex/BANK-EDITS.json": { + "blob": "f0605faa932f1cc7ac69ea4870710bed4f53d658", + "sha256": "8a02af7965c1c9154487b861d2fac57d9e1cd250c2f141fc45e5226ffef75752" + }, + "research/p104-dual-supplier-lift/complex/BASIS-EDITS.json.gz": { + "blob": "485c0d907566cf5fed1493d1aace80ae329f8d7d", + "sha256": "e9ddc5db956aca18f5dbc5a543d08c798bb3fffc437410580700073e6d95abc4" + }, + "research/p104-dual-supplier-lift/complex/CALLER.md": { + "blob": "f7cc8518946e44afec48b35f16d1afd8f700f0ae", + "sha256": "bcd3433270d0016a3a9704aac5f85916e5f38f58771aa8ff9a8de3992c5fa3bd" + }, + "research/p104-dual-supplier-lift/complex/CHARTS-0.json": { + "blob": "ad2897c6d58f46692519b34d3e8c7c12823cc555", + "sha256": "172e3465c72d89b761c822d656e7138266dc00b03ce46640465a1258c496e3d9" + }, + "research/p104-dual-supplier-lift/complex/CHARTS-1.json": { + "blob": "949aa8667f681d9508ee5315fce81ada52aaf676", + "sha256": "d1574787c9573dc621151d614db3b35d96a883bf51a6c9e8c4babb4fa9e9e468" + }, + "research/p104-dual-supplier-lift/complex/CHARTS-2.json": { + "blob": "7df5dda1e34085287335890d2fa463eb2d86d6ad", + "sha256": "14e4dd2c8b9a05c2f6c2cb6e2cfdf65f69df46cbf8f05397413695267b57c1e1" + }, + "research/p104-dual-supplier-lift/complex/GRAPH.json.gz": { + "blob": "a38668562cb18bd1a0319b17ead3c2a9ebd7d059", + "sha256": "584a1bc9e6d6ea5e9abf0c115c66c56f9447466f19b1a0393e7d8b6128c45f92" + }, + "research/p104-dual-supplier-lift/complex/JOINT-EDITS.json.gz": { + "blob": "d853dee0c7f8f695e392add71710b3b6dbbd785d", + "sha256": "a8e047863f2b59ecf495e14aa9299071c2de3915dcf598a441145d631d75e016" + }, + "research/p104-dual-supplier-lift/complex/LAYOUT.json.gz": { + "blob": "fafa7afbd4f5a4f14432b33d32e8cc089fbdf864", + "sha256": "6ca5f70604fbb81fc44e498f7b1450c37214b7cc95f9848e7b8be031adb99b34" + }, + "research/p104-dual-supplier-lift/complex/NATIVE-GRID.json": { + "blob": "d5926ab3e9615eb8ff750ae62c20e127c2dd8898", + "sha256": "c5beae5fec23e0f550cd5029c37dd697d95e8bfe7a2f82ded0a5623ea516bc41" + }, + "research/p104-dual-supplier-lift/complex/PARENT-SOURCES.json": { + "blob": "f89e4c06ac7fe727abf61c682929f92b53acdb7f", + "sha256": "3aa354c829da73985f8f34aa34c8add723f5a9ba78824d69bcca1b0c41b3b519" + }, + "research/p104-dual-supplier-lift/complex/PRICE.json": { + "blob": "b6c33c074745ec5cbcc3b248e20e225c1c700a0e", + "sha256": "b7a7813a6300cabaf7d78a7f3bcc2dad203a70b8f1a866d0472cd6e19b6350e4" + }, + "research/p104-dual-supplier-lift/complex/PROOF.md": { + "blob": "a8e95b857de7b42f4450f6d1d32526ecd7fe9c60", + "sha256": "73aaea58a2ef7e8ce5c407b6a90885da75988790eb28df6c16719b4806b8619e" + }, + "research/p104-dual-supplier-lift/complex/PUBLIC-EDITS.json": { + "blob": "366cb1fa38e010a031d7c9ce1fc6708e62450c18", + "sha256": "8d4d4ffe23ceb78e3cb43beaba4e42b2f5c192c49c33326bcfc2096ef38363e1" + }, + "research/p104-dual-supplier-lift/complex/RESULT.json": { + "blob": "bc79b6af3d560b2f2aaaffe478da7c2c0e390377", + "sha256": "145853ea4d35e6b82ad08f9bacb9f4c655dc139c2fb4e11339e198e9b8c46eb7" + }, + "research/p104-dual-supplier-lift/complex/bank_split.py": { + "blob": "bec6e66421694dd4eef08d71d86693dc36fc3a24", + "sha256": "d02590768a74bf326f9c331bcf3e4b514abe8ff8b19fafc8d4e4e2fb0100becc" + }, + "research/p104-dual-supplier-lift/complex/birth_event.py": { + "blob": "7ea89cbb8e12aa780afb8bea5417b7927800c207", + "sha256": "b64c955e5183b93cc48fe7a1a6149b242d5e3b0e9abcdd0c64bbb4de9361995a" + }, + "research/p104-dual-supplier-lift/complex/catalogue.py": { + "blob": "a2db79b8e74b6f7525c57c5241d56717af066ea7", + "sha256": "7c64f12a5ad3fd6b8400711e972b5ab52bfab806256d027b86a61e0dc86dc99a" + }, + "research/p104-dual-supplier-lift/complex/closed_application.py": { + "blob": "0a58c832099b1c0f12729b471912cc56d3c88e26", + "sha256": "09fce5496681d03bf106f6bdd8531b083fb8b4e0cea73a1c72f0144240d9c35e" + }, + "research/p104-dual-supplier-lift/complex/closed_caller.py": { + "blob": "122d046f84c1bf4606d40187202e644dd93856c1", + "sha256": "b82b9710d85d62e0f98aa1a1d7c70f97bdbdd64a6e4c92406019ca580a8c52ce" + }, + "research/p104-dual-supplier-lift/complex/graph_delta.py": { + "blob": "6faebc23d2bfaf7efe8db3887560f75f7f32a6c2", + "sha256": "3a1bcf1469c0bd078aee890c2414b55fa764c9663bbf575202f9db486cce9a06" + }, + "research/p104-dual-supplier-lift/complex/public_split.py": { + "blob": "9e2099c90548e718e2e9ed53b3a0069a39f7fad2", + "sha256": "a69c9128d7bb582c63dc60c1b7fa8eb42eaae9ed95eca4f0b0a9dfd006dbdf0d" + }, + "research/p104-dual-supplier-lift/complex/puncture.py": { + "blob": "5196457f5b5b72762f575e7f9e06e4e51c8771bd", + "sha256": "adee4c8212193854ada80ef385af1acf51486adb7def50566dcb7288b506934d" + }, + "research/p104-dual-supplier-lift/complex/relays/7774-NOTICE": { + "blob": "7367367da791d1ced49ad0a667dc66358c7a944b", + "sha256": "757dc360f6468b5b38d2c66aeed02504bc4eacc8cb3715d98282777f0d9a32d4" + }, + "research/p104-dual-supplier-lift/complex/relays/7774-PAID-EDITS.json.gz": { + "blob": "772c82a6a71d5d4d4834f4db57b252bd2b04a177", + "sha256": "780e981a7edf7f5f1f748483725a04b5ab383f2b501d3452a49b202c71c9bcae" + }, + "research/p104-dual-supplier-lift/complex/relays/DELTA.json.gz": { + "blob": "a669487205b56753241da21fc957f067a2562b42", + "sha256": "e931e814d2105ec9b4fef520a70a6192aa784ebc8b7454b0c70685153b711f10" + }, + "research/p104-dual-supplier-lift/complex/relays/NOTICE": { + "blob": "9d1a318f3bcb2544fe0e015358c48b9b562ecacb", + "sha256": "25d9e74e2f376d3c7b90c60edfcf0ef3f04b4286ff9f36739db4ddef81c1c0bd" + }, + "research/p104-dual-supplier-lift/complex/relays/OMISSIONS.json": { + "blob": "5578a8cd8c5fb676a660a12778eb6912011e56b1", + "sha256": "41c3ca252121ffc97d8f9e9dbb31cc76c1388ebfb231659ed162f80b00a05bfa" + }, + "research/p104-dual-supplier-lift/complex/relays/STACK-DELTA.json.gz": { + "blob": "e58fc5b8e8499d141cf2d284ffe854017df66bd1", + "sha256": "afcf80a360ebaa65749448c8b1c35f6497f0356934cc97c3251965e177b8f5ca" + }, + "research/p104-dual-supplier-lift/complex/retained/.gitattributes": { + "blob": "85aa032067a2a84ca2240611025b49839b2d2e99", + "sha256": "8809106a77c5111b765961c96ce0faff15f4ee5dd6b89ffb4db18d8c19f5e6b8" + }, + "research/p104-dual-supplier-lift/complex/retained/CREDITS.md": { + "blob": "a37cba81c7abca439e30303e38e392b109b68d95", + "sha256": "298a542162010686d1306aa9ba46f2b93f2229e383c9e57d5b9a9e816db7fc3e" + }, + "research/p104-dual-supplier-lift/complex/retained/LICENSE": { + "blob": "261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64", + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4" + }, + "research/p104-dual-supplier-lift/complex/retained/NOTICE": { + "blob": "051d4cba2d47c65d5b2591aec77a17e7c44ed69c", + "sha256": "4e79158050dcf11ae2aa3867f15d66f4e5586e774a7167c61c2cb24bda9879b9" + }, + "research/p104-dual-supplier-lift/complex/retained/credits/7658-NOTICE": { + "blob": "2baa2a719ea3a9ec94c2e7aec72702ec8c92b346", + "sha256": "2732575164931c53cc4bc57145c31d87741489e3048afee6899e856c0ea503b5" + }, + "research/p104-dual-supplier-lift/complex/retained/credits/7700-CITATION.cff": { + "blob": "d80f6b8660d6caaa82cb194fc22d0817d642d043", + "sha256": "50399ea15e9ce49baafbd00d6da16e662ac46c566e3c04af3993e23cf0b62ff4" + }, + "research/p104-dual-supplier-lift/complex/retained/credits/7700-NOTICE": { + "blob": "59d8e0cf3102e15bd11db430838365531e2d7f18", + "sha256": "b49022cb4104d90b182e4c335f670faf45529025b15db77bf0291835083c28bd" + }, + "research/p104-dual-supplier-lift/complex/retained/credits/7726-CREDITS.md": { + "blob": "503ab0d3e88085f599263a5718fb786ab0dcc9b4", + "sha256": "4f58fb0bc8d4e66868ceeac55328ef55d85a26085e2109e1123026fcc40bc9e1" + }, + "research/p104-dual-supplier-lift/complex/retained/credits/7726-NOTICE": { + "blob": "051d4cba2d47c65d5b2591aec77a17e7c44ed69c", + "sha256": "4e79158050dcf11ae2aa3867f15d66f4e5586e774a7167c61c2cb24bda9879b9" + }, + "research/p104-dual-supplier-lift/complex/retained/credits/OUTER-GATE-NOTICE": { + "blob": "1bc9b4da2b8398954cd7a49356eb9d397785d0a6", + "sha256": "cadbc642ca84311d2c7a6cf704c7828cb4cf77e3c784b66e4c6e8a5c28002fb8" + }, + "research/p104-dual-supplier-lift/complex/retained/credits/PR7663-NOTICE": { + "blob": "6ce1bc49a3612c9e906df02de81bcba84be8e803", + "sha256": "5fd4367578d2339fbdcd7dc116b6c12cb4fa72e92d2e3d67be537a36c8bd9d40" + }, + "research/p104-dual-supplier-lift/complex/retained/credits/PR7669-PROVENANCE.md": { + "blob": "bbee2437f012c3268eb5cd920adfa37394c1de72", + "sha256": "706c6c852e87e371ddf1828244b2f0c2b00279728818023aa911c8947d69ab83" + }, + "research/p104-dual-supplier-lift/complex/retained/credits/PR7674-NOTICE": { + "blob": "951f081717e0769f3bcc0f442f133965c064d2ce", + "sha256": "382537634a3d9fa0a8089d6121a506a399382f9310088b1f29586dcc93eec92d" + }, + "research/p104-dual-supplier-lift/complex/retained/credits/PR7682-NOTICE": { + "blob": "4654631de087fe5034d30abc17e9d57582e5ed9c", + "sha256": "7590f71de481c424d2315e9ea4884bea1557481676fa5f930f7a0bed637a56a1" + }, + "research/p104-dual-supplier-lift/complex/retained/credits/PR7704-NOTICE": { + "blob": "7d2dfec60a3a8c30bbc639104905d5ce1c0926e4", + "sha256": "49657dd50c9431642a9527b0d625197cb34d1838dcf00fe4d92040f9605c8ce0" + }, + "research/p104-dual-supplier-lift/complex/retained/credits/PR7705-NOTICE": { + "blob": "2a92a9df69de4335966a1b12f79355244a7710f4", + "sha256": "43510816b93ea09e0d716ccc6261c84ce081821c0d5dea7d6e748863d55f8f40" + }, + "research/p104-dual-supplier-lift/complex/retained/credits/PR7708-NOTICE": { + "blob": "4a24e9bcb74d349b7f245f2b43edb6faba716429", + "sha256": "c3762acca6fa198c621e0aacf8aa06526aa7716c20c761141c07393fdba6bc46" + }, + "research/p104-dual-supplier-lift/complex/retained/credits/PR7713-NOTICE": { + "blob": "8fa17b3fd69ddd3be7caeaaff72848e0ac8d517a", + "sha256": "8852b94801cd022eb5d42dc57b7592ab22f87b441566a1ce62c8697733c82da6" + }, + "research/p104-dual-supplier-lift/complex/retained/credits/PR7716-CREDITS.md": { + "blob": "baa9d2f16c76c21437a61916a06f4be4d38ad54a", + "sha256": "dad56f9bca6dd9b902cf77dfbae0da49bbc091e63857313f5e6add52021085b2" + }, + "research/p104-dual-supplier-lift/complex/retained/credits/PR7717-CREDITS.md": { + "blob": "538263114c08217081d3f05bd2383c50a7ae74b8", + "sha256": "515a2d475a2580bbe1c213d10526ce5eef7eaa9a11924e5d72e30221676f7aa4" + }, + "research/p104-dual-supplier-lift/complex/retained/data/CALLER-PHASE-BASES.json": { + "blob": "3e4aa383a5e3343c4688bff62bd39587b90c31b4", + "sha256": "325a1eb4aa7fe5f918b1d8344b88ad132ef4606268bccec20f223ace5feda18b" + }, + "research/p104-dual-supplier-lift/complex/retained/data/CALLER.json.gz": { + "blob": "26a75a1ae32cb4944a65281cfb08775967cb39a0", + "sha256": "d889996a337f648087208ab51c98eaf052705d4fca88b5d01b6e9257a829897a" + }, + "research/p104-dual-supplier-lift/complex/retained/data/CONJUGATE-CALLER.json.gz": { + "blob": "66185da4b0b93afd6b8c10bcfb5a1bff3966f77b", + "sha256": "80009663da460229a57f09bde90e35294329a210ae7fc7ef6d1f05b61ffccbf4" + }, + "research/p104-dual-supplier-lift/complex/retained/mixed_application.py": { + "blob": "59419a653b076d1f8fc56f8ab664112a408ef288", + "sha256": "e762a61f48411dff22117ce1a5154e8e530341f61d5264afeb839b398dd8345e" + }, + "research/p104-dual-supplier-lift/complex/retained/mixed_caller.py": { + "blob": "a7b85d921f3928b5a88f1d2e76c102ed461b6aa9", + "sha256": "4824b2aaadb592550d3a25c16ff0a453705e10b8868f5c22fe10c2874bcb9bae" + }, + "research/p104-dual-supplier-lift/complex/retained/mixed_geometry.py": { + "blob": "c90359f68d58f1c57300db338361d71dd78311ca", + "sha256": "5a7f8ed2deb6b9f8253372539b452b94ce15847200e4bf4b3721447b00362e70" + }, + "research/p104-dual-supplier-lift/complex/retained/mixed_grid.py": { + "blob": "fe30e567317a1f59907c0215e1d038d747d9ea81", + "sha256": "95b0526530467e84e1dd295e98fb1442d68e97a724b1b8724d04fcd2284d646b" + }, + "research/p104-dual-supplier-lift/complex/retained/vendor/binding16.py": { + "blob": "d07341b81719d96e336a47907d48c73772ec1ccb", + "sha256": "589058311e44f2d8909495c005bee6d54828ebe561d4673b599193d269006170" + }, + "research/p104-dual-supplier-lift/complex/retained/vendor/caller16.py": { + "blob": "2865530b7878dec54286a67e82b83093911ec43c", + "sha256": "ced48867f07ca0143604aa98cfd74fa7453696b9d3221f7c230d73e9ab9ba81f" + }, + "research/p104-dual-supplier-lift/complex/retained/vendor/network.py": { + "blob": "0ebc1925c40cc6c11af59e405221ea51801a6e92", + "sha256": "a9169fd6ad0a13c69cf39bd32649d53256f6d6fa2ed2ceda854f848b64f4c546" + }, + "research/p104-dual-supplier-lift/complex/retained/vendor/physical.py": { + "blob": "e7c4e5798bd37df287f431069ab0cffe73dbe3a3", + "sha256": "24c9cf906596c9ef1533c1d25f61403db3ff6389478f64359d9d12c5fef87b69" + }, + "research/p104-dual-supplier-lift/complex/retained/vendor/upstream_application.py": { + "blob": "1a6d358cbec88e70615e5314cdfca9e123124f83", + "sha256": "d98987db98553dc55bfc80e3ca47abfcd51c57af6f8cda61101391d8eae94184" + }, + "research/p104-dual-supplier-lift/complex/supplier.py": { + "blob": "4fb74ed657abc5aad66732c0a601cc7a4a7eb5c2", + "sha256": "be5f9c74170b1793f33b4c0e72b49f135f445159bc6c27734701fdce4bd904ee" + }, + "research/p104-dual-supplier-lift/complex/supplier_gate.py": { + "blob": "fe05580142b56854436ca7b5d9b829393a99f075", + "sha256": "3796b2e5a27f3caa142d16364154788e60d0099f1e24a8dcd028e4fbd35a84ca" + }, + "research/p104-dual-supplier-lift/verify.py": { + "blob": "319f8858f5f34548c57b1ef382121bafa5ea96be", + "sha256": "4fcea94f34de28981da69c24e1119af304c653f722127a02492d3d50ba565c8a" + }, + "research/paired-query-only-bit/EFREE-CALLER.json.gz": { + "blob": "f022272a8d51ede841778dec76e2bfb24b614d04", + "sha256": "757b3523798f840bdb02028b23708c3416627a99ea09e7a3c4bcdc5cd0c7ce4b" + }, + "research/paired-query-only-bit/EFREE-RESULT.json": { + "blob": "575f76487f9999ecc3e7b1b70f9f71bc582ef8a8", + "sha256": "a46b6c6040f75184cab5467656811ad988c216e3bc8e44d595a5015b6e49620b" + }, + "research/paired-query-only-bit/check.py": { + "blob": "0f27d6b90c94466756096911dc02786f60cf5039", + "sha256": "460ed9a77d66264b00c31d0a7f8dab1db9aab21ec4cc0eaf0452bd4be4ef585e" + }, + "research/paired-query-only-bit/independent/interval_gate.py": { + "blob": "6d5a751dde7554b2bb3ccb9a958a3508d74ea155", + "sha256": "8dc2bc4c64cba3f83c664373984a075f1a14b4d53958084091345c8cab189dec" + }, + "research/paired-query-only-bit/retained/audit_binary_mixed.py": { + "blob": "4e685c0906dbd64b97661a3f9693dfb3b673be41", + "sha256": "bb6616dbf536acf10163b8fff65ebfa69d01dfdeda3c0ead388c03377361b298" + }, + "research/paired-query-only-bit/retained/inputs/BIT-NATIVE-WORD.json.gz": { + "blob": "b718d6b2848215ad785022106dfa9f871a3d1c0c", + "sha256": "51203e7fc75ba10bd3ac3f8e675759f47e13d262bea66b6600d1e515095cad78" + }, + "research/paired-query-only-bit/retained/inputs/credited_trim.py": { + "blob": "33645029117c8f027443d5aa93764cf06c23338a", + "sha256": "fcff17fdd3108be68761fbde0fcbfe218be166cf518c99f7163e60d53ab785d9" + }, + "research/paired-query-only-bit/retained/inputs/inputs/exact_arithmetic.py": { + "blob": "4b24a5096154736ce060474eb8c72dc64c303699", + "sha256": "0ce7e7137422d5ffeda22085c81fa88471bbe963100fdad62e659f1e3bf89326" + }, + "research/shared-wire-split-composition/frozen/clifford_exact.py": { + "blob": "166841a037f069249f6f7f6dedb89248812f59e2", + "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962" + }, + "research/shared-wire-split-composition/frozen/native_verify.py": { + "blob": "2c209dfa9cfade3bc20ac5fc9d876b433a147f8c", + "sha256": "3049471905b47b385c88378a1a3be7a18b8858aadd035b8a6da2f4a03b470f38" + }, + "scripts/compare_recursive_invoices.py": { + "blob": "fda2a852e9937e42fe40df0707694465ca7c1b48", + "sha256": "3930c22c11da7bc6042cfeb6e459ecb06e4478430037bee3469d034353855fc6" + }, + "scripts/evaluate_recursive_power.py": { + "blob": "ca50f8021fc3238a58fd420383f4619a8d008ace", + "sha256": "52b20f41fd0bb55fa88dccd6015af2ce358917817b9506720f3e60ce681cc3ad" + } + }, + "path": "", + "repository": "aliromman/integer-mult-bounds" + } + } +} diff --git a/research/p104-final-helper-audit/retained/source7781/complex/FINAL-BIRTH.json b/research/p104-final-helper-audit/retained/source7781/complex/FINAL-BIRTH.json new file mode 100644 index 0000000000..18d111866b --- /dev/null +++ b/research/p104-final-helper-audit/retained/source7781/complex/FINAL-BIRTH.json @@ -0,0 +1,1711 @@ +{ + "changed_row_delta_sha256": "86c804e40fe781ad5e5bb5ee1444761a3fbd8b0b22dcbc1c0770393805e86dbd", + "event": { + "calibration": [ + [ + 35, + "-2" + ], + [ + 57, + "-2" + ], + [ + 90177, + "2" + ], + [ + 90178, + "-2" + ], + [ + 90183, + "-1" + ], + [ + 90186, + "1" + ], + [ + 90189, + "2" + ], + [ + 90191, + "1" + ], + [ + 90193, + "-1" + ], + [ + 90198, + "-2" + ] + ], + "pulse": [ + [ + 92740, + "-5" + ], + [ + 98411, + "-2" + ], + [ + 98796, + "-2" + ] + ], + "readout": [ + [ + 61, + "757680" + ], + [ + 90177, + "-757680" + ], + [ + 90183, + "-378840" + ], + [ + 90186, + "378840" + ], + [ + 90189, + "-757680" + ] + ], + "return_chart": 517, + "return_covector": [ + [ + 1166, + "-1" + ] + ], + "return_direction": [ + [ + 1164, + "-2" + ], + [ + 1166, + "-8" + ] + ], + "role": 1164, + "source_chart": 3, + "source_covector": [ + [ + 3, + "-227304" + ], + [ + 21, + "606144" + ], + [ + 129, + "303072" + ], + [ + 133, + "-75768" + ], + [ + 150, + "-303072" + ], + [ + 159, + "303072" + ], + [ + 164, + "-303072" + ], + [ + 172, + "-303072" + ], + [ + 173, + "5124672" + ], + [ + 188, + "-113652" + ], + [ + 205, + "151536" + ], + [ + 226, + "-416724" + ], + [ + 228, + "-881664" + ], + [ + 230, + "-1515360" + ], + [ + 231, + "-113652" + ], + [ + 235, + "909216" + ], + [ + 239, + "303072" + ], + [ + 240, + "-606144" + ], + [ + 245, + "75768" + ], + [ + 246, + "-24948" + ], + [ + 247, + "-113652" + ], + [ + 249, + "-113652" + ], + [ + 252, + "-137760" + ], + [ + 254, + "606144" + ], + [ + 260, + "-56826" + ], + [ + 262, + "4849152" + ], + [ + 263, + "-151536" + ], + [ + 266, + "-2121504" + ], + [ + 270, + "303072" + ], + [ + 273, + "-1212288" + ], + [ + 274, + "-1212288" + ], + [ + 277, + "909216" + ], + [ + 283, + "-95040" + ], + [ + 288, + "105864" + ], + [ + 289, + "82104" + ], + [ + 292, + "-475200" + ], + [ + 299, + "-151536" + ], + [ + 302, + "-606144" + ], + [ + 304, + "-1212288" + ], + [ + 307, + "-454608" + ], + [ + 309, + "606144" + ], + [ + 310, + "-303072" + ], + [ + 315, + "37884" + ], + [ + 317, + "37884" + ], + [ + 320, + "75768" + ], + [ + 322, + "-909216" + ], + [ + 328, + "303072" + ], + [ + 329, + "-75768" + ], + [ + 335, + "303072" + ], + [ + 336, + "-151536" + ], + [ + 338, + "75768" + ], + [ + 340, + "-151536" + ], + [ + 344, + "909216" + ], + [ + 347, + "-2424576" + ], + [ + 348, + "303072" + ], + [ + 349, + "-303072" + ], + [ + 350, + "-1212288" + ], + [ + 356, + "-303072" + ], + [ + 359, + "606144" + ], + [ + 361, + "1046976" + ], + [ + 362, + "303072" + ], + [ + 365, + "-1515360" + ], + [ + 368, + "-151536" + ], + [ + 370, + "75768" + ], + [ + 376, + "-454608" + ], + [ + 381, + "-303072" + ], + [ + 383, + "-1515360" + ], + [ + 384, + "303072" + ], + [ + 388, + "-606144" + ], + [ + 390, + "909216" + ], + [ + 391, + "1212288" + ], + [ + 392, + "-151536" + ], + [ + 401, + "-303072" + ], + [ + 402, + "4849152" + ], + [ + 404, + "-66792" + ], + [ + 406, + "-606144" + ], + [ + 409, + "440832" + ], + [ + 410, + "151536" + ], + [ + 411, + "757680" + ], + [ + 413, + "-1212288" + ], + [ + 414, + "303072" + ], + [ + 420, + "-606144" + ], + [ + 421, + "-4849152" + ], + [ + 427, + "1515360" + ], + [ + 428, + "1818432" + ], + [ + 429, + "-909216" + ], + [ + 433, + "-1212288" + ], + [ + 434, + "1212288" + ], + [ + 443, + "-2424576" + ], + [ + 448, + "1060752" + ], + [ + 452, + "606144" + ], + [ + 453, + "-1212288" + ], + [ + 454, + "530376" + ], + [ + 455, + "-606144" + ], + [ + 457, + "606144" + ], + [ + 458, + "303072" + ], + [ + 459, + "-151536" + ], + [ + 460, + "-303072" + ], + [ + 463, + "-303072" + ], + [ + 464, + "-1212288" + ], + [ + 468, + "3030720" + ], + [ + 469, + "-1818432" + ], + [ + 470, + "-1818432" + ], + [ + 471, + "1212288" + ], + [ + 472, + "303072" + ], + [ + 474, + "-1212288" + ], + [ + 475, + "-3636864" + ], + [ + 476, + "3636864" + ], + [ + 479, + "-2562336" + ], + [ + 481, + "1818432" + ], + [ + 483, + "-606144" + ], + [ + 484, + "-303072" + ], + [ + 486, + "-606144" + ], + [ + 487, + "-1212288" + ], + [ + 488, + "303072" + ], + [ + 490, + "-2424576" + ], + [ + 492, + "-757680" + ], + [ + 493, + "1515360" + ], + [ + 495, + "303072" + ], + [ + 496, + "-606144" + ], + [ + 497, + "-606144" + ], + [ + 498, + "-7273728" + ], + [ + 500, + "1212288" + ], + [ + 501, + "-113652" + ], + [ + 502, + "-757680" + ], + [ + 503, + "303072" + ], + [ + 508, + "-3636864" + ], + [ + 509, + "3636864" + ], + [ + 510, + "-909216" + ], + [ + 511, + "303072" + ], + [ + 512, + "606144" + ], + [ + 513, + "-303072" + ], + [ + 514, + "-757680" + ], + [ + 516, + "-1515360" + ], + [ + 517, + "-303072" + ], + [ + 519, + "-75768" + ], + [ + 522, + "151536" + ], + [ + 527, + "-757680" + ], + [ + 529, + "151536" + ], + [ + 530, + "-151536" + ], + [ + 531, + "151536" + ], + [ + 537, + "1212288" + ], + [ + 538, + "-303072" + ], + [ + 540, + "909216" + ], + [ + 546, + "-303072" + ], + [ + 547, + "-2424576" + ], + [ + 552, + "-151536" + ], + [ + 553, + "454608" + ], + [ + 555, + "-1515360" + ], + [ + 565, + "-303072" + ], + [ + 574, + "-303072" + ], + [ + 578, + "-75768" + ], + [ + 579, + "-151536" + ], + [ + 581, + "-303072" + ], + [ + 588, + "-151536" + ], + [ + 590, + "606144" + ], + [ + 595, + "606144" + ], + [ + 608, + "909216" + ], + [ + 616, + "757680" + ], + [ + 624, + "-151536" + ], + [ + 630, + "-151536" + ], + [ + 633, + "-75768" + ], + [ + 634, + "-303072" + ], + [ + 645, + "606144" + ], + [ + 649, + "-4849152" + ], + [ + 651, + "-523488" + ], + [ + 652, + "1212288" + ], + [ + 655, + "-1818432" + ], + [ + 666, + "-1515360" + ], + [ + 679, + "606144" + ], + [ + 683, + "-1" + ], + [ + 696, + "-909216" + ], + [ + 700, + "151536" + ], + [ + 770, + "1212288" + ], + [ + 771, + "1212288" + ], + [ + 772, + "1212288" + ], + [ + 773, + "606144" + ], + [ + 774, + "606144" + ], + [ + 775, + "606144" + ], + [ + 776, + "-606144" + ], + [ + 777, + "606144" + ], + [ + 778, + "-606144" + ], + [ + 781, + "606144" + ], + [ + 782, + "606144" + ], + [ + 783, + "-606144" + ], + [ + 785, + "606144" + ], + [ + 791, + "606144" + ], + [ + 792, + "606144" + ], + [ + 793, + "606144" + ], + [ + 794, + "606144" + ], + [ + 795, + "606144" + ], + [ + 797, + "606144" + ], + [ + 798, + "606144" + ], + [ + 800, + "151536" + ], + [ + 801, + "606144" + ], + [ + 804, + "75768" + ], + [ + 807, + "606144" + ], + [ + 810, + "-606144" + ], + [ + 811, + "151536" + ], + [ + 813, + "606144" + ], + [ + 814, + "606144" + ], + [ + 816, + "-606144" + ], + [ + 817, + "606144" + ], + [ + 818, + "606144" + ], + [ + 819, + "606144" + ], + [ + 820, + "1212288" + ], + [ + 823, + "606144" + ], + [ + 824, + "-606144" + ], + [ + 825, + "-606144" + ], + [ + 826, + "606144" + ], + [ + 827, + "606144" + ], + [ + 828, + "1212288" + ], + [ + 830, + "606144" + ], + [ + 831, + "606144" + ], + [ + 832, + "606144" + ], + [ + 833, + "606144" + ], + [ + 834, + "1212288" + ], + [ + 835, + "606144" + ], + [ + 836, + "606144" + ], + [ + 837, + "1212288" + ], + [ + 840, + "606144" + ], + [ + 841, + "-606144" + ], + [ + 842, + "606144" + ], + [ + 843, + "-606144" + ], + [ + 844, + "606144" + ], + [ + 845, + "1212288" + ], + [ + 846, + "1212288" + ], + [ + 847, + "606144" + ], + [ + 848, + "606144" + ], + [ + 849, + "606144" + ], + [ + 850, + "606144" + ], + [ + 851, + "606144" + ], + [ + 852, + "1212288" + ], + [ + 853, + "1212288" + ], + [ + 858, + "606144" + ], + [ + 859, + "606144" + ], + [ + 863, + "606144" + ], + [ + 864, + "606144" + ], + [ + 867, + "606144" + ], + [ + 868, + "606144" + ], + [ + 870, + "606144" + ], + [ + 871, + "606144" + ], + [ + 872, + "-606144" + ], + [ + 873, + "-606144" + ], + [ + 874, + "303072" + ], + [ + 877, + "606144" + ], + [ + 879, + "-7273728" + ], + [ + 884, + "909216" + ], + [ + 887, + "606144" + ], + [ + 890, + "606144" + ], + [ + 891, + "-151536" + ], + [ + 892, + "1" + ], + [ + 894, + "-3636864" + ], + [ + 896, + "303072" + ], + [ + 898, + "1212288" + ], + [ + 899, + "303072" + ], + [ + 902, + "303072" + ], + [ + 904, + "1212288" + ], + [ + 906, + "-1212288" + ], + [ + 907, + "606144" + ], + [ + 916, + "-1818432" + ], + [ + 917, + "1212288" + ], + [ + 918, + "-606144" + ], + [ + 919, + "-1212288" + ], + [ + 923, + "-1212288" + ], + [ + 924, + "-606144" + ], + [ + 927, + "-606144" + ], + [ + 929, + "-303072" + ], + [ + 931, + "-909216" + ], + [ + 935, + "-303072" + ], + [ + 937, + "303072" + ], + [ + 939, + "-909216" + ], + [ + 943, + "-303072" + ], + [ + 944, + "-606144" + ], + [ + 946, + "1212288" + ], + [ + 947, + "303072" + ], + [ + 948, + "-378840" + ], + [ + 949, + "-303072" + ], + [ + 950, + "-606144" + ], + [ + 956, + "606144" + ], + [ + 961, + "909216" + ], + [ + 964, + "151536" + ], + [ + 965, + "1212288" + ], + [ + 968, + "151536" + ], + [ + 973, + "303072" + ], + [ + 978, + "303072" + ], + [ + 981, + "757680" + ], + [ + 988, + "606144" + ], + [ + 992, + "-3636864" + ], + [ + 994, + "-606144" + ], + [ + 995, + "-606144" + ], + [ + 996, + "-3636864" + ], + [ + 999, + "606144" + ], + [ + 1001, + "-606144" + ], + [ + 1003, + "606144" + ], + [ + 1005, + "303072" + ], + [ + 1009, + "-606144" + ], + [ + 1010, + "606144" + ], + [ + 1011, + "1212288" + ], + [ + 1024, + "-606144" + ], + [ + 1025, + "303072" + ], + [ + 1029, + "-2424576" + ], + [ + 1033, + "1212288" + ], + [ + 1037, + "-606144" + ], + [ + 1038, + "1818432" + ], + [ + 1040, + "-606144" + ], + [ + 1043, + "-606144" + ], + [ + 1044, + "-1212288" + ], + [ + 1045, + "-303072" + ], + [ + 1047, + "-606144" + ], + [ + 1049, + "303072" + ], + [ + 1052, + "303072" + ], + [ + 1053, + "-303072" + ], + [ + 1054, + "-606144" + ], + [ + 1057, + "-606144" + ], + [ + 1060, + "-1212288" + ], + [ + 1061, + "-909216" + ], + [ + 1063, + "-151536" + ], + [ + 1064, + "606144" + ], + [ + 1065, + "606144" + ], + [ + 1067, + "606144" + ], + [ + 1069, + "-303072" + ], + [ + 1070, + "606144" + ], + [ + 1071, + "606144" + ], + [ + 1073, + "606144" + ], + [ + 1074, + "151536" + ], + [ + 1076, + "151536" + ], + [ + 1077, + "606144" + ], + [ + 1079, + "1818432" + ], + [ + 1080, + "-1060752" + ], + [ + 1081, + "-606144" + ], + [ + 1084, + "151536" + ], + [ + 1086, + "-606144" + ], + [ + 1088, + "-1212288" + ], + [ + 1089, + "1818432" + ], + [ + 1090, + "606144" + ], + [ + 1092, + "606144" + ], + [ + 1094, + "-909216" + ], + [ + 1095, + "-303072" + ], + [ + 1097, + "-909216" + ], + [ + 1100, + "-303072" + ], + [ + 1102, + "909216" + ], + [ + 1103, + "151536" + ], + [ + 1104, + "-3636864" + ], + [ + 1105, + "-303072" + ], + [ + 1106, + "-75768" + ], + [ + 1111, + "-3636864" + ], + [ + 1112, + "-3030720" + ], + [ + 1115, + "-1212288" + ], + [ + 1116, + "-606144" + ], + [ + 1117, + "909216" + ], + [ + 1118, + "-303072" + ], + [ + 1119, + "-113652" + ], + [ + 1121, + "-1212288" + ], + [ + 1122, + "808192" + ], + [ + 1123, + "-5606832" + ], + [ + 1124, + "-3333792" + ], + [ + 1125, + "1060752" + ], + [ + 1126, + "1818432" + ], + [ + 1127, + "303072" + ], + [ + 1132, + "606144" + ], + [ + 1138, + "-606144" + ], + [ + 1139, + "-1212288" + ], + [ + 1140, + "-1212288" + ], + [ + 1144, + "1515360" + ], + [ + 1145, + "-2424576" + ], + [ + 1147, + "-303072" + ], + [ + 1164, + "3030720" + ], + [ + 1173, + "-454608" + ], + [ + 1242, + "-303072" + ] + ], + "source_direction": [ + [ + 1164, + "-2" + ], + [ + 1166, + "-8" + ] + ], + "split_chart": 232 + }, + "max_changed_coefficient_bits": 23, + "owners": { + "new_label": 1531, + "new_role": 1278, + "retired_label": 1307, + "retired_role": 1164 + }, + "paid_manifest_sha256": "b96ab569eca5626a2c3babbfc0b0029d580e16f11133bcbf137f1942a544c7b9", + "result": { + "graph_sha256": "03ef8f6cc9ebb7394b5c7f8da70d44df965659ae4ff361bbc8d32c7a12121445", + "invoice": { + "paid": { + "1": 185280, + "16": 1248, + "2": 38160, + "24": 1248, + "3": 23472, + "32": 1248, + "4": 10656, + "40": 1248, + "48": 1248, + "5": 14736, + "56": 1248, + "6": 2160, + "7": 192, + "8": 1344 + }, + "targets": { + "1": 864, + "129": 624, + "17": 1248, + "2": 336, + "25": 1248, + "3": 384, + "33": 1248, + "4": 11280, + "41": 1248, + "49": 1248, + "5": 1200, + "57": 1248, + "65": 1248, + "7": 720, + "8": 1584, + "9": 26304 + } + }, + "layout_sha256": "37c04b0a349c1b7f7ada22533d3e4e6bacb42e4c6549f4257f4cbcae189a0275", + "native_delta_from_7776": { + "paid": { + "1": 15, + "2": -2, + "4": -1, + "5": 12, + "6": -10, + "7": -1 + }, + "targets": { + "3": 1, + "4": 15, + "5": 14, + "8": -2, + "9": -13 + } + }, + "native_delta_from_overlay": { + "paid": {}, + "targets": { + "4": 2, + "8": -1 + } + }, + "native_inventory": { + "paid": { + "1": 3850, + "2": 795, + "3": 489, + "4": 222, + "5": 307, + "6": 45, + "7": 4, + "8": 2 + }, + "targets": { + "1": 18, + "2": 7, + "3": 8, + "4": 235, + "5": 25, + "7": 15, + "8": 33, + "9": 538 + } + }, + "prices": { + "0.00386380485468": [ + "6.135683366630429532171595", + "6.135683366630429532171596" + ], + "0.00386896184248": [ + "0.868846744951752270764343", + "0.868846744951752270764344" + ], + "0.0038696995": [ + "0.115485594930098140677787", + "0.115485594930098140677788" + ] + } + }, + "schema": "p104-final-free-helper-birth/v1", + "source": { + "base_pr": 7776, + "graph_sha256": "6eba6bb65015df98cf103ce6d12fdd982ba4dcd24a69000bcc58e05477b17c19", + "head": "4f7c67ae387cc91580f469aeda4d508b372b9ec1", + "layout_sha256": "60ced30a6d7b69c580c8822756f38c11c0d2a904e3ed1235fbbfd176419e36d3", + "repository": "aliromman/integer-mult-bounds" + } +} diff --git a/research/p104-final-helper-audit/retained/source7781/complex/LAYOUT.json.gz b/research/p104-final-helper-audit/retained/source7781/complex/LAYOUT.json.gz new file mode 100644 index 0000000000..b35dc96caa Binary files /dev/null and b/research/p104-final-helper-audit/retained/source7781/complex/LAYOUT.json.gz differ diff --git a/research/p104-final-helper-audit/retained/source7781/complex/OVERLAY.json.gz b/research/p104-final-helper-audit/retained/source7781/complex/OVERLAY.json.gz new file mode 100644 index 0000000000..c3a9132e70 Binary files /dev/null and b/research/p104-final-helper-audit/retained/source7781/complex/OVERLAY.json.gz differ diff --git a/research/p104-final-helper-audit/retained/source7781/complex/PROOF.md b/research/p104-final-helper-audit/retained/source7781/complex/PROOF.md new file mode 100644 index 0000000000..3f821272e6 --- /dev/null +++ b/research/p104-final-helper-audit/retained/source7781/complex/PROOF.md @@ -0,0 +1,49 @@ +# Fourteen calibrated subdivisions on the #7776 complex carrier + +The fourteen split steps preserve the 400 main port boundaries and add fourteen independent productive helpers. The complex signed crossing on the existing 48-call schedule lies in **[0.00386771818086, 0.00386771818087]**. The finite joint guarantee uses the physical application and the separately qualified binary supplier. The arithmetic replay starts from the #7776 complex graph at `934b7d4d792a5771bbcd28053d7797a9938f6b23faddaafe46451158eec81849` and reconstructs the pure split graph at `46420023b4846fb287f6ea8088d7a375f8997aabc8310f3f54583d563e7cf79b`. [Rational journal](BIRTHS.json) · [Released #7776 source](https://github.com/aliromman/integer-mult-bounds/tree/4f7c67ae387cc91580f469aeda4d508b372b9ec1/research/p104-dual-supplier-lift/complex) + +## Paid contact and independent return + +An original paid leg sends the locally computed row from chart \(a\) to chart \(b\). Insert a strictly nested chart \(c\) and transfer that exact row first to \(c\) under a fresh private bank identifier. The old identifier then sends from \(c\) to \(b\). Without the helper edit, that continuation copies the row returned to \(c\). The ordered relative operators compose through \(c\). Both daughter ranks enter the paid invoice. + +The chosen helper has initial chart \(s\) and return chart \(t\), with \(c\) strictly interior. Work in the chosen forward or transposed orientation. Let \(M\) be the exact original public coefficient map and \(h\) the helper role. The journal records a source direction \(d\) and covector \(p\) at \(s\), a readout of \(p\) at \(c\), and a preset local combination of sends whose unit pulse has output \(Md\). A local calibration reads \(k M\) at \(c\), where \(k\) is a covector at \(t\). Both \(p d\) and \(k M d\) are nonzero. The selected coordinate \((Md)_h\) is a nonzero pivot. The readout and calibration are blind to the applied pulse on the replayed graph. + +Let \(u\) be the original public input with helper coordinate \(h\) set to zero. Use the independent input \(x\) in that coordinate and replace the incident source direction with +\[ +u' = u + d\frac{x-pu}{pd}. +\] +The readout returns \(x\) locally at \(c\). For independent input \(y\) installed at \(c\), the normalized pulse is +\[ +\frac{y-k M u'}{k M d}. +\] +The original terminal vector now differs from \(M u\) only by a multiple of \(M d\). Subtracting the pivot from the other affected terminals cancels that multiple. The new terminal at \(t\) returns \(y\). The readout and pulse are local to the introduced contact and all consumers keep their prescribed charts. The three reverse-oriented steps are transposed back after applying their exact scalar edits. + +For the first step, bank identifier 98411 originally sends from chart 325 to chart 517 at rank five. The edit routes it through chart 232 with a new paid identifier 35. The daughter ranks are one and four. Helper role 133 has old charts 3 and 127 and becomes two independent rank-four and rank-five targets. The first readout at chart 232 combines identifier 35 and four existing returns. The pulse enters send 103891. This step saves 0.676359216551554695049309 across 48 calls at the round target. The ordered journal gives the literal source form, chart and role bindings, calibration, pulse, digest of all changed rows, and exact before and after graph hashes for each edit. + +## Replay and costs + +The replay verifies the complex portion of the package source lock by SHA-256 and Git blob hash. It reconstructs the linear graph, checks acyclic locality of every row, preserves all main port charts and compares each of the 1,633,284 endpoint coefficients in both directions. For each split it deletes the pulse in a separate control and computes the missing return on that split's fresh independent input. The existing source labels keep their labels and the fourteen new labels are allocated above them. + +The native debit increases per call by thirteen rank-one, one rank-two, two rank-four and ten rank-five jobs. It decreases by eleven rank-six and one rank-seven job. The productive changes add one rank-three, thirteen rank-four and fourteen rank-five targets and remove one rank-eight and thirteen rank-nine targets. The total 48-call invoice contains 283,536 paid positions and 51,984 productive positions. At κ 0.00386380485468 the directed signed gain is at least 8.588924317292111030653156 and the full signed margin is at least 3.998844451180933992061607. The finite complex application checks the held homes, integer conversions, complete signed caller and ordinary charges separately. [Exact invoice](BIRTHS.json) · [Application and binary replay commands](../README.md) + +Run with ordinary Python 3.12 from the package root after preparing the pinned source cache. + +```sh +python3 -IB complex/birth_replay.py --source-root /tmp/p104-subdivision-sources/source --out /tmp/p104-complex-births +``` + +## Final rank-eight refinement + +The verified chart and sparse-row overlay gives the exact preimage `6eba6bb65015df98cf103ce6d12fdd982ba4dcd24a69000bcc58e05477b17c19`. The final forward edit splits helper role 1164, source label 1307, from charts 3 and 517 through chart 232. It retains the original label on the first rank-four target and binds fresh role 1278, label 1531, to the second rank-four target. The local calibration reads paid returns 35 and 57 produced by the first two subdivisions, together with eight established local rows. The pulse enters sends 92740, 98411 and 98796. The complete paid MOVE table is identical before and after the free split. + +The final native graph is `03ef8f6cc9ebb7394b5c7f8da70d44df965659ae4ff361bbc8d32c7a12121445`. Its 1,279 owners give 1,635,841 endpoint coefficient positions in each direction. The independent fresh input returns at chart 517. Removing its pulse removes the fresh return. Adding that fresh input to the original local readout at chart 232 produces a detected cross-owner coefficient. The changed rows use at most 23 bits per rational numerator or denominator. The complete signed margin is at least 0.868846744951752270764343 at κ 0.00386896184248 and at least 0.115485594930098140677787 at the binary finite cap 0.00386969950. The directed complex crossing lies in [0.00386981257852, 0.00386981257853]. With the verified ordinary binary certificate, the full finite application gives conditional κ ≥ 0.00386969949992 under the five retained assumptions. [Final edit and invoice](FINAL-BIRTH.json) · [Final forward and adjoint replay](final_birth.py) + +Invoke the final replay once the chart and sparse-row overlay has written its intermediate word. + +```sh +python3 -IB complex/final_birth.py --source-root /tmp/p104-subdivision-sources/source \ + --word /tmp/p104-overlay/intermediate.json.gz --layout complex/LAYOUT.json.gz \ + --out /tmp/p104-final-complex +``` + +Ali Romman's published split algebra and #7776 carrier supply the calibrated basis and source realization. The new paid-contact screen adapts the construction used for this package's binary helper births. The retained #7776 notices document the prior engines and contributions. [Binary derivation](../binary/PROOF.md) · [Source lock](../SOURCE-LOCK.json) diff --git a/research/p104-final-helper-audit/retained/source7781/complex/WORD.json.gz b/research/p104-final-helper-audit/retained/source7781/complex/WORD.json.gz new file mode 100644 index 0000000000..f4368731b6 Binary files /dev/null and b/research/p104-final-helper-audit/retained/source7781/complex/WORD.json.gz differ diff --git a/research/p104-final-helper-audit/retained/source7781/complex/birth_replay.py b/research/p104-final-helper-audit/retained/source7781/complex/birth_replay.py new file mode 100644 index 0000000000..df0f49de32 --- /dev/null +++ b/research/p104-final-helper-audit/retained/source7781/complex/birth_replay.py @@ -0,0 +1,235 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Reconstruct calibrated rational helper births from the released #7776 supplier.""" + +from collections import Counter +from fractions import Fraction +from functools import cache +from hashlib import sha1, sha256 +from math import gcd, lcm +from pathlib import Path +import argparse +import gzip +import json +import sys + + +HERE = Path(__file__).resolve().parent +SOURCE = Path('research/p104-dual-supplier-lift/complex') + + +def require(ok, reason): + if not ok: + raise ValueError(reason) + + +def canonical(value): + return json.dumps(value, sort_keys=True, separators=(',', ':')).encode() + + +def digest(value): + return sha256(canonical(value)).hexdigest() + + +def locked_source(root, journal): + lock = json.loads((HERE.parent/'SOURCE-LOCK.json').read_bytes())['sources']['source'] + require(lock['commit'] == journal['source']['head'] + and lock['repository'] == journal['source']['repository'], 'source-lock commit and repository') + paths = tuple((k, v) for k, v in lock['files'].items() if Path(k).is_relative_to(SOURCE)) + require(paths, 'original complex source inventory') + for relative, pin in paths: + raw = (root/relative).read_bytes() + blob = b'blob ' + str(len(raw)).encode() + b'\0' + raw + require(sha256(raw).hexdigest() == pin['sha256'] and sha1(blob).hexdigest() == pin['blob'], + f'changed original source {relative}') + return root/SOURCE, len(paths) + + +@cache +def subspace(axes): + values = {0} + for a in axes: + require(type(a) is int and 0 < a < 512 and a not in values, 'independent ambient chart axes') + values.update(v ^ a for v in tuple(values)) + return frozenset(values) + + +def interior(a, c, b, spans): + return spans[a] < spans[c] < spans[b] or spans[b] < spans[c] < spans[a] + + +def endpoint_map(layout, n): + expected = [{i: Fraction(1)} for i in range(n)] + hosted = set(layout['hosted']['Dports']) + mains = set() + for i, x in enumerate(layout['live']): + y = x + 112 + mains.update((x, y)) + if i in hosted: + expected[y][x] = Fraction(1) + else: + expected[x][y] = Fraction(-1) + expected[y] = {x: Fraction(1, 2), y: Fraction(1, 2)} + for x, y in zip(layout['hosted']['X2'], layout['hosted']['Y2'], strict=True): + expected[x][y] = Fraction(-1) + mains.update((x, y)) + require(len(mains) == 400 and len(layout['live']) == len(set(layout['ports'])) == 104, + 'complete retained main-port layout') + return expected, mains + + +def transpose_rows(rows): + result = [{} for _ in rows] + for i, row in enumerate(rows): + for j, q in row.items(): + result[j][i] = q + return result + + +def arbitrary_inputs(net, expected): + """Compute each rational coefficient exactly, using a common denominator per row.""" + inputs = {~i: (1, {i: 1}) for i in range(len(expected))} + for k in net.schedule(): + terms = [] + for i, q in net.forms[k].items(): + denominator, values = inputs[i] + if values: + terms.append((q.numerator, denominator*q.denominator, values)) + denominator = lcm(*(d for _, d, _ in terms)) + row = {} + for q, d, values in terms: + weight = q*(denominator//d) + for j, v in values.items(): + row[j] = row.get(j, 0) + weight*v + row = {j:v for j, v in row.items() if v} + common = gcd(denominator, *row.values()) + if k < net.first_output: + inputs[k] = denominator//common, {j:v//common for j, v in row.items()} + else: + require({j: Fraction(v, denominator) for j, v in row.items()} == expected[k-net.first_output], + f'arbitrary input endpoint {k-net.first_output}') + + +def one_column(net, input_role): + value = {~input_role: Fraction(1)} + for node in net.schedule(): + q = sum((c*value[i] for i, c in net.forms[node].items() if i in value), Fraction(0)) + if q: + value[node] = q + return {k-net.first_output: str(v) for k, v in value.items() if k >= net.first_output} + + +def row_wire(row): + return None if row is None else [[i,str(q)] for i,q in sorted(row.items())] + + +def apply_step(net, frames, spans, labels, step, supplier, birth): + event = step['event'] + e, f = step['source_paid'], step['new_paid'] + c = event['split_chart'] + old = net.transpose() if step['descending'] else net + a, b = old.moves[e] + require([a,b] == step['old_paid_charts'] and type(f) is int and 0 <= f < old.first_output + and f not in old.moves, 'paid subdivision preimage and fresh home') + h = event['role'] + s, t = old.initial[h], old.final[h] + require((s,t) == (event['source_chart'], event['return_chart']) + and interior(a,c,b,spans) and interior(s,c,t,spans), 'nested paid and productive daughter charts') + require([abs(len(frames[i])-len(frames[c])) for i in (a,b)] == step['paid_daughter_ranks'] + and [abs(len(frames[i])-len(frames[c])) for i in (s,t)] == step['target_daughter_ranks'], + 'literal rank split lists') + fresh = len(old.initial) + require(fresh == step['allocated_role'] and len(labels) > fresh, 'fresh independent input and output label') + delta = old.forms | {f: old.forms[e], e: {f: Fraction(1)}} + split = type(old)(old.first_output, old.initial, old.final, + old.moves | {f:(a,c), e:(c,b)}, delta) + result = birth(split, event) + omitted = birth(split, dict(event, pulse=[])) + if step['descending']: + result, omitted = result.transpose(), omitted.transpose() + omitted_value = one_column(omitted, fresh) + require(omitted_value != {fresh:'1'}, f'original output control for newly born owner {fresh}') + affected = [k for k in sorted(net.forms.keys() | result.forms.keys()) if + net.forms.get(k) != result.forms.get(k)] + original_send = row_wire(old.forms[e]) + proof = dict(parent_sha256=digest(supplier.dump_graph(net, frames)), result_sha256=digest(supplier.dump_graph(result, frames)), + original_owner_label=labels[h], new_owner_label=labels[fresh], + original_oriented_paid_row=original_send, affected_rows=len(affected), + literal_row_delta_sha256=digest([[k,row_wire(net.forms.get(k)),row_wire(result.forms.get(k))] + for k in affected]), + omitted_fresh_input_row=omitted_value, expected_fresh_input_row={str(fresh):'1'}) + if 'replay' in step: + normalized = json.loads(canonical(proof)) + differences = [key for key in normalized if normalized[key] != step['replay'].get(key)] + require(normalized == step['replay'], f'exact ordered graph and omission receipt for paid {e}: {differences}') + return result, proof + + +def charges(net, frames, spans, mains): + paid = Counter() + for a, b in net.moves.values(): + require(spans[a] < spans[b] or spans[b] < spans[a], 'all paid charts strictly nested') + paid[abs(len(frames[a])-len(frames[b]))] += 1 + targets = Counter() + for i, (a,b) in enumerate(zip(net.initial, net.final, strict=True)): + if i not in mains: + require(spans[a] < spans[b], 'positive same-owner productive target') + targets[len(frames[b])-len(frames[a])] += 1 + return {'paid': dict(paid), 'targets': dict(targets)} + + +def write_word(path, document): + raw = canonical(document) + path.write_bytes(gzip.compress(raw, mtime=0)) + + +def replay(root, out): + journal = json.loads((HERE/'BIRTHS.json').read_bytes()) + directory, count = locked_source(root, journal) + sys.path.insert(0, str(directory)) + import supplier + from birth_event import apply_split as birth + initial, initial_layout, net = supplier.build() + require(digest(initial) == journal['source']['graph_sha256'] + and digest(initial_layout) == journal['source']['layout_sha256'], 'published exact #7776 graph and layout') + frames = initial['frames'] + spans = [subspace(tuple(f)) for f in frames] + original, mains = endpoint_map(initial_layout, len(net.initial)) + require(len(net.initial) == initial_layout['public'], 'original public count') + protected = {i:(net.initial[i],net.final[i]) for i in mains} + existing_labels = initial_layout['source_labels'] + next_label = 1+max(existing_labels) + labels = existing_labels+list(range(next_label, next_label+len(journal['steps']))) + steps = [] + for step in journal['steps']: + require(step['event']['role'] not in mains, 'subdivided owner is an independent helper') + net, evidence = apply_step(net, frames, spans, labels, step, supplier, birth) + require(all((net.initial[i],net.final[i]) == b for i,b in protected.items()), '400 protected port roles') + steps.append(evidence) + word = supplier.dump_graph(net, frames) + layout = dict(initial_layout, public=len(net.initial), source_labels=labels) + require(digest(word) == journal['result']['graph_sha256'] and digest(layout) == journal['result']['layout_sha256'], + 'final canonical word and expanded caller layout') + expected, _ = endpoint_map(layout, len(net.initial)) + require(expected[:len(original)] == original and len(set(labels)) == len(expected), + 'every original and newborn independent owner') + arbitrary_inputs(net, expected) + arbitrary_inputs(net.transpose(), transpose_rows(expected)) + inventory = charges(net, frames, spans, mains) + require(canonical(inventory) == canonical(journal['result']['native_inventory']), 'exact paid and productive ranks') + out.mkdir(parents=True,exist_ok=True) + write_word(out/'WORD.json.gz', word) + write_word(out/'LAYOUT.json.gz', layout) + receipt = dict(source=journal['source'], result=journal['result'], source_files=count, + checked_coefficients_per_direction=len(expected)**2, omission_checks=len(steps), steps=steps) + (out/'BIRTH-REPLAY.json').write_text(json.dumps(receipt, indent=2, sort_keys=True)+'\n') + return receipt + + +if __name__ == '__main__': + p = argparse.ArgumentParser(description=__doc__) + p.add_argument('--source-root', required=True, type=Path, help='root of the published #7776 source cache') + p.add_argument('--out', required=True, type=Path) + args = p.parse_args() + result = replay(args.source_root, args.out) + print(result['result']['graph_sha256'], result['checked_coefficients_per_direction'], result['omission_checks']) diff --git a/research/p104-final-helper-audit/retained/source7781/complex/final_birth.py b/research/p104-final-helper-audit/retained/source7781/complex/final_birth.py new file mode 100644 index 0000000000..85baca8ef2 --- /dev/null +++ b/research/p104-final-helper-audit/retained/source7781/complex/final_birth.py @@ -0,0 +1,111 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Refine a productive helper on the exact post-overlay complex graph.""" + +from fractions import Fraction +from pathlib import Path +import argparse +import gzip +import json +import sys + +HERE = Path(__file__).resolve().parent +sys.path.insert(0, str(HERE)) +from birth_replay import (arbitrary_inputs, canonical, charges, digest, endpoint_map, locked_source, + one_column, require, row_wire, subspace, transpose_rows, write_word) + + +def load(path): + raw = path.read_bytes() + return json.loads(gzip.decompress(raw) if raw.startswith(b'\x1f\x8b') else raw) + + +def replay(source_root, word_path, layout_path, out): + journal = load(HERE/'FINAL-BIRTH.json') + donor, count = locked_source(source_root, journal) + sys.path.insert(0, str(donor)) + import supplier + from birth_event import apply_split + + graph, layout = load(word_path), load(layout_path) + source = journal['source'] + require(digest(graph) == source['graph_sha256'] and digest(layout) == source['layout_sha256'], + 'exact post-overlay graph and layout') + before = supplier.Network(graph['first_output'], graph['initial'], graph['final'], + {k:(a,b) for k,a,b in graph['moves']}, + {k:{i:Fraction(q) for i,q in row} for k,row in graph['forms']}) + frames = graph['frames'] + require(digest(supplier.dump_graph(before, frames)) == source['graph_sha256'], + 'complete source row, chart and schedule inventory') + event = journal['event'] + old, fresh = event['role'], len(before.initial) + chart = event['split_chart'] + a, b = before.initial[old], before.final[old] + spans = [subspace(tuple(frame)) for frame in frames] + required, mains = endpoint_map(layout, fresh) + require(old not in mains and (a,b) == (event['source_chart'],event['return_chart']) + and spans[a] < spans[chart] < spans[b], 'positive nested targets on the same original owner') + label = 1+max(layout['source_labels']) + require(journal['owners'] == {'retired_role':old, 'retired_label':layout['source_labels'][old], + 'new_role':fresh, 'new_label':label}, 'independent owner allocation') + revised_layout = dict(layout, public=fresh+1, source_labels=layout['source_labels']+[label]) + edited = apply_split(before, event) + require(len(edited.initial) == len(edited.final) == fresh+1 + and all((edited.initial[i],edited.final[i]) == (before.initial[i],before.final[i]) + for i in range(fresh) if i != old) + and (edited.initial[old],edited.final[old],edited.initial[fresh],edited.final[fresh]) == (a,chart,chart,b), + 'restore every prescribed source and return chart') + require(edited.moves == before.moves and digest(graph['moves']) == journal['paid_manifest_sha256'], + 'every paid MOVE and its rank is retained') + changed = [k for k in sorted(edited.forms.keys() | before.forms.keys()) + if edited.forms.get(k) != before.forms.get(k)] + require(digest([[k,row_wire(before.forms.get(k)),row_wire(edited.forms.get(k))] + for k in changed]) == journal['changed_row_delta_sha256'], 'exact changed read and sender rows') + width = max(max(abs(q.numerator).bit_length(),q.denominator.bit_length()) + for k in changed for q in edited.forms.get(k,{}).values()) + require(width == journal['max_changed_coefficient_bits'] <= 24, 'bounded introduced scalar components') + final = supplier.dump_graph(edited, frames) + result = journal['result'] + require(digest(final) == result['graph_sha256'] and digest(revised_layout) == result['layout_sha256'], + 'exact final carrier and caller layout') + required.append({fresh: Fraction(1)}) + arbitrary_inputs(edited, required) + arbitrary_inputs(edited.transpose(), transpose_rows(required)) + + expect_fresh = {fresh:'1'} + omitted = apply_split(before, dict(event,pulse=[])) + omitted_row = one_column(omitted, fresh) + require(omitted_row != expect_fresh, 'fresh owner pulse omission control') + terminal = edited.first_output + old + wrong = edited.forms | {terminal: edited.forms[terminal] | {~fresh:Fraction(1)}} + contaminated = type(edited)(edited.first_output, edited.initial, edited.final, edited.moves, wrong) + contaminated_row = one_column(contaminated,fresh) + require(~fresh not in edited.forms[terminal] and contaminated_row == {old:'1',fresh:'1'} + and one_column(edited,fresh) == expect_fresh, 'independent old readout rejects distinct fresh input') + expect_old = {old:'1'} + observed_old = one_column(edited,old) + require(observed_old == expect_old, 'arbitrary retired-owner basis column returns at its new chart') + inventory = charges(edited,frames,spans,mains) + require(canonical(inventory) == canonical(result['native_inventory']), 'actual final native paid and target counts') + + out.mkdir(parents=True,exist_ok=True) + write_word(out/'WORD.json.gz',final) + write_word(out/'LAYOUT.json.gz',revised_layout) + receipt = dict(source=source,result=result,source_files=count,owners=journal['owners'], + checked_each_orientation=(fresh+1)**2,changed_rows=len(changed),scalar_bits=width, + unchanged_paid_moves=len(edited.moves),original_basis_column=observed_old, + expected_fresh_basis_column=expect_fresh,omitted_pulse_column=omitted_row, + contaminated_readout_column=contaminated_row) + (out/'FINAL-BIRTH-REPLAY.json').write_text(json.dumps(receipt,indent=2,sort_keys=True)+'\n') + return receipt + + +if __name__=='__main__': + p = argparse.ArgumentParser(description=__doc__) + p.add_argument('--source-root',type=Path,required=True) + p.add_argument('--word',type=Path,required=True) + p.add_argument('--layout',type=Path,required=True) + p.add_argument('--out',type=Path,required=True) + a = p.parse_args() + v = replay(a.source_root,a.word,a.layout,a.out) + print(v['result']['graph_sha256'],v['checked_each_orientation'],v['unchanged_paid_moves']) diff --git a/research/p104-final-helper-audit/retained/source7781/complex/overlay.py b/research/p104-final-helper-audit/retained/source7781/complex/overlay.py new file mode 100644 index 0000000000..7049b0904a --- /dev/null +++ b/research/p104-final-helper-audit/retained/source7781/complex/overlay.py @@ -0,0 +1,78 @@ +"""Apply a canonical coefficient-and-paid-route journal to the pure birth carrier.""" +import argparse +from fractions import Fraction +import gzip +from hashlib import sha256 +import json +from pathlib import Path + + +def encode(value): + return json.dumps(value, sort_keys=True, separators=(",", ":")).encode() + + +def digest(value): + return sha256(encode(value)).hexdigest() + + +def load(path): + raw = path.read_bytes() + return json.loads(gzip.decompress(raw) if raw[:2] == b"\x1f\x8b" else raw) + + +def require(value, text): + if not value: + raise ValueError(text) + + +def apply(graph, journal): + require(digest(graph) == journal["source"], "overlay source graph") + routes = {k: (a, b) for k, a, b in graph["moves"]} + forms = {k: dict(terms) for k, terms in graph["forms"]} + for key, old, new in journal["routes"]: + require(routes.get(key) == (tuple(old) if old else None), "old paid route") + if new is None: + del routes[key] + else: + routes[key] = tuple(new) + for key, present_before, present_after, changes in journal["forms"]: + require((key in forms) == present_before, "old scalar row") + row = dict(forms.get(key, {})) + for donor, before, after in changes: + require(row.get(donor) == before, "old scalar coefficient") + if after is None: + del row[donor] + else: + require(str(Fraction(after)) == after and Fraction(after) != 0, "canonical nonzero coefficient") + row[donor] = after + if present_after: + forms[key] = row + else: + require(not row, "retiring a nonempty row") + del forms[key] + public = len(graph["initial"]) + first = graph["first_output"] + require(set(forms) == set(routes) | set(range(first, first + public)), "all paid and terminal rows") + order = journal["schedule"] + require(len(order) == len(forms) and set(order) == set(forms), "complete scheduled rows") + available = {~i: chart for i, chart in enumerate(graph["initial"])} + for key in order: + chart = routes[key][0] if key in routes else graph["final"][key-first] + require(all(available.get(src) == chart for src in forms[key]), "all coefficient reads local and causal") + if key in routes: + available[key] = routes[key][1] + child = dict(graph, moves=[[k,*v] for k,v in sorted(routes.items())], + forms=[[k,sorted(row.items())] for k,row in sorted(forms.items())],schedule=order) + require(digest(child) == journal["result"], "overlay output") + return child + + +if __name__ == "__main__": + p = argparse.ArgumentParser(description=__doc__) + p.add_argument("source",type=Path) + p.add_argument("journal",type=Path) + p.add_argument("output",type=Path) + args = p.parse_args() + word = apply(load(args.source),load(args.journal)) + args.output.write_bytes(gzip.compress(encode(word),mtime=0)) + print("PASS_COMPLETE_LITERAL_OVERLAY", digest(word)) diff --git a/research/p104-final-helper-audit/verify.py b/research/p104-final-helper-audit/verify.py new file mode 100644 index 0000000000..bb6067e755 --- /dev/null +++ b/research/p104-final-helper-audit/verify.py @@ -0,0 +1,279 @@ +"""Check the final helper split and its rational pulse error space.""" +from collections import Counter +from fractions import Fraction as F +from graphlib import TopologicalSorter +from hashlib import sha1, sha256 +from pathlib import Path +import argparse +import importlib.util +import json +import time + +HERE = Path(__file__).resolve().parent + + +def module(name, file): + spec = importlib.util.spec_from_file_location(name, file) + value = importlib.util.module_from_spec(spec) + spec.loader.exec_module(value) + return value + + +v = module('coefficient_audit7777', HERE/'retained/operator7777/verify.py') +need, read, add, terms = v.need, v.read, v.add, v.terms + + +def digest(value): + return sha256(v.encoded(value)).hexdigest() + + +def pack(graph, rows): + deps = {k: sorted(j for j in row if j >= 0) for k, row in sorted(rows.items())} + return dict(graph, forms=[[k, terms(row)] for k, row in sorted(rows.items())], + schedule=list(TopologicalSorter(deps).static_order())) + + +def reverse_graph(graph, rows): + first, n = graph['first_output'], len(graph['initial']) + def reverse(k): + return first + ~k if k < 0 else ~(k-first) if k >= first else k + result = {k:{} for k, _, _ in graph['moves']} + result.update({first+i:{} for i in range(n)}) + for k, row in rows.items(): + for j, q in row.items(): + result[reverse(j)][reverse(k)] = q + return pack(dict(graph, initial=graph['final'], final=graph['initial'], + moves=[[k,b,a] for k,a,b in graph['moves']]), result), result + + +class Network: + def __init__(self, first_output, initial, final, moves, forms): + self.first_output, self.initial, self.final = first_output, initial, final + self.moves, self.forms = moves, forms + + +def recover(graph, rows, event): + """Undo the terminal change, pulse and input map, in this order.""" + first, fresh, h = graph['first_output'], len(graph['initial'])-1, event['role'] + need((h, fresh) == (1164, 1278), 'named owner pair') + old = {k:r.copy() for k,r in rows.items()} + old[first+h] = add({j:-q/F(4) for j,q in rows[first+fresh].items()}, rows[first+1166], -F(1,4)) + old[first+1166] = {j:-q for j,q in rows[first+fresh].items()} + del old[first+fresh] + calibration = {j:F(q) for j,q in event['calibration']} + need(all(j >= 0 for j in calibration), 'calibration has only paid returns') + for k, literal in event['pulse']: + q = F(literal) + add(old[k], {~fresh:F(1)}, -q/8) + add(old[k], calibration, q/8) + p = {i:F(q) for i,q in event['source_covector']} + d = {i:F(q) for i,q in event['source_direction']} + restored = {} + for k,row in old.items(): + result = {j:q for j,q in row.items() if j >= 0} + for j,q in row.items(): + if j >= 0: + continue + i = ~j + need(i < fresh, 'fresh input removed') + if i == h: + add(result, {~t:a for t,a in p.items()}, q) + else: + add(result, {j:F(1)}, q) + if i in d: + add(result, {~h:F(1)}, -q*d[i]/d[h]) + restored[k] = result + final = graph['final'][:-1] + final[h] = event['return_chart'] + return pack(dict(graph, initial=graph['initial'][:-1], final=final), restored), restored + + +def expected(layout, n): + result = [{i:F(1)} for i in range(n)] + mains = set() + for i,x in enumerate(layout['live']): + y = x+112 + mains.update((x,y)) + if i in layout['hosted']['Dports']: + result[y][x] = F(1) + else: + result[x][y] = F(-1) + result[y] = {x:F(1,2), y:F(1,2)} + for x,y in zip(layout['hosted']['X2'],layout['hosted']['Y2'],strict=True): + result[x][y] = F(-1) + mains.update((x,y)) + need(len(mains) == 400, 'all main ports') + return result, mains + + +def construct(before, event): + """Apply the stated input substitution and terminal projection.""" + moves, old = v.unpack(before) + h, fresh, first = event['role'], len(before['initial']), before['first_output'] + d, p, r, k = [{i:F(q) for i,q in event[name]} for name in + ('source_direction','source_covector','return_direction','return_covector')] + pd, kr = v.dot(p,d), v.dot(k,r) + multiplier = {~i:-q/pd for i,q in p.items() if i != h} + multiplier[~h] = 1/pd + def substitute(row): + result = {j:q for j,q in row.items() if j != ~h} + coefficient = sum(row.get(~i,0)*q for i,q in d.items()) + return add(result,multiplier,coefficient) + rows = {j:substitute(row) for j,row in old.items()} + readout = substitute({i:F(q) for i,q in event['readout']}) + calibration = substitute({i:F(q) for i,q in event['calibration']}) + excitation = add({~fresh:1/kr},calibration,-1/kr) + for j,q in event['pulse']: + add(rows[j],excitation,F(q)) + returned = {} + for i,q in k.items(): + add(returned,rows[first+i],q) + pivot = rows[first+h] + for i,q in r.items(): + if i != h: + add(rows[first+i],pivot,-q/r[h]) + rows[first+h], rows[first+fresh] = readout, returned + final = before['final']+[event['return_chart']] + final[h] = event['split_chart'] + graph = pack(dict(before,initial=before['initial']+[event['split_chart']],final=final),rows) + return graph + + +def run(): + pins = read(HERE/'SOURCE-PINS.json')['sources'] + for pin in pins: + raw = (HERE/pin['retained']).read_bytes() + need(sha256(raw).hexdigest() == pin['sha256'] and + sha1(b'blob '+str(len(raw)).encode()+b'\0'+raw).hexdigest() == pin['git_blob'], 'exact source bytes') + source = HERE/'retained/source7781/complex' + pure, original_layout, journal = [read(source/f) for f in ('WORD.json.gz','LAYOUT.json.gz','FINAL-BIRTH.json')] + overlay = module('overlay7781',source/'overlay.py') + original = overlay.apply(pure,read(source/'OVERLAY.json.gz')) + need(digest(original) == journal['source']['graph_sha256'], 'published pre-split overlay') + graph = construct(original,journal['event']) + layout = dict(original_layout,public=original_layout['public']+1, + source_labels=original_layout['source_labels']+[journal['owners']['new_label']]) + need(digest(graph) == journal['result']['graph_sha256'] and digest(layout) == journal['result']['layout_sha256'], 'exact final objects') + moves, rows = v.unpack(graph) + event, first, n = journal['event'], graph['first_output'], len(graph['initial']) + before, old = recover(graph, rows, event) + need(digest(before) == journal['source']['graph_sha256'], 'independently recovered preimage') + need(v.encoded(before) == v.encoded(original), 'exact recovered overlay') + before_layout = dict(layout, public=n-1, source_labels=layout['source_labels'][:-1]) + need(digest(before_layout) == journal['source']['layout_sha256'], 'prior layout') + need(digest(graph['moves']) == journal['paid_manifest_sha256'] and len(moves) == 5714, 'identical paid table') + algebra = module('split7776', HERE/'retained/algebra7776/birth_event.py') + original = Network(first,before['initial'],before['final'],moves,old) + roundtrip = algebra.apply_split(original,event) + need(roundtrip.forms == rows and roundtrip.initial == graph['initial'] and roundtrip.final == graph['final'], 'retained forward round trip') + changes = [[k,terms(old[k]) if k in old else None,terms(rows[k])] for k in sorted(rows) if old.get(k) != rows[k]] + need(digest(changes) == journal['changed_row_delta_sha256'], 'literal delta receipt') + want, mains = expected(layout,n) + products = 0 + for label, g, r, target in [('before',before,old,want[:-1]),('after',graph,rows,want)]: + values, count = v.expand(g,moves,r) + products += count + need(all(v.vector(values[first+i]) == row for i,row in enumerate(target)), label+' complete operator') + if label == 'after': + calibration_row, readout_row = {}, {} + for field,destination in [('calibration',calibration_row),('readout',readout_row)]: + for node,q in event[field]: + add(destination,v.vector(values[node]),F(q)) + p = {i:F(q) for i,q in event['source_covector']} + expected_calibration = {i:q/F(757680) for i,q in p.items() if i != 1164} + add(expected_calibration,{1164:F(1)},-F(1,757680)) + add(expected_calibration,{1166:F(1)},F(-1)) + need(calibration_row == expected_calibration and readout_row == {1164:F(1)}, 'exact local probes') + del values + adjoint, adjoint_rows = reverse_graph(graph,rows) + transposed = [{} for _ in want] + for i,row in enumerate(want): + for j,q in row.items(): + transposed[j][i] = q + values, count = v.expand(adjoint, {k:(b,a) for k,(a,b) in moves.items()},adjoint_rows) + products += count + need(all(v.vector(values[first+i]) == row for i,row in enumerate(transposed)), 'complete adjoint operator') + del values + # Each independent injection response is computed on the submitted graph. + pulses = [(k,F(q)) for k,q in event['pulse']] + response = [v.scalar(graph,moves,rows,{},[(k,q/8)]) for k,q in pulses] + calibration = {k:F(q) for k,q in event['calibration']} + readout = {k:F(q) for k,q in event['readout']} + need(all(sum(q*a[k] for k,q in calibration.items()) == 0 and + sum(q*a[k] for k,q in readout.items()) == 0 for a in response), 'each pulse is invisible to both local probes') + columns = [{i:a[first+i] for i in range(n) if a[first+i]} for a in response] + minor = [[c.get(i,F(0)) for c in columns] for i in [17,38,1278]] + need(minor == [[-F(5,2),0,F(5,2)],[F(5,2),-F(5,2),0],[0,F(1,2),F(1,2)]], 'rank-three response minor') + total_response = {} + for column in columns: + add(total_response,column,F(1)) + need(total_response == {1278:F(1)}, 'complete pulse has only the fresh return') + basis = {} + for column in columns: + reduced = v.reduced(column,basis) + if reduced: + pivot = max(reduced) + basis[pivot] = {j:q/reduced[pivot] for j,q in reduced.items()} + controls = [] + for mask in range(8): + changed = {k:r.copy() for k,r in rows.items()} + for bit,(k,q) in enumerate(pulses): + if not (mask>>bit & 1): + add(changed[k], {~(n-1):F(1)}, -q/8) + actual = v.scalar(graph,moves,changed,{n-1:F(1)}) + error = {i:actual[first+i]-(i == n-1) for i in range(n)} + predicted = {} + for bit,column in enumerate(columns): + if not (mask>>bit & 1): + add(predicted,column,F(-1)) + need({i:q for i,q in error.items() if q} == predicted, 'all fresh-term omission subsets') + controls.append(dict(mask=mask,errors=terms(predicted))) + # Compare full pulse changes with the exact outer-product error law. + weights = [(F(0),F(0),F(0)),(F(1,2),F(-2,3),F(7,5)),(F(1),F(1),F(1))] + rational_controls = [] + for inputs in ({n-1:F(1)},{1164:F(1)},{1166:F(1)},{3:F(1),683:F(-2),n-1:F(3)}): + good = v.scalar(graph,moves,rows,inputs) + excitation = inputs.get(n-1,F(0))-sum(q*good[k] for k,q in calibration.items()) + for weight in weights: + changed = {k:r.copy() for k,r in rows.items()} + for (k,q),scale in zip(pulses,weight,strict=True): + add(changed[k], {~(n-1):F(1)}, (scale-1)*q/8) + add(changed[k], calibration, -(scale-1)*q/8) + actual = v.scalar(graph,moves,changed,inputs) + prediction = {} + for scale,column in zip(weight,columns,strict=True): + add(prediction,column,excitation*(scale-1)) + error = {i:actual[first+i]-good[first+i] for i in range(n) if actual[first+i] != good[first+i]} + need(error == prediction, 'all rational pulse-weight errors') + rational_controls.append(dict(input=terms(inputs),weights=[str(q) for q in weight],error=terms(error))) + rank = lambda a,b: len(graph['frames'][b])-len(graph['frames'][a]) + h = event['role'] + spans = [v.span(f) for f in graph['frames']] + need(spans[3] < spans[232] < spans[517] and [rank(3,232),rank(232,517),rank(3,517)] == [4,4,8], 'productive split geometry') + need(all((before['initial'][i],before['final'][i]) == (graph['initial'][i],graph['final'][i]) for i in range(n-1) if i != h), 'all other owner charts') + paid = Counter(abs(rank(a,b)) for a,b in moves.values()) + targets = Counter(rank(a,b) for i,(a,b) in enumerate(zip(graph['initial'],graph['final'],strict=True)) if i not in mains) + need({str(k):v for k,v in paid.items()} == journal['result']['native_inventory']['paid'] and + {str(k):v for k,v in targets.items()} == journal['result']['native_inventory']['targets'], 'literal native invoice') + return dict(source_files=len(pins),source_graph=digest(before),final_graph=digest(graph), + public_owners=n,paid_moves=len(moves),changed_rows=len(changes), + coefficient_positions=(n-1)**2+2*n*n,exact_scalar_products=products, + pulse_ids=[k for k,q in pulses],pulse_response_columns=[terms(c) for c in columns], + pulse_response_rank=len(basis),response_minor=[[str(q) for q in row] for row in minor], + response_minor_determinant='25/4',calibration_row=terms(calibration_row), + omission_controls=controls,rational_controls=rational_controls, + paid=dict(sorted(paid.items())),targets=dict(sorted(targets.items())), + native_delta=dict(paid={},targets={4:2,8:-1}),both_probes_blind_to_each_pulse=True) + + +if __name__ == '__main__': + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--record',action='store_true') + args = parser.parse_args() + start = time.monotonic() + result = json.loads(v.encoded(run())) + if args.record: + (HERE/'RESULT.json').write_text(json.dumps(result,indent=2)+'\n') + else: + need(result == read(HERE/'RESULT.json'),'deposited exact certificate') + print('PASS_P104_FINAL_HELPER_AUDIT',result['public_owners'],'owners',result['pulse_response_rank'],'pulse rank',round(time.monotonic()-start,2),'seconds')