diff --git a/.github/workflows/p104-subdivided-helper-births.yml b/.github/workflows/p104-subdivided-helper-births.yml new file mode 100644 index 0000000000..60afdaf055 --- /dev/null +++ b/.github/workflows/p104-subdivided-helper-births.yml @@ -0,0 +1,38 @@ +name: P104 paid subdivision replay + +on: + pull_request: + paths: + - research/p104-subdivided-helper-births/** + - .github/workflows/p104-subdivided-helper-births.yml + workflow_dispatch: + +permissions: + contents: read + +jobs: + replay: + name: P104 paid subdivisions / ${{ matrix.part }} + runs-on: ubuntu-24.04 + timeout-minutes: 25 + strategy: + fail-fast: false + max-parallel: 4 + matrix: + part: [binary, construction, operator, application, charts-0, charts-1, charts-2] + steps: + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 + with: + persist-credentials: false + sparse-checkout: research/p104-subdivided-helper-births + - uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 + with: + python-version: '3.12' + - name: Fetch and verify the peer source commits + run: python -IB research/p104-subdivided-helper-births/prepare_sources.py "$RUNNER_TEMP/sources" --fetch + - name: Rebuild and independently check the selected part + env: + REPLAY_PART: ${{ matrix.part }} + run: | + python -IB research/p104-subdivided-helper-births/verify.py \ + --cache "$RUNNER_TEMP/sources" --out "$RUNNER_TEMP/result" --part "$REPLAY_PART" diff --git a/research/p104-subdivided-helper-births/CLAIM.json b/research/p104-subdivided-helper-births/CLAIM.json new file mode 100644 index 0000000000..8de9c59b9f --- /dev/null +++ b/research/p104-subdivided-helper-births/CLAIM.json @@ -0,0 +1,31 @@ +{ + "schema": "p104-subdivided-helper-births/v1", + "base_main": "e54523517d0f03e58352e647c403a5af3e525a57", + "comparator_pr": 7776, + "comparator_head": "4f7c67ae387cc91580f469aeda4d508b372b9ec1", + "comparator_complex": "934b7d4d792a5771bbcd28053d7797a9938f6b23faddaafe46451158eec81849", + "comparator_binary": "07f5fe923b50ecc26983054cf8f462b1a2b4a008a5e2c7a472209363abaaa35c", + "comparator_raw_joint_upper": "0.00385896184248", + "complex_word": "03ef8f6cc9ebb7394b5c7f8da70d44df965659ae4ff361bbc8d32c7a12121445", + "pure_birth_word": "46420023b4846fb287f6ea8088d7a375f8997aabc8310f3f54583d563e7cf79b", + "layout": "37c04b0a349c1b7f7ada22533d3e4e6bacb42e4c6549f4257f4cbcae189a0275", + "binary_word": "861f5181e4f34db638ab0c573c319fe26ff034d63b21242d67220a4a5d6433ff", + "conditional_lower": "0.00386969949992", + "complex_raw_bracket": [ + "0.00386981257852", + "0.00386981257853" + ], + "binary_ordinary": "0.00386969950", + "target": "0.00386380485468", + "gain": "67110359/6250000000000", + "required_assumptions": [ + "native_all_columns", + "owned_erasure", + "compiler", + "precision_tape", + "analytic_recovery" + ], + "free_birth_parent": "6eba6bb65015df98cf103ce6d12fdd982ba4dcd24a69000bcc58e05477b17c19", + "intermediate_layout": "60ced30a6d7b69c580c8822756f38c11c0d2a904e3ed1235fbbfd176419e36d3", + "free_split": "1164:1278" +} diff --git a/research/p104-subdivided-helper-births/LICENSE b/research/p104-subdivided-helper-births/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/p104-subdivided-helper-births/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-subdivided-helper-births/NOTICE b/research/p104-subdivided-helper-births/NOTICE new file mode 100644 index 0000000000..e47774f92a --- /dev/null +++ b/research/p104-subdivided-helper-births/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-subdivided-helper-births/README.md b/research/p104-subdivided-helper-births/README.md new file mode 100644 index 0000000000..18a5c26c2f --- /dev/null +++ b/research/p104-subdivided-helper-births/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-subdivided-helper-births/SOURCE-LOCK.json b/research/p104-subdivided-helper-births/SOURCE-LOCK.json new file mode 100644 index 0000000000..48a781cd9f --- /dev/null +++ b/research/p104-subdivided-helper-births/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-subdivided-helper-births/binary/BIRTHS.json b/research/p104-subdivided-helper-births/binary/BIRTHS.json new file mode 100644 index 0000000000..d4f03a904f --- /dev/null +++ b/research/p104-subdivided-helper-births/binary/BIRTHS.json @@ -0,0 +1,1377 @@ +{ + "credited_donor_head": "6b0b2f7de0f068834264fc50b75a39a72c52ea22", + "parent_head": "4f7c67ae387cc91580f469aeda4d508b372b9ec1", + "parent_pr": 7776, + "parent_program_sha256": "07f5fe923b50ecc26983054cf8f462b1a2b4a008a5e2c7a472209363abaaa35c", + "previous_public_head": "0b86d0f618b8c64be9410a83a417067049076067", + "program_sha256": "861f5181e4f34db638ab0c573c319fe26ff034d63b21242d67220a4a5d6433ff", + "schema": "binary-subdivided-helper-births-recipe/1", + "steps": [ + { + "new_packet": 3530, + "old_helper_charts": [ + 1, + 0 + ], + "old_move_charts": [ + 412, + 140 + ], + "original_selected_source_clock": 21171, + "paid_daughter_ranks": [ + 2, + 2 + ], + "reverse": true, + "source_packet": 1397, + "target_daughter_ranks": [ + 4, + 4 + ], + "witness": { + "calibration": [ + 3530 + ], + "chart": 519, + "d": [ + 293 + ], + "k": [ + 162, + 293, + 316 + ], + "pulse": [ + 1397, + 1405 + ], + "q": [ + 41, + 75, + 82, + 293, + 345, + 362, + 407, + 421 + ], + "readout": [ + 2331, + 3530 + ], + "role": 293 + } + }, + { + "new_packet": 3532, + "old_helper_charts": [ + 1, + 0 + ], + "old_move_charts": [ + 497, + 196 + ], + "original_selected_source_clock": 21764, + "paid_daughter_ranks": [ + 2, + 2 + ], + "reverse": true, + "source_packet": 1621, + "target_daughter_ranks": [ + 4, + 4 + ], + "witness": { + "calibration": [ + 2349, + 2351, + 2354, + 2359 + ], + "chart": 521, + "d": [ + 249 + ], + "k": [ + 119, + 123, + 184, + 192, + 249, + 298, + 313, + 409, + 423, + 466 + ], + "pulse": [ + 1617, + 1621 + ], + "q": [ + 10, + 42, + 76, + 79, + 248, + 249, + 318, + 319, + 409, + 410, + 415, + 472 + ], + "readout": [ + 2353, + 3532 + ], + "role": 249 + } + }, + { + "new_packet": 3534, + "old_helper_charts": [ + 1, + 0 + ], + "old_move_charts": [ + 501, + 200 + ], + "original_selected_source_clock": 21807, + "paid_daughter_ranks": [ + 2, + 2 + ], + "reverse": true, + "source_packet": 1637, + "target_daughter_ranks": [ + 4, + 4 + ], + "witness": { + "calibration": [ + 2349, + 2353, + 2355, + 2357, + 2358, + 2360 + ], + "chart": 521, + "d": [ + 297, + 298 + ], + "k": [ + 119, + 142, + 148, + 151, + 156, + 189, + 298, + 319, + 410, + 423 + ], + "pulse": [ + 1617, + 1621, + 1637, + 1641 + ], + "q": [ + 10, + 13, + 32, + 83, + 85, + 104, + 107, + 248, + 249, + 256, + 298, + 301, + 423, + 424, + 428 + ], + "readout": [ + 2357, + 3534 + ], + "role": 297 + } + }, + { + "new_packet": 3536, + "old_helper_charts": [ + 1, + 0 + ], + "old_move_charts": [ + 490, + 206 + ], + "original_selected_source_clock": 21871, + "paid_daughter_ranks": [ + 2, + 2 + ], + "reverse": true, + "source_packet": 1661, + "target_daughter_ranks": [ + 4, + 4 + ], + "witness": { + "calibration": [ + 2349, + 2353, + 2355, + 2359 + ], + "chart": 521, + "d": [ + 318, + 319 + ], + "k": [ + 119, + 142, + 148, + 184, + 257, + 319, + 410, + 467 + ], + "pulse": [ + 1617, + 1621, + 1637, + 1641, + 1661, + 1673 + ], + "q": [ + 10, + 13, + 32, + 34, + 83, + 85, + 248, + 249, + 256, + 257, + 297, + 302, + 312, + 318, + 424, + 466, + 472, + 473 + ], + "readout": [ + 2349, + 3536 + ], + "role": 318 + } + }, + { + "new_packet": 3538, + "old_helper_charts": [ + 1, + 0 + ], + "old_move_charts": [ + 483, + 215 + ], + "original_selected_source_clock": 21966, + "paid_daughter_ranks": [ + 2, + 2 + ], + "reverse": true, + "source_packet": 1697, + "target_daughter_ranks": [ + 4, + 4 + ], + "witness": { + "calibration": [ + 2363, + 2364, + 2366, + 2367, + 2370 + ], + "chart": 522, + "d": [ + 241, + 242 + ], + "k": [ + 115, + 125, + 127, + 201, + 214, + 225, + 241, + 283, + 289 + ], + "pulse": [ + 1685, + 1697 + ], + "q": [ + 99, + 101, + 242, + 281, + 291, + 456, + 457, + 460, + 461, + 471 + ], + "readout": [ + 2370, + 3538 + ], + "role": 241 + } + }, + { + "new_packet": 3540, + "old_helper_charts": [ + 1, + 0 + ], + "old_move_charts": [ + 465, + 237 + ], + "original_selected_source_clock": 22197, + "paid_daughter_ranks": [ + 2, + 2 + ], + "reverse": true, + "source_packet": 1785, + "target_daughter_ranks": [ + 4, + 4 + ], + "witness": { + "calibration": [ + 2379, + 2381, + 2383, + 2384 + ], + "chart": 523, + "d": [ + 258, + 259 + ], + "k": [ + 139, + 140, + 209, + 211, + 258, + 262, + 268, + 272 + ], + "pulse": [ + 1781, + 1785 + ], + "q": [ + 14, + 258, + 273, + 437, + 438, + 448 + ], + "readout": [ + 2382, + 3540 + ], + "role": 258 + } + }, + { + "new_packet": 3542, + "old_helper_charts": [ + 1, + 0 + ], + "old_move_charts": [ + 455, + 243 + ], + "original_selected_source_clock": 22260, + "paid_daughter_ranks": [ + 2, + 2 + ], + "reverse": true, + "source_packet": 1809, + "target_daughter_ranks": [ + 4, + 4 + ], + "witness": { + "calibration": [ + 3542 + ], + "chart": 523, + "d": [ + 433 + ], + "k": [ + 217, + 263, + 433 + ], + "pulse": [ + 1809, + 1825 + ], + "q": [ + 2, + 227, + 258, + 259, + 262, + 263, + 268, + 269, + 272, + 433, + 434, + 437, + 464, + 476 + ], + "readout": [ + 2374, + 3542 + ], + "role": 433 + } + }, + { + "new_packet": 3544, + "old_helper_charts": [ + 1, + 0 + ], + "old_move_charts": [ + 449, + 257 + ], + "original_selected_source_clock": 22406, + "paid_daughter_ranks": [ + 2, + 2 + ], + "reverse": true, + "source_packet": 1865, + "target_daughter_ranks": [ + 4, + 4 + ], + "witness": { + "calibration": [ + 3544 + ], + "chart": 524, + "d": [ + 420 + ], + "k": [ + 187, + 309, + 420 + ], + "pulse": [ + 1865, + 1873 + ], + "q": [ + 8, + 243, + 309, + 420, + 468, + 478 + ], + "readout": [ + 2396, + 3544 + ], + "role": 420 + } + }, + { + "new_packet": 3546, + "old_helper_charts": [ + 1, + 0 + ], + "old_move_charts": [ + 441, + 262 + ], + "original_selected_source_clock": 22459, + "paid_daughter_ranks": [ + 2, + 2 + ], + "reverse": true, + "source_packet": 1885, + "target_daughter_ranks": [ + 4, + 4 + ], + "witness": { + "calibration": [ + 2389 + ], + "chart": 524, + "d": [ + 315 + ], + "k": [ + 143, + 314, + 315, + 326, + 402 + ], + "pulse": [ + 1881, + 1885 + ], + "q": [ + 40, + 45, + 105, + 110, + 243, + 254, + 315, + 327, + 413, + 414, + 468, + 469, + 478, + 479 + ], + "readout": [ + 2392, + 3546 + ], + "role": 315 + } + }, + { + "new_packet": 3548, + "old_helper_charts": [ + 1, + 0 + ], + "old_move_charts": [ + 1, + 157 + ], + "original_selected_source_clock": 21349, + "paid_daughter_ranks": [ + 4, + 2 + ], + "reverse": true, + "source_packet": 1465, + "target_daughter_ranks": [ + 4, + 4 + ], + "witness": { + "calibration": [ + 2292, + 2295, + 2298, + 2299 + ], + "chart": 508, + "d": [ + 435 + ], + "k": [ + 128, + 144, + 270, + 271, + 287, + 435 + ], + "pulse": [ + 1449, + 1465 + ], + "q": [ + 19, + 27, + 435, + 436, + 452, + 453 + ], + "readout": [ + 2298, + 2299 + ], + "role": 435 + } + }, + { + "new_packet": 3550, + "old_helper_charts": [ + 1, + 0 + ], + "old_move_charts": [ + 1, + 166 + ], + "original_selected_source_clock": 21445, + "paid_daughter_ranks": [ + 4, + 2 + ], + "reverse": true, + "source_packet": 1501, + "target_daughter_ranks": [ + 4, + 4 + ], + "witness": { + "calibration": [ + 2336 + ], + "chart": 520, + "d": [ + 274 + ], + "k": [ + 126, + 274, + 275, + 285, + 306, + 307, + 324, + 417, + 446 + ], + "pulse": [ + 1493, + 1501 + ], + "q": [ + 21, + 274, + 275, + 462 + ], + "readout": [ + 3550 + ], + "role": 274 + } + }, + { + "new_packet": 3552, + "old_helper_charts": [ + 1, + 0 + ], + "old_move_charts": [ + 0, + 517 + ], + "original_selected_source_clock": 26917, + "paid_daughter_ranks": [ + 4, + 3 + ], + "reverse": true, + "source_packet": 2965, + "target_daughter_ranks": [ + 4, + 4 + ], + "witness": { + "calibration": [ + 2307 + ], + "chart": 509, + "d": [ + 411, + 412, + 653 + ], + "k": [ + 138, + 653 + ], + "pulse": [ + 1581, + 1589, + 2306 + ], + "q": [ + 38, + 77, + 87, + 310, + 411, + 431 + ], + "readout": [ + 2316, + 3552 + ], + "role": 411 + } + }, + { + "new_packet": 3554, + "old_helper_charts": [ + 1, + 0 + ], + "old_move_charts": [ + 599, + 0 + ], + "original_selected_source_clock": 33580, + "paid_daughter_ranks": [ + 3, + 4 + ], + "reverse": true, + "source_packet": 3457, + "target_daughter_ranks": [ + 4, + 4 + ], + "witness": { + "calibration": [ + 2307, + 2313 + ], + "chart": 509, + "d": [ + 432, + 653 + ], + "k": [ + 138, + 146, + 300, + 653 + ], + "pulse": [ + 1581, + 1589, + 1593, + 1597 + ], + "q": [ + 38, + 310, + 311, + 432 + ], + "readout": [ + 2314, + 3554 + ], + "role": 432 + } + }, + { + "new_packet": 3556, + "old_helper_charts": [ + 1, + 0 + ], + "old_move_charts": [ + 0, + 510 + ], + "original_selected_source_clock": 26861, + "paid_daughter_ranks": [ + 1, + 6 + ], + "reverse": true, + "source_packet": 2937, + "target_daughter_ranks": [ + 7, + 1 + ], + "witness": { + "calibration": [ + 702 + ], + "chart": 8, + "d": [ + 237, + 238, + 240 + ], + "k": [ + 111, + 122, + 141, + 142, + 147, + 148, + 150, + 152, + 153, + 155, + 240 + ], + "pulse": [ + 695, + 696, + 698 + ], + "q": [ + 6, + 237, + 238, + 239, + 240 + ], + "readout": [ + 703, + 3556 + ], + "role": 237 + } + }, + { + "new_packet": 3558, + "old_helper_charts": [ + 1, + 0 + ], + "old_move_charts": [ + 0, + 511 + ], + "original_selected_source_clock": 26869, + "paid_daughter_ranks": [ + 1, + 6 + ], + "reverse": true, + "source_packet": 2941, + "target_daughter_ranks": [ + 7, + 1 + ], + "witness": { + "calibration": [ + 732 + ], + "chart": 13, + "d": [ + 250, + 251, + 252 + ], + "k": [ + 116, + 117, + 214, + 215, + 216, + 217, + 218, + 219, + 220, + 221, + 252 + ], + "pulse": [ + 726, + 727, + 728 + ], + "q": [ + 11, + 250, + 251, + 252, + 253 + ], + "readout": [ + 734, + 3558 + ], + "role": 250 + } + }, + { + "new_packet": 3560, + "old_helper_charts": [ + 1, + 0 + ], + "old_move_charts": [ + 0, + 512 + ], + "original_selected_source_clock": 26877, + "paid_daughter_ranks": [ + 1, + 6 + ], + "reverse": true, + "source_packet": 2945, + "target_daughter_ranks": [ + 7, + 1 + ], + "witness": { + "calibration": [ + 979 + ], + "chart": 58, + "d": [ + 351, + 353, + 354 + ], + "k": [ + 130, + 133, + 141, + 155, + 157, + 165, + 186, + 195, + 203, + 208, + 353 + ], + "pulse": [ + 973, + 975, + 976 + ], + "q": [ + 56, + 351, + 352, + 353, + 354 + ], + "readout": [ + 981, + 3560 + ], + "role": 351 + } + }, + { + "new_packet": 3562, + "old_helper_charts": [ + 1, + 0 + ], + "old_move_charts": [ + 0, + 513 + ], + "original_selected_source_clock": 26885, + "paid_daughter_ranks": [ + 1, + 6 + ], + "reverse": true, + "source_packet": 2949, + "target_daughter_ranks": [ + 7, + 1 + ], + "witness": { + "calibration": [ + 989 + ], + "chart": 59, + "d": [ + 355, + 356, + 358 + ], + "k": [ + 111, + 112, + 113, + 114, + 115, + 116, + 117, + 118, + 119, + 121, + 123, + 124, + 125, + 128, + 129, + 130, + 131, + 134, + 135, + 137, + 141, + 144, + 145, + 146, + 147, + 150, + 151, + 153, + 158, + 159, + 160, + 161, + 162, + 165, + 167, + 168, + 170, + 172, + 174, + 175, + 177, + 178, + 180, + 183, + 184, + 185, + 186, + 188, + 191, + 192, + 196, + 197, + 199, + 200, + 201, + 203, + 206, + 207, + 212, + 213, + 214, + 217, + 219, + 220, + 358 + ], + "pulse": [ + 982, + 983, + 985 + ], + "q": [ + 57, + 355, + 356, + 357, + 358 + ], + "readout": [ + 990, + 3562 + ], + "role": 355 + } + }, + { + "new_packet": 3564, + "old_helper_charts": [ + 1, + 0 + ], + "old_move_charts": [ + 0, + 514 + ], + "original_selected_source_clock": 26893, + "paid_daughter_ranks": [ + 1, + 6 + ], + "reverse": true, + "source_packet": 2953, + "target_daughter_ranks": [ + 7, + 1 + ], + "witness": { + "calibration": [ + 1055 + ], + "chart": 69, + "d": [ + 383, + 384, + 386 + ], + "k": [ + 126, + 134, + 142, + 150, + 190, + 197, + 205, + 213, + 386 + ], + "pulse": [ + 1048, + 1049, + 1051 + ], + "q": [ + 67, + 383, + 384, + 385, + 386 + ], + "readout": [ + 1056, + 3564 + ], + "role": 383 + } + }, + { + "new_packet": 3566, + "old_helper_charts": [ + 1, + 0 + ], + "old_move_charts": [ + 0, + 515 + ], + "original_selected_source_clock": 26901, + "paid_daughter_ranks": [ + 1, + 6 + ], + "reverse": true, + "source_packet": 2957, + "target_daughter_ranks": [ + 7, + 1 + ], + "witness": { + "calibration": [ + 1072 + ], + "chart": 71, + "d": [ + 391, + 393, + 394 + ], + "k": [ + 127, + 140, + 148, + 150, + 190, + 192, + 199, + 212, + 393 + ], + "pulse": [ + 1066, + 1068, + 1069 + ], + "q": [ + 69, + 391, + 392, + 393, + 394 + ], + "readout": [ + 1074, + 3566 + ], + "role": 391 + } + }, + { + "new_packet": 3568, + "old_helper_charts": [ + 1, + 0 + ], + "old_move_charts": [ + 0, + 516 + ], + "original_selected_source_clock": 26909, + "paid_daughter_ranks": [ + 1, + 6 + ], + "reverse": true, + "source_packet": 2961, + "target_daughter_ranks": [ + 7, + 1 + ], + "witness": { + "calibration": [ + 1064 + ], + "chart": 70, + "d": [ + 387, + 388, + 390 + ], + "k": [ + 123, + 124, + 160, + 162, + 172, + 174, + 181, + 182, + 218, + 221, + 390 + ], + "pulse": [ + 1057, + 1058, + 1060 + ], + "q": [ + 68, + 387, + 388, + 389, + 390 + ], + "readout": [ + 1065, + 3568 + ], + "role": 387 + } + }, + { + "new_packet": 3570, + "old_helper_charts": [ + 1, + 0 + ], + "old_move_charts": [ + 0, + 518 + ], + "original_selected_source_clock": 26925, + "paid_daughter_ranks": [ + 1, + 6 + ], + "reverse": true, + "source_packet": 2969, + "target_daughter_ranks": [ + 7, + 1 + ], + "witness": { + "calibration": [ + 767 + ], + "chart": 19, + "d": [ + 264, + 266, + 267 + ], + "k": [ + 119, + 124, + 125, + 131, + 138, + 200, + 209, + 211, + 216, + 218, + 267 + ], + "pulse": [ + 760, + 762, + 763 + ], + "q": [ + 17, + 264, + 265, + 266, + 267 + ], + "readout": [ + 768, + 3570 + ], + "role": 264 + } + } + ] +} diff --git a/research/p104-subdivided-helper-births/binary/FINITE.json b/research/p104-subdivided-helper-births/binary/FINITE.json new file mode 100644 index 0000000000..806ef47d3e --- /dev/null +++ b/research/p104-subdivided-helper-births/binary/FINITE.json @@ -0,0 +1,225 @@ +{ + "covered": "0.00386969980", + "crossing_margins": [ + [ + "168694759438355867714976590331486669846122178531801122803104806297577/2500000000000000000000000000000000000000000000000000000000000000000000000000000", + "210868449297944834643720737914358337307652723164751403503881009068219/3125000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + [ + "-7966098777328470019046376261041051692087642281616181469152051871017943/25000000000000000000000000000000000000000000000000000000000000000000000000000000", + "-318643951093138800761855050441642067683505691264647258766082074459639/1000000000000000000000000000000000000000000000000000000000000000000000000000000" + ] + ], + "delayed_cover_loss": "1/10000000000", + "derivative_upper_interval": [ + "-19000061699142436839149297889416257296026439986136751961421321297173193542857064337729/50000000000000000000000000000000000000000000000000000000000000000000000000000000", + "-19000061699142436839149297889416257296026439986136751961421321297173193542856921101589/50000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "donor_head": "4f7c67ae387cc91580f469aeda4d508b372b9ec1", + "donor_inputs": { + "BIT-PROOF.md": "c87bd698ec5d9bb8741d509bc1d2f7d421d9686a95b515829c5c042a0a71f15b", + "BIT-RESULT.json": "907858ba4c6f4c110662c8ea9faa1209acca07a9ae281ba29e9291a41fe8e6e1", + "bit_application.py": "fa76543d0aa0d515b48eaa9516f73df2c34a5f482114080fe3bcd6d37c32bbbd", + "bit_native.py": "4368c62a5d42f81189d6776b8dba8c85a311b6a199b816244b545c6bb7d3dc1e" + }, + "donor_pr": 7776, + "donor_word_sha256": "07f5fe923b50ecc26983054cf8f462b1a2b4a008a5e2c7a472209363abaaa35c", + "finite_separation": { + "alpha": { + "lower": "0.999999547993554305662725571461", + "upper": "0.999999547993554305662725571462" + }, + "construction": "chronological product; specialize low complete targets to owned zero; retain all original paid calls; split paid calls on disjoint axes", + "cutoff_base": 15, + "floor_base": 16, + "gamma": { + "lower": "0.872798544807909232716151613943", + "upper": "0.872798544807909232716151613944" + }, + "label": "twenty-one binary helper births", + "lambda": { + "lower": "0.950920668515790232689013357229", + "upper": "0.950920668515790232689013357230" + }, + "largest_productive_rank": "127^768", + "maximum_paid": "15^768", + "minimum_retained_target": "16^768", + "normalized_paid_plus_lost_target_upper": { + "lower": "0.999652979515260674989376232359", + "upper": "0.999652979515260674989376232360" + }, + "owned_allocation_records_bound": "2*20418^768", + "paid": { + "1": 50340, + "14": 444, + "2": 45828, + "21": 444, + "28": 444, + "3": 2016, + "35": 444, + "4": 1512, + "42": 444, + "49": 444, + "5": 324, + "56": 444, + "6": 3960, + "7": 444 + }, + "paid_tail_offset": "1/5", + "product_or_uniform_word_materialized": false, + "product_raw_invocation_count": "sum(i=0..767, 20418^(767-i)*107532^i)", + "rank_mass_surplus": "positive by separated t-moment advantage; no discarded target mass retained as credit", + "rational_upper_limits": [ + "199999909598711/200000000000000", + "87279854480791/100000000000000", + "950920668515791/1000000000000000" + ], + "retained_productive_fields": "W = sum over target tuples with product >= 16^768 of their multiplicities", + "source_paid_calls": 107532, + "source_paid_rank_mass": 291360, + "source_public_fields": 20418, + "source_status": "unadmitted", + "specialized_initial_and_final": 0, + "specialized_owned_fields": "D = 20418^768 - W", + "split_paid_calls_upper": "291360^768", + "strict_normalized_gap": { + "lower": "0.000347020484739325010623767640", + "upper": "0.000347020484739325010623767641" + }, + "target_tail_offset": "1/5", + "targets": { + "1": 288, + "127": 222, + "15": 444, + "2": 36, + "22": 444, + "29": 444, + "36": 444, + "4": 1548, + "43": 444, + "50": 444, + "57": 444, + "6": 36, + "64": 444, + "7": 288, + "8": 14448 + }, + "tensor_power": 768, + "tested_saving": "38697/10000000" + }, + "independent_ratio_intervals": [ + [ + "49999977399677715283136278573073361963762279143309803401402459189871380880658563/50000000000000000000000000000000000000000000000000000000000000000000000000000000", + "49999977399677715283136278573073361963762279143309803401402459189871380880658629/50000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + [ + "3491194179231636930864606455773281523909151893190198733767229944270409133469497/4000000000000000000000000000000000000000000000000000000000000000000000000000000", + "4363992724039546163580758069716601904886439866487748417209037430338011416836911/5000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + [ + "11886508356447377908612666965373399664360475610435897304749817845317917843735487/12500000000000000000000000000000000000000000000000000000000000000000000000000000", + "95092066851579023268901335722987197314883804883487178437998542762543342749884847/100000000000000000000000000000000000000000000000000000000000000000000000000000000" + ] + ], + "ordinary": { + "caller_bank_transits": 3507600, + "native_bank_transits_per_call": 2914897920, + "native_banks_and_scratch": 4224, + "ordinary_records": 933004517520, + "owned_backing": 6998328, + "raw_ordinary_allowance": 1000000000000, + "raw_owned_allowance": 10000000, + "route_groups": 572184, + "route_records": 828064684800 + }, + "ordinary_admitted": "0.00386969950", + "ordinary_bootstrap": [ + { + "admitted": "0.00386963090", + "envelope": "4837038651/1250000000000", + "previous": "12039/3125000", + "slack": "13/625000000000" + }, + { + "admitted": "0.00386969950", + "envelope": "9674248811/2500000000000", + "previous": "38696309/10000000000", + "slack": "61/2500000000000" + } + ], + "paid": { + "1": 50340, + "2": 45828, + "3": 2016, + "4": 1512, + "5": 324, + "6": 3960, + "7": 444, + "14": 444, + "21": 444, + "28": 444, + "35": 444, + "42": 444, + "49": 444, + "56": 444 + }, + "raw_crossing": [ + "0.003870038707744", + "0.003870038707745" + ], + "rho": "1/250", + "status": "PASS_FINITE_BIT_BIRTHS_COMPILER_AND_ORDINARY_BOOTSTRAP", + "targets": { + "1": 288, + "2": 36, + "4": 1548, + "6": 36, + "7": 288, + "8": 14448, + "15": 444, + "22": 444, + "29": 444, + "36": 444, + "43": 444, + "50": 444, + "57": 444, + "64": 444, + "127": 222 + }, + "tested_saving": "0.00386970000", + "trial_margin": [ + "653912757724976756369178788874626513408790601882765773184551052094356544458677/5000000000000000000000000000000000000000000000000000000000000000000000000000000", + "130782551544995351273835757774925302681758120376553154636910210418871309271167/1000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "trusted_inputs": { + "certificates/frontier7000/CLAIM.json": "3f8add8252adb223b60418ec69351a69b6b5edfe601ec1c6b4b65cd9e2afd9b2", + "research/paired-query-only-bit/EFREE-CALLER.json.gz": "757b3523798f840bdb02028b23708c3416627a99ea09e7a3c4bcdc5cd0c7ce4b", + "research/paired-query-only-bit/independent/interval_gate.py": "8dc2bc4c64cba3f83c664373984a075f1a14b4d53958084091345c8cab189dec", + "research/paired-query-only-bit/retained/inputs/credited_trim.py": "fcff17fdd3108be68761fbde0fcbfe218be166cf518c99f7163e60d53ab785d9", + "research/paired-query-only-bit/retained/inputs/inputs/exact_arithmetic.py": "0ce7e7137422d5ffeda22085c81fa88471bbe963100fdad62e659f1e3bf89326" + }, + "uniform": { + "H": 297620000000000, + "N": "2^297620000000000", + "eta": { + "lower": "0.000000475018405997932847886160", + "upper": "0.000000475018405997932847886161" + }, + "gap": "1/10000000000", + "integer_test_exponent": 29762, + "logarithm_power": 619, + "ordinary_base_bound": { + "lower": "2097035.162052930830364566602646453931", + "upper": "2097035.162052930830364566602646453932" + }, + "preceding_integer_grid_fails": true, + "previous_logarithm_power_fails": true, + "proof": "retained separated finite compiler and logarithmic majorant, with all new owned fields charged", + "theta": "42/43", + "uniform_saving": "38696999/10000000000" + }, + "uniform_loss": "1/10000000000", + "word_file_sha256": "e5871a4cf87d62aa90e6660d351636aa5ca47f50239916a0943cd433c7f3d323", + "word_sha256": "861f5181e4f34db638ab0c573c319fe26ff034d63b21242d67220a4a5d6433ff", + "working_ambient": "134^768" +} diff --git a/research/p104-subdivided-helper-births/binary/PROOF.md b/research/p104-subdivided-helper-births/binary/PROOF.md new file mode 100644 index 0000000000..0b73182a9d --- /dev/null +++ b/research/p104-subdivided-helper-births/binary/PROOF.md @@ -0,0 +1,62 @@ +# Ordinary BIT from 21 subdivided helper births + +The 36-call word supplies ordinary BIT saving **0.00386969950** under the retained BIT realization, owned-erasure, finite compiler and precision-tape assumptions. Its complete raw crossing lies in `[0.003870038707744, 0.003870038707745]`. The raw crossing measures the signed rank invoice. The ordinary saving follows after the finite compilation, cover loss and two bootstrap steps described below. [Finite receipt](FINITE.json) + +The source is Ali Romman's eight-puncture native word in PR #7776 at `4f7c67ae387cc91580f469aeda4d508b372b9ec1`. Its canonical SHA-256 is `07f5fe923b50ecc26983054cf8f462b1a2b4a008a5e2c7a472209363abaaa35c`. The candidate has canonical SHA-256 `861f5181e4f34db638ab0c573c319fe26ff034d63b21242d67220a4a5d6433ff`. The decompressed file SHA-256 is `e5871a4cf87d62aa90e6660d351636aa5ca47f50239916a0943cd433c7f3d323`. [Source BIT proof](https://github.com/aliromman/integer-mult-bounds/blob/4f7c67ae387cc91580f469aeda4d508b372b9ec1/research/p104-dual-supplier-lift/BIT-PROOF.md) · [Edit journal](BIRTHS.json) · [Literal word](WORD.json.gz) + +## One birth + +Work in the transposed native network, with complete binary transfer $M$. Let an existing productive owner $h$ start in chart $A$ and return in chart $B$. Subdivide one paid move $a\to b$ into $a\to c\to b$ at an intermediate chart $c$. The second leg initially copies the first arrival. The chart sequences $a,c,b$ and $A,c,B$ must each be strictly nested rational frames, in either orientation. Subdivision preserves the original scalar transfer and provides a new local arrival and sender on chart $c$. + +Let $x$ contain the old arbitrary public inputs. At $c$, the replay finds readout and calibration forms with measured rows $q$ and $k$ on $x$. The input direction $d$ and $q$ use only owners on $A$. An XOR into a specified subset of the paid sends on $c$ produces the measured terminal response $v=M d$, supported on $B$. The output covector $kM^{-1}$ is also supported on $B$. Require $v_h=1$, $q d=1$ and $k d=1$. The readout and calibration have zero response to the injection. The replay checks these two zeros for every recorded edit before scheduling the new graph. + +Take $x^0=x+e_h x_h$ and feed the old graph + +$$ +U(x)=x^0+d(x_h+q x^0). +$$ + +Then $qU(x)=x_h$, so the local readout at $c$ returns the old owner's value. With a fresh independent input $w$ on $c$, inject $w+kU(x)$. The old terminals become + +$$ +Y=M x^0+v(x_h+q x^0+w+kU(x)). +$$ + +The $h$ coordinate of $M x^0$ is zero because $h$ was an independent helper. Adding $Y_h$ to the other affected returns on $B$ leaves $(M x^0)_i=(M x)_i$ for every $i\ne h$. The fresh return on $B$ is $(kM^{-1})Y=w$ because $kd=1$. This preserves all other helper inputs and the main transfer, and gives both independent daughter returns on arbitrary fields. + +The edit journal specifies the source packet, intermediate chart, signal combinations and changed sender set. Every composition step is replayed on its predecessor and rescheduled with the full remaining dependency graph. Transposing back gives the physical forward word. The literal source audit checks same-frame contacts, nested paid moves, 636 rational frames, 111 main port charts, and every owned activation and CLEAR. Across the 672 public fields, both orientations check all 451,584 coefficients, including the 21 independent additional helper inputs. The native caller retains 36 invocations and exact separate polynomial checks of all $38^2$ coefficients in each orientation. The controls reject a missing readout, a zeroed new paid payload and a missing CLEAR. [Literal replay](replay.py) · [Replay receipt](REPLAY.json) + +The frame test preserves the projector interpretation from #7776. On a complete pair of address chunks, a chart is a partial interchange with diagonal blocks $I-P$ and off-diagonal blocks $P$, where $P$ projects onto its recorded rational subspace along the orthogonal complement. Nested projections commute. The difference between nested dimensions is the charged MOVE grade, and local XOR acts on whole fields in a common view. The 636 charts and their rational witnesses are inherited. The new paid contacts and public helper endpoints use those same frames. [Inherited physical realization and prime selection](https://github.com/aliromman/integer-mult-bounds/blob/4f7c67ae387cc91580f469aeda4d508b372b9ec1/research/p104-dual-supplier-lift/BIT-PROOF.md) + +## Complete rank and resource bill + +At $C>0$, put $H_r=r^{1-C}$. The native word replaces 13 productive $H_8$ with $2H_4$ each and eight with $H_1+H_7$ each. Its paid changes replace nine $H_4$ with $2H_2$ each, two $H_6$ with $H_2+H_4$ each, two $H_7$ with $H_3+H_4$ each and eight $H_7$ with $H_1+H_6$ each. Each count is repeated in 36 calls. For example, a grade-four subdivision supporting a $4+4$ helper birth gains $36(2H_4-H_8-2H_2+H_4)$ on the complete caller. At $C=0.00386380485468$, that contribution is between 0.38205793083006 and 0.38205793083008. + +The rebuilt invoice contains 20,418 productive fields, including 16,200 independently supplied native helpers, and 107,532 paid calls. Its raw rank surplus is 1,506. It includes the complete paid native positions, all paired caller queries, every idle mask and the individual productive caller roots. Serial storage reserves 4,224 native banks including four field buffers. Applying the retained 16 traversals per opcode and separately charging 572,184 route groups gives 933,004,517,520 raw ordinary records. The bound on raw owned backing is 6,998,328 full fields. These fit the inherited allowances of $10^{12}$ raw ordinary records and $10^7$ raw owned fields per raw invocation of the paired word in the product compiler. Actual tape transit still pays the complete field size. [Signed positions and resource recount](REPLAY.json) · [Finite inputs and resource recount](FINITE.json) + +## Finite compiler and ordinary stock + +Two rational arithmetic engines check the signed moment at trial $C=0.00386970000$ and the narrow crossing. At chronological power 768, paid cutoff base 15, productive completion base 16, and both tail offsets $1/5$, the normalized paid and surrendered-productive bound is strictly below one. The slack is at least $0.000347020484739325$. Productive tuples below the floor become charged owned zero specializations. The compiler retains every paid tuple and charges its splits. The maximum productive tuple rank is $127^{768}$, and the working ambient is $134^{768}$. The latter determines the logarithmic checks with $\theta=42/43$, power 619 and uniform $N=2^{297620000000000}$. The exact integer comparison passes there and fails at the preceding grid point. + +Take a uniform loss of $10^{-10}$ and a delayed-cover loss of $10^{-10}$. The resulting covered saving is 0.00386969980. The retained delayed-cover theorem charges the fallback classes and uses fixed rational matchers with weights independent of fresh descendants. After fixing the finite compiler catalogue, choose an odd prime greater than $2^{45}N^5$ that preserves all its denominators, nonzero determinants and rank witnesses. In the completed tape count the public, paid, owned, routing and setup terms include discarded targets, split specializations and additional compiler work. The finite catalogue, routing constants and prime stay fixed as the final widths grow. [Retained delayed cover and stock proof](https://github.com/CrocSwap/integer-mult-bounds/blob/e54523517d0f03e58352e647c403a5af3e525a57/research/p104-shared-native-helper-splits/retained/compiler/bit-audit/PROOF.md) + +Start from the selected ordinary saving 0.00385248. For $\rho=1/250$, each successor $b_{\mathrm{new}}$ satisfies + +$$ +b_{\mathrm{old}} 0 > margin(Q(right, scale))[1], "outer crossing bracket") + while right-left > 1: + middle = (left+right)//2 + lower, upper = margin(Q(middle, scale)) + if lower > 0: + left = middle + else: + need(upper < 0, "directed interior crossing sign") + right = middle + lo, hi = Q(left, scale), Q(right, scale) + endpoints = [f"{k//scale}.{k%scale:015d}" for k in (left, right)] + raw = margin(TRIAL) + need(raw[0] > 0 and TRIAL < lo, "strict finite binary trial") + need(margin(lo)[0] > 0 > margin(hi)[1], "complete binary crossing signs") + derivative = (0, 0) + for rank in targets.keys() | paid.keys(): + count = targets.get(rank, 0) - paid.get(rank, 0) + bound = iv.mul(iv.power(rank, hi if count >= 0 else Q(0)), iv.log(rank)) + derivative = iv.add(derivative, iv.smul(bound, -count)) + need(derivative[1] < 0, "unique crossing on the tested interval") + + finite = compiler.certificate(targets, paid, TRIAL, POWER, CUTOFF, FLOOR, OFFSET, OFFSET, + label="twenty-one binary helper births") + need(finite.pop("ambient") == "127^768", "largest productive rank") + finite["largest_productive_rank"] = "127^768" + uniform = compiler.uniform_certificate(TRIAL, POWER, CUTOFF, FLOOR, AMBIENT, GAP) + + def expplus(x): + return iv.div(iv.exact(1), iv.expminus(x)) + + def shifted(histogram, offset): + result = (0, 0) + for rank, quantity in histogram.items(): + x = iv.smul(iv.log(rank), abs(offset)) + factor = expplus(x) if offset > 0 else iv.expminus(x) + result = iv.add(result, iv.smul(iv.mul(iv.power(rank, TRIAL), factor), quantity)) + return result + + tt = iv.moment(targets, TRIAL) + ratios = ( + iv.div(iv.moment(paid, TRIAL), tt), + iv.div(shifted(paid, OFFSET), iv.mul(expplus(iv.smul(iv.log(CUTOFF), OFFSET)), tt)), + iv.div(iv.mul(expplus(iv.smul(iv.log(FLOOR), OFFSET)), shifted(targets, -OFFSET)), tt), + ) + limits = [Q(bound) for bound in finite["rational_upper_limits"]] + need(all(0 < l <= u <= b*iv.B < iv.B for (l, u), b in zip(ratios, limits)), + "independent interval comparison for all three ratios") + alpha, gamma, loss = limits + need(1/(1+POWER*(1-alpha))+2*gamma**POWER+loss**POWER < 1, + "finite paid and surrendered productive moment") + theta, power, h = Q(uniform["theta"]), uniform["logarithm_power"], uniform["H"] + base = expplus(iv.smul(iv.log(AMBIENT), TRIAL)) + factor, n = iv.exact(1), POWER + while n: + if n & 1: + factor = iv.mul(factor, base) + n //= 2 + if n: + base = iv.mul(base, base) + eta = iv.div(iv.exact(1-TRIAL), factor) + need(2*CUTOFF**(POWER*theta.denominator) <= AMBIENT**(POWER*theta.numerator), + "shifted logarithm inequality") + need(theta**power < Q(eta[0], iv.B) and Q(factor[1], iv.B) < 2**power, + "working ambient logarithm inequalities") + need((h+1)**power < 2**(h//GAP.denominator) + and (h-GAP.denominator+1)**power >= 2**(h//GAP.denominator-1), + "exact uniform threshold and preceding point") + + need(previous == Q("0.00385248"), "selected completed ordinary backend") + covered, rho, steps = TRIAL-2*GAP, Q(1, 250), [] + for admitted in STEPS: + saving = Q(admitted) + envelope = (1-rho)*covered + rho*previous + need(previous < saving < envelope < rho < 1-envelope, "acyclic ordinary bootstrap envelope") + steps.append(dict(previous=str(previous), admitted=admitted, envelope=str(envelope), slack=str(envelope-saving))) + previous = saving + need(previous > Q("0.00386932267588"), "qualified ordinary backend headroom") + return dict(raw_crossing=endpoints, crossing_margins=[iv.show(margin(lo)), iv.show(margin(hi))], + derivative_upper_interval=iv.show(derivative), tested_saving="0.00386970000", + trial_margin=iv.show(raw), finite_separation=finite, working_ambient="134^768", + independent_ratio_intervals=[iv.show(row) for row in ratios], uniform=uniform, + uniform_loss=str(GAP), delayed_cover_loss=str(GAP), covered="0.00386969980", rho=str(rho), + ordinary_bootstrap=steps, ordinary_admitted=STEPS[-1]) + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--upstream", type=Path, required=True) + parser.add_argument("--supplier", type=Path, required=True) + parser.add_argument("--native-report", type=Path, required=True) + parser.add_argument("--word", type=Path, default=HERE / "WORD.json.gz") + parser.add_argument("--out", type=Path) + args = parser.parse_args() + + file = args.word.read_bytes() + raw = gzip.decompress(file) if file.startswith(b"\x1f\x8b") else file + need(sha256(raw).hexdigest() == WORD_BYTES, "literal binary word bytes") + word = json.loads(raw) + canonical = json.dumps(word, sort_keys=True, separators=(",", ":")).encode() + need(sha256(canonical).hexdigest() == WORD, "canonical binary word") + native = json.loads(args.native_report.read_bytes()) + need(native["word_sha256"] == WORD and native["word_file_sha256"] == WORD_BYTES, + "literal replay bound to the word") + need(native["parent_pr"] == 7776 and native["source_head"] == HEAD and native["source_word_sha256"] == BASE, + "literal replay bound to published #7776") + + path = args.supplier / PACKAGE + if not path.is_dir(): + path = args.supplier + donor = {name: pinned(path / name, digest) for name, digest in DONOR_PINS.items()} + trusted = {name: pinned(args.upstream / name, digest) for name, digest in INPUT_PINS.items()} + caller = json.loads(gzip.decompress(trusted[CALLER])) + targets, paid, ordinary = invoice(native, word, json.loads(donor["BIT-RESULT.json"]), caller) + previous = Q(json.loads(trusted[SELECTED])["admitted_BIT_saving"]) + finite = qualify(args.upstream, targets, paid, previous) + report = dict(status="PASS_FINITE_BIT_BIRTHS_COMPILER_AND_ORDINARY_BOOTSTRAP", + donor_pr=7776, donor_head=HEAD, donor_word_sha256=BASE, word_sha256=WORD, word_file_sha256=WORD_BYTES, + trusted_inputs={str(name): value for name, value in INPUT_PINS.items()}, donor_inputs=DONOR_PINS, + targets=targets, paid=paid, ordinary=ordinary, **finite) + if args.out: + args.out.write_text(json.dumps(report, indent=2, sort_keys=True)+"\n") + print(report["status"], report["ordinary_admitted"], *report["raw_crossing"]) + + +if __name__ == "__main__": + main() diff --git a/research/p104-subdivided-helper-births/binary/independent/README.md b/research/p104-subdivided-helper-births/binary/independent/README.md new file mode 100644 index 0000000000..6d9451a257 --- /dev/null +++ b/research/p104-subdivided-helper-births/binary/independent/README.md @@ -0,0 +1,18 @@ +# Independent binary replay + +Run from the package directory with Python 3.11 or later. Give `--source-root` the sparse `source` tree prepared by `prepare_sources.py` for PR #7776 at `4f7c67ae387cc91580f469aeda4d508b372b9ec1`. + +```sh +python3 -B binary/independent/verify.py \ + --source-root /path/to/pinned-sources/source \ + --word binary/WORD.json.gz \ + --out independent-binary.json +``` + +The command writes one receipt with `native` and `finite` sections, and finishes with `PASS_INDEPENDENT_BINARY_BIRTHS_AND_FINITE_ORDINARY`. The source tree needs the selected claim, paired caller, selected native tape, and original #7776 binary and complex result files listed in the package source lock. The command authenticates these inputs, the published birth recipe, and both compressed and decompressed bytes of the checked-in word. + +The literal verifier rebuilds the #7776 route inventory from its selected native tape and eight published deletions. It checks each of the 21 archived source clocks, nested daughter ranks and productive boundary changes against the literal word. A separate interpreter replays the word and its adjoint, checking every chart tag and private lifetime. Its held-out controls omit one XOR into a paid bank from helper 671 and omit a dirty CLEAR. A packed polynomial interpreter verifies the paired caller in each direction. The 36-call paid and target histograms and the ordinary allowances are derived from those operations. + +The pricing verifier uses outward-rounded rational Taylor bounds for the two public #7776 crossings, the new signed crossing and the finite product. It then checks the finite separation, uniform carrier threshold and exact bootstrap inequalities. The package's two ordinary stages reach `0.00386969950` under the retained assumptions. The receipt also gives the optional third stage to `0.00386969970`. Joint multiplication requires the compatible complex supplier and outer application. + +The replay checks Ali Romman's eight-puncture binary service and the new subdivided helper births. Jerry Chen (CubeJerry) supplied the selected #7000/#7001 paired service. DreamingOfClouds contributed the chain and caller lineage, zxv and the retained authors supplied the selected native and finite compiler lineages, and Cinna Davis contributed to the root and native lineage. The independent Python implementation and checks used substantial OpenAI Codex assistance. [Original BIT proof](https://github.com/aliromman/integer-mult-bounds/blob/4f7c67ae387cc91580f469aeda4d508b372b9ec1/research/p104-dual-supplier-lift/BIT-PROOF.md) diff --git a/research/p104-subdivided-helper-births/binary/independent/literal.py b/research/p104-subdivided-helper-births/binary/independent/literal.py new file mode 100644 index 0000000000..eb1b1651d0 --- /dev/null +++ b/research/p104-subdivided-helper-births/binary/independent/literal.py @@ -0,0 +1,598 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Independent literal verifier for the Ali Romman and #7001 BIT lineage.""" +from collections import Counter +from fractions import Fraction as F +from functools import cache +from hashlib import sha256 +from pathlib import Path +import gzip +import json + +HERE = Path(__file__).resolve().parent +PAIRED = Path('research/paired-query-only-bit') +ALI = Path('research/p104-dual-supplier-lift') +OLD_WORD = PAIRED / 'retained' / 'inputs' / 'BIT-NATIVE-WORD.json.gz' +OLD_WORD_SHA = '51203e7fc75ba10bd3ac3f8e675759f47e13d262bea66b6600d1e515095cad78' +OLD_RESULT_SHA = '907858ba4c6f4c110662c8ea9faa1209acca07a9ae281ba29e9291a41fe8e6e1' +CALLER_SHA = '757b3523798f840bdb02028b23708c3416627a99ea09e7a3c4bcdc5cd0c7ce4b' +WORD_GZIP_SHA = 'a63f07a5f5ac4aa28b5b635c7836f36efafd03b735ab13f24c8b481d137d54e8' +WORD_SHA = 'e5871a4cf87d62aa90e6660d351636aa5ca47f50239916a0943cd433c7f3d323' +CANONICAL_WORD = '861f5181e4f34db638ab0c573c319fe26ff034d63b21242d67220a4a5d6433ff' +RECIPE_SHA = '9cdb651f7166c01abb9027535d36424da71944932f3b6f84057a12ae12ba6ad2' +RESIDUAL_WORD = '07f5fe923b50ecc26983054cf8f462b1a2b4a008a5e2c7a472209363abaaa35c' +PR7776_HEAD = '4f7c67ae387cc91580f469aeda4d508b372b9ec1' + + +def need(test, description): + if not test: + raise ValueError(description) + + +def canonical(obj): + return sha256(json.dumps(obj, separators=(',', ':'), sort_keys=True).encode()).hexdigest() + + +def pinned(path, expected): + raw = path.read_bytes() + need(sha256(raw).hexdigest() == expected, f'immutable input bytes for {path.name}') + return json.loads(gzip.decompress(raw) if path.suffix == '.gz' else raw) + + +def candidate_word(path): + packed = path.read_bytes() + need(sha256(packed).hexdigest() == WORD_GZIP_SHA, 'checked-in compressed word SHA-256') + raw = gzip.decompress(packed) + need(sha256(raw).hexdigest() == WORD_SHA, 'literal word SHA-256') + word = json.loads(raw) + need(canonical(word) == CANONICAL_WORD, 'canonical word SHA-256') + return word + + +def determinant(rows): + square = [list(row) for row in rows] + n = len(square) + value = F(1) + for c in range(n): + pivot = next((i for i in range(c, n) if square[i][c]), None) + need(pivot is not None, 'singular rational frame') + if pivot != c: + square[c], square[pivot] = square[pivot], square[c] + value *= -1 + entry = square[c][c] + value *= entry + for i in range(c + 1, n): + factor = square[i][c] / entry + if factor: + square[i] = [x - factor * y for x, y in zip(square[i], square[c])] + return value + + +def orthogonal(xs, ys): + return all(sum(x * y for x, y in zip(v, w)) == 0 for v in xs for w in ys) + + +class Charts: + def __init__(self, frames): + self.frames = {} + self.prime_factors = {2} + for label, frame in frames.items(): + b = [tuple(map(F, row)) for row in frame['B']] + a = [tuple(map(F, row)) for row in frame['A']] + need( + len(b) == frame['dim'] + and len(a) + len(b) == 8 + and all(len(row) == 8 for row in b + a), + 'physical frame ranks', + ) + need(orthogonal(b, a), 'dual rational frame annihilation') + d = determinant(b + a) + self.prime_factors.update([abs(d.numerator), d.denominator]) + self.prime_factors.update(x.denominator for row in b + a for x in row) + self.frames[int(label)] = (b, a) + self.rank = {label: len(b) for label, (b, _) in self.frames.items()} + + @cache + def leg(self, a, b): + lower, upper = sorted((a, b), key=self.rank.__getitem__) + n = self.rank[upper] - self.rank[lower] + need( + n > 0 and orthogonal(self.frames[lower][0], self.frames[upper][1]), + 'positive nested rational MOVE or helper grade', + ) + return n + + def main_contacts(self, start, end): + for j in range(111): + x, y = j, j + 111 + head = self.frames[start[x]][0] + body = self.frames[end[y]][0] + need( + len(head) == 1 + and len(body) == 7 + and not self.rank[start[y]] + and self.rank[end[x]] == 8, + 'literal main port quartet', + ) + need(orthogonal(head, body), 'same fixed head and disjoint rational body') + d = determinant(head + body) + self.prime_factors.update([abs(d.numerator), d.denominator]) + return 111 + + +def tape(word, charts, *, adjoint=False, omit=None, readouts=()): + public, owned = word['public'], word['owned_fields'] + steps = word['program'] + bank = [(1 << j) if j < public else 0 for j in range(public + owned)] + origin, destination = ( + (word['final'], word['start']) if adjoint else (word['start'], word['final']) + ) + tags = list(origin) + [None] * owned + counts, paid, routes = Counter(), Counter(), Counter() + live, peak, erase_dirty = 0, 0, 0 + found = {} + sequence = range(len(steps) - 1, -1, -1) if adjoint else range(len(steps)) + for clock in sequence: + if clock == omit: + continue + operation, r, *args = steps[clock] + need(0 <= r < len(bank), f'bank address at {clock}') + counts[operation] += 1 + if operation in ('INIT', 'CLEAR'): + need(r >= public and args[0] in charts.frames, f'private lifetime at {clock}') + opens = (operation == 'CLEAR') if adjoint else (operation == 'INIT') + if opens: + need(tags[r] is None, f'activation of live bank at {clock}') + live += 1 + peak = max(peak, live) + tags[r] = args[0] + else: + need(tags[r] == args[0], f'wrong chart at erasure {clock}') + live -= 1 + erase_dirty += int(bool(bank[r])) + tags[r] = None + bank[r] = 0 + elif operation == 'ADD': + source, chart = args + need( + 0 <= source < len(bank) + and r != source + and tags[r] == tags[source] == chart + and chart in charts.frames, + f'XOR chart contact at {clock}', + ) + if clock in readouts: + found[clock] = bank[r if adjoint else source] + if adjoint: + bank[source] ^= bank[r] + else: + bank[r] ^= bank[source] + elif operation == 'SWAP': + (other,) = args + need( + 0 <= other < len(bank) + and r != other + and tags[r] is not None + and tags[other] is not None, + f'whole-field swap at {clock}', + ) + bank[r], bank[other] = bank[other], bank[r] + tags[r], tags[other] = tags[other], tags[r] + else: + need(operation == 'MOVE' and r >= public, f'paid owned transfer at {clock}') + a, b = args[::-1] if adjoint else args + need(tags[r] == a, f'literal MOVE chronology at {clock}') + paid[charts.leg(a, b)] += 1 + routes[a, b] += 1 + tags[r] = b + need( + tags == list(destination) + [None] * owned and not live and not any(bank[public:]), + 'public endpoints and complete private retirement', + ) + return ( + bank[:public], + dict(counts=counts, paid=paid, routes=routes, peak=peak, erase_dirty=erase_dirty), + found, + ) + + +def expected_rows(n, adjoint): + result = [] + for r in range(n): + want = 1 << r + if adjoint and r < 111: + want ^= 1 << (r + 111) + if not adjoint and 111 <= r < 222: + want ^= 1 << (r - 111) + result.append(want) + return result + + +def different(observed, expected): + return ( + tuple(i for i, (actual, want) in enumerate(zip(observed, expected)) if actual != want), + sum((a ^ b).bit_count() for a, b in zip(observed, expected)), + ) + + +def held_out(word, charts, paid_banks): + n = word['public'] + held = n - 1 + choices = { + i + for i, (op, dst, *args) in enumerate(word['program']) + if op == 'ADD' and args[0] == held and dst in paid_banks + } + _, _, forward = tape(word, charts, readouts=choices) + official, _, backward = tape(word, charts, adjoint=True, readouts=choices) + need(official == expected_rows(n, True), 'official transpose before omission') + clock = min(i for i in choices if forward[i] and backward[i]) + mutated, _, _ = tape(word, charts, omit=clock) + flipped, number = different(mutated, expected_rows(n, False)) + transpose, _, _ = tape(word, charts, adjoint=True, omit=clock) + columns, count = different(transpose, expected_rows(n, True)) + expected_columns = tuple(j for j in range(n) if (forward[clock] >> j) & 1) + expected_outputs = tuple(j for j in range(n) if (backward[clock] >> j) & 1) + need( + flipped == expected_outputs and columns == expected_columns and number == count > 0, + 'held-out XOR omission with a nonzero exact endpoint change', + ) + retired = next(i for i, e in enumerate(word['program']) if e[0] == 'CLEAR') + try: + tape(word, charts, omit=retired) + except ValueError as exc: + need(str(exc) == 'public endpoints and complete private retirement', 'dirty CLEAR control') + else: + raise ValueError('held-out erasure accepted') + return dict( + helper=held, + omitted_ADD_clock=clock, + operation=word['program'][clock], + changed_output_rows=flipped, + changed_input_columns=columns, + changed_coefficients=number, + omitted_CLEAR_clock=retired, + dirty_CLEAR_control='rejected at terminal retirement', + ) + + +def birth_deltas(word, old, witness, paid_routes, charts): + # Ali's eight source restrictions are projected in the published #7776 binary proof. + removed_helpers = {633, 638, 646, 640, 649, 636, 651, 635} + removed_paid_ordinals = { + 2323, + 2657, + 2342, + 2669, + 2381, + 2695, + 2453, + 2743, + 2496, + 2771, + 2497, + 2773, + 2513, + 2783, + 2532, + 2795, + } + old_start = [c for j, c in enumerate(old['start']) if j not in removed_helpers] + old_end = [c for j, c in enumerate(old['final']) if j not in removed_helpers] + original_moves = [ + (clock, tuple(e[2:])) for clock, e in enumerate(old['program']) if e[0] == 'MOVE' + ] + retained = { + clock: edge + for j, (clock, edge) in enumerate(original_moves) + if j not in removed_paid_ordinals + } + base_routes = Counter(retained.values()) + base_native_paid = Counter() + for (a, b), amount in base_routes.items(): + base_native_paid[charts.leg(a, b)] += amount + base_native_targets = Counter( + charts.leg(old_start[j], old_end[j]) for j in range(222, len(old_start)) + ) + need( + len(old_start) == len(old_end) == 651 and len(witness['steps']) == 21, + 'source birth lineage inventory', + ) + revised_start, revised_end = old_start.copy(), old_end.copy() + seen, seen_clocks = set(), set() + paid_deltas, target_deltas = Counter(), Counter() + for entry in witness['steps']: + role, via = (entry['witness'][k] for k in ('role', 'chart')) + need( + role >= 222 and role not in seen and entry['reverse'], + 'distinct transposed helper birth', + ) + seen.add(role) + a, b = entry['old_move_charts'][::-1] + clock = entry['original_selected_source_clock'] + need( + retained.get(clock) == (a, b) and clock not in seen_clocks and base_routes[a, b] > 0, + 'distinct retained archived MOVE with the exact oriented charts', + ) + seen_clocks.add(clock) + base_routes[a, b] -= 1 + base_routes[a, via] += 1 + base_routes[via, b] += 1 + paid_deltas[charts.leg(a, b)] -= 1 + paid_deltas[charts.leg(a, via)] += 1 + paid_deltas[charts.leg(via, b)] += 1 + s, t = revised_start[role], revised_end[role] + need([t, s] == entry['old_helper_charts'], 'archived helper start and end') + need( + charts.rank[s] < charts.rank[via] < charts.rank[t], 'strict forward helper grade split' + ) + need( + [charts.leg(b, via), charts.leg(via, a)] == entry['paid_daughter_ranks'] + and [charts.leg(t, via), charts.leg(via, s)] == entry['target_daughter_ranks'], + 'literal daughter ranks', + ) + target_deltas[charts.leg(s, t)] -= 1 + target_deltas[charts.leg(s, via)] += 1 + target_deltas[charts.leg(via, t)] += 1 + revised_start[role] = via + revised_start.append(s) + revised_end.append(via) + need( + (revised_start, revised_end) == (word['start'], word['final']), + 'every old and new helper boundary', + ) + need(base_routes == paid_routes, 'complete literal oriented route multiset matches 21 births') + return dict( + parent_native_paid=base_native_paid, + parent_native_targets=base_native_targets, + native_paid_delta=paid_deltas, + native_target_delta=target_deltas, + split_roles=sorted(seen), + ) + + +def shift(form, count, q=False): + return {(monomial + count) ^ int(q): coefficients for monomial, coefficients in form.items()} + + +def add(receiver, donor): + out = receiver.copy() + for monomial, coefficients in donor.items(): + value = out.get(monomial, 0) ^ coefficients + if value: + out[monomial] = value + else: + out.pop(monomial, None) + return out + + +def caller_monomial(stages): + return sum(1 << (10 * (stage - 1) + 1) for stage in stages) + + +def caller_rows(caller, adjoint=False): + """Encode independent stage exponents in disjoint 10-bit slots, q in low bit.""" + n = caller['roles'] + need(len(caller['events']) < 2**10, 'independent stage monomial exponents cannot carry') + rows = [{0: 1 << j} for j in range(n)] + order = reversed(caller['events']) if adjoint else caller['events'] + for op, *args in order: + if op == 'ADD' or op == 'QUERY': + destination, source = args[::-1] if adjoint else args + rows[destination] = add(rows[destination], shift(rows[source], 0, op == 'QUERY')) + elif op == 'SWAP': + a, b = args + rows[a], rows[b] = rows[b], rows[a] + elif op == 'LOCAL': + stage, a, b = args + if adjoint: + a, b = b, a + count = caller_monomial([stage]) + rows[a], rows[b] = shift(rows[a], count), shift( + add(rows[b], shift(rows[a], 0, True)), count + ) + elif op == 'IDLE_ONE': + a, stages = args + rows[a] = shift(rows[a], caller_monomial(stages)) + else: + raise ValueError(f'unknown caller event {op}') + return rows + + +def paired_invoice(caller, native_paid, native_targets, caller_event_counts): + need( + ( + caller['roles'], + caller['ports'], + caller['stages'], + caller['body_rank'], + caller['ambient_rank'], + ) + == (38, 111, 18, 7, 127), + '111 physical ports, 38 root roles, 18 stages and seven body directions', + ) + roots = [ + {caller_monomial(owner['stages']) | owner['q']: 1 << j} + for j, owner in enumerate(caller['diagonal']) + ] + need( + caller_rows(caller) == roots == caller_rows(caller, True), + 'every paired caller coefficient in both directions', + ) + need( + all( + owner['q'] == 1 + and owner['stages'] + and set(owner['stages']) <= set(range(1, 19)) + and len(owner['stages']) == len(set(owner['stages'])) + for owner in caller['diagonal'] + ), + 'nonempty root body and productive q grade', + ) + paid, targets = Counter(), Counter() + stage_roles = {} + stages = [] + ports = caller['ports'] + for op, *args in caller['events']: + if op in ('ADD', 'SWAP', 'QUERY'): + a, b = args + need(a != b and 0 <= a < 38 and 0 <= b < 38, 'distinct cocharted caller operands') + if op == 'QUERY': + paid[1] += ports + elif op == 'LOCAL': + stage, a, b = args + touched = stage_roles.setdefault(stage, set()) + need( + a != b + and 0 <= a < 38 + and 0 <= b < 38 + and stage in range(1, 19) + and not touched.intersection({a, b}), + 'both actual disjoint main pairs at their fresh stage', + ) + touched.update((a, b)) + stages.append(stage) + paid.update(native_paid) + targets.update(native_targets) + elif op == 'IDLE_ONE': + a, ss = args + need( + 0 <= a < 38 and ss and len(ss) == len(set(ss)) and set(ss) <= set(range(1, 19)), + 'complete charged idle mask', + ) + paid[7 * len(ss)] += ports + need(stages == [i for i in range(1, 19) for _ in range(2)], '36 actual sealed LOCAL blocks') + for owner in caller['diagonal']: + targets[1 + 7 * len(owner['stages'])] += ports + copies = caller_event_counts['LOCAL'] + need( + sum(targets.values()) == 111 * 38 + copies * sum(native_targets.values()), + 'complete public count with disjoint independent helpers', + ) + return paid, targets + + +def ordinary(word, caller, events, paid, targets): + ports, roles = caller['ports'], caller['roles'] + copies, query, idles = (events[k] for k in ('LOCAL', 'QUERY', 'IDLE_ONE')) + owned, public = word['owned_fields'], word['public'] + scratch = 4 + banks = owned + public + scratch + native_flow = 16 * banks * len(word['program']) + total_op = ports * (8 * (events['ADD'] + 3 * events['SWAP']) + 256 * (copies + query + roles)) + groups = 4 * (sum(targets.values()) + sum(paid.values())) + 8 * ports * (copies + idles) + route_flow = groups * 80 * (134**2 + 134) + whole = copies * native_flow + total_op + route_flow + reserve = ( + copies * (owned + scratch) + + 2 * ports * roles * len(caller['events']) + + 16 * ports * (copies + query + roles) + ) + need(whole < 10**12 and reserve < 10**7, 'whole-job raw ordinary and owned allowances') + return dict( + native_banks_and_scratch=banks, + native_bank_transits_per_call=native_flow, + caller_bank_transits=total_op, + route_groups=groups, + route_records=route_flow, + ordinary_records=whole, + owned_backing=reserve, + raw_ordinary_allowance=10**12, + raw_owned_allowance=10**7, + ) + + +def histogram(row): + return Counter({int(k): n for k, n in row.items()}) + + +def verify(source_root, word_path): + word = candidate_word(word_path) + witness = pinned(HERE.parent / 'BIRTHS.json', RECIPE_SHA) + old = pinned(source_root / OLD_WORD, OLD_WORD_SHA) + old_result = pinned(source_root / ALI / 'BIT-RESULT.json', OLD_RESULT_SHA) + caller = pinned(source_root / PAIRED / 'EFREE-CALLER.json.gz', CALLER_SHA) + n = word['public'] + need( + witness['parent_head'] == PR7776_HEAD + and witness['parent_pr'] == 7776 + and witness['parent_program_sha256'] + == old_result['native']['program_sha256'] + == RESIDUAL_WORD, + 'recipe and published #7776 residual native word', + ) + need(witness['program_sha256'] == CANONICAL_WORD and n == 672, 'frozen 672-owner construction') + need( + word['frames'] == old['frames'] and len(word['frames']) == 636, + 'all physical frames unchanged', + ) + charts = Charts(word['frames']) + main_ports = charts.main_contacts(word['start'], word['final']) + forward, forward_log, _ = tape(word, charts) + transpose, reverse_log, _ = tape(word, charts, adjoint=True) + need( + forward == expected_rows(n, False) and transpose == expected_rows(n, True), + 'all arbitrary native scalar coefficients', + ) + need(forward_log['paid'] == reverse_log['paid'], 'both literal paid rank histograms') + native_targets = Counter( + charts.leg(a, b) for a, b in zip(word['start'][222:], word['final'][222:]) + ) + need( + all( + charts.rank[a] < charts.rank[b] + for a, b in zip(word['start'][222:], word['final'][222:]) + ), + 'positive native helper grades', + ) + composition = birth_deltas(word, old, witness, forward_log['routes'], charts) + paid_banks = {event[1] for event in word['program'] if event[0] == 'MOVE'} + controls = held_out(word, charts, paid_banks) + call_events = Counter(e[0] for e in caller['events']) + paid, targets = paired_invoice(caller, forward_log['paid'], native_targets, call_events) + old_paid, old_targets = paired_invoice( + caller, composition['parent_native_paid'], composition['parent_native_targets'], call_events + ) + need( + old_paid == histogram(old_result['paid']) + and old_targets == histogram(old_result['targets']), + 'independently reconstructed #7776 full signed invoice', + ) + old_paid.update({k: 36 * v for k, v in composition['native_paid_delta'].items()}) + old_targets.update({k: 36 * v for k, v in composition['native_target_delta'].items()}) + need(paid == old_paid and targets == old_targets, 'complete 36-call independent invoice') + ledger = ordinary(word, caller, call_events, paid, targets) + return dict( + status='PASS_INDEPENDENT_LITERAL_BINARY_BIRTHS', + source_pr=7776, + source_head=PR7776_HEAD, + source_residual_native_sha256=RESIDUAL_WORD, + candidate_file_sha256=WORD_SHA, + candidate_gzip_sha256=WORD_GZIP_SHA, + candidate_canonical_sha256=CANONICAL_WORD, + source_word_sha256=OLD_WORD_SHA, + caller_sha256=CALLER_SHA, + witnessed_input_sha256=RECIPE_SHA, + public=n, + native_scalar_coefficients_each_way=n * n, + caller_polynomial_coefficients_each_way=38**2, + frames=len(charts.frames), + main_ports=main_ports, + raw_prime_exclusion_factors=sorted(charts.prime_factors), + instruction_counts=forward_log['counts'], + forward_peak_owned=forward_log['peak'], + reverse_peak_owned=reverse_log['peak'], + owned_nonzero_CLEAR=forward_log['erase_dirty'], + dual_nonzero_retirement=reverse_log['erase_dirty'], + birth_composition=composition, + native_paid=forward_log['paid'], + native_targets=native_targets, + held_out_controls=controls, + caller_events=call_events, + native_calls=36, + paid=paid, + targets=targets, + signed_rank_surplus=sum(r * k for r, k in targets.items()) + - sum(r * k for r, k in paid.items()), + ordinary=ledger, + ) diff --git a/research/p104-subdivided-helper-births/binary/independent/price.py b/research/p104-subdivided-helper-births/binary/independent/price.py new file mode 100644 index 0000000000..eb352c57bd --- /dev/null +++ b/research/p104-subdivided-helper-births/binary/independent/price.py @@ -0,0 +1,364 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Directed arithmetic replay of the credited finite BIT compiler and bootstrap.""" +from collections import Counter +from fractions import Fraction as F +from functools import cache + +from literal import ALI, CANONICAL_WORD, OLD_RESULT_SHA, PR7776_HEAD, histogram, need, pinned + +GRID = 10**72 +TRIAL = F('0.00386970000') +TARGET_TEXT = '0.00386380485468' +TARGET = F(TARGET_TEXT) +LOSS = F(1, 10**10) +CLAIM_SHA = '3f8add8252adb223b60418ec69351a69b6b5edfe601ec1c6b4b65cd9e2afd9b2' +OLD_COMPLEX_SHA = '145853ea4d35e6b82ad08f9bacb9f4c655dc139c2fb4e11339e198e9b8c46eb7' +CLAIMS = ('0.00386963090', '0.00386969950', '0.00386969970') + + +def ceiling(num, den): + return -((-num) // den) + + +def point(x): + q = F(x) + return q.numerator * GRID // q.denominator, ceiling(q.numerator * GRID, q.denominator) + + +def add(a, b): + return a[0] + b[0], a[1] + b[1] + + +def sub(a, b): + return a[0] - b[1], a[1] - b[0] + + +def mul(a, b): + products = [x * y for x in a for y in b] + return min(products) // GRID, ceiling(max(products), GRID) + + +def scale(a, x): + return mul(a, point(x)) + + +def invert(a): + need(a[0] > 0, 'strictly positive interval denominator') + return GRID * GRID // a[1], ceiling(GRID * GRID, a[0]) + + +def divide(a, b): + return mul(a, invert(b)) + + +def decimal_interval(a, digits=39): + display = 10**digits + + def fixed(n): + integer, tail = divmod(abs(n), display) + return f'{"-" if n<0 else ""}{integer}.{tail:0{digits}}' + + return [fixed(a[0] * display // GRID), fixed(ceiling(a[1] * display, GRID))] + + +def rational_display(q, digits=18): + return decimal_interval(point(q), digits) + + +def log_taylor(t): + total = F(0) + factor = t + square = t * t + for j in range(85): + total += 2 * factor / (2 * j + 1) + factor *= square + tail = 2 * factor / (171 * (1 - square)) + return point(total)[0], point(total + tail)[1] + + +@cache +def ln(rank): + need(isinstance(rank, int) and rank >= 1, 'positive integer rank') + bit = rank.bit_length() - 1 + scaled = F(rank, 1 << bit) + return add(scale(log_taylor(F(1, 3)), bit), log_taylor((scaled - 1) / (scaled + 1))) + + +def positive_exp(x): + # With x<2, each term after degree 101 is at most half its predecessor. + need(0 <= x[0] <= x[1] < 2 * GRID, 'positive exponential Taylor interval') + term = total = point(1) + for j in range(1, 101): + term = scale(mul(term, x), F(1, j)) + total = add(total, term) + following = scale(mul(term, x), F(1, 101)) + return total[0], total[1] + 2 * following[1] + + +@cache +def exp_log(rank, scale_factor): + positive = positive_exp(scale(ln(rank), abs(scale_factor))) + return invert(positive) if scale_factor < 0 else positive + + +def raise_interval(base, n): + product = point(1) + while n: + if n & 1: + product = mul(product, base) + base = mul(base, base) + n //= 2 + return product + + +@cache +def price(rank, k, offset=F(0)): + return scale(exp_log(rank, offset - k), rank) + + +def moment(hist, k, offset=F(0)): + out = (0, 0) + for rank, amount in hist.items(): + if amount: + out = add(out, scale(price(rank, k, offset), amount)) + return out + + +def signed_profile(targets, paid): + out = Counter(targets) + out.subtract(paid) + return out + + +def derivative_bound(signed, cap): + # Positive coefficients contribute their least negative term at cap. + # Negative coefficients contribute their greatest positive term at zero. + bound = (0, 0) + for rank, count in signed.items(): + if count: + power = price(rank, cap if count > 0 else F(0)) + bound = add(bound, scale(mul(power, ln(rank)), -count)) + need(bound[1] < 0, 'strictly decreasing complete signed tariff on the comparison interval') + return bound[1] + + +def crossing(signed): + scale = 10**15 + low, high = int(TARGET * scale), int(F('0.0039') * scale) + need( + moment(signed, F(low, scale))[0] > 0 and moment(signed, F(high, scale))[1] < 0, + 'positive and negative signed crossing endpoints', + ) + derivative = derivative_bound(signed, F(high, scale)) + + def str_rank(k): + return f'0.{k:015}' + + while high - low > 1: + mid = (low + high) // 2 + test = moment(signed, F(mid, scale)) + need(test[0] > 0 or test[1] < 0, 'decisive interval sign at crossing grid point') + if test[0] > 0: + low = mid + else: + high = mid + return dict( + bracket=[str_rank(low), str_rank(high)], + endpoint_margins=[decimal_interval(moment(signed, F(k, scale))) for k in (low, high)], + derivative_upper=decimal_interval((derivative, derivative), 12)[1], + ) + + +def compiler(paid, targets, trial): + v, c, b, m = 768, 15, 16, 134 + offset = F(1, 5) + need( + offset >= trial and max(paid) < max(targets) <= m and 1 < c < b < max(targets), + 'separated rank cutoffs', + ) + total_targets = moment(targets, trial) + ratios = ( + divide(moment(paid, trial), total_targets), + divide(moment(paid, trial, offset), mul(exp_log(c, offset), total_targets)), + divide(mul(exp_log(b, offset), moment(targets, trial, -offset)), total_targets), + ) + bound_grid = 10**22 + alpha, gamma, lam = (F(ceiling(z[1] * bound_grid, GRID), bound_grid) for z in ratios) + need(all(0 < r < 1 for r in (alpha, gamma, lam)), 'three finite-product tail bounds below one') + volume = 1 / (1 + v * (1 - alpha)) + 2 * gamma**v + lam**v + need(volume < 1, 'strict complete paid and discarded productive moment') + theta = F(42, 43) + need( + c**43 < b**42 and c**42 >= b**41 and 2 * c ** (v * 43) <= m ** (v * 42), + 'actual ambient and both separated shifted-log bounds', + ) + base = raise_interval(exp_log(m, trial), v) + eta = scale(invert(base), 1 - trial) + power = 1 + + def threshold_passes(k): + return theta**k < F(eta[0], GRID) and F(base[1], GRID) < 2**k + + while not threshold_passes(power): + power += 1 + need( + theta ** (power - 1) >= F(eta[1], GRID) or F(base[0], GRID) >= 2 ** (power - 1), + 'preceding shifted-log power excluded', + ) + step = LOSS.denominator + + def carrier_passes(test): + return (step * test + 1) ** power < 2**test + + lo, hi = 1, 2 + while not carrier_passes(hi): + lo, hi = hi, 2 * hi + while hi - lo > 1: + mid = (hi + lo) // 2 + if carrier_passes(mid): + hi = mid + else: + lo = mid + need( + carrier_passes(hi) and not carrier_passes(hi - 1), + 'uniform integer threshold and preceding grid point', + ) + return dict( + trial=str(trial), + product_exponent=v, + cutoff=c, + productive_floor=b, + ambient_base=m, + paid_offset=str(offset), + target_offset=str(offset), + upper_ratios=[str(alpha), str(gamma), str(lam)], + ratio_intervals=[decimal_interval(z) for z in ratios], + normalized_separation_slack=rational_display(1 - volume), + theta=str(theta), + logarithm_power=power, + H=step * hi, + N=f'2^{step*hi}', + eta=decimal_interval(eta), + previous_power_failed=True, + preceding_grid_failed=True, + lost_low_targets='charged owned zero specializations', + maximum_productive_rank=f'{max(targets)}^{v}', + working_ambient=f'{m}^{v}', + ) + + +def bootstrap(start, covered, steps): + rho = F(1, 250) + stages = [] + old = start + for step in steps: + k = F(step) + envelope = (1 - rho) * covered + rho * old + need( + old < k < envelope < rho < 1 - envelope, + 'literal ordinary stage estimate and stock inequalities', + ) + stages.append( + dict( + previous=str(old), + claim=str(step), + envelope=rational_display(envelope, 18), + slack=rational_display(envelope - k, 18), + ) + ) + old = k + return old, stages + + +def verify(source_root, word, literal_receipt_sha256): + need( + word['candidate_canonical_sha256'] == CANONICAL_WORD and word['native_calls'] == 36, + 'independently replayed 36-call source word', + ) + paid, targets = map(histogram, (word['paid'], word['targets'])) + signed = signed_profile(targets, paid) + old = pinned(source_root / ALI / 'BIT-RESULT.json', OLD_RESULT_SHA) + old_complex = pinned(source_root / ALI / 'complex' / 'RESULT.json', OLD_COMPLEX_SHA)[ + 'application' + ] + before = signed_profile(histogram(old['targets']), histogram(old['paid'])) + complex_invoice = old_complex['invoice'] + complex_signed = signed_profile( + histogram(complex_invoice['targets']), histogram(complex_invoice['paid']) + ) + old_bracket = old['compiler']['raw_bracket'] + complex_bracket = old_complex['bracket'] + need( + moment(before, F(old_bracket[0]))[0] > 0 and moment(before, F(old_bracket[1]))[1] < 0, + 'independent signs for original binary crossing', + ) + need( + moment(complex_signed, F(complex_bracket[0]))[0] > 0 + and moment(complex_signed, F(complex_bracket[1]))[1] < 0, + 'independent signs for original complex crossing', + ) + derivative_bound(before, F('0.0039')) + derivative_bound(complex_signed, F('0.0039')) + old_joint_raw_upper = min(old_bracket[1], complex_bracket[1], key=F) + need( + moment(before, TARGET)[1] < 0 + and moment(signed, TARGET)[0] > 0 + and moment(signed, TRIAL)[0] > 0, + 'old negative and new positive full invoice at frozen target and finite trial', + ) + crossing_report = crossing(signed) + proof = compiler(paid, targets, TRIAL) + start = F( + pinned(source_root / 'certificates' / 'frontier7000' / 'CLAIM.json', CLAIM_SHA)[ + 'admitted_BIT_saving' + ] + ) + need(start == F('0.00385248'), 'selected completed base backend') + covered = TRIAL - 2 * LOSS + final, stages = bootstrap(start, covered, CLAIMS) + old_finite = F(old['compiler']['ordinary_admitted']) + need(F('0.00385896149') == old_finite < F(old_bracket[1]), 'old finite ordinary BIT') + published = F(CLAIMS[1]) + need( + final > published > TARGET + and published - old_finite > F('0.00001') + and published - F(old_joint_raw_upper) > F('0.00001'), + 'strict published ordinary improvement and original target clearance', + ) + return dict( + status='PASS_INDEPENDENT_BINARY_FINITE_AND_ORDINARY', + candidate_canonical_sha256=CANONICAL_WORD, + independent_literal_receipt_sha256=literal_receipt_sha256, + target=TARGET_TEXT, + old_7776_binary_margin=decimal_interval(moment(before, TARGET)), + new_binary_signed_margin=decimal_interval(moment(signed, TARGET)), + binary_signed_gain=decimal_interval(sub(moment(signed, TARGET), moment(before, TARGET))), + margin_at_finite_trial=decimal_interval(moment(signed, TRIAL)), + raw_crossing=crossing_report, + old_public_binary_bracket=old_bracket, + old_public_complex_bracket=complex_bracket, + old_source_head=PR7776_HEAD, + old_joint_raw_upper=old_joint_raw_upper, + old_conditional_lower=old_complex['claim'], + complete_binary_paid=paid, + complete_productive=targets, + compiler=proof, + per_phase_uniform_and_cover_loss=str(LOSS), + after_uniform=str(TRIAL - LOSS), + after_delayed_cover=str(covered), + ordinary_stages=stages, + published_ordinary_admitted=CLAIMS[1], + ordinary_admitted=CLAIMS[-1], + above_previous_ordinary=rational_display(final - old_finite), + above_public_7776_joint_raw_upper=rational_display(final - F(old_joint_raw_upper)), + above_frozen_target=rational_display(final - TARGET), + stock=dict( + rho='1/250', + w='ceil(e^rho)', + D='2+ceil(log_N(max(1,ceil(e/w))))', + small_width_backing='W(w)^D * predecessor', + high_digit_backing='O_fixed(w log e)', + ), + record_scope='Conditional ordinary BIT under inherited physical, finite compiler, cover and stock theorems.', + ) diff --git a/research/p104-subdivided-helper-births/binary/independent/verify.py b/research/p104-subdivided-helper-births/binary/independent/verify.py new file mode 100644 index 0000000000..9367cbac53 --- /dev/null +++ b/research/p104-subdivided-helper-births/binary/independent/verify.py @@ -0,0 +1,49 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Independently verify the literal binary births, caller tariff and ordinary bound.""" +import argparse +from hashlib import sha256 +import json +from pathlib import Path +import sys + +sys.path.insert(0, str(Path(__file__).resolve().parent)) +import literal +import price + +HERE = Path(__file__).resolve().parent + + +def encode(receipt): + return (json.dumps(receipt, indent=2, sort_keys=True) + '\n').encode() + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument( + '--source-root', type=Path, required=True, help='sparse root of pinned public PR #7776' + ) + parser.add_argument( + '--word', + type=Path, + default=HERE.parent / 'WORD.json.gz', + help='checked-in compressed binary tape', + ) + parser.add_argument( + '--out', type=Path, required=True, help='destination for combined verification receipt' + ) + args = parser.parse_args() + + native = literal.verify(args.source_root, args.word) + finite = price.verify(args.source_root, native, sha256(encode(native)).hexdigest()) + status = 'PASS_INDEPENDENT_BINARY_BIRTHS_AND_FINITE_ORDINARY' + args.out.write_bytes(encode(dict(status=status, native=native, finite=finite))) + print(native['status'], native['public'], native['native_calls']) + print( + finite['status'], finite['published_ordinary_admitted'], *finite['raw_crossing']['bracket'] + ) + print(status) + + +if __name__ == '__main__': + main() diff --git a/research/p104-subdivided-helper-births/binary/replay.py b/research/p104-subdivided-helper-births/binary/replay.py new file mode 100644 index 0000000000..62b6f975bf --- /dev/null +++ b/research/p104-subdivided-helper-births/binary/replay.py @@ -0,0 +1,392 @@ +#!/usr/bin/env python3 +"""Rebuild and audit the 21 funded GF(2) helper births. Apache-2.0. + +The #7776 eight-puncture graph, native emitter and paired caller are retained +with attribution to Ali Romman and the #7000/#7001 lineage. The new paid +subdivisions and calibrated helper returns are constructive replay records. +""" +import argparse +from collections import Counter +from dataclasses import dataclass +from hashlib import sha256 +import gzip +import importlib.util +import json +from pathlib import Path +import subprocess +import sys + +HERE = Path(__file__).resolve().parent +ALI = Path("research/p104-dual-supplier-lift") +PAIRED = Path("research/paired-query-only-bit") +HEAD = "4f7c67ae387cc91580f469aeda4d508b372b9ec1" +EARLIER_HEAD = "0b86d0f618b8c64be9410a83a417067049076067" +PARENT = "07f5fe923b50ecc26983054cf8f462b1a2b4a008a5e2c7a472209363abaaa35c" +PROGRAM = "861f5181e4f34db638ab0c573c319fe26ff034d63b21242d67220a4a5d6433ff" +PAYLOAD = "e5871a4cf87d62aa90e6660d351636aa5ca47f50239916a0943cd433c7f3d323" +RECIPE = "9cdb651f7166c01abb9027535d36424da71944932f3b6f84057a12ae12ba6ad2" +GZIP = "a63f07a5f5ac4aa28b5b635c7836f36efafd03b735ab13f24c8b481d137d54e8" +SOURCE_PINS = { + ALI / "bit_native.py": "4368c62a5d42f81189d6776b8dba8c85a311b6a199b816244b545c6bb7d3dc1e", + ALI / "bit_application.py": "fa76543d0aa0d515b48eaa9516f73df2c34a5f482114080fe3bcd6d37c32bbbd", + ALI / "BIT-RESULT.json": "907858ba4c6f4c110662c8ea9faa1209acca07a9ae281ba29e9291a41fe8e6e1", + PAIRED / "EFREE-CALLER.json.gz": "757b3523798f840bdb02028b23708c3416627a99ea09e7a3c4bcdc5cd0c7ce4b", + PAIRED / "check.py": "460ed9a77d66264b00c31d0a7f8dab1db9aab21ec4cc0eaf0452bd4be4ef585e", + PAIRED / "retained/audit_binary_mixed.py": "bb6616dbf536acf10163b8fff65ebfa69d01dfdeda3c0ead388c03377361b298", + PAIRED / "retained/inputs/BIT-NATIVE-WORD.json.gz": + "51203e7fc75ba10bd3ac3f8e675759f47e13d262bea66b6600d1e515095cad78", +} +HEAD_MASK = (1 << 111) - 1 +CALLS = 36 +BIRTHS = 21 + + +def need(condition, message): + if not condition: + raise ValueError(message) + + +def read_sha(path, expected): + raw = path.read_bytes() + need(sha256(raw).hexdigest() == expected, "SHA-256 pin: " + str(path)) + return raw + + +def module(path, name): + spec = importlib.util.spec_from_file_location(name, path) + loaded = importlib.util.module_from_spec(spec) + sys.modules[name] = loaded + spec.loader.exec_module(loaded) + return loaded + + +def bits(row): + while row: + least = row & -row + yield least.bit_length() - 1 + row ^= least + + +def mask(labels): + need(len(labels) == len(set(labels)) and all(type(r) is int and r >= 0 for r in labels), + "distinct nonnegative basis labels") + return sum(1 << r for r in labels) + + +def xor(row, values): + result = 0 + for k in bits(row): + result ^= values[k] + return result + + +def transfer(column, reverse): + """Full endpoint on a column in the selected orientation.""" + if reverse: + return column ^ ((column >> 111) & HEAD_MASK) + return column ^ ((column & HEAD_MASK) << 111) + + +def parity(u, v): + return (u & v).bit_count() & 1 + + +@dataclass +class Network: + initial: dict + final: dict + moves: dict + rows: dict + + def transpose(self): + rows = dict.fromkeys(self.rows, 0) + for k, row in self.rows.items(): + sender = ~k if k < 0 else k + for j in bits(row): + rows[~j if j in self.initial else j] ^= 1 << sender + return Network(self.final, self.initial, {k: (b, a) for k, (a, b) in self.moves.items()}, rows) + + def validate(self, edge, reverse): + order = edge.schedule(self.initial, self.final, self.moves, self.rows) + values = {r: 1 << r for r in self.initial} + for k in order: + values[k] = xor(self.rows[k], values) + columns = dict.fromkeys(values, 0) + for r in self.initial: + row = self.rows[~r] + need(xor(row, values) == transfer(1 << r, not reverse), + f"forward public return at owner {r}") + for k in bits(row): + columns[k] ^= 1 << r + for k in reversed(order): + for j in bits(self.rows[k]): + columns[j] ^= columns[k] + for r in self.initial: + need(columns[r] == transfer(1 << r, reverse), + f"adjoint public return at owner {r}") + return order, values, columns + + +def make_baseline(root, edge): + source = edge.read_pinned(root, edge.NATIVE, edge.NATIVE_SHA) + initial, final, moves, rows, original_clocks = edge.extract(source) + for r, *ordinals in edge.PUNCTURES: + zero, alias, donor = [source["public"] + i for i in ordinals] + order = edge.schedule(initial, final, moves, rows) + impulse = edge.basis(initial, moves, rows, order) + need(impulse[zero] == impulse[alias] ^ impulse[donor] == 1 << r, + "retained helper puncture impulse") + need(moves[alias][0] == moves[donor][0], "retained helper puncture sender") + initial, final, moves, rows = edge.puncture(initial, final, moves, rows, r, zero, alias, donor) + graph = Network(initial, final, moves, rows) + order, _, _ = graph.validate(edge, False) + word = edge.emit_word(source, initial, final, moves, rows, order) + need(edge.digest(word) == PARENT, "canonical #7776 public BIT baseline") + clocks = [j for j, op in enumerate(word["program"]) if op[0] == "MOVE"] + need((len(initial), len(order), len(clocks)) == (651, 2855, 2855), "source inventory") + return source, graph, original_clocks, dict(zip(order, clocks)) + + +def strict_chain(frames, audit, a, c, b): + source, middle, target = (frames[str(x)] for x in (a, c, b)) + if source["dim"] > target["dim"]: + source, target = target, source + return (source["dim"] < middle["dim"] < target["dim"] + and audit.included(source, middle) and audit.included(middle, target)) + + +def apply_birth(net, step, frames, edge, audit): + """Subdivide the paid contact, then insert calibrated independent local input.""" + need(step["reverse"] is True, "recorded transposed birth orientation") + witness = step["witness"] + h, c = witness["role"], witness["chart"] + e, f = step["source_packet"], step["new_packet"] + a, b = net.moves[e] + A, B = net.initial[h], net.final[h] + need(h >= 222, "only a productive helper can split") + need(([a, b], [A, B]) == (step["old_move_charts"], step["old_helper_charts"]), + "paid and productive endpoint preimage") + need(strict_chain(frames, audit, a, c, b) and strict_chain(frames, audit, A, c, B), + "both intermediate rational nesting chains") + dim = {key: frames[str(key)]["dim"] for key in (a, b, A, B, c)} + paid_ranks = [abs(dim[a] - dim[c]), abs(dim[b] - dim[c])] + target_ranks = [abs(dim[A] - dim[c]), abs(dim[B] - dim[c])] + need((paid_ranks, target_ranks) == (step["paid_daughter_ranks"], step["target_daughter_ranks"]), + "all four daughter grades") + need(f == max(net.initial.keys() | net.moves.keys()) + 1, "fresh subdividing paid field") + fresh = f + 1 + moves = net.moves | {f: (a, c), e: (c, b)} + divided_rows = net.rows | {f: net.rows[e], e: 1 << f} + subdivided = Network(net.initial, net.final, moves, divided_rows) + + q, k, d, readout, calibration, pulse = ( + mask(witness[name]) for name in ("q", "k", "d", "readout", "calibration", "pulse") + ) + response = transfer(d, True) + return_combination = transfer(k, False) + pivot = 1 << h + need(all(net.initial.get(i) == A for i in bits(q | d)), "cocharted entrance basis") + need(all(net.final.get(i) == B for i in bits(response | return_combination)), + "cocharted exit basis") + need(response & pivot and parity(q, d) and parity(k, d), "nondegenerate calibration") + schedule, values, columns = subdivided.validate(edge, True) + donors = net.initial | {j: v for j, (_, v) in moves.items()} + need(all(donors.get(j) == c for j in bits(readout | calibration)), "local readout and calibration") + need(all(j in moves and moves[j][0] == c for j in bits(pulse)), "local injection at paid sender") + need(xor(readout, values) == q and xor(calibration, values) == k, "exact measured basis rows") + need(xor(pulse, columns) == response, "exact measured terminal impulse") + + # Propagate a common unit pulse on the subdivided graph with all + # independent inputs set to zero. The added signal cannot feed either + # local readout or calibration. + feedback = 0 + for t in schedule: + sender = 1 << t + if parity(divided_rows[t], feedback) ^ bool(pulse & sender): + feedback |= sender + need(parity(feedback, readout) == parity(feedback, calibration) == 0, + "zero pulse feedback into local readout and calibration") + + replacement = pivot | (q & ~pivot) + + def rewrite(row): + return (row & ~pivot) ^ (replacement if parity(row, d) else 0) + + rows = {t: rewrite(row) for t, row in divided_rows.items()} + correction = (1 << fresh) ^ rewrite(calibration) + for t in bits(pulse): + rows[t] ^= correction + returned = 0 + for i in bits(return_combination): + returned ^= rows[~i] + old_pivot = rows[~h] + for i in bits(response & ~pivot): + rows[~i] ^= old_pivot + rows[~h], rows[~fresh] = rewrite(readout), returned + + candidate = Network(net.initial | {fresh: c}, net.final | {h: c, fresh: B}, moves, rows) + candidate.validate(edge, True) + return candidate, fresh + + +def rejection(function, expected): + try: + function() + except ValueError as error: + need(expected in str(error), "wrong mutation failure: " + str(error)) + return str(error) + raise ValueError("mutation was accepted: " + expected) + + +def zero_paid_packet(word, paid_slot): + """Preserve events and charts, but replace the selected private payload by zero.""" + program = word["program"] + moves = [j for j, event in enumerate(program) if event[0] == "MOVE"] + clock = moves[paid_slot] + field = program[clock][1] + birth = next(j for j in range(clock - 1, -1, -1) if program[j][:2] == ["INIT", field]) + need(birth + 1 < clock and all(event[:2] == ["ADD", field] + for event in program[birth + 1:clock]), "complete local accumulator") + return word | {"program": program[:birth + 1] + program[clock:]}, clock, field + + +def counter(value): + return Counter({int(rank): count for rank, count in value.items()}) + + +def replay(root, *, frozen_word=HERE / "WORD.json.gz"): + if (root / ".git").exists(): + actual_head = subprocess.run( + ["git", "-C", str(root), "rev-parse", "HEAD"], check=True, + capture_output=True, text=True, + ).stdout.strip() + need(actual_head in (HEAD, EARLIER_HEAD), "#7776 source checkout head") + sys.dont_write_bytecode = True + for path, digest in SOURCE_PINS.items(): + read_sha(root / path, digest) + edge = module(root / ALI / "bit_native.py", "bit_native") + app = module(root / ALI / "bit_application.py", "birth_parent_application") + audit = module(root / PAIRED / "retained/audit_binary_mixed.py", "birth_parent_physical_audit") + paired = module(root / PAIRED / "check.py", "birth_parent_paired_caller") + recipe = json.loads(read_sha(HERE / "BIRTHS.json", RECIPE)) + need(recipe["schema"] == "binary-subdivided-helper-births-recipe/1" + and (recipe["parent_pr"], recipe["parent_head"], recipe["previous_public_head"], + recipe["parent_program_sha256"], recipe["program_sha256"], len(recipe["steps"])) + == (7776, HEAD, EARLIER_HEAD, PARENT, PROGRAM, BIRTHS), + "pinned recipe and both program identities") + source, baseline, old_clocks, baseline_clocks = make_baseline(root, edge) + adjoint = baseline.transpose() + adjoint.validate(edge, True) + base_receipt = json.loads((root / ALI / "BIT-RESULT.json").read_bytes()) + need(base_receipt["native"]["program_sha256"] == PARENT, "public #7776 result binding") + expected_paid = counter(base_receipt["native_paid"]) + expected_targets = counter(base_receipt["native_targets"]) + controls = {} + new_moves = [] + step_results = [] + for ordinal, step in enumerate(recipe["steps"], 1): + e = step["source_packet"] + need(old_clocks[e] == step["original_selected_source_clock"], "literal selected source clock") + if ordinal == 1: + broken = step | {"witness": step["witness"] | {"readout": []}} + controls["omitted_readout"] = rejection( + lambda: apply_birth(adjoint, broken, source["frames"], edge, audit), + "exact measured basis rows") + adjoint, new_helper = apply_birth(adjoint, step, source["frames"], edge, audit) + paid = step["paid_daughter_ranks"] + targets = step["target_daughter_ranks"] + expected_paid[sum(paid)] -= 1 + expected_paid.update(paid) + expected_targets[sum(targets)] -= 1 + expected_targets.update(targets) + new_moves.append(step["new_packet"]) + step_results.append(dict(step=ordinal, helper_owner=step["witness"]["role"], + new_helper_owner=new_helper, selected_original_clock=old_clocks[e], + residual_forward_clock=baseline_clocks[e], source_packet=e, + new_packet=step["new_packet"], internal_chart=step["witness"]["chart"])) + forward = adjoint.transpose() + schedule, _, _ = forward.validate(edge, False) + need((len(forward.initial), len(schedule)) == (672, 2876), "candidate inventory") + need(all(forward.initial[r] == baseline.initial[r] and forward.final[r] == baseline.final[r] + for r in range(222)), "all 222 literal main boundaries") + for r in set(baseline.initial) - {step["witness"]["role"] for step in recipe["steps"]}: + need((forward.initial[r], forward.final[r]) == (baseline.initial[r], baseline.final[r]), + f"unchanged helper boundary {r}") + + word = edge.emit_word(source, forward.initial, forward.final, forward.moves, forward.rows, schedule) + need(edge.digest(word) == PROGRAM, "canonical emitted program") + wire = (json.dumps(word, separators=(",", ":")) + "\n").encode() + need(sha256(wire).hexdigest() == PAYLOAD, "exact emitted file payload") + gzip_hash = None + if frozen_word is not None: + raw = read_sha(frozen_word, GZIP) + need(gzip.decompress(raw) == wire, "frozen word is reproduced byte for byte") + gzip_hash = sha256(raw).hexdigest() + app.reverse(word) + literal_paid, literal_targets, native = audit.source_audit(word) + need(literal_paid == +expected_paid and literal_targets == +expected_targets, "native histograms") + caller = app.read_pinned(root, PAIRED / "EFREE-CALLER.json.gz", app.CALLER_SHA) + coefficients = paired.forward(caller) + need(coefficients == audit.backward(caller) == 38 ** 2, "complete paired caller in both directions") + targets, paid, contacts = app.frames_and_sites(word, caller, native, audit) + for name, base, improved, native_base, native_improved in ( + ("paid", base_receipt["paid"], paid, base_receipt["native_paid"], literal_paid), + ("targets", base_receipt["targets"], targets, base_receipt["native_targets"], literal_targets), + ): + predicted = counter(base) + native_parent = counter(native_base) + for rank in native_improved.keys() | native_parent.keys(): + predicted[rank] += CALLS * (native_improved[rank] - native_parent[rank]) + need(+predicted == improved, "signed 36-call " + name) + need(contacts["rank_surplus"] == base_receipt["signed_positions"]["rank_surplus"] + and contacts["native_calls"] == CALLS, "conserved rank mass and 36 actual invocations") + ordinary = app.ordinary(word, caller, targets, paid) + + # Zero one demonstrably active fresh paid payload with all charts and + # field lifetimes held fixed. Independent literal adjoint must reject. + modified, clock, field = zero_paid_packet(word, schedule.index(new_moves[0])) + controls["zero_first_new_paid"] = dict(clock=clock, field=field, rejection=rejection( + lambda: app.reverse(modified), "independent emitted-word full transpose")) + # Missing release of one owned full field is a physical lifetime failure. + deleted_clear = dict(word, program=word["program"][:-1]) + controls["missing_clear"] = rejection(lambda: audit.source_audit(deleted_clear), + "all endpoints and owned lifetimes") + receipt = dict( + schema="binary-subdivided-helper-births-replay/1", parent_pr=7776, source_head=HEAD, + source_word_sha256=PARENT, word_sha256=PROGRAM, word_file_sha256=PAYLOAD, + word_gzip_sha256=gzip_hash, recipe_sha256=RECIPE, + source_inputs={str(k): v for k, v in SOURCE_PINS.items()}, + steps=step_results, added_helpers=BIRTHS, instruction_counts=dict(Counter( + instruction[0] for instruction in word["program"])), + checked_literal_coefficients_each_direction=word["public"] ** 2, + caller_coefficients_each_way=coefficients, + native_paid=dict(literal_paid), native_targets=dict(literal_targets), + paid=dict(paid), targets=dict(targets), signed_positions=contacts, ordinary=ordinary, + native={k: v for k, v in native.items() if k != "charts"}, + mutation_controls=controls, + ) + return wire, receipt + + +def main(): + cli = argparse.ArgumentParser(description=__doc__) + cli.add_argument("--source-root", type=Path, required=True, + help="checkout or unpacked source tree of #7776 at " + HEAD) + cli.add_argument("--write-json", type=Path, help="write complete replay receipt") + cli.add_argument("--rebuild-word", type=Path, + help="generate a new gzip from the pinned payload instead of reading WORD.json.gz") + args = cli.parse_args() + frozen = HERE / "WORD.json.gz" if args.rebuild_word is None else None + wire, receipt = replay(args.source_root.resolve(), frozen_word=frozen) + if args.rebuild_word is not None: + raw = gzip.compress(wire, compresslevel=9, mtime=0) + args.rebuild_word.write_bytes(raw) + receipt["word_gzip_sha256"] = sha256(raw).hexdigest() + if args.write_json: + args.write_json.write_text(json.dumps(receipt, indent=2, sort_keys=True) + "\n", encoding="utf-8") + print("PASS_21_BINARY_HELPER_BIRTHS", receipt["word_sha256"], + receipt["native"]["public"], receipt["signed_positions"]["native_calls"]) + + +if __name__ == "__main__": + main() diff --git a/research/p104-subdivided-helper-births/complex/BANKS.json b/research/p104-subdivided-helper-births/complex/BANKS.json new file mode 100644 index 0000000000..a7bf05c68a --- /dev/null +++ b/research/p104-subdivided-helper-births/complex/BANKS.json @@ -0,0 +1 @@ +{"anchor_head":"4f7c67ae387cc91580f469aeda4d508b372b9ec1","anchor_pr":7776,"anchor_word_sha256":"934b7d4d792a5771bbcd28053d7797a9938f6b23faddaafe46451158eec81849","bank_plans":[{"alternate_frame":[30,70,134,299],"bank":236,"crossing_representations":[],"generators":[],"hub":1061,"mask":255,"old_hub_frame":[7,25,65,129,299],"paid_rank_savings":{"1":-1,"2":1,"4":1,"5":-1},"per_call_saving":["0.004278885114301863386647828934","0.004278885114301863386647828935"],"ports":[{"far_chart":411,"key":14,"kind":"donor","move":true,"new_rank":2,"old_clock":1044,"old_rank":3},{"far_chart":127,"key":20009,"kind":"reader","move":true,"new_rank":5,"old_clock":5610,"old_rank":4},{"far_chart":3,"key":97730,"kind":"donor","move":true,"new_rank":4,"old_clock":46,"old_rank":5},{"far_chart":739,"key":99516,"kind":"donor","move":true,"new_rank":1,"old_clock":5352,"old_rank":2},{"far_chart":127,"key":99518,"kind":"reader","move":true,"new_rank":5,"old_clock":5611,"old_rank":4},{"far_chart":739,"key":99514,"kind":"donor","move":true,"new_rank":1,"old_clock":5351,"old_rank":2},{"far_chart":1070,"key":99623,"kind":"reader","move":true,"new_rank":2,"old_clock":5608,"old_rank":1},{"far_chart":920,"key":101037,"kind":"reader","move":true,"new_rank":3,"old_clock":5609,"old_rank":2}],"total_saving":["0.205386485486489442559095788841","0.205386485486489442559095788842"]},{"alternate_frame":[12,18,193,262],"bank":712,"crossing_representations":[],"generators":[],"hub":1063,"mask":255,"old_hub_frame":[12,18,97,160,262],"paid_rank_savings":{"1":-1,"2":1,"4":1,"5":-1},"per_call_saving":["0.004278885114301863386647828934","0.004278885114301863386647828935"],"ports":[{"far_chart":735,"key":99738,"kind":"donor","move":true,"new_rank":1,"old_clock":2704,"old_rank":2},{"far_chart":127,"key":20004,"kind":"reader","move":true,"new_rank":5,"old_clock":3461,"old_rank":4},{"far_chart":735,"key":95397,"kind":"donor","move":true,"new_rank":1,"old_clock":1810,"old_rank":2},{"far_chart":1079,"key":95845,"kind":"reader","move":true,"new_rank":2,"old_clock":3462,"old_rank":1},{"far_chart":412,"key":95398,"kind":"donor","move":true,"new_rank":2,"old_clock":1723,"old_rank":3},{"far_chart":922,"key":99468,"kind":"reader","move":true,"new_rank":3,"old_clock":2611,"old_rank":2},{"far_chart":412,"key":99737,"kind":"donor","move":true,"new_rank":2,"old_clock":2075,"old_rank":3},{"far_chart":922,"key":101106,"kind":"reader","move":true,"new_rank":3,"old_clock":3463,"old_rank":2}],"total_saving":["0.205386485486489442559095788841","0.205386485486489442559095788842"]},{"alternate_frame":[12,51,196,273],"bank":791,"crossing_representations":[],"generators":[],"hub":1040,"mask":255,"old_hub_frame":[12,51,64,132,273],"paid_rank_savings":{"1":-1,"2":1,"4":1,"5":-1},"per_call_saving":["0.004278885114301863386647828934","0.004278885114301863386647828935"],"ports":[{"far_chart":571,"key":96075,"kind":"donor","move":true,"new_rank":1,"old_clock":1910,"old_rank":2},{"far_chart":127,"key":20008,"kind":"reader","move":true,"new_rank":5,"old_clock":3561,"old_rank":4},{"far_chart":450,"key":96076,"kind":"donor","move":true,"new_rank":2,"old_clock":1743,"old_rank":3},{"far_chart":571,"key":96271,"kind":"donor","move":true,"new_rank":1,"old_clock":2834,"old_rank":2},{"far_chart":930,"key":96082,"kind":"reader","move":true,"new_rank":3,"old_clock":2628,"old_rank":2},{"far_chart":1044,"key":96283,"kind":"reader","move":true,"new_rank":2,"old_clock":3562,"old_rank":1},{"far_chart":450,"key":96270,"kind":"donor","move":true,"new_rank":2,"old_clock":1911,"old_rank":3},{"far_chart":930,"key":101126,"kind":"reader","move":true,"new_rank":3,"old_clock":3563,"old_rank":2}],"total_saving":["0.205386485486489442559095788841","0.205386485486489442559095788842"]},{"alternate_frame":[7,9,51,82,129,257],"bank":600,"crossing_representations":[[20000,[[0,"1"]]],[99806,[[0,"-1/16"]]]],"generators":[{"available_at_reader":20000,"from_alternate":false,"old_clock":5086,"row":[[94070,"-16"],[98998,"-32"]]}],"hub":712,"mask":70,"old_hub_frame":[7,9,97,435],"paid_rank_savings":{"3":-1,"4":1,"5":1,"6":-1},"per_call_saving":["0.001737583011462859942234246636","0.001737583011462859942234246637"],"ports":[{"far_chart":302,"key":94070,"kind":"donor","move":false,"new_rank":1,"old_clock":2966,"old_rank":1},{"far_chart":127,"key":20000,"kind":"reader","move":true,"new_rank":3,"old_clock":5086,"old_rank":5},{"far_chart":3,"key":94072,"kind":"donor","move":true,"new_rank":6,"old_clock":45,"old_rank":4},{"far_chart":593,"key":98998,"kind":"donor","move":false,"new_rank":3,"old_clock":5001,"old_rank":3},{"far_chart":302,"key":94063,"kind":"donor","move":false,"new_rank":1,"old_clock":2549,"old_rank":1},{"far_chart":859,"key":96048,"kind":"reader","move":false,"new_rank":2,"old_clock":5087,"old_rank":2},{"far_chart":867,"key":99806,"kind":"reader","move":true,"new_rank":0,"old_clock":5088,"old_rank":2},{"far_chart":1094,"key":103254,"kind":"reader","move":false,"new_rank":1,"old_clock":5089,"old_rank":1},{"far_chart":1094,"key":103257,"kind":"reader","move":false,"new_rank":1,"old_clock":3296,"old_rank":1},{"far_chart":593,"key":94066,"kind":"donor","move":false,"new_rank":3,"old_clock":1679,"old_rank":3}],"total_saving":["0.083403984550217277227243838575","0.083403984550217277227243838576"]}],"candidate_word_sha256":"d8f7a310dee37764336019dc3ff099be2ec0d2cf39f6bc318b0fac502a705495","collapsed_moves":[99806],"realized_sites":[{"bank":236,"existing_hub":1061,"fresh_relays":[],"moved_donors":[14,97730,99514,99516],"moved_readers":[20009,99518,99623,101037],"selected_chart":796},{"bank":712,"existing_hub":1063,"fresh_relays":[],"moved_donors":[95397,95398,99737,99738],"moved_readers":[20004,95845,99468,101106],"selected_chart":798},{"bank":791,"existing_hub":1040,"fresh_relays":[],"moved_donors":[96075,96076,96270,96271],"moved_readers":[20008,96082,96283,101126],"selected_chart":585},{"bank":600,"existing_hub":712,"fresh_relays":[70],"moved_donors":[94072],"moved_readers":[20000,99806],"selected_chart":867}],"replay_evidence_sha256":"ab5e23fd9f82bebda5fde33decc68747d66607dbe38a1d5b6e0023e0b2c908cf","schema":"p104-closed-supplier-chart-retiming/v1","source_caller_sha256":"156fdf3a4a129b39225fd6ca51011de27974d7f104e8b04907c17ed5344bc858","source_word_sha256":"46420023b4846fb287f6ea8088d7a375f8997aabc8310f3f54583d563e7cf79b"} diff --git a/research/p104-subdivided-helper-births/complex/BIRTHS.json b/research/p104-subdivided-helper-births/complex/BIRTHS.json new file mode 100644 index 0000000000..e89bab1821 --- /dev/null +++ b/research/p104-subdivided-helper-births/complex/BIRTHS.json @@ -0,0 +1,20853 @@ +{ + "result": { + "added_helpers": 14, + "graph_sha256": "46420023b4846fb287f6ea8088d7a375f8997aabc8310f3f54583d563e7cf79b", + "layout_sha256": "60ced30a6d7b69c580c8822756f38c11c0d2a904e3ed1235fbbfd176419e36d3", + "native_calls": 48, + "native_delta": { + "paid": { + "1": 13, + "2": 1, + "4": 2, + "5": 10, + "6": -11, + "7": -1 + }, + "targets": { + "3": 1, + "4": 13, + "5": 14, + "8": -1, + "9": -13 + } + }, + "native_inventory": { + "paid": { + "1": 3848, + "2": 798, + "3": 489, + "4": 225, + "5": 305, + "6": 44, + "7": 4, + "8": 2 + }, + "targets": { + "1": 18, + "2": 7, + "3": 8, + "4": 233, + "5": 25, + "7": 15, + "8": 34, + "9": 538 + } + }, + "prices": { + "0.00386380485468": { + "gain": [ + "8.588924317292111030653156", + "8.588924317292111030653157" + ], + "margin": [ + "3.998844451180933992061607", + "3.998844451180933992061608" + ] + }, + "0.00386896184248": { + "gain": [ + "8.600282397684598578793833", + "8.600282397684598578793834" + ], + "margin": [ + "-1.270825899047729480967623", + "-1.270825899047729480967622" + ] + } + }, + "signed_invoice": { + "paid": { + "1": 185184, + "16": 1248, + "2": 38304, + "24": 1248, + "3": 23472, + "32": 1248, + "4": 10800, + "40": 1248, + "48": 1248, + "5": 14640, + "56": 1248, + "6": 2112, + "7": 192, + "8": 1344 + }, + "targets": { + "1": 864, + "129": 624, + "17": 1248, + "2": 336, + "25": 1248, + "3": 384, + "33": 1248, + "4": 11184, + "41": 1248, + "49": 1248, + "5": 1200, + "57": 1248, + "65": 1248, + "7": 720, + "8": 1632, + "9": 26304 + } + } + }, + "schema": "p104-rational-helper-births/v1", + "source": { + "graph_sha256": "934b7d4d792a5771bbcd28053d7797a9938f6b23faddaafe46451158eec81849", + "head": "4f7c67ae387cc91580f469aeda4d508b372b9ec1", + "layout_sha256": "d233f9ba1fc39c4be51685a45da1940fe43dc3a3fd7699a8b27339e1e063b489", + "pr": 7776, + "repository": "aliromman/integer-mult-bounds" + }, + "steps": [ + { + "allocated_role": 1264, + "chart": 232, + "credit": [ + "0.676359216551554695049309", + "0.676359216551554695049310" + ], + "descending": false, + "event": { + "calibration": [ + [ + 90178, + "-55104" + ], + [ + 90186, + "-27552" + ], + [ + 90189, + "55104" + ], + [ + 90191, + "-27552" + ] + ], + "pulse": [ + [ + 103891, + "1" + ] + ], + "readout": [ + [ + 35, + "20" + ], + [ + 90178, + "20" + ], + [ + 90183, + "10" + ], + [ + 90186, + "-10" + ], + [ + 90198, + "20" + ] + ], + "return_chart": 127, + "return_covector": [ + [ + 3, + "-3444" + ], + [ + 12, + "-27552" + ], + [ + 17, + "-13776" + ], + [ + 21, + "27552" + ], + [ + 100, + "-27552" + ], + [ + 103, + "-27552" + ], + [ + 126, + "-9184" + ], + [ + 133, + "-13776" + ], + [ + 173, + "-55104" + ], + [ + 188, + "-5166" + ], + [ + 226, + "-18942" + ], + [ + 230, + "-68880" + ], + [ + 231, + "-5166" + ], + [ + 235, + "41328" + ], + [ + 236, + "-5166" + ], + [ + 241, + "-27552" + ], + [ + 244, + "-82656" + ], + [ + 246, + "-1134" + ], + [ + 247, + "-5166" + ], + [ + 249, + "-15498" + ], + [ + 252, + "-6888" + ], + [ + 254, + "27552" + ], + [ + 260, + "6027" + ], + [ + 261, + "-27552" + ], + [ + 262, + "110208" + ], + [ + 263, + "6888" + ], + [ + 266, + "-82656" + ], + [ + 270, + "6888" + ], + [ + 273, + "-55104" + ], + [ + 274, + "-27552" + ], + [ + 276, + "-27552" + ], + [ + 283, + "-4320" + ], + [ + 288, + "1368" + ], + [ + 289, + "288" + ], + [ + 292, + "-21600" + ], + [ + 299, + "-34440" + ], + [ + 302, + "-27552" + ], + [ + 304, + "-137760" + ], + [ + 307, + "-20664" + ], + [ + 309, + "27552" + ], + [ + 310, + "-13776" + ], + [ + 317, + "27552" + ], + [ + 320, + "10332" + ], + [ + 321, + "13776" + ], + [ + 322, + "-165312" + ], + [ + 326, + "55104" + ], + [ + 328, + "-27552" + ], + [ + 335, + "13776" + ], + [ + 336, + "-6888" + ], + [ + 344, + "-13776" + ], + [ + 347, + "-55104" + ], + [ + 349, + "-82656" + ], + [ + 350, + "-27552" + ], + [ + 354, + "27552" + ], + [ + 356, + "-82656" + ], + [ + 358, + "27552" + ], + [ + 359, + "27552" + ], + [ + 361, + "27552" + ], + [ + 362, + "13776" + ], + [ + 364, + "13776" + ], + [ + 365, + "-27552" + ], + [ + 376, + "-158424" + ], + [ + 381, + "68880" + ], + [ + 383, + "-41328" + ], + [ + 384, + "27552" + ], + [ + 386, + "-36736" + ], + [ + 388, + "-165312" + ], + [ + 389, + "55104" + ], + [ + 390, + "91840" + ], + [ + 391, + "55104" + ], + [ + 395, + "-13776" + ], + [ + 398, + "-13776" + ], + [ + 401, + "27552" + ], + [ + 402, + "220416" + ], + [ + 404, + "-1314" + ], + [ + 406, + "-27552" + ], + [ + 410, + "6888" + ], + [ + 411, + "27552" + ], + [ + 413, + "-55104" + ], + [ + 414, + "13776" + ], + [ + 419, + "13776" + ], + [ + 420, + "-110208" + ], + [ + 421, + "-220416" + ], + [ + 425, + "-13776" + ], + [ + 428, + "27552" + ], + [ + 429, + "-13776" + ], + [ + 432, + "27552" + ], + [ + 433, + "-41328" + ], + [ + 434, + "27552" + ], + [ + 443, + "-82656" + ], + [ + 453, + "-55104" + ], + [ + 457, + "27552" + ], + [ + 458, + "13776" + ], + [ + 459, + "-6888" + ], + [ + 460, + "-82656" + ], + [ + 464, + "-27552" + ], + [ + 468, + "55104" + ], + [ + 469, + "-13776" + ], + [ + 470, + "-82656" + ], + [ + 471, + "-13776" + ], + [ + 474, + "-55104" + ], + [ + 475, + "-55104" + ], + [ + 476, + "55104" + ], + [ + 479, + "-27552" + ], + [ + 481, + "41328" + ], + [ + 483, + "-165312" + ], + [ + 484, + "-117096" + ], + [ + 486, + "-27552" + ], + [ + 487, + "-55104" + ], + [ + 488, + "13776" + ], + [ + 490, + "-275520" + ], + [ + 491, + "137760" + ], + [ + 492, + "-61992" + ], + [ + 493, + "-13776" + ], + [ + 495, + "13776" + ], + [ + 496, + "-330624" + ], + [ + 497, + "-234192" + ], + [ + 498, + "-110208" + ], + [ + 501, + "-1722" + ], + [ + 502, + "-13776" + ], + [ + 510, + "-6888" + ], + [ + 511, + "-13776" + ], + [ + 512, + "27552" + ], + [ + 514, + "-13776" + ], + [ + 515, + "-13776" + ], + [ + 516, + "-27552" + ], + [ + 517, + "-13776" + ], + [ + 519, + "-3444" + ], + [ + 520, + "-6888" + ], + [ + 522, + "6888" + ], + [ + 527, + "-13776" + ], + [ + 528, + "55104" + ], + [ + 529, + "13776" + ], + [ + 530, + "-6888" + ], + [ + 531, + "6888" + ], + [ + 537, + "55104" + ], + [ + 539, + "6888" + ], + [ + 540, + "20664" + ], + [ + 546, + "-13776" + ], + [ + 547, + "-55104" + ], + [ + 552, + "-24108" + ], + [ + 553, + "10332" + ], + [ + 555, + "-13776" + ], + [ + 559, + "20664" + ], + [ + 561, + "-34440" + ], + [ + 565, + "-48216" + ], + [ + 574, + "-6888" + ], + [ + 579, + "6888" + ], + [ + 590, + "-41328" + ], + [ + 595, + "-27552" + ], + [ + 608, + "13776" + ], + [ + 609, + "3444" + ], + [ + 610, + "-6888" + ], + [ + 616, + "6888" + ], + [ + 624, + "-6888" + ], + [ + 630, + "-206640" + ], + [ + 634, + "-13776" + ], + [ + 645, + "13776" + ], + [ + 649, + "-110208" + ], + [ + 651, + "-13776" + ], + [ + 652, + "55104" + ], + [ + 655, + "-55104" + ], + [ + 666, + "-27552" + ], + [ + 679, + "27552" + ], + [ + 683, + "55104" + ], + [ + 692, + "13776" + ], + [ + 696, + "6888" + ], + [ + 700, + "6888" + ], + [ + 701, + "55104" + ], + [ + 800, + "13776" + ], + [ + 811, + "13776" + ], + [ + 874, + "-20664" + ], + [ + 877, + "-27552" + ], + [ + 884, + "27552" + ], + [ + 887, + "55104" + ], + [ + 888, + "13776" + ], + [ + 890, + "27552" + ], + [ + 892, + "-55104" + ], + [ + 894, + "-55104" + ], + [ + 898, + "55104" + ], + [ + 902, + "13776" + ], + [ + 906, + "-27552" + ], + [ + 907, + "-27552" + ], + [ + 915, + "-82656" + ], + [ + 916, + "-82656" + ], + [ + 917, + "27552" + ], + [ + 919, + "-96432" + ], + [ + 927, + "-27552" + ], + [ + 931, + "-27552" + ], + [ + 934, + "-34440" + ], + [ + 935, + "-48216" + ], + [ + 937, + "20664" + ], + [ + 939, + "-6888" + ], + [ + 941, + "-55104" + ], + [ + 944, + "-55104" + ], + [ + 946, + "27552" + ], + [ + 947, + "13776" + ], + [ + 949, + "-34440" + ], + [ + 950, + "-27552" + ], + [ + 952, + "6888" + ], + [ + 956, + "27552" + ], + [ + 957, + "55104" + ], + [ + 958, + "55104" + ], + [ + 961, + "20664" + ], + [ + 962, + "6888" + ], + [ + 964, + "6888" + ], + [ + 965, + "55104" + ], + [ + 968, + "13776" + ], + [ + 970, + "-13776" + ], + [ + 973, + "-13776" + ], + [ + 978, + "13776" + ], + [ + 979, + "6888" + ], + [ + 981, + "27552" + ], + [ + 988, + "55104" + ], + [ + 990, + "-27552" + ], + [ + 992, + "-55104" + ], + [ + 994, + "-27552" + ], + [ + 996, + "-55104" + ], + [ + 997, + "27552" + ], + [ + 999, + "-27552" + ], + [ + 1001, + "-27552" + ], + [ + 1003, + "-27552" + ], + [ + 1005, + "13776" + ], + [ + 1009, + "-165312" + ], + [ + 1010, + "-27552" + ], + [ + 1011, + "-146944" + ], + [ + 1024, + "146944" + ], + [ + 1025, + "27552" + ], + [ + 1029, + "-82656" + ], + [ + 1033, + "27552" + ], + [ + 1035, + "-27552" + ], + [ + 1037, + "-27552" + ], + [ + 1038, + "41328" + ], + [ + 1040, + "-27552" + ], + [ + 1056, + "27552" + ], + [ + 1057, + "-27552" + ], + [ + 1058, + "13776" + ], + [ + 1059, + "6888" + ], + [ + 1060, + "-27552" + ], + [ + 1061, + "-27552" + ], + [ + 1063, + "-6888" + ], + [ + 1064, + "55104" + ], + [ + 1067, + "55104" + ], + [ + 1070, + "27552" + ], + [ + 1071, + "27552" + ], + [ + 1073, + "27552" + ], + [ + 1078, + "27552" + ], + [ + 1079, + "27552" + ], + [ + 1082, + "-68880" + ], + [ + 1084, + "13776" + ], + [ + 1085, + "13776" + ], + [ + 1086, + "-27552" + ], + [ + 1088, + "13776" + ], + [ + 1089, + "-27552" + ], + [ + 1090, + "13776" + ], + [ + 1091, + "13776" + ], + [ + 1092, + "13776" + ], + [ + 1094, + "-13776" + ], + [ + 1096, + "-27552" + ], + [ + 1097, + "-27552" + ], + [ + 1099, + "-3444" + ], + [ + 1100, + "-13776" + ], + [ + 1101, + "10332" + ], + [ + 1102, + "27552" + ], + [ + 1104, + "-27552" + ], + [ + 1105, + "-6888" + ], + [ + 1106, + "-3444" + ], + [ + 1108, + "-27552" + ], + [ + 1111, + "-82656" + ], + [ + 1115, + "-55104" + ], + [ + 1117, + "6888" + ], + [ + 1118, + "-13776" + ], + [ + 1119, + "-5166" + ], + [ + 1122, + "18368" + ], + [ + 1123, + "-18368" + ], + [ + 1124, + "36736" + ], + [ + 1125, + "41328" + ], + [ + 1126, + "27552" + ], + [ + 1132, + "27552" + ], + [ + 1139, + "-55104" + ], + [ + 1140, + "-55104" + ], + [ + 1142, + "27552" + ], + [ + 1144, + "-27552" + ], + [ + 1145, + "-110208" + ], + [ + 1147, + "-27552" + ], + [ + 1173, + "-6888" + ], + [ + 1174, + "-55104" + ] + ], + "return_direction": [ + [ + 133, + "1" + ] + ], + "role": 133, + "source_chart": 3, + "source_covector": [ + [ + 133, + "-5" + ], + [ + 251, + "-5" + ], + [ + 261, + "-5" + ], + [ + 308, + "-5" + ], + [ + 364, + "4" + ], + [ + 440, + "4" + ], + [ + 1148, + "-2" + ], + [ + 1166, + "5" + ], + [ + 1242, + "4" + ] + ], + "source_direction": [ + [ + 133, + "1" + ] + ], + "split_chart": 232 + }, + "max_changed_coefficient_bits": 15, + "native_delta": { + "paid": { + "1": 1, + "4": 1, + "5": -1 + }, + "targets": { + "4": 1, + "5": 1, + "9": -1 + } + }, + "new_paid": 35, + "old_paid_charts": [ + 325, + 517 + ], + "paid_daughter_ranks": [ + 1, + 4 + ], + "replay": { + "affected_rows": 16, + "expected_fresh_input_row": { + "1264": "1" + }, + "literal_row_delta_sha256": "f8de75c9ce8ec1e3f04fa49cf3d3446d4602adec7c234eb12bb3cd2abeb88a56", + "new_owner_label": 1517, + "omitted_fresh_input_row": {}, + "original_oriented_paid_row": [ + [ + 90171, + "-1" + ], + [ + 90172, + "-1" + ] + ], + "original_owner_label": 133, + "parent_sha256": "934b7d4d792a5771bbcd28053d7797a9938f6b23faddaafe46451158eec81849", + "result_sha256": "f94ede1173ddbd3216edb6589c5f3a794c24a62baa969bd5849217d982a70c41" + }, + "source_paid": 98411, + "target_daughter_ranks": [ + 4, + 5 + ] + }, + { + "allocated_role": 1265, + "chart": 232, + "credit": [ + "0.676359216551554695049309", + "0.676359216551554695049310" + ], + "descending": false, + "event": { + "calibration": [ + [ + 91800, + "-192" + ], + [ + 91806, + "-96" + ], + [ + 98231, + "-96" + ] + ], + "pulse": [ + [ + 98411, + "4" + ], + [ + 98796, + "-4" + ], + [ + 103244, + "40" + ], + [ + 103324, + "-10" + ], + [ + 104033, + "-10" + ] + ], + "readout": [ + [ + 91794, + "303072" + ] + ], + "return_chart": 127, + "return_covector": [ + [ + 3, + "-84" + ], + [ + 56, + "48" + ], + [ + 100, + "-48" + ], + [ + 173, + "-192" + ], + [ + 226, + "48" + ], + [ + 235, + "-144" + ], + [ + 241, + "-96" + ], + [ + 249, + "6" + ], + [ + 252, + "-24" + ], + [ + 260, + "3" + ], + [ + 262, + "-384" + ], + [ + 266, + "288" + ], + [ + 270, + "-24" + ], + [ + 274, + "96" + ], + [ + 276, + "-96" + ], + [ + 302, + "96" + ], + [ + 307, + "72" + ], + [ + 309, + "-96" + ], + [ + 310, + "48" + ], + [ + 322, + "48" + ], + [ + 335, + "-48" + ], + [ + 347, + "192" + ], + [ + 350, + "96" + ], + [ + 365, + "96" + ], + [ + 383, + "192" + ], + [ + 391, + "-192" + ], + [ + 398, + "-48" + ], + [ + 406, + "96" + ], + [ + 410, + "-24" + ], + [ + 411, + "-96" + ], + [ + 414, + "-48" + ], + [ + 427, + "-96" + ], + [ + 428, + "-96" + ], + [ + 429, + "48" + ], + [ + 433, + "48" + ], + [ + 434, + "-96" + ], + [ + 443, + "96" + ], + [ + 457, + "-96" + ], + [ + 458, + "-48" + ], + [ + 459, + "24" + ], + [ + 464, + "96" + ], + [ + 468, + "-192" + ], + [ + 469, + "96" + ], + [ + 475, + "192" + ], + [ + 476, + "-192" + ], + [ + 479, + "96" + ], + [ + 481, + "-96" + ], + [ + 484, + "-24" + ], + [ + 486, + "96" + ], + [ + 487, + "192" + ], + [ + 488, + "-48" + ], + [ + 493, + "-48" + ], + [ + 494, + "48" + ], + [ + 495, + "-48" + ], + [ + 497, + "-48" + ], + [ + 498, + "384" + ], + [ + 501, + "6" + ], + [ + 502, + "48" + ], + [ + 508, + "192" + ], + [ + 509, + "-192" + ], + [ + 510, + "48" + ], + [ + 512, + "-48" + ], + [ + 513, + "48" + ], + [ + 514, + "48" + ], + [ + 516, + "96" + ], + [ + 517, + "48" + ], + [ + 527, + "48" + ], + [ + 530, + "24" + ], + [ + 531, + "-24" + ], + [ + 535, + "-24" + ], + [ + 537, + "-192" + ], + [ + 538, + "24" + ], + [ + 540, + "-48" + ], + [ + 546, + "48" + ], + [ + 547, + "192" + ], + [ + 552, + "12" + ], + [ + 553, + "-12" + ], + [ + 555, + "48" + ], + [ + 559, + "-24" + ], + [ + 561, + "-24" + ], + [ + 565, + "24" + ], + [ + 574, + "24" + ], + [ + 578, + "12" + ], + [ + 581, + "24" + ], + [ + 588, + "24" + ], + [ + 590, + "48" + ], + [ + 608, + "-48" + ], + [ + 616, + "-48" + ], + [ + 624, + "24" + ], + [ + 645, + "-48" + ], + [ + 649, + "384" + ], + [ + 651, + "48" + ], + [ + 655, + "96" + ], + [ + 666, + "96" + ], + [ + 683, + "-192" + ], + [ + 696, + "24" + ], + [ + 716, + "96" + ], + [ + 758, + "-96" + ], + [ + 874, + "-48" + ], + [ + 884, + "-96" + ], + [ + 891, + "24" + ], + [ + 892, + "576" + ], + [ + 894, + "192" + ], + [ + 906, + "96" + ], + [ + 916, + "192" + ], + [ + 917, + "-96" + ], + [ + 919, + "96" + ], + [ + 931, + "48" + ], + [ + 934, + "-24" + ], + [ + 935, + "24" + ], + [ + 937, + "-24" + ], + [ + 939, + "48" + ], + [ + 946, + "-96" + ], + [ + 950, + "96" + ], + [ + 961, + "-48" + ], + [ + 970, + "48" + ], + [ + 978, + "-48" + ], + [ + 981, + "-48" + ], + [ + 989, + "48" + ], + [ + 990, + "192" + ], + [ + 992, + "192" + ], + [ + 996, + "192" + ], + [ + 1029, + "96" + ], + [ + 1033, + "-96" + ], + [ + 1037, + "48" + ], + [ + 1038, + "-96" + ], + [ + 1040, + "48" + ], + [ + 1045, + "48" + ], + [ + 1051, + "96" + ], + [ + 1059, + "-24" + ], + [ + 1060, + "96" + ], + [ + 1061, + "96" + ], + [ + 1063, + "24" + ], + [ + 1067, + "-96" + ], + [ + 1071, + "-96" + ], + [ + 1073, + "-48" + ], + [ + 1079, + "-96" + ], + [ + 1082, + "-48" + ], + [ + 1086, + "96" + ], + [ + 1088, + "48" + ], + [ + 1089, + "-96" + ], + [ + 1090, + "-48" + ], + [ + 1092, + "-48" + ], + [ + 1094, + "96" + ], + [ + 1095, + "48" + ], + [ + 1097, + "48" + ], + [ + 1100, + "24" + ], + [ + 1101, + "-12" + ], + [ + 1102, + "-48" + ], + [ + 1104, + "192" + ], + [ + 1105, + "24" + ], + [ + 1111, + "192" + ], + [ + 1112, + "192" + ], + [ + 1117, + "-48" + ], + [ + 1118, + "48" + ], + [ + 1122, + "-64" + ], + [ + 1125, + "-48" + ], + [ + 1126, + "-96" + ], + [ + 1144, + "-96" + ], + [ + 1173, + "24" + ], + [ + 1174, + "96" + ] + ], + "return_direction": [ + [ + 3, + "-8" + ], + [ + 21, + "8" + ], + [ + 39, + "16" + ], + [ + 228, + "4" + ], + [ + 235, + "4" + ], + [ + 241, + "8" + ], + [ + 249, + "-16" + ], + [ + 254, + "8" + ], + [ + 255, + "16" + ], + [ + 261, + "16" + ], + [ + 266, + "4" + ], + [ + 272, + "-8" + ], + [ + 273, + "-16" + ], + [ + 276, + "-8" + ], + [ + 278, + "8" + ], + [ + 279, + "8" + ], + [ + 299, + "-8" + ], + [ + 302, + "-16" + ], + [ + 304, + "-16" + ], + [ + 307, + "-8" + ], + [ + 308, + "16" + ], + [ + 309, + "16" + ], + [ + 314, + "16" + ], + [ + 320, + "-16" + ], + [ + 322, + "4" + ], + [ + 326, + "7" + ], + [ + 332, + "4" + ], + [ + 335, + "4" + ], + [ + 342, + "-8" + ], + [ + 343, + "-8" + ], + [ + 348, + "28" + ], + [ + 362, + "20" + ], + [ + 364, + "52" + ], + [ + 365, + "-16" + ], + [ + 368, + "4" + ], + [ + 381, + "4" + ], + [ + 391, + "4" + ], + [ + 402, + "-4" + ], + [ + 406, + "16" + ], + [ + 408, + "-8" + ], + [ + 409, + "-8" + ], + [ + 410, + "-8" + ], + [ + 411, + "-8" + ], + [ + 414, + "16" + ], + [ + 417, + "16" + ], + [ + 421, + "-16" + ], + [ + 424, + "-16" + ], + [ + 427, + "-16" + ], + [ + 428, + "8" + ], + [ + 433, + "-16" + ], + [ + 440, + "4" + ], + [ + 443, + "-16" + ], + [ + 453, + "-16" + ], + [ + 458, + "-8" + ], + [ + 465, + "-8" + ], + [ + 468, + "-8" + ], + [ + 474, + "-16" + ], + [ + 475, + "-16" + ], + [ + 476, + "8" + ], + [ + 481, + "4" + ], + [ + 482, + "8" + ], + [ + 484, + "-8" + ], + [ + 486, + "16" + ], + [ + 497, + "-4" + ], + [ + 498, + "-4" + ], + [ + 508, + "-16" + ], + [ + 509, + "-16" + ], + [ + 511, + "-8" + ], + [ + 512, + "-16" + ], + [ + 516, + "-16" + ], + [ + 518, + "16" + ], + [ + 528, + "4" + ], + [ + 529, + "4" + ], + [ + 535, + "16" + ], + [ + 537, + "4" + ], + [ + 540, + "4" + ], + [ + 546, + "-8" + ], + [ + 552, + "-24" + ], + [ + 553, + "16" + ], + [ + 555, + "8" + ], + [ + 559, + "-28" + ], + [ + 561, + "-8" + ], + [ + 565, + "28" + ], + [ + 566, + "-8" + ], + [ + 568, + "4" + ], + [ + 574, + "-8" + ], + [ + 578, + "-8" + ], + [ + 588, + "4" + ], + [ + 596, + "4" + ], + [ + 602, + "4" + ], + [ + 603, + "64" + ], + [ + 608, + "-64" + ], + [ + 610, + "8" + ], + [ + 616, + "4" + ], + [ + 624, + "-4" + ], + [ + 638, + "-16" + ], + [ + 651, + "34" + ], + [ + 654, + "-8" + ], + [ + 679, + "-40" + ], + [ + 683, + "-1" + ], + [ + 696, + "32" + ], + [ + 702, + "1" + ], + [ + 804, + "8" + ], + [ + 811, + "-12" + ], + [ + 890, + "-32" + ], + [ + 892, + "-10" + ], + [ + 894, + "16" + ], + [ + 904, + "-10" + ], + [ + 919, + "16" + ], + [ + 930, + "-32" + ], + [ + 934, + "-16" + ], + [ + 935, + "24" + ], + [ + 937, + "32" + ], + [ + 946, + "-8" + ], + [ + 947, + "-26" + ], + [ + 949, + "32" + ], + [ + 956, + "8" + ], + [ + 961, + "-16" + ], + [ + 963, + "16" + ], + [ + 970, + "16" + ], + [ + 981, + "-16" + ], + [ + 989, + "32" + ], + [ + 990, + "4" + ], + [ + 996, + "16" + ], + [ + 1029, + "16" + ], + [ + 1037, + "4" + ], + [ + 1038, + "30" + ], + [ + 1040, + "-4" + ], + [ + 1045, + "-52" + ], + [ + 1051, + "-8" + ], + [ + 1054, + "3" + ], + [ + 1070, + "-4" + ], + [ + 1073, + "8" + ], + [ + 1082, + "12" + ], + [ + 1088, + "-20" + ], + [ + 1090, + "4" + ], + [ + 1096, + "13" + ], + [ + 1097, + "2" + ], + [ + 1100, + "40" + ], + [ + 1101, + "-8" + ], + [ + 1102, + "2" + ], + [ + 1104, + "-1" + ], + [ + 1108, + "8" + ], + [ + 1112, + "-8" + ], + [ + 1115, + "-16" + ], + [ + 1117, + "8" + ], + [ + 1132, + "-8" + ], + [ + 1138, + "-5" + ], + [ + 1139, + "16" + ], + [ + 1140, + "64" + ], + [ + 1145, + "8" + ], + [ + 1146, + "-8" + ], + [ + 1148, + "-8" + ], + [ + 1173, + "-16" + ] + ], + "role": 683, + "source_chart": 3, + "source_covector": [ + [ + 3, + "-113652" + ], + [ + 21, + "303072" + ], + [ + 126, + "-101024" + ], + [ + 129, + "151536" + ], + [ + 150, + "-151536" + ], + [ + 159, + "151536" + ], + [ + 164, + "-151536" + ], + [ + 172, + "-151536" + ], + [ + 173, + "2562336" + ], + [ + 188, + "-56826" + ], + [ + 205, + "75768" + ], + [ + 226, + "-208362" + ], + [ + 228, + "-440832" + ], + [ + 230, + "-757680" + ], + [ + 231, + "-56826" + ], + [ + 235, + "454608" + ], + [ + 236, + "-56826" + ], + [ + 239, + "151536" + ], + [ + 240, + "-303072" + ], + [ + 245, + "37884" + ], + [ + 246, + "-12474" + ], + [ + 247, + "-56826" + ], + [ + 249, + "-56826" + ], + [ + 252, + "-68880" + ], + [ + 254, + "303072" + ], + [ + 260, + "-28413" + ], + [ + 262, + "2424576" + ], + [ + 263, + "-75768" + ], + [ + 266, + "-1060752" + ], + [ + 270, + "151536" + ], + [ + 273, + "-606144" + ], + [ + 274, + "-606144" + ], + [ + 277, + "454608" + ], + [ + 283, + "-47520" + ], + [ + 288, + "52932" + ], + [ + 289, + "41052" + ], + [ + 292, + "-237600" + ], + [ + 299, + "-75768" + ], + [ + 302, + "-303072" + ], + [ + 304, + "-606144" + ], + [ + 307, + "-227304" + ], + [ + 309, + "303072" + ], + [ + 310, + "-151536" + ], + [ + 315, + "-37884" + ], + [ + 317, + "18942" + ], + [ + 320, + "37884" + ], + [ + 322, + "-454608" + ], + [ + 328, + "151536" + ], + [ + 329, + "-37884" + ], + [ + 335, + "151536" + ], + [ + 336, + "-75768" + ], + [ + 338, + "37884" + ], + [ + 340, + "-75768" + ], + [ + 344, + "454608" + ], + [ + 347, + "-1212288" + ], + [ + 348, + "151536" + ], + [ + 349, + "-151536" + ], + [ + 350, + "-606144" + ], + [ + 356, + "-151536" + ], + [ + 359, + "303072" + ], + [ + 361, + "523488" + ], + [ + 362, + "151536" + ], + [ + 365, + "-757680" + ], + [ + 368, + "-75768" + ], + [ + 370, + "37884" + ], + [ + 376, + "-227304" + ], + [ + 381, + "-151536" + ], + [ + 383, + "-757680" + ], + [ + 384, + "151536" + ], + [ + 386, + "-176792" + ], + [ + 388, + "-303072" + ], + [ + 390, + "404096" + ], + [ + 391, + "606144" + ], + [ + 392, + "-75768" + ], + [ + 401, + "-151536" + ], + [ + 402, + "2424576" + ], + [ + 404, + "-33396" + ], + [ + 406, + "-303072" + ], + [ + 409, + "220416" + ], + [ + 410, + "75768" + ], + [ + 411, + "378840" + ], + [ + 413, + "-606144" + ], + [ + 414, + "151536" + ], + [ + 420, + "-303072" + ], + [ + 421, + "-2424576" + ], + [ + 427, + "757680" + ], + [ + 428, + "909216" + ], + [ + 429, + "-454608" + ], + [ + 433, + "-606144" + ], + [ + 434, + "606144" + ], + [ + 443, + "-1212288" + ], + [ + 452, + "303072" + ], + [ + 453, + "-606144" + ], + [ + 455, + "-303072" + ], + [ + 457, + "303072" + ], + [ + 458, + "151536" + ], + [ + 459, + "-75768" + ], + [ + 460, + "-151536" + ], + [ + 463, + "-151536" + ], + [ + 464, + "-606144" + ], + [ + 468, + "1515360" + ], + [ + 469, + "-909216" + ], + [ + 470, + "-909216" + ], + [ + 471, + "606144" + ], + [ + 472, + "151536" + ], + [ + 474, + "-606144" + ], + [ + 475, + "-1818432" + ], + [ + 476, + "1818432" + ], + [ + 479, + "-1281168" + ], + [ + 481, + "909216" + ], + [ + 483, + "-303072" + ], + [ + 484, + "-151536" + ], + [ + 486, + "-303072" + ], + [ + 487, + "-606144" + ], + [ + 488, + "151536" + ], + [ + 490, + "-1212288" + ], + [ + 492, + "-378840" + ], + [ + 493, + "757680" + ], + [ + 495, + "151536" + ], + [ + 496, + "-303072" + ], + [ + 497, + "-303072" + ], + [ + 498, + "-3636864" + ], + [ + 500, + "606144" + ], + [ + 501, + "-56826" + ], + [ + 502, + "-378840" + ], + [ + 503, + "151536" + ], + [ + 508, + "-1818432" + ], + [ + 509, + "1818432" + ], + [ + 510, + "-454608" + ], + [ + 511, + "151536" + ], + [ + 512, + "303072" + ], + [ + 513, + "-151536" + ], + [ + 514, + "-378840" + ], + [ + 516, + "-757680" + ], + [ + 517, + "-151536" + ], + [ + 519, + "-37884" + ], + [ + 522, + "75768" + ], + [ + 527, + "-378840" + ], + [ + 529, + "75768" + ], + [ + 530, + "-75768" + ], + [ + 531, + "75768" + ], + [ + 537, + "606144" + ], + [ + 538, + "-151536" + ], + [ + 540, + "454608" + ], + [ + 546, + "-151536" + ], + [ + 547, + "-1212288" + ], + [ + 552, + "-75768" + ], + [ + 553, + "227304" + ], + [ + 555, + "-757680" + ], + [ + 565, + "-151536" + ], + [ + 574, + "-151536" + ], + [ + 578, + "-37884" + ], + [ + 579, + "-75768" + ], + [ + 581, + "-151536" + ], + [ + 588, + "-75768" + ], + [ + 590, + "303072" + ], + [ + 595, + "303072" + ], + [ + 608, + "454608" + ], + [ + 616, + "378840" + ], + [ + 624, + "-75768" + ], + [ + 630, + "-75768" + ], + [ + 633, + "-37884" + ], + [ + 634, + "-151536" + ], + [ + 645, + "303072" + ], + [ + 649, + "-2424576" + ], + [ + 651, + "-261744" + ], + [ + 652, + "606144" + ], + [ + 655, + "-909216" + ], + [ + 666, + "-757680" + ], + [ + 679, + "303072" + ], + [ + 683, + "1818432" + ], + [ + 696, + "-454608" + ], + [ + 700, + "75768" + ], + [ + 770, + "606144" + ], + [ + 771, + "606144" + ], + [ + 772, + "606144" + ], + [ + 773, + "303072" + ], + [ + 774, + "303072" + ], + [ + 775, + "303072" + ], + [ + 776, + "-303072" + ], + [ + 777, + "303072" + ], + [ + 778, + "-303072" + ], + [ + 781, + "303072" + ], + [ + 782, + "303072" + ], + [ + 783, + "-303072" + ], + [ + 785, + "303072" + ], + [ + 791, + "303072" + ], + [ + 792, + "303072" + ], + [ + 793, + "303072" + ], + [ + 794, + "303072" + ], + [ + 795, + "303072" + ], + [ + 797, + "303072" + ], + [ + 798, + "303072" + ], + [ + 800, + "75768" + ], + [ + 801, + "303072" + ], + [ + 804, + "37884" + ], + [ + 807, + "303072" + ], + [ + 810, + "-303072" + ], + [ + 811, + "75768" + ], + [ + 813, + "303072" + ], + [ + 814, + "303072" + ], + [ + 816, + "-303072" + ], + [ + 817, + "303072" + ], + [ + 818, + "303072" + ], + [ + 819, + "303072" + ], + [ + 820, + "606144" + ], + [ + 823, + "303072" + ], + [ + 824, + "-303072" + ], + [ + 825, + "-303072" + ], + [ + 826, + "303072" + ], + [ + 827, + "303072" + ], + [ + 828, + "606144" + ], + [ + 830, + "303072" + ], + [ + 831, + "303072" + ], + [ + 832, + "303072" + ], + [ + 833, + "303072" + ], + [ + 834, + "606144" + ], + [ + 835, + "303072" + ], + [ + 836, + "303072" + ], + [ + 837, + "606144" + ], + [ + 840, + "303072" + ], + [ + 841, + "-303072" + ], + [ + 842, + "303072" + ], + [ + 843, + "-303072" + ], + [ + 844, + "303072" + ], + [ + 845, + "606144" + ], + [ + 846, + "606144" + ], + [ + 847, + "303072" + ], + [ + 848, + "303072" + ], + [ + 849, + "303072" + ], + [ + 850, + "303072" + ], + [ + 851, + "303072" + ], + [ + 852, + "606144" + ], + [ + 853, + "606144" + ], + [ + 858, + "303072" + ], + [ + 859, + "303072" + ], + [ + 863, + "303072" + ], + [ + 864, + "303072" + ], + [ + 867, + "303072" + ], + [ + 868, + "303072" + ], + [ + 870, + "303072" + ], + [ + 871, + "303072" + ], + [ + 872, + "-303072" + ], + [ + 873, + "-303072" + ], + [ + 874, + "151536" + ], + [ + 877, + "303072" + ], + [ + 879, + "303072" + ], + [ + 884, + "454608" + ], + [ + 887, + "303072" + ], + [ + 890, + "303072" + ], + [ + 891, + "-75768" + ], + [ + 892, + "-606144" + ], + [ + 894, + "-1818432" + ], + [ + 896, + "151536" + ], + [ + 898, + "606144" + ], + [ + 899, + "151536" + ], + [ + 902, + "151536" + ], + [ + 904, + "606144" + ], + [ + 906, + "-606144" + ], + [ + 907, + "303072" + ], + [ + 916, + "-909216" + ], + [ + 917, + "606144" + ], + [ + 918, + "-303072" + ], + [ + 919, + "-606144" + ], + [ + 923, + "-606144" + ], + [ + 924, + "-606144" + ], + [ + 927, + "-303072" + ], + [ + 931, + "-454608" + ], + [ + 935, + "-151536" + ], + [ + 937, + "151536" + ], + [ + 939, + "-454608" + ], + [ + 942, + "-303072" + ], + [ + 943, + "-151536" + ], + [ + 944, + "-303072" + ], + [ + 946, + "606144" + ], + [ + 947, + "151536" + ], + [ + 948, + "-189420" + ], + [ + 949, + "-151536" + ], + [ + 950, + "-303072" + ], + [ + 956, + "303072" + ], + [ + 961, + "454608" + ], + [ + 964, + "75768" + ], + [ + 965, + "606144" + ], + [ + 968, + "75768" + ], + [ + 973, + "151536" + ], + [ + 978, + "151536" + ], + [ + 981, + "378840" + ], + [ + 988, + "303072" + ], + [ + 990, + "-1818432" + ], + [ + 992, + "-1818432" + ], + [ + 994, + "-303072" + ], + [ + 995, + "-303072" + ], + [ + 996, + "-1818432" + ], + [ + 999, + "303072" + ], + [ + 1001, + "-303072" + ], + [ + 1003, + "303072" + ], + [ + 1005, + "151536" + ], + [ + 1009, + "-303072" + ], + [ + 1010, + "303072" + ], + [ + 1011, + "-1010240" + ], + [ + 1024, + "1313312" + ], + [ + 1025, + "151536" + ], + [ + 1029, + "-1212288" + ], + [ + 1033, + "606144" + ], + [ + 1037, + "-303072" + ], + [ + 1038, + "909216" + ], + [ + 1040, + "-303072" + ], + [ + 1043, + "-303072" + ], + [ + 1044, + "-606144" + ], + [ + 1045, + "-151536" + ], + [ + 1047, + "-303072" + ], + [ + 1049, + "151536" + ], + [ + 1052, + "151536" + ], + [ + 1053, + "-151536" + ], + [ + 1054, + "-303072" + ], + [ + 1057, + "-303072" + ], + [ + 1060, + "-606144" + ], + [ + 1061, + "-454608" + ], + [ + 1063, + "-75768" + ], + [ + 1064, + "303072" + ], + [ + 1065, + "303072" + ], + [ + 1067, + "303072" + ], + [ + 1069, + "-151536" + ], + [ + 1070, + "303072" + ], + [ + 1071, + "303072" + ], + [ + 1073, + "303072" + ], + [ + 1074, + "75768" + ], + [ + 1076, + "75768" + ], + [ + 1077, + "303072" + ], + [ + 1079, + "909216" + ], + [ + 1081, + "-303072" + ], + [ + 1084, + "75768" + ], + [ + 1086, + "-303072" + ], + [ + 1088, + "-606144" + ], + [ + 1089, + "909216" + ], + [ + 1090, + "303072" + ], + [ + 1092, + "303072" + ], + [ + 1094, + "-454608" + ], + [ + 1095, + "-151536" + ], + [ + 1097, + "-454608" + ], + [ + 1100, + "-151536" + ], + [ + 1102, + "454608" + ], + [ + 1103, + "75768" + ], + [ + 1104, + "-1818432" + ], + [ + 1105, + "-151536" + ], + [ + 1106, + "-37884" + ], + [ + 1111, + "-1818432" + ], + [ + 1112, + "-1515360" + ], + [ + 1115, + "-606144" + ], + [ + 1116, + "-303072" + ], + [ + 1117, + "454608" + ], + [ + 1118, + "-151536" + ], + [ + 1119, + "-56826" + ], + [ + 1121, + "-606144" + ], + [ + 1122, + "404096" + ], + [ + 1123, + "25256" + ], + [ + 1124, + "404096" + ], + [ + 1125, + "530376" + ], + [ + 1126, + "909216" + ], + [ + 1127, + "151536" + ], + [ + 1132, + "303072" + ], + [ + 1138, + "-303072" + ], + [ + 1139, + "-606144" + ], + [ + 1140, + "-606144" + ], + [ + 1144, + "757680" + ], + [ + 1145, + "-1212288" + ], + [ + 1147, + "-151536" + ], + [ + 1164, + "1515360" + ], + [ + 1173, + "-227304" + ], + [ + 1242, + "-303072" + ] + ], + "source_direction": [ + [ + 3, + "-8" + ], + [ + 21, + "8" + ], + [ + 39, + "16" + ], + [ + 228, + "4" + ], + [ + 235, + "4" + ], + [ + 241, + "8" + ], + [ + 249, + "-16" + ], + [ + 254, + "8" + ], + [ + 255, + "16" + ], + [ + 261, + "16" + ], + [ + 266, + "4" + ], + [ + 272, + "-8" + ], + [ + 273, + "-16" + ], + [ + 276, + "-8" + ], + [ + 278, + "8" + ], + [ + 279, + "8" + ], + [ + 299, + "-8" + ], + [ + 302, + "-16" + ], + [ + 304, + "-16" + ], + [ + 307, + "-8" + ], + [ + 308, + "16" + ], + [ + 309, + "16" + ], + [ + 314, + "16" + ], + [ + 320, + "-16" + ], + [ + 322, + "4" + ], + [ + 326, + "7" + ], + [ + 332, + "4" + ], + [ + 335, + "4" + ], + [ + 342, + "-8" + ], + [ + 343, + "-8" + ], + [ + 348, + "28" + ], + [ + 362, + "20" + ], + [ + 364, + "52" + ], + [ + 365, + "-16" + ], + [ + 368, + "4" + ], + [ + 381, + "4" + ], + [ + 391, + "4" + ], + [ + 402, + "-4" + ], + [ + 406, + "16" + ], + [ + 408, + "-8" + ], + [ + 409, + "-8" + ], + [ + 410, + "-8" + ], + [ + 411, + "-8" + ], + [ + 414, + "16" + ], + [ + 417, + "16" + ], + [ + 421, + "-16" + ], + [ + 424, + "-16" + ], + [ + 427, + "-16" + ], + [ + 428, + "8" + ], + [ + 433, + "-16" + ], + [ + 440, + "4" + ], + [ + 443, + "-16" + ], + [ + 453, + "-16" + ], + [ + 458, + "-8" + ], + [ + 465, + "-8" + ], + [ + 468, + "-8" + ], + [ + 474, + "-16" + ], + [ + 475, + "-16" + ], + [ + 476, + "8" + ], + [ + 481, + "4" + ], + [ + 482, + "8" + ], + [ + 484, + "-8" + ], + [ + 486, + "16" + ], + [ + 497, + "-4" + ], + [ + 498, + "-4" + ], + [ + 508, + "-16" + ], + [ + 509, + "-16" + ], + [ + 511, + "-8" + ], + [ + 512, + "-16" + ], + [ + 516, + "-16" + ], + [ + 518, + "16" + ], + [ + 528, + "4" + ], + [ + 529, + "4" + ], + [ + 535, + "16" + ], + [ + 537, + "4" + ], + [ + 540, + "4" + ], + [ + 546, + "-8" + ], + [ + 552, + "-24" + ], + [ + 553, + "16" + ], + [ + 555, + "8" + ], + [ + 559, + "-28" + ], + [ + 561, + "-8" + ], + [ + 565, + "28" + ], + [ + 566, + "-8" + ], + [ + 568, + "4" + ], + [ + 574, + "-8" + ], + [ + 578, + "-8" + ], + [ + 588, + "4" + ], + [ + 596, + "4" + ], + [ + 602, + "4" + ], + [ + 603, + "64" + ], + [ + 608, + "-64" + ], + [ + 610, + "8" + ], + [ + 616, + "4" + ], + [ + 624, + "-4" + ], + [ + 638, + "-16" + ], + [ + 651, + "34" + ], + [ + 654, + "-8" + ], + [ + 679, + "-40" + ], + [ + 683, + "-1" + ], + [ + 696, + "32" + ], + [ + 702, + "1" + ], + [ + 804, + "8" + ], + [ + 811, + "-12" + ], + [ + 890, + "-32" + ], + [ + 892, + "-10" + ], + [ + 894, + "16" + ], + [ + 904, + "-10" + ], + [ + 919, + "16" + ], + [ + 930, + "-32" + ], + [ + 934, + "-16" + ], + [ + 935, + "24" + ], + [ + 937, + "32" + ], + [ + 946, + "-8" + ], + [ + 947, + "-26" + ], + [ + 949, + "32" + ], + [ + 956, + "8" + ], + [ + 961, + "-16" + ], + [ + 963, + "16" + ], + [ + 970, + "16" + ], + [ + 981, + "-16" + ], + [ + 989, + "32" + ], + [ + 990, + "4" + ], + [ + 996, + "16" + ], + [ + 1029, + "16" + ], + [ + 1037, + "4" + ], + [ + 1038, + "30" + ], + [ + 1040, + "-4" + ], + [ + 1045, + "-52" + ], + [ + 1051, + "-8" + ], + [ + 1054, + "3" + ], + [ + 1070, + "-4" + ], + [ + 1073, + "8" + ], + [ + 1082, + "12" + ], + [ + 1088, + "-20" + ], + [ + 1090, + "4" + ], + [ + 1096, + "13" + ], + [ + 1097, + "2" + ], + [ + 1100, + "40" + ], + [ + 1101, + "-8" + ], + [ + 1102, + "2" + ], + [ + 1104, + "-1" + ], + [ + 1108, + "8" + ], + [ + 1112, + "-8" + ], + [ + 1115, + "-16" + ], + [ + 1117, + "8" + ], + [ + 1132, + "-8" + ], + [ + 1138, + "-5" + ], + [ + 1139, + "16" + ], + [ + 1140, + "64" + ], + [ + 1145, + "8" + ], + [ + 1146, + "-8" + ], + [ + 1148, + "-8" + ], + [ + 1173, + "-16" + ] + ], + "split_chart": 232 + }, + "max_changed_coefficient_bits": 23, + "native_delta": { + "paid": { + "1": 1, + "4": 1, + "5": -1 + }, + "targets": { + "4": 1, + "5": 1, + "9": -1 + } + }, + "new_paid": 57, + "old_paid_charts": [ + 326, + 517 + ], + "paid_daughter_ranks": [ + 1, + 4 + ], + "replay": { + "affected_rows": 471, + "expected_fresh_input_row": { + "1265": "1" + }, + "literal_row_delta_sha256": "1503db1fbac1b62d177e93e91e6db5938dac7366f80dc63654098c6c8b19e64c", + "new_owner_label": 1518, + "omitted_fresh_input_row": {}, + "original_oriented_paid_row": [ + [ + 90174, + "1" + ], + [ + 90175, + "1" + ] + ], + "original_owner_label": 793, + "parent_sha256": "f94ede1173ddbd3216edb6589c5f3a794c24a62baa969bd5849217d982a70c41", + "result_sha256": "98db91313e0aa80b5eb667074b6bd61fa4c7c1ce40fe18859fd7f5a1c1e85976" + }, + "source_paid": 98796, + "target_daughter_ranks": [ + 4, + 5 + ] + }, + { + "allocated_role": 1266, + "chart": 306, + "credit": [ + "0.639388808980847010450658", + "0.639388808980847010450659" + ], + "descending": false, + "event": { + "calibration": [ + [ + 58, + "-1" + ], + [ + 90122, + "-4" + ], + [ + 90124, + "2" + ], + [ + 90126, + "4" + ], + [ + 90129, + "-2" + ], + [ + 90130, + "2" + ], + [ + 90131, + "-4" + ], + [ + 94336, + "2" + ], + [ + 96307, + "-2" + ], + [ + 96325, + "4" + ], + [ + 96330, + "-2" + ] + ], + "pulse": [ + [ + 91128, + "2" + ], + [ + 97135, + "1" + ], + [ + 103327, + "-1" + ] + ], + "readout": [ + [ + 94028, + "303072" + ] + ], + "return_chart": 127, + "return_covector": [ + [ + 245, + "2" + ], + [ + 296, + "-1" + ], + [ + 899, + "4" + ], + [ + 943, + "-4" + ], + [ + 948, + "-5" + ] + ], + "return_direction": [ + [ + 296, + "2" + ], + [ + 942, + "1" + ], + [ + 959, + "-1" + ], + [ + 972, + "-1" + ], + [ + 1012, + "1" + ], + [ + 1031, + "-1" + ], + [ + 1116, + "-1" + ], + [ + 1248, + "-1" + ] + ], + "role": 942, + "source_chart": 3, + "source_covector": [ + [ + 3, + "-75768" + ], + [ + 21, + "-303072" + ], + [ + 126, + "-101024" + ], + [ + 131, + "-151536" + ], + [ + 142, + "-151536" + ], + [ + 150, + "-151536" + ], + [ + 172, + "-303072" + ], + [ + 173, + "1639344" + ], + [ + 188, + "-85239" + ], + [ + 226, + "-161007" + ], + [ + 228, + "-881664" + ], + [ + 230, + "-530376" + ], + [ + 231, + "-85239" + ], + [ + 233, + "-151536" + ], + [ + 235, + "227304" + ], + [ + 236, + "-85239" + ], + [ + 240, + "-303072" + ], + [ + 244, + "-454608" + ], + [ + 245, + "-113652" + ], + [ + 246, + "-18711" + ], + [ + 247, + "-85239" + ], + [ + 249, + "-37884" + ], + [ + 252, + "-402948" + ], + [ + 254, + "-303072" + ], + [ + 260, + "-18942" + ], + [ + 262, + "1818432" + ], + [ + 263, + "-37884" + ], + [ + 270, + "189420" + ], + [ + 273, + "606144" + ], + [ + 274, + "-454608" + ], + [ + 276, + "1060752" + ], + [ + 277, + "-1363824" + ], + [ + 283, + "-71280" + ], + [ + 288, + "-91080" + ], + [ + 289, + "-108900" + ], + [ + 292, + "-356400" + ], + [ + 299, + "-37884" + ], + [ + 302, + "-151536" + ], + [ + 304, + "-151536" + ], + [ + 307, + "-113652" + ], + [ + 309, + "151536" + ], + [ + 310, + "-75768" + ], + [ + 315, + "113652" + ], + [ + 317, + "-208362" + ], + [ + 320, + "-56826" + ], + [ + 321, + "75768" + ], + [ + 322, + "-606144" + ], + [ + 326, + "303072" + ], + [ + 328, + "151536" + ], + [ + 329, + "113652" + ], + [ + 335, + "75768" + ], + [ + 336, + "189420" + ], + [ + 338, + "-113652" + ], + [ + 340, + "227304" + ], + [ + 344, + "530376" + ], + [ + 347, + "-909216" + ], + [ + 348, + "-454608" + ], + [ + 350, + "-454608" + ], + [ + 354, + "151536" + ], + [ + 358, + "151536" + ], + [ + 359, + "454608" + ], + [ + 361, + "895440" + ], + [ + 362, + "227304" + ], + [ + 364, + "75768" + ], + [ + 365, + "-1060752" + ], + [ + 368, + "227304" + ], + [ + 370, + "-113652" + ], + [ + 376, + "113652" + ], + [ + 381, + "-378840" + ], + [ + 383, + "-378840" + ], + [ + 384, + "757680" + ], + [ + 386, + "-1086008" + ], + [ + 389, + "303072" + ], + [ + 390, + "2828672" + ], + [ + 391, + "303072" + ], + [ + 392, + "-227304" + ], + [ + 397, + "303072" + ], + [ + 401, + "-151536" + ], + [ + 402, + "-2424576" + ], + [ + 404, + "35145" + ], + [ + 406, + "-151536" + ], + [ + 409, + "440832" + ], + [ + 410, + "37884" + ], + [ + 411, + "-75768" + ], + [ + 413, + "606144" + ], + [ + 414, + "75768" + ], + [ + 419, + "-75768" + ], + [ + 421, + "2424576" + ], + [ + 425, + "75768" + ], + [ + 427, + "303072" + ], + [ + 428, + "606144" + ], + [ + 429, + "-303072" + ], + [ + 432, + "-151536" + ], + [ + 433, + "75768" + ], + [ + 434, + "454608" + ], + [ + 435, + "-151536" + ], + [ + 443, + "151536" + ], + [ + 452, + "-909216" + ], + [ + 453, + "606144" + ], + [ + 455, + "909216" + ], + [ + 457, + "151536" + ], + [ + 458, + "75768" + ], + [ + 459, + "-37884" + ], + [ + 463, + "454608" + ], + [ + 464, + "-454608" + ], + [ + 468, + "909216" + ], + [ + 469, + "-530376" + ], + [ + 470, + "-1212288" + ], + [ + 471, + "75768" + ], + [ + 472, + "151536" + ], + [ + 474, + "606144" + ], + [ + 475, + "-1212288" + ], + [ + 476, + "1212288" + ], + [ + 479, + "-592368" + ], + [ + 481, + "530376" + ], + [ + 484, + "37884" + ], + [ + 486, + "-151536" + ], + [ + 487, + "-303072" + ], + [ + 488, + "75768" + ], + [ + 490, + "-303072" + ], + [ + 491, + "-454608" + ], + [ + 492, + "-492492" + ], + [ + 493, + "454608" + ], + [ + 494, + "151536" + ], + [ + 495, + "75768" + ], + [ + 496, + "-454608" + ], + [ + 497, + "-378840" + ], + [ + 498, + "-2424576" + ], + [ + 500, + "-1818432" + ], + [ + 501, + "-37884" + ], + [ + 502, + "-227304" + ], + [ + 508, + "-1212288" + ], + [ + 509, + "1212288" + ], + [ + 510, + "-340956" + ], + [ + 511, + "-530376" + ], + [ + 512, + "303072" + ], + [ + 514, + "-151536" + ], + [ + 515, + "-75768" + ], + [ + 516, + "-303072" + ], + [ + 517, + "-75768" + ], + [ + 519, + "-56826" + ], + [ + 520, + "265188" + ], + [ + 522, + "113652" + ], + [ + 527, + "-227304" + ], + [ + 528, + "303072" + ], + [ + 529, + "75768" + ], + [ + 530, + "-37884" + ], + [ + 531, + "37884" + ], + [ + 535, + "-75768" + ], + [ + 537, + "303072" + ], + [ + 538, + "-75768" + ], + [ + 539, + "-37884" + ], + [ + 540, + "340956" + ], + [ + 546, + "-75768" + ], + [ + 547, + "-909216" + ], + [ + 552, + "-18942" + ], + [ + 553, + "170478" + ], + [ + 555, + "-530376" + ], + [ + 559, + "37884" + ], + [ + 561, + "37884" + ], + [ + 565, + "-37884" + ], + [ + 574, + "-113652" + ], + [ + 578, + "151536" + ], + [ + 579, + "-37884" + ], + [ + 581, + "-75768" + ], + [ + 590, + "-378840" + ], + [ + 595, + "151536" + ], + [ + 608, + "303072" + ], + [ + 609, + "-18942" + ], + [ + 610, + "37884" + ], + [ + 616, + "492492" + ], + [ + 619, + "75768" + ], + [ + 624, + "-37884" + ], + [ + 632, + "-75768" + ], + [ + 633, + "113652" + ], + [ + 634, + "-227304" + ], + [ + 645, + "227304" + ], + [ + 649, + "-1818432" + ], + [ + 651, + "-296184" + ], + [ + 652, + "-606144" + ], + [ + 655, + "-606144" + ], + [ + 656, + "75768" + ], + [ + 666, + "-606144" + ], + [ + 679, + "-303072" + ], + [ + 692, + "-75768" + ], + [ + 696, + "-265188" + ], + [ + 700, + "113652" + ], + [ + 771, + "-303072" + ], + [ + 773, + "303072" + ], + [ + 774, + "303072" + ], + [ + 776, + "303072" + ], + [ + 778, + "-606144" + ], + [ + 779, + "-303072" + ], + [ + 780, + "-303072" + ], + [ + 781, + "-303072" + ], + [ + 782, + "303072" + ], + [ + 783, + "303072" + ], + [ + 785, + "-606144" + ], + [ + 786, + "303072" + ], + [ + 789, + "-606144" + ], + [ + 790, + "-606144" + ], + [ + 791, + "-303072" + ], + [ + 793, + "-303072" + ], + [ + 795, + "606144" + ], + [ + 796, + "303072" + ], + [ + 797, + "-606144" + ], + [ + 798, + "303072" + ], + [ + 800, + "75768" + ], + [ + 801, + "-606144" + ], + [ + 802, + "303072" + ], + [ + 803, + "303072" + ], + [ + 804, + "-113652" + ], + [ + 805, + "-606144" + ], + [ + 806, + "-606144" + ], + [ + 807, + "-303072" + ], + [ + 808, + "-606144" + ], + [ + 809, + "-303072" + ], + [ + 811, + "151536" + ], + [ + 813, + "303072" + ], + [ + 814, + "303072" + ], + [ + 815, + "-303072" + ], + [ + 816, + "-303072" + ], + [ + 818, + "-606144" + ], + [ + 819, + "-606144" + ], + [ + 820, + "-303072" + ], + [ + 821, + "-909216" + ], + [ + 822, + "303072" + ], + [ + 823, + "606144" + ], + [ + 824, + "-303072" + ], + [ + 825, + "-303072" + ], + [ + 826, + "-303072" + ], + [ + 827, + "-303072" + ], + [ + 829, + "303072" + ], + [ + 830, + "606144" + ], + [ + 831, + "606144" + ], + [ + 834, + "303072" + ], + [ + 835, + "-303072" + ], + [ + 836, + "-303072" + ], + [ + 841, + "-303072" + ], + [ + 842, + "606144" + ], + [ + 843, + "-303072" + ], + [ + 844, + "-303072" + ], + [ + 848, + "303072" + ], + [ + 849, + "606144" + ], + [ + 850, + "303072" + ], + [ + 851, + "-303072" + ], + [ + 854, + "-303072" + ], + [ + 856, + "-303072" + ], + [ + 857, + "-303072" + ], + [ + 860, + "303072" + ], + [ + 862, + "-606144" + ], + [ + 863, + "-303072" + ], + [ + 864, + "-303072" + ], + [ + 865, + "303072" + ], + [ + 866, + "-909216" + ], + [ + 867, + "-606144" + ], + [ + 868, + "-606144" + ], + [ + 869, + "-606144" + ], + [ + 870, + "-303072" + ], + [ + 871, + "-303072" + ], + [ + 872, + "-303072" + ], + [ + 873, + "-303072" + ], + [ + 874, + "189420" + ], + [ + 876, + "-303072" + ], + [ + 877, + "151536" + ], + [ + 879, + "-909216" + ], + [ + 884, + "151536" + ], + [ + 887, + "606144" + ], + [ + 888, + "75768" + ], + [ + 890, + "-303072" + ], + [ + 892, + "-303072" + ], + [ + 894, + "-1212288" + ], + [ + 896, + "151536" + ], + [ + 898, + "-606144" + ], + [ + 899, + "1363824" + ], + [ + 902, + "227304" + ], + [ + 903, + "151536" + ], + [ + 906, + "-454608" + ], + [ + 907, + "151536" + ], + [ + 908, + "1212288" + ], + [ + 912, + "151536" + ], + [ + 914, + "303072" + ], + [ + 915, + "151536" + ], + [ + 916, + "-1060752" + ], + [ + 917, + "454608" + ], + [ + 918, + "909216" + ], + [ + 919, + "-227304" + ], + [ + 923, + "-606144" + ], + [ + 927, + "-454608" + ], + [ + 931, + "-454608" + ], + [ + 934, + "37884" + ], + [ + 935, + "-37884" + ], + [ + 937, + "113652" + ], + [ + 939, + "-265188" + ], + [ + 941, + "-303072" + ], + [ + 942, + "909216" + ], + [ + 943, + "454608" + ], + [ + 944, + "-606144" + ], + [ + 946, + "-757680" + ], + [ + 947, + "-378840" + ], + [ + 948, + "-947100" + ], + [ + 949, + "-37884" + ], + [ + 950, + "-151536" + ], + [ + 952, + "-37884" + ], + [ + 956, + "-1060752" + ], + [ + 959, + "303072" + ], + [ + 961, + "265188" + ], + [ + 962, + "-265188" + ], + [ + 964, + "37884" + ], + [ + 965, + "-303072" + ], + [ + 968, + "151536" + ], + [ + 970, + "-530376" + ], + [ + 973, + "-378840" + ], + [ + 978, + "75768" + ], + [ + 979, + "113652" + ], + [ + 981, + "227304" + ], + [ + 988, + "606144" + ], + [ + 989, + "151536" + ], + [ + 990, + "-1363824" + ], + [ + 992, + "-1212288" + ], + [ + 994, + "-454608" + ], + [ + 995, + "-303072" + ], + [ + 996, + "-1212288" + ], + [ + 997, + "-151536" + ], + [ + 999, + "151536" + ], + [ + 1001, + "-454608" + ], + [ + 1003, + "151536" + ], + [ + 1005, + "227304" + ], + [ + 1010, + "151536" + ], + [ + 1011, + "-3434816" + ], + [ + 1024, + "2525600" + ], + [ + 1025, + "-151536" + ], + [ + 1027, + "303072" + ], + [ + 1029, + "151536" + ], + [ + 1033, + "454608" + ], + [ + 1035, + "-454608" + ], + [ + 1037, + "-303072" + ], + [ + 1038, + "530376" + ], + [ + 1040, + "-303072" + ], + [ + 1051, + "303072" + ], + [ + 1053, + "454608" + ], + [ + 1054, + "-606144" + ], + [ + 1056, + "-151536" + ], + [ + 1057, + "-454608" + ], + [ + 1058, + "-530376" + ], + [ + 1059, + "265188" + ], + [ + 1060, + "-303072" + ], + [ + 1061, + "-454608" + ], + [ + 1063, + "-37884" + ], + [ + 1064, + "606144" + ], + [ + 1065, + "303072" + ], + [ + 1067, + "303072" + ], + [ + 1069, + "454608" + ], + [ + 1070, + "-757680" + ], + [ + 1071, + "151536" + ], + [ + 1073, + "303072" + ], + [ + 1074, + "75768" + ], + [ + 1076, + "-227304" + ], + [ + 1077, + "-909216" + ], + [ + 1078, + "-151536" + ], + [ + 1079, + "606144" + ], + [ + 1081, + "303072" + ], + [ + 1082, + "75768" + ], + [ + 1084, + "151536" + ], + [ + 1085, + "75768" + ], + [ + 1086, + "-151536" + ], + [ + 1088, + "-378840" + ], + [ + 1089, + "909216" + ], + [ + 1090, + "-378840" + ], + [ + 1092, + "227304" + ], + [ + 1094, + "-227304" + ], + [ + 1095, + "-151536" + ], + [ + 1096, + "151536" + ], + [ + 1097, + "-454608" + ], + [ + 1099, + "-18942" + ], + [ + 1100, + "-151536" + ], + [ + 1101, + "18942" + ], + [ + 1102, + "-151536" + ], + [ + 1103, + "-227304" + ], + [ + 1104, + "-1060752" + ], + [ + 1105, + "-113652" + ], + [ + 1106, + "-56826" + ], + [ + 1108, + "151536" + ], + [ + 1111, + "-1060752" + ], + [ + 1112, + "-909216" + ], + [ + 1114, + "606144" + ], + [ + 1115, + "606144" + ], + [ + 1117, + "340956" + ], + [ + 1118, + "-75768" + ], + [ + 1119, + "-85239" + ], + [ + 1121, + "-606144" + ], + [ + 1122, + "303072" + ], + [ + 1123, + "-883960" + ], + [ + 1124, + "404096" + ], + [ + 1125, + "303072" + ], + [ + 1126, + "606144" + ], + [ + 1127, + "-454608" + ], + [ + 1129, + "151536" + ], + [ + 1132, + "-303072" + ], + [ + 1138, + "-303072" + ], + [ + 1139, + "606144" + ], + [ + 1140, + "606144" + ], + [ + 1142, + "151536" + ], + [ + 1144, + "606144" + ], + [ + 1145, + "1212288" + ], + [ + 1147, + "-303072" + ], + [ + 1173, + "-151536" + ], + [ + 1248, + "-606144" + ] + ], + "source_direction": [ + [ + 296, + "2" + ], + [ + 942, + "1" + ], + [ + 959, + "-1" + ], + [ + 972, + "-1" + ], + [ + 1012, + "1" + ], + [ + 1031, + "-1" + ], + [ + 1116, + "-1" + ], + [ + 1248, + "-1" + ] + ], + "split_chart": 306 + }, + "max_changed_coefficient_bits": 23, + "native_delta": { + "paid": { + "1": 1, + "5": 1, + "6": -1 + }, + "targets": { + "4": 1, + "5": 1, + "9": -1 + } + }, + "new_paid": 58, + "old_paid_charts": [ + 300, + 127 + ], + "paid_daughter_ranks": [ + 1, + 5 + ], + "replay": { + "affected_rows": 316, + "expected_fresh_input_row": { + "1266": "1" + }, + "literal_row_delta_sha256": "c730e79492a5e0e98129a872944decde6269a750da558ed7c3cf76866b08f812", + "new_owner_label": 1519, + "omitted_fresh_input_row": {}, + "original_oriented_paid_row": [ + [ + 90069, + "2" + ], + [ + 90070, + "2" + ] + ], + "original_owner_label": 1058, + "parent_sha256": "98db91313e0aa80b5eb667074b6bd61fa4c7c1ce40fe18859fd7f5a1c1e85976", + "result_sha256": "dfe7dfa2076f6e264d44c08cf634225ae67fa18340b524c2eb7005fd7b3d93eb" + }, + "source_paid": 91128, + "target_daughter_ranks": [ + 4, + 5 + ] + }, + { + "allocated_role": 1267, + "chart": 234, + "credit": [ + "0.639388808980847010450658", + "0.639388808980847010450659" + ], + "descending": false, + "event": { + "calibration": [ + [ + 89050, + "27552" + ], + [ + 89051, + "13776" + ], + [ + 89058, + "-6888" + ], + [ + 89063, + "13776" + ] + ], + "pulse": [ + [ + 103236, + "1" + ] + ], + "readout": [ + [ + 59, + "-20" + ], + [ + 89050, + "20" + ], + [ + 89065, + "-10" + ], + [ + 89071, + "-20" + ], + [ + 89077, + "-10" + ] + ], + "return_chart": 127, + "return_covector": [ + [ + 18, + "6888" + ], + [ + 19, + "6888" + ], + [ + 21, + "20664" + ], + [ + 40, + "3444" + ], + [ + 54, + "-6888" + ], + [ + 101, + "-6888" + ], + [ + 151, + "3444" + ], + [ + 173, + "-55104" + ], + [ + 188, + "-2583" + ], + [ + 226, + "-2583" + ], + [ + 230, + "-6888" + ], + [ + 231, + "-2583" + ], + [ + 233, + "-6888" + ], + [ + 235, + "41328" + ], + [ + 236, + "-6027" + ], + [ + 240, + "-6888" + ], + [ + 244, + "-27552" + ], + [ + 245, + "-1722" + ], + [ + 246, + "-567" + ], + [ + 247, + "-2583" + ], + [ + 254, + "20664" + ], + [ + 262, + "-55104" + ], + [ + 266, + "-61992" + ], + [ + 273, + "-41328" + ], + [ + 274, + "13776" + ], + [ + 276, + "-55104" + ], + [ + 277, + "-20664" + ], + [ + 283, + "-2160" + ], + [ + 288, + "-1038" + ], + [ + 289, + "-1578" + ], + [ + 292, + "-10800" + ], + [ + 299, + "-6888" + ], + [ + 302, + "-27552" + ], + [ + 304, + "-41328" + ], + [ + 307, + "-20664" + ], + [ + 315, + "1722" + ], + [ + 317, + "12915" + ], + [ + 320, + "6888" + ], + [ + 321, + "13776" + ], + [ + 322, + "-41328" + ], + [ + 324, + "6888" + ], + [ + 326, + "55104" + ], + [ + 329, + "1722" + ], + [ + 336, + "-3444" + ], + [ + 338, + "-1722" + ], + [ + 340, + "3444" + ], + [ + 347, + "27552" + ], + [ + 348, + "-6888" + ], + [ + 349, + "-20664" + ], + [ + 350, + "13776" + ], + [ + 356, + "-20664" + ], + [ + 365, + "-27552" + ], + [ + 368, + "3444" + ], + [ + 370, + "-1722" + ], + [ + 376, + "-37884" + ], + [ + 381, + "27552" + ], + [ + 384, + "6888" + ], + [ + 386, + "-10332" + ], + [ + 388, + "-41328" + ], + [ + 389, + "55104" + ], + [ + 390, + "27552" + ], + [ + 392, + "-3444" + ], + [ + 397, + "13776" + ], + [ + 400, + "6888" + ], + [ + 402, + "165312" + ], + [ + 404, + "204" + ], + [ + 411, + "30996" + ], + [ + 413, + "-41328" + ], + [ + 421, + "-165312" + ], + [ + 425, + "-6888" + ], + [ + 427, + "-13776" + ], + [ + 433, + "-13776" + ], + [ + 434, + "-13776" + ], + [ + 435, + "-6888" + ], + [ + 443, + "-27552" + ], + [ + 452, + "-13776" + ], + [ + 453, + "-41328" + ], + [ + 455, + "13776" + ], + [ + 457, + "27552" + ], + [ + 460, + "-20664" + ], + [ + 463, + "6888" + ], + [ + 464, + "13776" + ], + [ + 468, + "27552" + ], + [ + 470, + "-27552" + ], + [ + 471, + "-6888" + ], + [ + 474, + "-41328" + ], + [ + 479, + "27552" + ], + [ + 481, + "6888" + ], + [ + 483, + "-41328" + ], + [ + 484, + "-30996" + ], + [ + 486, + "-27552" + ], + [ + 490, + "-82656" + ], + [ + 491, + "27552" + ], + [ + 492, + "-20664" + ], + [ + 494, + "6888" + ], + [ + 496, + "-89544" + ], + [ + 497, + "-68880" + ], + [ + 500, + "-27552" + ], + [ + 502, + "6888" + ], + [ + 508, + "41328" + ], + [ + 509, + "-41328" + ], + [ + 510, + "3444" + ], + [ + 511, + "-20664" + ], + [ + 514, + "-3444" + ], + [ + 515, + "-13776" + ], + [ + 516, + "-6888" + ], + [ + 519, + "-1722" + ], + [ + 520, + "3444" + ], + [ + 522, + "3444" + ], + [ + 527, + "6888" + ], + [ + 528, + "55104" + ], + [ + 529, + "6888" + ], + [ + 535, + "-3444" + ], + [ + 539, + "3444" + ], + [ + 540, + "6888" + ], + [ + 546, + "-13776" + ], + [ + 547, + "27552" + ], + [ + 552, + "-5166" + ], + [ + 555, + "13776" + ], + [ + 559, + "13776" + ], + [ + 561, + "-10332" + ], + [ + 565, + "-10332" + ], + [ + 574, + "3444" + ], + [ + 579, + "6888" + ], + [ + 581, + "3444" + ], + [ + 588, + "3444" + ], + [ + 590, + "-6888" + ], + [ + 609, + "1722" + ], + [ + 610, + "-3444" + ], + [ + 616, + "-3444" + ], + [ + 619, + "3444" + ], + [ + 624, + "-6888" + ], + [ + 630, + "-134316" + ], + [ + 632, + "-3444" + ], + [ + 633, + "1722" + ], + [ + 634, + "-6888" + ], + [ + 645, + "-6888" + ], + [ + 649, + "55104" + ], + [ + 651, + "-13776" + ], + [ + 652, + "41328" + ], + [ + 655, + "-20664" + ], + [ + 656, + "3444" + ], + [ + 679, + "20664" + ], + [ + 692, + "6888" + ], + [ + 696, + "13776" + ], + [ + 700, + "3444" + ], + [ + 701, + "41328" + ], + [ + 783, + "13776" + ], + [ + 800, + "10332" + ], + [ + 804, + "-1722" + ], + [ + 811, + "10332" + ], + [ + 876, + "-13776" + ], + [ + 879, + "-13776" + ], + [ + 890, + "20664" + ], + [ + 891, + "3444" + ], + [ + 898, + "41328" + ], + [ + 899, + "-6888" + ], + [ + 902, + "6888" + ], + [ + 903, + "6888" + ], + [ + 906, + "13776" + ], + [ + 912, + "6888" + ], + [ + 914, + "13776" + ], + [ + 915, + "-41328" + ], + [ + 916, + "20664" + ], + [ + 917, + "-13776" + ], + [ + 918, + "13776" + ], + [ + 919, + "-34440" + ], + [ + 923, + "-13776" + ], + [ + 927, + "-13776" + ], + [ + 931, + "6888" + ], + [ + 934, + "-10332" + ], + [ + 935, + "-10332" + ], + [ + 937, + "13776" + ], + [ + 939, + "6888" + ], + [ + 943, + "6888" + ], + [ + 944, + "-13776" + ], + [ + 946, + "-13776" + ], + [ + 947, + "6888" + ], + [ + 948, + "8610" + ], + [ + 949, + "-3444" + ], + [ + 952, + "3444" + ], + [ + 957, + "13776" + ], + [ + 958, + "41328" + ], + [ + 959, + "13776" + ], + [ + 961, + "3444" + ], + [ + 962, + "-3444" + ], + [ + 964, + "-3444" + ], + [ + 965, + "-13776" + ], + [ + 968, + "3444" + ], + [ + 970, + "-6888" + ], + [ + 973, + "-13776" + ], + [ + 979, + "3444" + ], + [ + 981, + "3444" + ], + [ + 990, + "13776" + ], + [ + 994, + "-13776" + ], + [ + 997, + "13776" + ], + [ + 1001, + "-13776" + ], + [ + 1005, + "6888" + ], + [ + 1009, + "-41328" + ], + [ + 1011, + "-27552" + ], + [ + 1024, + "13776" + ], + [ + 1027, + "13776" + ], + [ + 1029, + "-27552" + ], + [ + 1033, + "-13776" + ], + [ + 1035, + "-13776" + ], + [ + 1037, + "6888" + ], + [ + 1038, + "6888" + ], + [ + 1040, + "6888" + ], + [ + 1053, + "6888" + ], + [ + 1056, + "3444" + ], + [ + 1057, + "-13776" + ], + [ + 1058, + "-6888" + ], + [ + 1059, + "3444" + ], + [ + 1061, + "-6888" + ], + [ + 1065, + "3444" + ], + [ + 1069, + "6888" + ], + [ + 1070, + "13776" + ], + [ + 1073, + "6888" + ], + [ + 1076, + "-3444" + ], + [ + 1077, + "-13776" + ], + [ + 1078, + "13776" + ], + [ + 1081, + "13776" + ], + [ + 1082, + "-20664" + ], + [ + 1084, + "3444" + ], + [ + 1085, + "13776" + ], + [ + 1087, + "-55104" + ], + [ + 1088, + "27552" + ], + [ + 1089, + "-6888" + ], + [ + 1090, + "6888" + ], + [ + 1091, + "10332" + ], + [ + 1092, + "-6888" + ], + [ + 1094, + "-13776" + ], + [ + 1095, + "6888" + ], + [ + 1096, + "-13776" + ], + [ + 1097, + "6888" + ], + [ + 1101, + "6888" + ], + [ + 1102, + "13776" + ], + [ + 1103, + "-3444" + ], + [ + 1104, + "27552" + ], + [ + 1105, + "3444" + ], + [ + 1106, + "-1722" + ], + [ + 1108, + "-13776" + ], + [ + 1111, + "-13776" + ], + [ + 1112, + "13776" + ], + [ + 1114, + "6888" + ], + [ + 1115, + "-41328" + ], + [ + 1117, + "-3444" + ], + [ + 1119, + "-2583" + ], + [ + 1121, + "-6888" + ], + [ + 1122, + "-9184" + ], + [ + 1123, + "-10332" + ], + [ + 1125, + "6888" + ], + [ + 1127, + "-6888" + ], + [ + 1129, + "6888" + ], + [ + 1132, + "20664" + ], + [ + 1138, + "13776" + ], + [ + 1139, + "-41328" + ], + [ + 1140, + "-41328" + ], + [ + 1142, + "6888" + ], + [ + 1144, + "-13776" + ], + [ + 1145, + "-82656" + ] + ], + "return_direction": [ + [ + 324, + "1" + ] + ], + "role": 324, + "source_chart": 3, + "source_covector": [ + [ + 315, + "-5" + ], + [ + 324, + "5" + ], + [ + 461, + "4" + ], + [ + 481, + "4" + ], + [ + 1117, + "-2" + ] + ], + "source_direction": [ + [ + 324, + "1" + ] + ], + "split_chart": 234 + }, + "max_changed_coefficient_bits": 15, + "native_delta": { + "paid": { + "1": 1, + "5": 1, + "6": -1 + }, + "targets": { + "4": 1, + "5": 1, + "9": -1 + } + }, + "new_paid": 59, + "old_paid_charts": [ + 344, + 127 + ], + "paid_daughter_ranks": [ + 1, + 5 + ], + "replay": { + "affected_rows": 14, + "expected_fresh_input_row": { + "1267": "1" + }, + "literal_row_delta_sha256": "595463a6f2872cdfe4bc0ac4b0fe7960ed90f7623d4e2dd8b3dc3f7fc712401c", + "new_owner_label": 1520, + "omitted_fresh_input_row": {}, + "original_oriented_paid_row": [ + [ + 89040, + "1" + ], + [ + 89041, + "1" + ] + ], + "original_owner_label": 338, + "parent_sha256": "dfe7dfa2076f6e264d44c08cf634225ae67fa18340b524c2eb7005fd7b3d93eb", + "result_sha256": "59d4ffe7ca252615193df4d0d43cc5f977f64c924a8c277b9153263b423985b8" + }, + "source_paid": 95923, + "target_daughter_ranks": [ + 4, + 5 + ] + }, + { + "allocated_role": 1268, + "chart": 306, + "credit": [ + "0.639388808980847010450658", + "0.639388808980847010450659" + ], + "descending": false, + "event": { + "calibration": [ + [ + 60, + "2" + ], + [ + 90122, + "4" + ], + [ + 90126, + "-4" + ], + [ + 90129, + "-2" + ], + [ + 90130, + "4" + ], + [ + 94336, + "-2" + ], + [ + 96307, + "2" + ], + [ + 96330, + "-2" + ] + ], + "pulse": [ + [ + 96518, + "-8" + ], + [ + 97129, + "-4" + ], + [ + 103327, + "4" + ] + ], + "readout": [ + [ + 96307, + "55104" + ] + ], + "return_chart": 127, + "return_covector": [ + [ + 89, + "4" + ], + [ + 94, + "4" + ], + [ + 245, + "-1" + ], + [ + 256, + "1" + ], + [ + 297, + "2" + ], + [ + 303, + "-4" + ], + [ + 899, + "8" + ], + [ + 943, + "-8" + ], + [ + 948, + "-10" + ] + ], + "return_direction": [ + [ + 297, + "-8" + ], + [ + 309, + "8" + ], + [ + 535, + "-16" + ], + [ + 961, + "4" + ], + [ + 990, + "-1" + ], + [ + 1073, + "-8" + ], + [ + 1173, + "16" + ], + [ + 1248, + "8" + ] + ], + "role": 990, + "source_chart": 3, + "source_covector": [ + [ + 3, + "13776" + ], + [ + 21, + "27552" + ], + [ + 126, + "9184" + ], + [ + 129, + "-27552" + ], + [ + 131, + "-13776" + ], + [ + 142, + "-13776" + ], + [ + 150, + "13776" + ], + [ + 159, + "-27552" + ], + [ + 164, + "27552" + ], + [ + 173, + "-316848" + ], + [ + 188, + "2583" + ], + [ + 205, + "-13776" + ], + [ + 226, + "23247" + ], + [ + 230, + "89544" + ], + [ + 231, + "2583" + ], + [ + 233, + "-13776" + ], + [ + 235, + "-61992" + ], + [ + 236, + "2583" + ], + [ + 239, + "-27552" + ], + [ + 240, + "27552" + ], + [ + 244, + "-41328" + ], + [ + 245, + "-17220" + ], + [ + 246, + "567" + ], + [ + 247, + "2583" + ], + [ + 249, + "6888" + ], + [ + 252, + "-24108" + ], + [ + 254, + "27552" + ], + [ + 260, + "3444" + ], + [ + 262, + "-275520" + ], + [ + 263, + "10332" + ], + [ + 266, + "192864" + ], + [ + 270, + "-10332" + ], + [ + 273, + "-55104" + ], + [ + 274, + "68880" + ], + [ + 276, + "-123984" + ], + [ + 277, + "-206640" + ], + [ + 283, + "2160" + ], + [ + 288, + "-17904" + ], + [ + 289, + "-17364" + ], + [ + 292, + "10800" + ], + [ + 299, + "10332" + ], + [ + 302, + "41328" + ], + [ + 304, + "96432" + ], + [ + 307, + "30996" + ], + [ + 309, + "-41328" + ], + [ + 310, + "20664" + ], + [ + 315, + "17220" + ], + [ + 317, + "-22386" + ], + [ + 320, + "-12054" + ], + [ + 321, + "6888" + ], + [ + 322, + "27552" + ], + [ + 326, + "27552" + ], + [ + 328, + "-13776" + ], + [ + 329, + "17220" + ], + [ + 335, + "-20664" + ], + [ + 336, + "30996" + ], + [ + 338, + "-17220" + ], + [ + 340, + "34440" + ], + [ + 344, + "-34440" + ], + [ + 347, + "137760" + ], + [ + 348, + "-68880" + ], + [ + 349, + "27552" + ], + [ + 350, + "68880" + ], + [ + 354, + "13776" + ], + [ + 356, + "27552" + ], + [ + 358, + "13776" + ], + [ + 359, + "-13776" + ], + [ + 361, + "-13776" + ], + [ + 362, + "-6888" + ], + [ + 364, + "6888" + ], + [ + 365, + "41328" + ], + [ + 368, + "34440" + ], + [ + 370, + "-17220" + ], + [ + 376, + "51660" + ], + [ + 381, + "-6888" + ], + [ + 383, + "103320" + ], + [ + 384, + "41328" + ], + [ + 386, + "-66584" + ], + [ + 388, + "55104" + ], + [ + 389, + "27552" + ], + [ + 390, + "183680" + ], + [ + 391, + "-82656" + ], + [ + 392, + "-6888" + ], + [ + 397, + "27552" + ], + [ + 401, + "13776" + ], + [ + 402, + "220416" + ], + [ + 404, + "9267" + ], + [ + 406, + "41328" + ], + [ + 410, + "-10332" + ], + [ + 411, + "-75768" + ], + [ + 413, + "-55104" + ], + [ + 414, + "-20664" + ], + [ + 419, + "-6888" + ], + [ + 420, + "55104" + ], + [ + 421, + "-220416" + ], + [ + 425, + "6888" + ], + [ + 427, + "-110208" + ], + [ + 428, + "-110208" + ], + [ + 429, + "55104" + ], + [ + 432, + "-13776" + ], + [ + 433, + "6888" + ], + [ + 434, + "-68880" + ], + [ + 435, + "-13776" + ], + [ + 443, + "13776" + ], + [ + 452, + "-137760" + ], + [ + 453, + "-55104" + ], + [ + 455, + "137760" + ], + [ + 457, + "-41328" + ], + [ + 458, + "-20664" + ], + [ + 459, + "10332" + ], + [ + 460, + "27552" + ], + [ + 463, + "68880" + ], + [ + 464, + "68880" + ], + [ + 468, + "-192864" + ], + [ + 469, + "117096" + ], + [ + 470, + "55104" + ], + [ + 471, + "-103320" + ], + [ + 472, + "-13776" + ], + [ + 474, + "-55104" + ], + [ + 475, + "220416" + ], + [ + 476, + "-220416" + ], + [ + 479, + "179088" + ], + [ + 481, + "-117096" + ], + [ + 483, + "55104" + ], + [ + 484, + "30996" + ], + [ + 486, + "41328" + ], + [ + 487, + "82656" + ], + [ + 488, + "-20664" + ], + [ + 490, + "192864" + ], + [ + 491, + "-41328" + ], + [ + 492, + "24108" + ], + [ + 493, + "-96432" + ], + [ + 494, + "13776" + ], + [ + 495, + "-20664" + ], + [ + 496, + "13776" + ], + [ + 497, + "20664" + ], + [ + 498, + "440832" + ], + [ + 500, + "-275520" + ], + [ + 501, + "6888" + ], + [ + 502, + "48216" + ], + [ + 503, + "-27552" + ], + [ + 508, + "220416" + ], + [ + 509, + "-220416" + ], + [ + 510, + "51660" + ], + [ + 511, + "-75768" + ], + [ + 512, + "-27552" + ], + [ + 513, + "27552" + ], + [ + 514, + "55104" + ], + [ + 515, + "-6888" + ], + [ + 516, + "110208" + ], + [ + 517, + "20664" + ], + [ + 519, + "1722" + ], + [ + 520, + "24108" + ], + [ + 522, + "-3444" + ], + [ + 527, + "48216" + ], + [ + 528, + "27552" + ], + [ + 529, + "-6888" + ], + [ + 530, + "10332" + ], + [ + 531, + "-10332" + ], + [ + 535, + "-6888" + ], + [ + 537, + "-82656" + ], + [ + 538, + "20664" + ], + [ + 539, + "-3444" + ], + [ + 540, + "-51660" + ], + [ + 546, + "20664" + ], + [ + 547, + "137760" + ], + [ + 552, + "12054" + ], + [ + 553, + "-25830" + ], + [ + 555, + "89544" + ], + [ + 559, + "3444" + ], + [ + 561, + "3444" + ], + [ + 565, + "24108" + ], + [ + 574, + "17220" + ], + [ + 578, + "20664" + ], + [ + 579, + "10332" + ], + [ + 581, + "20664" + ], + [ + 588, + "13776" + ], + [ + 590, + "-89544" + ], + [ + 595, + "-41328" + ], + [ + 608, + "-55104" + ], + [ + 609, + "-1722" + ], + [ + 610, + "3444" + ], + [ + 616, + "-24108" + ], + [ + 619, + "6888" + ], + [ + 624, + "10332" + ], + [ + 630, + "13776" + ], + [ + 632, + "-6888" + ], + [ + 633, + "17220" + ], + [ + 634, + "6888" + ], + [ + 645, + "-34440" + ], + [ + 649, + "275520" + ], + [ + 651, + "20664" + ], + [ + 652, + "55104" + ], + [ + 655, + "110208" + ], + [ + 656, + "6888" + ], + [ + 666, + "82656" + ], + [ + 679, + "27552" + ], + [ + 692, + "-6888" + ], + [ + 696, + "58548" + ], + [ + 700, + "-3444" + ], + [ + 771, + "-27552" + ], + [ + 773, + "-27552" + ], + [ + 774, + "-27552" + ], + [ + 775, + "55104" + ], + [ + 776, + "-27552" + ], + [ + 777, + "55104" + ], + [ + 779, + "-27552" + ], + [ + 780, + "-27552" + ], + [ + 781, + "27552" + ], + [ + 782, + "-27552" + ], + [ + 783, + "82656" + ], + [ + 786, + "27552" + ], + [ + 789, + "55104" + ], + [ + 790, + "55104" + ], + [ + 791, + "27552" + ], + [ + 792, + "55104" + ], + [ + 793, + "27552" + ], + [ + 794, + "55104" + ], + [ + 796, + "27552" + ], + [ + 798, + "-27552" + ], + [ + 800, + "-6888" + ], + [ + 802, + "27552" + ], + [ + 803, + "27552" + ], + [ + 804, + "-17220" + ], + [ + 805, + "55104" + ], + [ + 806, + "55104" + ], + [ + 807, + "27552" + ], + [ + 808, + "55104" + ], + [ + 809, + "82656" + ], + [ + 810, + "55104" + ], + [ + 813, + "-27552" + ], + [ + 814, + "-27552" + ], + [ + 815, + "-27552" + ], + [ + 816, + "27552" + ], + [ + 817, + "-55104" + ], + [ + 820, + "-27552" + ], + [ + 821, + "27552" + ], + [ + 822, + "27552" + ], + [ + 824, + "27552" + ], + [ + 825, + "27552" + ], + [ + 826, + "27552" + ], + [ + 827, + "27552" + ], + [ + 829, + "27552" + ], + [ + 832, + "55104" + ], + [ + 833, + "55104" + ], + [ + 834, + "27552" + ], + [ + 835, + "27552" + ], + [ + 836, + "27552" + ], + [ + 840, + "-55104" + ], + [ + 841, + "27552" + ], + [ + 843, + "27552" + ], + [ + 844, + "27552" + ], + [ + 847, + "-55104" + ], + [ + 848, + "-27552" + ], + [ + 850, + "-27552" + ], + [ + 851, + "27552" + ], + [ + 854, + "-27552" + ], + [ + 856, + "-27552" + ], + [ + 857, + "82656" + ], + [ + 858, + "55104" + ], + [ + 859, + "55104" + ], + [ + 860, + "27552" + ], + [ + 862, + "55104" + ], + [ + 863, + "27552" + ], + [ + 864, + "27552" + ], + [ + 865, + "27552" + ], + [ + 866, + "27552" + ], + [ + 869, + "55104" + ], + [ + 870, + "27552" + ], + [ + 871, + "27552" + ], + [ + 872, + "27552" + ], + [ + 873, + "27552" + ], + [ + 874, + "-10332" + ], + [ + 876, + "-27552" + ], + [ + 877, + "-41328" + ], + [ + 879, + "-137760" + ], + [ + 884, + "-68880" + ], + [ + 888, + "6888" + ], + [ + 890, + "27552" + ], + [ + 891, + "13776" + ], + [ + 892, + "82656" + ], + [ + 894, + "220416" + ], + [ + 896, + "-13776" + ], + [ + 898, + "55104" + ], + [ + 899, + "-13776" + ], + [ + 902, + "-6888" + ], + [ + 903, + "13776" + ], + [ + 906, + "68880" + ], + [ + 907, + "-41328" + ], + [ + 912, + "13776" + ], + [ + 914, + "27552" + ], + [ + 915, + "13776" + ], + [ + 916, + "68880" + ], + [ + 917, + "-68880" + ], + [ + 918, + "137760" + ], + [ + 919, + "89544" + ], + [ + 923, + "55104" + ], + [ + 927, + "13776" + ], + [ + 931, + "41328" + ], + [ + 934, + "3444" + ], + [ + 935, + "24108" + ], + [ + 937, + "-17220" + ], + [ + 939, + "58548" + ], + [ + 941, + "-27552" + ], + [ + 943, + "68880" + ], + [ + 946, + "-179088" + ], + [ + 947, + "-61992" + ], + [ + 948, + "86100" + ], + [ + 949, + "24108" + ], + [ + 950, + "41328" + ], + [ + 952, + "-3444" + ], + [ + 956, + "-151536" + ], + [ + 959, + "27552" + ], + [ + 961, + "-58548" + ], + [ + 962, + "-24108" + ], + [ + 964, + "-10332" + ], + [ + 965, + "-137760" + ], + [ + 970, + "-48216" + ], + [ + 973, + "-61992" + ], + [ + 978, + "-20664" + ], + [ + 979, + "10332" + ], + [ + 981, + "-48216" + ], + [ + 989, + "13776" + ], + [ + 990, + "206640" + ], + [ + 992, + "220416" + ], + [ + 994, + "13776" + ], + [ + 995, + "27552" + ], + [ + 996, + "220416" + ], + [ + 997, + "-13776" + ], + [ + 999, + "-41328" + ], + [ + 1001, + "13776" + ], + [ + 1003, + "-41328" + ], + [ + 1005, + "-6888" + ], + [ + 1009, + "55104" + ], + [ + 1010, + "-41328" + ], + [ + 1011, + "-128576" + ], + [ + 1024, + "-9184" + ], + [ + 1025, + "-41328" + ], + [ + 1027, + "27552" + ], + [ + 1029, + "13776" + ], + [ + 1033, + "-68880" + ], + [ + 1035, + "-41328" + ], + [ + 1037, + "27552" + ], + [ + 1038, + "-117096" + ], + [ + 1040, + "27552" + ], + [ + 1043, + "55104" + ], + [ + 1044, + "110208" + ], + [ + 1045, + "27552" + ], + [ + 1047, + "55104" + ], + [ + 1049, + "-27552" + ], + [ + 1051, + "27552" + ], + [ + 1052, + "-27552" + ], + [ + 1053, + "68880" + ], + [ + 1056, + "-13776" + ], + [ + 1057, + "13776" + ], + [ + 1058, + "-48216" + ], + [ + 1059, + "24108" + ], + [ + 1060, + "82656" + ], + [ + 1061, + "41328" + ], + [ + 1063, + "10332" + ], + [ + 1065, + "-27552" + ], + [ + 1067, + "-27552" + ], + [ + 1069, + "68880" + ], + [ + 1070, + "-123984" + ], + [ + 1071, + "-41328" + ], + [ + 1073, + "-27552" + ], + [ + 1074, + "-6888" + ], + [ + 1076, + "-34440" + ], + [ + 1077, + "-137760" + ], + [ + 1078, + "-13776" + ], + [ + 1079, + "-110208" + ], + [ + 1081, + "82656" + ], + [ + 1082, + "6888" + ], + [ + 1085, + "6888" + ], + [ + 1086, + "41328" + ], + [ + 1088, + "75768" + ], + [ + 1089, + "-82656" + ], + [ + 1090, + "-89544" + ], + [ + 1092, + "-34440" + ], + [ + 1094, + "61992" + ], + [ + 1095, + "13776" + ], + [ + 1096, + "13776" + ], + [ + 1097, + "41328" + ], + [ + 1099, + "-1722" + ], + [ + 1100, + "13776" + ], + [ + 1101, + "1722" + ], + [ + 1102, + "-96432" + ], + [ + 1103, + "-34440" + ], + [ + 1104, + "234192" + ], + [ + 1105, + "17220" + ], + [ + 1106, + "1722" + ], + [ + 1108, + "13776" + ], + [ + 1111, + "234192" + ], + [ + 1112, + "192864" + ], + [ + 1114, + "55104" + ], + [ + 1115, + "-55104" + ], + [ + 1116, + "55104" + ], + [ + 1117, + "-51660" + ], + [ + 1118, + "20664" + ], + [ + 1119, + "2583" + ], + [ + 1121, + "55104" + ], + [ + 1122, + "-45920" + ], + [ + 1123, + "-84952" + ], + [ + 1124, + "-36736" + ], + [ + 1125, + "-68880" + ], + [ + 1126, + "-110208" + ], + [ + 1127, + "-68880" + ], + [ + 1129, + "13776" + ], + [ + 1132, + "27552" + ], + [ + 1138, + "27552" + ], + [ + 1139, + "-55104" + ], + [ + 1140, + "-55104" + ], + [ + 1142, + "13776" + ], + [ + 1144, + "-82656" + ], + [ + 1145, + "-110208" + ], + [ + 1173, + "27552" + ], + [ + 1248, + "55104" + ] + ], + "source_direction": [ + [ + 297, + "-8" + ], + [ + 309, + "8" + ], + [ + 535, + "-16" + ], + [ + 961, + "4" + ], + [ + 990, + "-1" + ], + [ + 1073, + "-8" + ], + [ + 1173, + "16" + ], + [ + 1248, + "8" + ] + ], + "split_chart": 306 + }, + "max_changed_coefficient_bits": 23, + "native_delta": { + "paid": { + "1": 1, + "5": 1, + "6": -1 + }, + "targets": { + "4": 1, + "5": 1, + "9": -1 + } + }, + "new_paid": 60, + "old_paid_charts": [ + 298, + 127 + ], + "paid_daughter_ranks": [ + 1, + 5 + ], + "replay": { + "affected_rows": 393, + "expected_fresh_input_row": { + "1268": "1" + }, + "literal_row_delta_sha256": "0116bb58508cbd3d0326af5b8a483175b5ad8268414fc6592c2e4d7b3d6faa40", + "new_owner_label": 1521, + "omitted_fresh_input_row": {}, + "original_oriented_paid_row": [ + [ + 90093, + "2" + ], + [ + 96321, + "2" + ] + ], + "original_owner_label": 1106, + "parent_sha256": "59d4ffe7ca252615193df4d0d43cc5f977f64c924a8c277b9153263b423985b8", + "result_sha256": "3d06312d5bbf6916a35b36ea6229d2556f925a2da96bb587d31903ff9dbb5460" + }, + "source_paid": 96518, + "target_daughter_ranks": [ + 4, + 5 + ] + }, + { + "allocated_role": 1269, + "chart": 232, + "credit": [ + "0.639388808980847010450658", + "0.639388808980847010450659" + ], + "descending": false, + "event": { + "calibration": [ + [ + 91794, + "4920" + ], + [ + 91795, + "4920" + ], + [ + 91800, + "-9840" + ], + [ + 91803, + "9840" + ], + [ + 91806, + "-22632" + ], + [ + 91808, + "-9840" + ], + [ + 91810, + "-45264" + ], + [ + 91815, + "4920" + ], + [ + 98231, + "-9840" + ], + [ + 98403, + "27552" + ] + ], + "pulse": [ + [ + 98406, + "-4" + ], + [ + 98411, + "-4" + ], + [ + 98796, + "4" + ], + [ + 103244, + "-20" + ] + ], + "readout": [ + [ + 35, + "1515360" + ], + [ + 61, + "757680" + ], + [ + 90177, + "-757680" + ], + [ + 90178, + "1515360" + ], + [ + 90183, + "378840" + ], + [ + 90186, + "-378840" + ], + [ + 90189, + "-757680" + ], + [ + 90198, + "1515360" + ], + [ + 91800, + "-606144" + ] + ], + "return_chart": 127, + "return_covector": [ + [ + 17, + "34440" + ], + [ + 21, + "-68880" + ], + [ + 31, + "-68880" + ], + [ + 56, + "-63960" + ], + [ + 100, + "-4920" + ], + [ + 103, + "68880" + ], + [ + 126, + "22960" + ], + [ + 173, + "118080" + ], + [ + 188, + "12915" + ], + [ + 226, + "52275" + ], + [ + 230, + "172200" + ], + [ + 231, + "12915" + ], + [ + 235, + "-118080" + ], + [ + 236, + "12915" + ], + [ + 241, + "59040" + ], + [ + 244, + "206640" + ], + [ + 246, + "2835" + ], + [ + 247, + "12915" + ], + [ + 249, + "-29520" + ], + [ + 252, + "14760" + ], + [ + 254, + "-68880" + ], + [ + 260, + "19680" + ], + [ + 262, + "-314880" + ], + [ + 263, + "-17220" + ], + [ + 266, + "236160" + ], + [ + 270, + "-19680" + ], + [ + 273, + "137760" + ], + [ + 274, + "78720" + ], + [ + 276, + "59040" + ], + [ + 283, + "10800" + ], + [ + 288, + "-3420" + ], + [ + 289, + "-720" + ], + [ + 292, + "54000" + ], + [ + 299, + "86100" + ], + [ + 302, + "78720" + ], + [ + 304, + "344400" + ], + [ + 307, + "59040" + ], + [ + 309, + "-78720" + ], + [ + 310, + "39360" + ], + [ + 317, + "-68880" + ], + [ + 320, + "-25830" + ], + [ + 321, + "-34440" + ], + [ + 322, + "418200" + ], + [ + 326, + "-137760" + ], + [ + 328, + "68880" + ], + [ + 335, + "-39360" + ], + [ + 336, + "17220" + ], + [ + 344, + "34440" + ], + [ + 347, + "157440" + ], + [ + 349, + "206640" + ], + [ + 350, + "78720" + ], + [ + 354, + "-68880" + ], + [ + 356, + "206640" + ], + [ + 358, + "-68880" + ], + [ + 359, + "-68880" + ], + [ + 361, + "-68880" + ], + [ + 362, + "-34440" + ], + [ + 364, + "-34440" + ], + [ + 365, + "78720" + ], + [ + 376, + "396060" + ], + [ + 381, + "-172200" + ], + [ + 383, + "123000" + ], + [ + 384, + "-68880" + ], + [ + 386, + "91840" + ], + [ + 388, + "413280" + ], + [ + 389, + "-137760" + ], + [ + 390, + "-229600" + ], + [ + 391, + "-157440" + ], + [ + 395, + "34440" + ], + [ + 398, + "29520" + ], + [ + 401, + "-68880" + ], + [ + 402, + "-551040" + ], + [ + 404, + "3285" + ], + [ + 406, + "78720" + ], + [ + 410, + "-19680" + ], + [ + 411, + "-78720" + ], + [ + 413, + "137760" + ], + [ + 414, + "-39360" + ], + [ + 419, + "-34440" + ], + [ + 420, + "275520" + ], + [ + 421, + "551040" + ], + [ + 425, + "34440" + ], + [ + 427, + "-9840" + ], + [ + 428, + "-78720" + ], + [ + 429, + "39360" + ], + [ + 432, + "-68880" + ], + [ + 433, + "108240" + ], + [ + 434, + "-78720" + ], + [ + 443, + "216480" + ], + [ + 453, + "137760" + ], + [ + 457, + "-78720" + ], + [ + 458, + "-39360" + ], + [ + 459, + "19680" + ], + [ + 460, + "206640" + ], + [ + 464, + "78720" + ], + [ + 468, + "-157440" + ], + [ + 469, + "44280" + ], + [ + 470, + "206640" + ], + [ + 471, + "34440" + ], + [ + 474, + "137760" + ], + [ + 475, + "157440" + ], + [ + 476, + "-157440" + ], + [ + 479, + "78720" + ], + [ + 481, + "-113160" + ], + [ + 483, + "413280" + ], + [ + 484, + "290280" + ], + [ + 486, + "78720" + ], + [ + 487, + "157440" + ], + [ + 488, + "-39360" + ], + [ + 490, + "688800" + ], + [ + 491, + "-344400" + ], + [ + 492, + "154980" + ], + [ + 493, + "29520" + ], + [ + 494, + "4920" + ], + [ + 495, + "-39360" + ], + [ + 496, + "826560" + ], + [ + 497, + "580560" + ], + [ + 498, + "314880" + ], + [ + 501, + "4920" + ], + [ + 502, + "39360" + ], + [ + 508, + "19680" + ], + [ + 509, + "-19680" + ], + [ + 510, + "22140" + ], + [ + 511, + "34440" + ], + [ + 512, + "-73800" + ], + [ + 513, + "4920" + ], + [ + 514, + "39360" + ], + [ + 515, + "34440" + ], + [ + 516, + "78720" + ], + [ + 517, + "39360" + ], + [ + 519, + "8610" + ], + [ + 520, + "17220" + ], + [ + 522, + "-17220" + ], + [ + 527, + "39360" + ], + [ + 528, + "-137760" + ], + [ + 529, + "-34440" + ], + [ + 530, + "19680" + ], + [ + 531, + "-19680" + ], + [ + 535, + "-2460" + ], + [ + 537, + "-157440" + ], + [ + 538, + "2460" + ], + [ + 539, + "-17220" + ], + [ + 540, + "-56580" + ], + [ + 546, + "39360" + ], + [ + 547, + "157440" + ], + [ + 552, + "61500" + ], + [ + 553, + "-27060" + ], + [ + 555, + "39360" + ], + [ + 559, + "-54120" + ], + [ + 561, + "83640" + ], + [ + 565, + "123000" + ], + [ + 574, + "19680" + ], + [ + 578, + "1230" + ], + [ + 579, + "-17220" + ], + [ + 581, + "2460" + ], + [ + 588, + "2460" + ], + [ + 590, + "108240" + ], + [ + 595, + "68880" + ], + [ + 608, + "-39360" + ], + [ + 609, + "-8610" + ], + [ + 610, + "17220" + ], + [ + 616, + "-22140" + ], + [ + 624, + "19680" + ], + [ + 630, + "516600" + ], + [ + 634, + "34440" + ], + [ + 645, + "-39360" + ], + [ + 649, + "314880" + ], + [ + 651, + "39360" + ], + [ + 652, + "-137760" + ], + [ + 655, + "147600" + ], + [ + 666, + "78720" + ], + [ + 679, + "-68880" + ], + [ + 692, + "-34440" + ], + [ + 696, + "-14760" + ], + [ + 700, + "-17220" + ], + [ + 701, + "-137760" + ], + [ + 716, + "9840" + ], + [ + 758, + "-9840" + ], + [ + 800, + "-34440" + ], + [ + 811, + "-34440" + ], + [ + 874, + "46740" + ], + [ + 877, + "68880" + ], + [ + 884, + "-78720" + ], + [ + 887, + "-137760" + ], + [ + 888, + "-34440" + ], + [ + 890, + "-68880" + ], + [ + 891, + "2460" + ], + [ + 892, + "267648" + ], + [ + 894, + "157440" + ], + [ + 898, + "-137760" + ], + [ + 902, + "-34440" + ], + [ + 906, + "78720" + ], + [ + 907, + "68880" + ], + [ + 915, + "206640" + ], + [ + 916, + "226320" + ], + [ + 917, + "-78720" + ], + [ + 919, + "250920" + ], + [ + 927, + "68880" + ], + [ + 931, + "73800" + ], + [ + 934, + "83640" + ], + [ + 935, + "123000" + ], + [ + 937, + "-54120" + ], + [ + 939, + "22140" + ], + [ + 941, + "137760" + ], + [ + 944, + "137760" + ], + [ + 946, + "-78720" + ], + [ + 947, + "-34440" + ], + [ + 949, + "86100" + ], + [ + 950, + "78720" + ], + [ + 952, + "-17220" + ], + [ + 956, + "-68880" + ], + [ + 957, + "-137760" + ], + [ + 958, + "-137760" + ], + [ + 961, + "-56580" + ], + [ + 962, + "-17220" + ], + [ + 964, + "-17220" + ], + [ + 965, + "-137760" + ], + [ + 968, + "-34440" + ], + [ + 970, + "39360" + ], + [ + 973, + "34440" + ], + [ + 978, + "-39360" + ], + [ + 979, + "-17220" + ], + [ + 981, + "-73800" + ], + [ + 988, + "-137760" + ], + [ + 989, + "4920" + ], + [ + 992, + "157440" + ], + [ + 994, + "68880" + ], + [ + 996, + "157440" + ], + [ + 997, + "-68880" + ], + [ + 999, + "68880" + ], + [ + 1001, + "68880" + ], + [ + 1003, + "68880" + ], + [ + 1005, + "-34440" + ], + [ + 1009, + "413280" + ], + [ + 1010, + "68880" + ], + [ + 1011, + "367360" + ], + [ + 1024, + "-367360" + ], + [ + 1025, + "-68880" + ], + [ + 1029, + "216480" + ], + [ + 1033, + "-78720" + ], + [ + 1035, + "68880" + ], + [ + 1037, + "73800" + ], + [ + 1038, + "-113160" + ], + [ + 1040, + "73800" + ], + [ + 1045, + "4920" + ], + [ + 1051, + "9840" + ], + [ + 1056, + "-68880" + ], + [ + 1057, + "68880" + ], + [ + 1058, + "-34440" + ], + [ + 1059, + "-19680" + ], + [ + 1060, + "78720" + ], + [ + 1061, + "78720" + ], + [ + 1063, + "19680" + ], + [ + 1064, + "-137760" + ], + [ + 1067, + "-147600" + ], + [ + 1070, + "-68880" + ], + [ + 1071, + "-78720" + ], + [ + 1073, + "-73800" + ], + [ + 1078, + "-68880" + ], + [ + 1079, + "-78720" + ], + [ + 1082, + "167280" + ], + [ + 1084, + "-34440" + ], + [ + 1085, + "-34440" + ], + [ + 1086, + "78720" + ], + [ + 1088, + "-29520" + ], + [ + 1089, + "59040" + ], + [ + 1090, + "-39360" + ], + [ + 1091, + "-34440" + ], + [ + 1092, + "-39360" + ], + [ + 1094, + "44280" + ], + [ + 1095, + "4920" + ], + [ + 1096, + "68880" + ], + [ + 1097, + "73800" + ], + [ + 1099, + "8610" + ], + [ + 1100, + "36900" + ], + [ + 1101, + "-27060" + ], + [ + 1102, + "-73800" + ], + [ + 1104, + "88560" + ], + [ + 1105, + "19680" + ], + [ + 1106, + "8610" + ], + [ + 1108, + "68880" + ], + [ + 1111, + "226320" + ], + [ + 1112, + "19680" + ], + [ + 1115, + "137760" + ], + [ + 1117, + "-22140" + ], + [ + 1118, + "39360" + ], + [ + 1119, + "12915" + ], + [ + 1122, + "-52480" + ], + [ + 1123, + "45920" + ], + [ + 1124, + "-91840" + ], + [ + 1125, + "-108240" + ], + [ + 1126, + "-78720" + ], + [ + 1132, + "-68880" + ], + [ + 1139, + "137760" + ], + [ + 1140, + "137760" + ], + [ + 1142, + "-68880" + ], + [ + 1144, + "59040" + ], + [ + 1145, + "275520" + ], + [ + 1147, + "68880" + ], + [ + 1173, + "19680" + ], + [ + 1174, + "147600" + ] + ], + "return_direction": [ + [ + 362, + "-10" + ], + [ + 364, + "-10" + ], + [ + 491, + "-10" + ], + [ + 546, + "-20" + ], + [ + 874, + "-40" + ], + [ + 892, + "-5" + ], + [ + 904, + "-5" + ], + [ + 1045, + "10" + ], + [ + 1100, + "-20" + ], + [ + 1154, + "20" + ] + ], + "role": 892, + "source_chart": 3, + "source_covector": [ + [ + 235, + "606144" + ], + [ + 251, + "-189420" + ], + [ + 307, + "303072" + ], + [ + 308, + "-378840" + ], + [ + 364, + "303072" + ], + [ + 440, + "303072" + ], + [ + 491, + "303072" + ], + [ + 683, + "-1" + ], + [ + 892, + "1212288" + ], + [ + 924, + "-606144" + ], + [ + 929, + "303072" + ], + [ + 1148, + "-151536" + ], + [ + 1166, + "378840" + ], + [ + 1242, + "-151536" + ] + ], + "source_direction": [ + [ + 362, + "-10" + ], + [ + 364, + "-10" + ], + [ + 491, + "-10" + ], + [ + 546, + "-20" + ], + [ + 874, + "-40" + ], + [ + 892, + "-5" + ], + [ + 904, + "-5" + ], + [ + 1045, + "10" + ], + [ + 1100, + "-20" + ], + [ + 1154, + "20" + ] + ], + "split_chart": 232 + }, + "max_changed_coefficient_bits": 24, + "native_delta": { + "paid": { + "1": 1, + "5": 1, + "6": -1 + }, + "targets": { + "4": 1, + "5": 1, + "9": -1 + } + }, + "new_paid": 61, + "old_paid_charts": [ + 324, + 127 + ], + "paid_daughter_ranks": [ + 1, + 5 + ], + "replay": { + "affected_rows": 278, + "expected_fresh_input_row": { + "1269": "1" + }, + "literal_row_delta_sha256": "f5f2715b831be51401283add2bfca73b8eba81ea9c82fa74424ba08eb25b4d01", + "new_owner_label": 1522, + "omitted_fresh_input_row": {}, + "original_oriented_paid_row": [ + [ + 90168, + "1" + ], + [ + 90169, + "1" + ], + [ + 91750, + "1/5" + ], + [ + 91752, + "1/5" + ] + ], + "original_owner_label": 1007, + "parent_sha256": "3d06312d5bbf6916a35b36ea6229d2556f925a2da96bb587d31903ff9dbb5460", + "result_sha256": "009e9bc5b81d5cfeaa266d6ba12d76e6991d591de14a3cd3b6d4db31007e7511" + }, + "source_paid": 98406, + "target_daughter_ranks": [ + 4, + 5 + ] + }, + { + "allocated_role": 1270, + "chart": 243, + "credit": [ + "0.639388808980847010450658", + "0.639388808980847010450659" + ], + "descending": false, + "event": { + "calibration": [ + [ + 92545, + "-8" + ], + [ + 92546, + "-8" + ], + [ + 92548, + "-8" + ], + [ + 92556, + "4" + ], + [ + 92559, + "-4" + ], + [ + 92562, + "-8" + ], + [ + 92564, + "-4" + ], + [ + 92566, + "4" + ] + ], + "pulse": [ + [ + 104217, + "1" + ] + ], + "readout": [ + [ + 62, + "2" + ], + [ + 92546, + "-4" + ], + [ + 92556, + "-2" + ], + [ + 92562, + "4" + ], + [ + 92564, + "-2" + ] + ], + "return_chart": 127, + "return_covector": [ + [ + 3, + "4" + ], + [ + 8, + "-4" + ], + [ + 26, + "-4" + ], + [ + 66, + "-4" + ], + [ + 67, + "4" + ], + [ + 80, + "4" + ], + [ + 88, + "4" + ], + [ + 95, + "-4" + ], + [ + 249, + "-2" + ], + [ + 258, + "4" + ], + [ + 260, + "-1" + ], + [ + 501, + "2" + ] + ], + "return_direction": [ + [ + 258, + "1" + ] + ], + "role": 258, + "source_chart": 3, + "source_covector": [ + [ + 34, + "8" + ], + [ + 39, + "-3" + ], + [ + 258, + "1" + ], + [ + 352, + "-4" + ], + [ + 353, + "4" + ], + [ + 355, + "8" + ], + [ + 357, + "4" + ], + [ + 360, + "-8" + ], + [ + 363, + "12" + ], + [ + 506, + "-4" + ], + [ + 642, + "12" + ], + [ + 702, + "48" + ], + [ + 900, + "-8" + ], + [ + 1164, + "12" + ], + [ + 1166, + "-3" + ] + ], + "source_direction": [ + [ + 258, + "1" + ] + ], + "split_chart": 243 + }, + "max_changed_coefficient_bits": 15, + "native_delta": { + "paid": { + "1": 1, + "5": 1, + "6": -1 + }, + "targets": { + "4": 1, + "5": 1, + "9": -1 + } + }, + "new_paid": 62, + "old_paid_charts": [ + 432, + 127 + ], + "paid_daughter_ranks": [ + 1, + 5 + ], + "replay": { + "affected_rows": 15, + "expected_fresh_input_row": { + "1270": "1" + }, + "literal_row_delta_sha256": "e13b3f4661115c8eb6b430e2b0291e977bb3c9fa0a19180fd55260ec7fd29dc4", + "new_owner_label": 1523, + "omitted_fresh_input_row": {}, + "original_oriented_paid_row": [ + [ + 92527, + "1" + ], + [ + 92528, + "1" + ] + ], + "original_owner_label": 262, + "parent_sha256": "009e9bc5b81d5cfeaa266d6ba12d76e6991d591de14a3cd3b6d4db31007e7511", + "result_sha256": "e9839b2ea1bbb1bf8293a655ca9c8deca74fe421f4cff2eb582c82a63fc3e19d" + }, + "source_paid": 99767, + "target_daughter_ranks": [ + 4, + 5 + ] + }, + { + "allocated_role": 1271, + "chart": 240, + "credit": [ + "0.639388808980847010450658", + "0.639388808980847010450659" + ], + "descending": false, + "event": { + "calibration": [ + [ + 91355, + "-8" + ], + [ + 91356, + "16" + ], + [ + 91357, + "16" + ], + [ + 93997, + "4" + ], + [ + 93998, + "8" + ], + [ + 96857, + "-4" + ] + ], + "pulse": [ + [ + 104169, + "-16" + ], + [ + 104246, + "-16" + ] + ], + "readout": [ + [ + 63, + "4" + ], + [ + 91352, + "32" + ], + [ + 91355, + "-64" + ], + [ + 93993, + "-8" + ], + [ + 93994, + "-24" + ], + [ + 93996, + "4" + ], + [ + 93997, + "4" + ], + [ + 93998, + "8" + ], + [ + 96513, + "4" + ], + [ + 96857, + "-4" + ] + ], + "return_chart": 127, + "return_covector": [ + [ + 1, + "-4" + ], + [ + 28, + "4" + ], + [ + 82, + "-4" + ], + [ + 350, + "2" + ], + [ + 464, + "2" + ], + [ + 502, + "1" + ], + [ + 547, + "4" + ], + [ + 645, + "1" + ], + [ + 886, + "32" + ], + [ + 897, + "-32" + ], + [ + 916, + "4" + ] + ], + "return_direction": [ + [ + 296, + "-2" + ], + [ + 338, + "8" + ], + [ + 547, + "4" + ], + [ + 645, + "16" + ], + [ + 959, + "1" + ], + [ + 972, + "1" + ], + [ + 986, + "-1" + ], + [ + 1012, + "-1" + ], + [ + 1031, + "1" + ], + [ + 1116, + "1" + ], + [ + 1248, + "1" + ] + ], + "role": 959, + "source_chart": 3, + "source_covector": [ + [ + 21, + "-10" + ], + [ + 93, + "-4" + ], + [ + 227, + "-8" + ], + [ + 245, + "-6" + ], + [ + 288, + "-6" + ], + [ + 289, + "-6" + ], + [ + 315, + "6" + ], + [ + 317, + "-3" + ], + [ + 323, + "-4" + ], + [ + 325, + "8" + ], + [ + 329, + "6" + ], + [ + 338, + "-10" + ], + [ + 368, + "12" + ], + [ + 370, + "-6" + ], + [ + 384, + "24" + ], + [ + 386, + "-36" + ], + [ + 390, + "96" + ], + [ + 392, + "-12" + ], + [ + 404, + "3" + ], + [ + 422, + "8" + ], + [ + 423, + "2" + ], + [ + 446, + "2" + ], + [ + 633, + "6" + ], + [ + 635, + "-16" + ], + [ + 645, + "4" + ], + [ + 679, + "-2" + ], + [ + 751, + "128" + ], + [ + 804, + "-6" + ], + [ + 879, + "-48" + ], + [ + 886, + "128" + ], + [ + 897, + "-128" + ], + [ + 899, + "-24" + ], + [ + 928, + "-1" + ], + [ + 943, + "24" + ], + [ + 948, + "30" + ], + [ + 985, + "32" + ], + [ + 986, + "16" + ], + [ + 1011, + "-96" + ], + [ + 1024, + "48" + ], + [ + 1123, + "-36" + ], + [ + 1190, + "2" + ], + [ + 1192, + "-20" + ] + ], + "source_direction": [ + [ + 296, + "-2" + ], + [ + 338, + "8" + ], + [ + 547, + "4" + ], + [ + 645, + "16" + ], + [ + 959, + "1" + ], + [ + 972, + "1" + ], + [ + 986, + "-1" + ], + [ + 1012, + "-1" + ], + [ + 1031, + "1" + ], + [ + 1116, + "1" + ], + [ + 1248, + "1" + ] + ], + "split_chart": 240 + }, + "max_changed_coefficient_bits": 23, + "native_delta": { + "paid": { + "1": 1, + "5": 1, + "6": -1 + }, + "targets": { + "4": 1, + "5": 1, + "9": -1 + } + }, + "new_paid": 63, + "old_paid_charts": [ + 739, + 127 + ], + "paid_daughter_ranks": [ + 1, + 5 + ], + "replay": { + "affected_rows": 195, + "expected_fresh_input_row": { + "1271": "1" + }, + "literal_row_delta_sha256": "2fac6c7956c07c12573f1117c84f693b390d03e7f3329c4ae0c27696d07d6a7c", + "new_owner_label": 1524, + "omitted_fresh_input_row": {}, + "original_oriented_paid_row": [ + [ + 98640, + "1" + ] + ], + "original_owner_label": 1075, + "parent_sha256": "e9839b2ea1bbb1bf8293a655ca9c8deca74fe421f4cff2eb582c82a63fc3e19d", + "result_sha256": "344c2b7b34ee144564c99fad9204535a8e41f511d893b4ed9e21ff0feccea3fd" + }, + "source_paid": 103583, + "target_daughter_ranks": [ + 4, + 5 + ] + }, + { + "allocated_role": 1272, + "chart": 234, + "credit": [ + "0.639388808980847010450658", + "0.639388808980847010450659" + ], + "descending": false, + "event": { + "calibration": [ + [ + 59, + "68880" + ] + ], + "pulse": [ + [ + 94852, + "-5" + ], + [ + 95923, + "4" + ], + [ + 98842, + "-5" + ], + [ + 103820, + "-20" + ], + [ + 103823, + "10" + ] + ], + "readout": [ + [ + 94376, + "-2" + ], + [ + 94384, + "2" + ] + ], + "return_chart": 127, + "return_covector": [ + [ + 21, + "34440" + ], + [ + 40, + "17220" + ], + [ + 101, + "-34440" + ], + [ + 102, + "-34440" + ], + [ + 188, + "12915" + ], + [ + 226, + "12915" + ], + [ + 230, + "34440" + ], + [ + 231, + "12915" + ], + [ + 233, + "34440" + ], + [ + 236, + "12915" + ], + [ + 240, + "34440" + ], + [ + 245, + "8610" + ], + [ + 246, + "2835" + ], + [ + 247, + "12915" + ], + [ + 254, + "34440" + ], + [ + 262, + "-275520" + ], + [ + 266, + "-34440" + ], + [ + 270, + "-34440" + ], + [ + 273, + "-68880" + ], + [ + 274, + "68880" + ], + [ + 276, + "-137760" + ], + [ + 277, + "103320" + ], + [ + 283, + "10800" + ], + [ + 288, + "5190" + ], + [ + 289, + "7890" + ], + [ + 292, + "54000" + ], + [ + 304, + "-68880" + ], + [ + 315, + "-8610" + ], + [ + 317, + "73185" + ], + [ + 320, + "34440" + ], + [ + 329, + "-8610" + ], + [ + 336, + "-17220" + ], + [ + 338, + "8610" + ], + [ + 340, + "-17220" + ], + [ + 347, + "137760" + ], + [ + 348, + "34440" + ], + [ + 349, + "-34440" + ], + [ + 350, + "68880" + ], + [ + 356, + "-34440" + ], + [ + 368, + "-17220" + ], + [ + 370, + "8610" + ], + [ + 376, + "-86100" + ], + [ + 381, + "137760" + ], + [ + 384, + "-34440" + ], + [ + 386, + "51660" + ], + [ + 388, + "-68880" + ], + [ + 390, + "-137760" + ], + [ + 392, + "17220" + ], + [ + 397, + "-68880" + ], + [ + 400, + "-34440" + ], + [ + 402, + "275520" + ], + [ + 404, + "-1020" + ], + [ + 411, + "17220" + ], + [ + 413, + "-68880" + ], + [ + 421, + "-275520" + ], + [ + 425, + "-34440" + ], + [ + 434, + "-68880" + ], + [ + 435, + "34440" + ], + [ + 452, + "68880" + ], + [ + 453, + "-68880" + ], + [ + 455, + "-68880" + ], + [ + 460, + "-34440" + ], + [ + 461, + "-13776" + ], + [ + 463, + "-34440" + ], + [ + 464, + "68880" + ], + [ + 470, + "137760" + ], + [ + 471, + "34440" + ], + [ + 474, + "-68880" + ], + [ + 481, + "20664" + ], + [ + 483, + "-68880" + ], + [ + 484, + "-51660" + ], + [ + 490, + "-137760" + ], + [ + 491, + "137760" + ], + [ + 492, + "68880" + ], + [ + 494, + "-34440" + ], + [ + 496, + "-103320" + ], + [ + 497, + "-68880" + ], + [ + 500, + "137760" + ], + [ + 502, + "34440" + ], + [ + 508, + "68880" + ], + [ + 509, + "-68880" + ], + [ + 510, + "17220" + ], + [ + 511, + "34440" + ], + [ + 514, + "-17220" + ], + [ + 516, + "-34440" + ], + [ + 519, + "8610" + ], + [ + 520, + "-17220" + ], + [ + 522, + "-17220" + ], + [ + 535, + "17220" + ], + [ + 539, + "17220" + ], + [ + 547, + "137760" + ], + [ + 552, + "-8610" + ], + [ + 561, + "-17220" + ], + [ + 565, + "-17220" + ], + [ + 574, + "17220" + ], + [ + 578, + "-17220" + ], + [ + 581, + "17220" + ], + [ + 588, + "17220" + ], + [ + 590, + "34440" + ], + [ + 609, + "8610" + ], + [ + 610, + "-17220" + ], + [ + 616, + "-17220" + ], + [ + 619, + "-17220" + ], + [ + 630, + "-223860" + ], + [ + 632, + "17220" + ], + [ + 633, + "-8610" + ], + [ + 634, + "34440" + ], + [ + 645, + "-34440" + ], + [ + 649, + "275520" + ], + [ + 652, + "68880" + ], + [ + 655, + "-34440" + ], + [ + 656, + "-17220" + ], + [ + 679, + "34440" + ], + [ + 692, + "34440" + ], + [ + 700, + "-17220" + ], + [ + 701, + "68880" + ], + [ + 783, + "-68880" + ], + [ + 800, + "17220" + ], + [ + 804, + "8610" + ], + [ + 811, + "-17220" + ], + [ + 874, + "-34440" + ], + [ + 876, + "68880" + ], + [ + 879, + "68880" + ], + [ + 890, + "34440" + ], + [ + 891, + "17220" + ], + [ + 898, + "68880" + ], + [ + 899, + "34440" + ], + [ + 902, + "-34440" + ], + [ + 903, + "-34440" + ], + [ + 906, + "68880" + ], + [ + 912, + "-34440" + ], + [ + 914, + "-68880" + ], + [ + 915, + "-68880" + ], + [ + 916, + "172200" + ], + [ + 917, + "-68880" + ], + [ + 918, + "-68880" + ], + [ + 919, + "-34440" + ], + [ + 923, + "68880" + ], + [ + 927, + "68880" + ], + [ + 931, + "34440" + ], + [ + 934, + "-17220" + ], + [ + 935, + "-17220" + ], + [ + 943, + "-34440" + ], + [ + 944, + "68880" + ], + [ + 946, + "68880" + ], + [ + 947, + "34440" + ], + [ + 948, + "-43050" + ], + [ + 949, + "-17220" + ], + [ + 952, + "17220" + ], + [ + 956, + "137760" + ], + [ + 957, + "68880" + ], + [ + 958, + "68880" + ], + [ + 961, + "17220" + ], + [ + 962, + "17220" + ], + [ + 964, + "17220" + ], + [ + 965, + "68880" + ], + [ + 968, + "-17220" + ], + [ + 970, + "34440" + ], + [ + 979, + "-17220" + ], + [ + 981, + "17220" + ], + [ + 994, + "68880" + ], + [ + 997, + "68880" + ], + [ + 1001, + "68880" + ], + [ + 1005, + "-34440" + ], + [ + 1009, + "-68880" + ], + [ + 1011, + "137760" + ], + [ + 1024, + "-68880" + ], + [ + 1027, + "-68880" + ], + [ + 1033, + "-68880" + ], + [ + 1035, + "68880" + ], + [ + 1037, + "34440" + ], + [ + 1038, + "34440" + ], + [ + 1040, + "34440" + ], + [ + 1053, + "-34440" + ], + [ + 1054, + "137760" + ], + [ + 1056, + "17220" + ], + [ + 1057, + "68880" + ], + [ + 1058, + "34440" + ], + [ + 1059, + "-17220" + ], + [ + 1061, + "34440" + ], + [ + 1065, + "-17220" + ], + [ + 1069, + "-34440" + ], + [ + 1070, + "68880" + ], + [ + 1073, + "-34440" + ], + [ + 1076, + "17220" + ], + [ + 1077, + "68880" + ], + [ + 1078, + "68880" + ], + [ + 1081, + "-68880" + ], + [ + 1082, + "-34440" + ], + [ + 1084, + "-17220" + ], + [ + 1089, + "-34440" + ], + [ + 1090, + "34440" + ], + [ + 1091, + "17220" + ], + [ + 1092, + "-34440" + ], + [ + 1095, + "34440" + ], + [ + 1096, + "-68880" + ], + [ + 1097, + "34440" + ], + [ + 1103, + "17220" + ], + [ + 1105, + "17220" + ], + [ + 1106, + "8610" + ], + [ + 1108, + "-68880" + ], + [ + 1111, + "-68880" + ], + [ + 1112, + "68880" + ], + [ + 1114, + "-34440" + ], + [ + 1115, + "-68880" + ], + [ + 1117, + "-10332" + ], + [ + 1119, + "12915" + ], + [ + 1121, + "34440" + ], + [ + 1122, + "-45920" + ], + [ + 1123, + "51660" + ], + [ + 1127, + "34440" + ], + [ + 1129, + "-34440" + ], + [ + 1132, + "34440" + ], + [ + 1138, + "68880" + ], + [ + 1139, + "-68880" + ], + [ + 1140, + "-68880" + ], + [ + 1142, + "-34440" + ], + [ + 1145, + "-137760" + ] + ], + "return_direction": [ + [ + 326, + "-5" + ], + [ + 348, + "-20" + ], + [ + 461, + "-20" + ], + [ + 876, + "-5" + ], + [ + 947, + "20" + ], + [ + 958, + "-5" + ], + [ + 1096, + "-10" + ] + ], + "role": 326, + "source_chart": 3, + "source_covector": [ + [ + 945, + "1" + ], + [ + 958, + "-4" + ] + ], + "source_direction": [ + [ + 326, + "-5" + ], + [ + 348, + "-20" + ], + [ + 461, + "-20" + ], + [ + 876, + "-5" + ], + [ + 947, + "20" + ], + [ + 958, + "-5" + ], + [ + 1096, + "-10" + ] + ], + "split_chart": 234 + }, + "max_changed_coefficient_bits": 23, + "native_delta": { + "paid": { + "1": 1, + "5": 1, + "6": -1 + }, + "targets": { + "4": 1, + "5": 1, + "9": -1 + } + }, + "new_paid": 64, + "old_paid_charts": [ + 722, + 127 + ], + "paid_daughter_ranks": [ + 1, + 5 + ], + "replay": { + "affected_rows": 229, + "expected_fresh_input_row": { + "1272": "1" + }, + "literal_row_delta_sha256": "72415cc460b182303983bc6d28b86596706ad6cecf8ac4c264025922d6bc1641", + "new_owner_label": 1525, + "omitted_fresh_input_row": {}, + "original_oriented_paid_row": [ + [ + 97595, + "1" + ], + [ + 97596, + "-1" + ] + ], + "original_owner_label": 340, + "parent_sha256": "344c2b7b34ee144564c99fad9204535a8e41f511d893b4ed9e21ff0feccea3fd", + "result_sha256": "7c1ec6a782ac4e7b67de587ce4d0a1c4e1442e963fba98f56ed96fd61ae7120f" + }, + "source_paid": 103820, + "target_daughter_ranks": [ + 4, + 5 + ] + }, + { + "allocated_role": 1273, + "chart": 1090, + "credit": [ + "0.639388808980847010450658", + "0.639388808980847010450659" + ], + "descending": false, + "event": { + "calibration": [ + [ + 89420, + "-27552" + ], + [ + 89451, + "13776" + ], + [ + 89563, + "-13776" + ] + ], + "pulse": [ + [ + 99064, + "9" + ], + [ + 103722, + "-48" + ], + [ + 104254, + "-32" + ], + [ + 104383, + "16" + ], + [ + 104408, + "64" + ], + [ + 104410, + "-32" + ], + [ + 104442, + "-24" + ] + ], + "readout": [ + [ + 65, + "-2" + ], + [ + 89420, + "-4" + ], + [ + 89451, + "2" + ], + [ + 89563, + "-2" + ] + ], + "return_chart": 127, + "return_covector": [ + [ + 15, + "6888" + ], + [ + 42, + "-6888" + ], + [ + 52, + "3444" + ], + [ + 106, + "-6888" + ], + [ + 173, + "13776" + ], + [ + 188, + "2583" + ], + [ + 226, + "2583" + ], + [ + 230, + "6888" + ], + [ + 231, + "2583" + ], + [ + 236, + "2583" + ], + [ + 244, + "6888" + ], + [ + 246, + "567" + ], + [ + 247, + "2583" + ], + [ + 252, + "3444" + ], + [ + 262, + "-55104" + ], + [ + 270, + "-3444" + ], + [ + 274, + "13776" + ], + [ + 276, + "-13776" + ], + [ + 283, + "2160" + ], + [ + 288, + "-684" + ], + [ + 289, + "-144" + ], + [ + 292, + "10800" + ], + [ + 299, + "3444" + ], + [ + 320, + "1722" + ], + [ + 322, + "13776" + ], + [ + 347, + "27552" + ], + [ + 349, + "6888" + ], + [ + 350, + "13776" + ], + [ + 356, + "6888" + ], + [ + 376, + "10332" + ], + [ + 381, + "-6888" + ], + [ + 383, + "-6888" + ], + [ + 388, + "13776" + ], + [ + 404, + "657" + ], + [ + 420, + "13776" + ], + [ + 433, + "6888" + ], + [ + 434, + "-13776" + ], + [ + 443, + "13776" + ], + [ + 460, + "6888" + ], + [ + 464, + "13776" + ], + [ + 470, + "6888" + ], + [ + 483, + "13776" + ], + [ + 484, + "10332" + ], + [ + 492, + "17220" + ], + [ + 493, + "13776" + ], + [ + 494, + "-6888" + ], + [ + 496, + "27552" + ], + [ + 497, + "20664" + ], + [ + 502, + "6888" + ], + [ + 519, + "1722" + ], + [ + 520, + "3444" + ], + [ + 522, + "-3444" + ], + [ + 527, + "3444" + ], + [ + 529, + "-3444" + ], + [ + 535, + "3444" + ], + [ + 538, + "-3444" + ], + [ + 547, + "27552" + ], + [ + 552, + "1722" + ], + [ + 553, + "-1722" + ], + [ + 559, + "-3444" + ], + [ + 561, + "3444" + ], + [ + 565, + "3444" + ], + [ + 574, + "3444" + ], + [ + 578, + "-1722" + ], + [ + 579, + "-3444" + ], + [ + 581, + "3444" + ], + [ + 588, + "3444" + ], + [ + 590, + "6888" + ], + [ + 595, + "6888" + ], + [ + 630, + "3444" + ], + [ + 634, + "6888" + ], + [ + 645, + "-6888" + ], + [ + 649, + "55104" + ], + [ + 696, + "-3444" + ], + [ + 700, + "-3444" + ], + [ + 811, + "-3444" + ], + [ + 877, + "-13776" + ], + [ + 878, + "55104" + ], + [ + 888, + "-3444" + ], + [ + 891, + "3444" + ], + [ + 902, + "-6888" + ], + [ + 906, + "13776" + ], + [ + 907, + "13776" + ], + [ + 916, + "27552" + ], + [ + 917, + "-13776" + ], + [ + 927, + "13776" + ], + [ + 931, + "6888" + ], + [ + 934, + "3444" + ], + [ + 935, + "3444" + ], + [ + 937, + "-3444" + ], + [ + 941, + "13776" + ], + [ + 944, + "13776" + ], + [ + 962, + "-3444" + ], + [ + 968, + "-3444" + ], + [ + 981, + "-3444" + ], + [ + 994, + "13776" + ], + [ + 999, + "13776" + ], + [ + 1001, + "13776" + ], + [ + 1003, + "13776" + ], + [ + 1005, + "-6888" + ], + [ + 1009, + "13776" + ], + [ + 1010, + "13776" + ], + [ + 1029, + "13776" + ], + [ + 1033, + "-13776" + ], + [ + 1037, + "6888" + ], + [ + 1040, + "6888" + ], + [ + 1054, + "13776" + ], + [ + 1056, + "-3444" + ], + [ + 1057, + "13776" + ], + [ + 1058, + "-6888" + ], + [ + 1073, + "-6888" + ], + [ + 1082, + "6888" + ], + [ + 1084, + "-3444" + ], + [ + 1088, + "-6888" + ], + [ + 1089, + "6888" + ], + [ + 1092, + "-6888" + ], + [ + 1094, + "-6888" + ], + [ + 1097, + "6888" + ], + [ + 1101, + "-1722" + ], + [ + 1102, + "-6888" + ], + [ + 1105, + "3444" + ], + [ + 1106, + "1722" + ], + [ + 1119, + "-861" + ], + [ + 1122, + "-9184" + ], + [ + 1125, + "-3444" + ], + [ + 1138, + "13776" + ], + [ + 1142, + "-13776" + ], + [ + 1144, + "6888" + ], + [ + 1174, + "13776" + ] + ], + "return_direction": [ + [ + 263, + "48" + ], + [ + 488, + "-24" + ], + [ + 579, + "-24" + ], + [ + 588, + "24" + ], + [ + 877, + "-6" + ], + [ + 878, + "3" + ], + [ + 891, + "-24" + ], + [ + 907, + "12" + ], + [ + 923, + "-9" + ], + [ + 931, + "-12" + ], + [ + 999, + "-15" + ], + [ + 1028, + "-24" + ], + [ + 1037, + "24" + ], + [ + 1040, + "-24" + ], + [ + 1094, + "-12" + ], + [ + 1097, + "12" + ], + [ + 1107, + "24" + ], + [ + 1119, + "48" + ] + ], + "role": 878, + "source_chart": 3, + "source_covector": [ + [ + 495, + "2" + ], + [ + 579, + "-1" + ], + [ + 877, + "-4" + ], + [ + 878, + "8" + ], + [ + 1094, + "-2" + ] + ], + "source_direction": [ + [ + 263, + "48" + ], + [ + 488, + "-24" + ], + [ + 579, + "-24" + ], + [ + 588, + "24" + ], + [ + 877, + "-6" + ], + [ + 878, + "3" + ], + [ + 891, + "-24" + ], + [ + 907, + "12" + ], + [ + 923, + "-9" + ], + [ + 931, + "-12" + ], + [ + 999, + "-15" + ], + [ + 1028, + "-24" + ], + [ + 1037, + "24" + ], + [ + 1040, + "-24" + ], + [ + 1094, + "-12" + ], + [ + 1097, + "12" + ], + [ + 1107, + "24" + ], + [ + 1119, + "48" + ] + ], + "split_chart": 1090 + }, + "max_changed_coefficient_bits": 23, + "native_delta": { + "paid": { + "1": 1, + "5": 1, + "6": -1 + }, + "targets": { + "4": 1, + "5": 1, + "9": -1 + } + }, + "new_paid": 65, + "old_paid_charts": [ + 476, + 127 + ], + "paid_daughter_ranks": [ + 1, + 5 + ], + "replay": { + "affected_rows": 47, + "expected_fresh_input_row": { + "1273": "1" + }, + "literal_row_delta_sha256": "4bff712f788e8a6439810e83fc2b7d463c852c98102836a5df2aa8167ccb1bf1", + "new_owner_label": 1526, + "omitted_fresh_input_row": {}, + "original_oriented_paid_row": [ + [ + 89449, + "-1" + ], + [ + 89561, + "-1" + ], + [ + 95823, + "-1" + ], + [ + 95825, + "1" + ] + ], + "original_owner_label": 992, + "parent_sha256": "7c1ec6a782ac4e7b67de587ce4d0a1c4e1442e963fba98f56ed96fd61ae7120f", + "result_sha256": "53652a8774a34d5844d17e00a7f97fd43e683e28022f5de5c4d42cc2ea6cd566" + }, + "source_paid": 104442, + "target_daughter_ranks": [ + 4, + 5 + ] + }, + { + "allocated_role": 1274, + "chart": 498, + "credit": [ + "0.639388808980847010450658", + "0.639388808980847010450659" + ], + "descending": true, + "event": { + "calibration": [ + [ + 66, + "96" + ], + [ + 92636, + "384" + ], + [ + 94005, + "384" + ], + [ + 95658, + "24" + ], + [ + 103595, + "-192" + ], + [ + 103933, + "-96" + ], + [ + 104021, + "72" + ], + [ + 104022, + "-12" + ], + [ + 104376, + "-240" + ], + [ + 104384, + "288" + ], + [ + 104418, + "144" + ] + ], + "pulse": [ + [ + 91933, + "6" + ], + [ + 92454, + "2" + ], + [ + 92458, + "-2" + ], + [ + 92464, + "-1" + ], + [ + 92471, + "1" + ], + [ + 92667, + "-2" + ], + [ + 92669, + "-4" + ], + [ + 92677, + "-2" + ], + [ + 92689, + "-4" + ], + [ + 92690, + "-4" + ] + ], + "readout": [ + [ + 103595, + "64" + ] + ], + "return_chart": 3, + "return_covector": [ + [ + 21, + "-192" + ], + [ + 112, + "192" + ], + [ + 114, + "192" + ], + [ + 116, + "192" + ], + [ + 117, + "192" + ], + [ + 118, + "192" + ], + [ + 120, + "192" + ], + [ + 121, + "-384" + ], + [ + 122, + "-192" + ], + [ + 123, + "-192" + ], + [ + 125, + "192" + ], + [ + 126, + "-384" + ], + [ + 128, + "-192" + ], + [ + 130, + "192" + ], + [ + 131, + "384" + ], + [ + 134, + "-192" + ], + [ + 135, + "-192" + ], + [ + 137, + "192" + ], + [ + 139, + "192" + ], + [ + 140, + "384" + ], + [ + 141, + "192" + ], + [ + 142, + "384" + ], + [ + 143, + "-192" + ], + [ + 144, + "192" + ], + [ + 147, + "-192" + ], + [ + 148, + "192" + ], + [ + 149, + "192" + ], + [ + 150, + "384" + ], + [ + 153, + "-192" + ], + [ + 154, + "-192" + ], + [ + 156, + "-192" + ], + [ + 161, + "192" + ], + [ + 162, + "192" + ], + [ + 163, + "-192" + ], + [ + 166, + "-192" + ], + [ + 167, + "-192" + ], + [ + 169, + "-384" + ], + [ + 170, + "192" + ], + [ + 171, + "384" + ], + [ + 172, + "768" + ], + [ + 173, + "-192" + ], + [ + 174, + "-192" + ], + [ + 175, + "-192" + ], + [ + 178, + "192" + ], + [ + 179, + "192" + ], + [ + 180, + "384" + ], + [ + 181, + "384" + ], + [ + 182, + "192" + ], + [ + 183, + "192" + ], + [ + 184, + "384" + ], + [ + 187, + "192" + ], + [ + 191, + "-192" + ], + [ + 192, + "384" + ], + [ + 193, + "-192" + ], + [ + 195, + "192" + ], + [ + 196, + "192" + ], + [ + 198, + "192" + ], + [ + 199, + "384" + ], + [ + 200, + "192" + ], + [ + 202, + "192" + ], + [ + 203, + "192" + ], + [ + 204, + "-192" + ], + [ + 206, + "-192" + ], + [ + 208, + "192" + ], + [ + 209, + "192" + ], + [ + 210, + "192" + ], + [ + 212, + "-192" + ], + [ + 215, + "192" + ], + [ + 216, + "-384" + ], + [ + 217, + "-192" + ], + [ + 218, + "-192" + ], + [ + 219, + "-192" + ], + [ + 222, + "-192" + ], + [ + 223, + "-192" + ], + [ + 228, + "-192" + ], + [ + 230, + "96" + ], + [ + 235, + "-288" + ], + [ + 241, + "-192" + ], + [ + 244, + "-96" + ], + [ + 249, + "192" + ], + [ + 250, + "-3120" + ], + [ + 252, + "384" + ], + [ + 254, + "-192" + ], + [ + 255, + "-384" + ], + [ + 260, + "-384" + ], + [ + 261, + "-384" + ], + [ + 266, + "-192" + ], + [ + 272, + "192" + ], + [ + 273, + "-5472" + ], + [ + 276, + "192" + ], + [ + 278, + "-192" + ], + [ + 279, + "-192" + ], + [ + 299, + "384" + ], + [ + 302, + "768" + ], + [ + 304, + "384" + ], + [ + 307, + "192" + ], + [ + 308, + "-384" + ], + [ + 309, + "-384" + ], + [ + 314, + "-384" + ], + [ + 322, + "-192" + ], + [ + 328, + "960" + ], + [ + 332, + "-192" + ], + [ + 333, + "24" + ], + [ + 335, + "-96" + ], + [ + 338, + "384" + ], + [ + 342, + "192" + ], + [ + 343, + "192" + ], + [ + 347, + "192" + ], + [ + 349, + "96" + ], + [ + 350, + "192" + ], + [ + 356, + "-96" + ], + [ + 362, + "-960" + ], + [ + 364, + "-1728" + ], + [ + 375, + "3120" + ], + [ + 384, + "-576" + ], + [ + 386, + "192" + ], + [ + 388, + "96" + ], + [ + 390, + "384" + ], + [ + 391, + "-72" + ], + [ + 401, + "960" + ], + [ + 402, + "480" + ], + [ + 406, + "-384" + ], + [ + 408, + "384" + ], + [ + 409, + "384" + ], + [ + 410, + "192" + ], + [ + 411, + "384" + ], + [ + 412, + "-1560" + ], + [ + 413, + "5856" + ], + [ + 414, + "-480" + ], + [ + 416, + "384" + ], + [ + 417, + "-384" + ], + [ + 418, + "-192" + ], + [ + 420, + "-384" + ], + [ + 421, + "768" + ], + [ + 424, + "384" + ], + [ + 428, + "-192" + ], + [ + 429, + "-192" + ], + [ + 431, + "96" + ], + [ + 433, + "384" + ], + [ + 435, + "96" + ], + [ + 436, + "384" + ], + [ + 437, + "384" + ], + [ + 440, + "-96" + ], + [ + 442, + "192" + ], + [ + 443, + "384" + ], + [ + 444, + "-12480" + ], + [ + 445, + "-384" + ], + [ + 447, + "-384" + ], + [ + 448, + "96" + ], + [ + 451, + "-96" + ], + [ + 452, + "384" + ], + [ + 453, + "384" + ], + [ + 454, + "-192" + ], + [ + 456, + "192" + ], + [ + 458, + "192" + ], + [ + 459, + "192" + ], + [ + 460, + "3120" + ], + [ + 461, + "960" + ], + [ + 463, + "192" + ], + [ + 464, + "192" + ], + [ + 465, + "192" + ], + [ + 470, + "-24" + ], + [ + 474, + "384" + ], + [ + 479, + "-768" + ], + [ + 481, + "-96" + ], + [ + 483, + "-240" + ], + [ + 485, + "384" + ], + [ + 486, + "-768" + ], + [ + 490, + "-192" + ], + [ + 491, + "-96" + ], + [ + 496, + "-120" + ], + [ + 504, + "-3120" + ], + [ + 505, + "3120" + ], + [ + 508, + "384" + ], + [ + 509, + "384" + ], + [ + 511, + "192" + ], + [ + 512, + "384" + ], + [ + 518, + "-384" + ], + [ + 519, + "-288" + ], + [ + 521, + "-24" + ], + [ + 522, + "96" + ], + [ + 523, + "-5856" + ], + [ + 524, + "5460" + ], + [ + 526, + "2049" + ], + [ + 527, + "-384" + ], + [ + 528, + "24" + ], + [ + 529, + "-96" + ], + [ + 535, + "-384" + ], + [ + 537, + "-96" + ], + [ + 546, + "-576" + ], + [ + 547, + "-288" + ], + [ + 552, + "240" + ], + [ + 553, + "144" + ], + [ + 555, + "-312" + ], + [ + 559, + "696" + ], + [ + 565, + "-888" + ], + [ + 566, + "384" + ], + [ + 568, + "-288" + ], + [ + 572, + "192" + ], + [ + 574, + "240" + ], + [ + 578, + "384" + ], + [ + 579, + "768" + ], + [ + 581, + "24" + ], + [ + 588, + "-864" + ], + [ + 603, + "-1536" + ], + [ + 608, + "1728" + ], + [ + 609, + "192" + ], + [ + 610, + "-384" + ], + [ + 623, + "96" + ], + [ + 624, + "192" + ], + [ + 630, + "-96" + ], + [ + 638, + "384" + ], + [ + 645, + "384" + ], + [ + 650, + "-1170" + ], + [ + 651, + "-1632" + ], + [ + 666, + "-192" + ], + [ + 679, + "960" + ], + [ + 696, + "-1200" + ], + [ + 700, + "-504" + ], + [ + 811, + "360" + ], + [ + 874, + "-1920" + ], + [ + 876, + "192" + ], + [ + 879, + "-96" + ], + [ + 888, + "-192" + ], + [ + 890, + "768" + ], + [ + 891, + "720" + ], + [ + 893, + "-3120" + ], + [ + 905, + "12" + ], + [ + 921, + "576" + ], + [ + 927, + "114" + ], + [ + 931, + "616" + ], + [ + 933, + "48" + ], + [ + 934, + "720" + ], + [ + 935, + "-576" + ], + [ + 937, + "-960" + ], + [ + 946, + "192" + ], + [ + 949, + "-1536" + ], + [ + 956, + "-384" + ], + [ + 958, + "192" + ], + [ + 963, + "-384" + ], + [ + 964, + "-432" + ], + [ + 965, + "-192" + ], + [ + 970, + "-384" + ], + [ + 973, + "384" + ], + [ + 981, + "-384" + ], + [ + 988, + "192" + ], + [ + 989, + "-768" + ], + [ + 992, + "768" + ], + [ + 996, + "384" + ], + [ + 1001, + "-480" + ], + [ + 1003, + "-384" + ], + [ + 1009, + "288" + ], + [ + 1011, + "120" + ], + [ + 1019, + "384" + ], + [ + 1022, + "-384" + ], + [ + 1024, + "36" + ], + [ + 1025, + "-960" + ], + [ + 1026, + "-432" + ], + [ + 1029, + "-384" + ], + [ + 1031, + "-60" + ], + [ + 1037, + "-1108" + ], + [ + 1038, + "-864" + ], + [ + 1040, + "1120" + ], + [ + 1045, + "1728" + ], + [ + 1051, + "192" + ], + [ + 1052, + "960" + ], + [ + 1054, + "120" + ], + [ + 1057, + "-24" + ], + [ + 1070, + "96" + ], + [ + 1073, + "-192" + ], + [ + 1080, + "96" + ], + [ + 1082, + "-384" + ], + [ + 1088, + "348" + ], + [ + 1090, + "-192" + ], + [ + 1094, + "-384" + ], + [ + 1096, + "-24" + ], + [ + 1097, + "-688" + ], + [ + 1098, + "192" + ], + [ + 1100, + "-1920" + ], + [ + 1101, + "144" + ], + [ + 1102, + "-96" + ], + [ + 1106, + "-96" + ], + [ + 1108, + "-192" + ], + [ + 1111, + "-384" + ], + [ + 1115, + "384" + ], + [ + 1117, + "192" + ], + [ + 1118, + "-96" + ], + [ + 1123, + "240" + ], + [ + 1124, + "-48" + ], + [ + 1126, + "96" + ], + [ + 1132, + "192" + ], + [ + 1138, + "-42" + ], + [ + 1139, + "-384" + ], + [ + 1140, + "-1536" + ], + [ + 1141, + "-96" + ], + [ + 1145, + "-192" + ], + [ + 1146, + "192" + ], + [ + 1148, + "192" + ], + [ + 1154, + "960" + ] + ], + "return_direction": [ + [ + 386, + "-2" + ], + [ + 390, + "4" + ], + [ + 448, + "-6" + ], + [ + 454, + "-3" + ], + [ + 879, + "8" + ], + [ + 1080, + "6" + ], + [ + 1124, + "-4" + ] + ], + "role": 386, + "source_chart": 127, + "source_covector": [ + [ + 16, + "-16" + ], + [ + 333, + "12" + ], + [ + 384, + "64" + ], + [ + 386, + "16" + ], + [ + 388, + "48" + ], + [ + 391, + "12" + ], + [ + 414, + "-48" + ], + [ + 435, + "48" + ], + [ + 470, + "-12" + ], + [ + 483, + "-24" + ], + [ + 496, + "-12" + ], + [ + 519, + "48" + ], + [ + 521, + "-12" + ], + [ + 528, + "12" + ], + [ + 552, + "24" + ], + [ + 553, + "-24" + ], + [ + 555, + "-12" + ], + [ + 559, + "12" + ], + [ + 565, + "-12" + ], + [ + 574, + "24" + ], + [ + 581, + "12" + ], + [ + 696, + "-24" + ], + [ + 700, + "36" + ], + [ + 706, + "8" + ], + [ + 712, + "-8" + ], + [ + 736, + "-8" + ], + [ + 757, + "-24" + ], + [ + 762, + "-16" + ], + [ + 811, + "-60" + ], + [ + 879, + "12" + ], + [ + 891, + "-24" + ], + [ + 905, + "6" + ], + [ + 927, + "9" + ], + [ + 931, + "-12" + ], + [ + 934, + "-24" + ], + [ + 964, + "-24" + ], + [ + 1024, + "-26" + ], + [ + 1026, + "-24" + ], + [ + 1031, + "-6" + ], + [ + 1037, + "6" + ], + [ + 1088, + "6" + ], + [ + 1101, + "-24" + ], + [ + 1106, + "-48" + ], + [ + 1123, + "-24" + ], + [ + 1124, + "24" + ], + [ + 1138, + "-9" + ] + ], + "source_direction": [ + [ + 386, + "-2" + ], + [ + 390, + "4" + ], + [ + 448, + "-6" + ], + [ + 454, + "-3" + ], + [ + 879, + "8" + ], + [ + 1080, + "6" + ], + [ + 1124, + "-4" + ] + ], + "split_chart": 498 + }, + "max_changed_coefficient_bits": 17, + "native_delta": { + "paid": { + "1": 1, + "5": 1, + "6": -1 + }, + "targets": { + "4": 1, + "5": 1, + "9": -1 + } + }, + "new_paid": 66, + "old_paid_charts": [ + 127, + 494 + ], + "paid_daughter_ranks": [ + 5, + 1 + ], + "replay": { + "affected_rows": 527, + "expected_fresh_input_row": { + "1274": "1" + }, + "literal_row_delta_sha256": "fed2117fced9f045cec483789092cfd5aa7f2c6f3066a4321b9dca01b7bb6007", + "new_owner_label": 1527, + "omitted_fresh_input_row": { + "1001": "-480", + "1003": "-384", + "1009": "288", + "1011": "120", + "1019": "384", + "1022": "-384", + "1024": "-900", + "1025": "-960", + "1026": "-1296", + "1029": "-384", + "1031": "-276", + "1037": "-892", + "1038": "-864", + "1040": "1120", + "1045": "1728", + "1051": "192", + "1052": "960", + "1054": "120", + "1057": "-24", + "1070": "96", + "1073": "-192", + "1080": "96", + "1082": "-384", + "1088": "564", + "1090": "-192", + "1094": "-384", + "1096": "-24", + "1097": "-688", + "1098": "192", + "1100": "-1920", + "1101": "-720", + "1102": "-96", + "1106": "-1824", + "1108": "-192", + "1111": "-384", + "1115": "384", + "1117": "192", + "1118": "-96", + "112": "192", + "1123": "-624", + "1124": "816", + "1126": "96", + "1132": "192", + "1138": "-366", + "1139": "-384", + "114": "192", + "1140": "-1536", + "1141": "-96", + "1145": "-192", + "1146": "192", + "1148": "192", + "1154": "960", + "116": "192", + "117": "192", + "118": "192", + "120": "192", + "121": "-384", + "122": "-192", + "123": "-192", + "125": "192", + "126": "-384", + "128": "-192", + "130": "192", + "131": "192", + "134": "-192", + "135": "-192", + "137": "192", + "139": "192", + "140": "384", + "141": "192", + "142": "192", + "143": "-192", + "144": "192", + "147": "-192", + "148": "192", + "149": "192", + "150": "192", + "153": "-192", + "154": "-192", + "156": "-192", + "16": "-576", + "161": "192", + "162": "192", + "163": "-192", + "166": "-192", + "167": "-192", + "169": "-384", + "170": "192", + "171": "384", + "172": "384", + "173": "-192", + "174": "-192", + "175": "-192", + "178": "192", + "179": "192", + "180": "384", + "181": "384", + "182": "192", + "183": "192", + "184": "384", + "187": "192", + "19": "-384", + "191": "-192", + "192": "384", + "193": "-192", + "195": "192", + "196": "192", + "198": "192", + "199": "384", + "200": "192", + "202": "192", + "203": "192", + "204": "-192", + "206": "-192", + "208": "192", + "209": "192", + "21": "-192", + "210": "192", + "212": "-192", + "215": "192", + "216": "-384", + "217": "-192", + "218": "-192", + "219": "-192", + "222": "-192", + "223": "-192", + "228": "-192", + "230": "96", + "235": "-288", + "241": "-192", + "244": "-96", + "249": "192", + "250": "-3120", + "252": "384", + "254": "-192", + "255": "-384", + "260": "-384", + "261": "-384", + "266": "-192", + "272": "192", + "273": "-5472", + "276": "192", + "278": "-192", + "279": "-192", + "299": "384", + "30": "-384", + "302": "768", + "304": "384", + "307": "192", + "308": "-384", + "309": "-384", + "314": "-384", + "322": "-192", + "328": "960", + "332": "-192", + "333": "456", + "335": "-96", + "338": "384", + "342": "192", + "343": "192", + "347": "192", + "349": "96", + "350": "192", + "356": "-96", + "362": "-960", + "364": "-1728", + "375": "3120", + "38": "-384", + "384": "1728", + "386": "-36", + "388": "1824", + "390": "384", + "391": "360", + "401": "960", + "402": "480", + "406": "-384", + "408": "384", + "409": "384", + "410": "192", + "411": "384", + "412": "-1560", + "413": "5856", + "414": "-2208", + "416": "384", + "417": "-384", + "418": "-192", + "420": "-384", + "421": "768", + "424": "384", + "428": "-192", + "429": "-192", + "431": "96", + "433": "384", + "435": "1824", + "436": "384", + "437": "384", + "440": "-96", + "442": "192", + "443": "384", + "444": "-12480", + "445": "-384", + "447": "-384", + "448": "96", + "451": "-96", + "452": "384", + "453": "384", + "454": "-192", + "456": "192", + "458": "192", + "459": "192", + "460": "3120", + "461": "960", + "463": "192", + "464": "192", + "465": "192", + "470": "-456", + "474": "384", + "479": "-768", + "481": "-96", + "483": "-1104", + "485": "384", + "486": "-768", + "490": "-192", + "491": "-96", + "496": "-552", + "504": "-3120", + "505": "3120", + "508": "384", + "509": "384", + "511": "192", + "512": "384", + "518": "-384", + "519": "1440", + "521": "-456", + "522": "96", + "523": "-5856", + "524": "5460", + "526": "2049", + "527": "-384", + "528": "456", + "529": "-96", + "535": "-384", + "537": "-96", + "546": "-576", + "547": "-288", + "552": "1104", + "553": "-720", + "555": "-744", + "559": "1128", + "565": "-1320", + "566": "384", + "568": "-288", + "572": "192", + "574": "1104", + "578": "384", + "579": "768", + "581": "456", + "588": "-864", + "60": "-768", + "603": "-1536", + "608": "1728", + "609": "192", + "610": "-384", + "623": "96", + "624": "192", + "630": "-96", + "638": "384", + "645": "384", + "650": "-1170", + "651": "-1632", + "666": "-192", + "679": "960", + "696": "-2064", + "700": "792", + "706": "288", + "712": "-288", + "736": "-288", + "757": "-864", + "762": "-576", + "811": "-1800", + "874": "-1920", + "876": "192", + "879": "336", + "888": "-192", + "890": "768", + "891": "-144", + "893": "-3120", + "905": "228", + "921": "576", + "927": "438", + "931": "184", + "933": "48", + "934": "-144", + "935": "-576", + "937": "-960", + "946": "192", + "949": "-1536", + "956": "-384", + "958": "192", + "963": "-384", + "964": "-1296", + "965": "-192", + "970": "-384", + "973": "384", + "981": "-384", + "988": "192", + "989": "-768", + "992": "768", + "996": "384" + }, + "original_oriented_paid_row": [ + [ + -1081, + "1" + ], + [ + -758, + "-1/2" + ], + [ + -713, + "-1/2" + ], + [ + -706, + "1/2" + ], + [ + -679, + "1/2" + ] + ], + "original_owner_label": 411, + "parent_sha256": "53652a8774a34d5844d17e00a7f97fd43e683e28022f5de5c4d42cc2ea6cd566", + "result_sha256": "435df671ca10eab6c28a2dc2b0f51f174871e9a97a297f465348d732634bb601" + }, + "source_paid": 91933, + "target_daughter_ranks": [ + 5, + 4 + ] + }, + { + "allocated_role": 1275, + "chart": 234, + "credit": [ + "0.639388808980847010450658", + "0.639388808980847010450659" + ], + "descending": true, + "event": { + "calibration": [ + [ + 94007, + "384" + ] + ], + "pulse": [ + [ + 89050, + "-8" + ], + [ + 89051, + "8" + ], + [ + 89065, + "-3" + ], + [ + 89071, + "-14" + ], + [ + 89088, + "8" + ], + [ + 102993, + "-4" + ], + [ + 104234, + "8" + ] + ], + "readout": [ + [ + 103996, + "96" + ] + ], + "return_chart": 3, + "return_covector": [ + [ + 113, + "-192" + ], + [ + 118, + "192" + ], + [ + 120, + "192" + ], + [ + 121, + "-192" + ], + [ + 122, + "-192" + ], + [ + 123, + "-192" + ], + [ + 128, + "-192" + ], + [ + 129, + "384" + ], + [ + 130, + "192" + ], + [ + 131, + "384" + ], + [ + 137, + "192" + ], + [ + 139, + "192" + ], + [ + 140, + "192" + ], + [ + 141, + "192" + ], + [ + 142, + "384" + ], + [ + 143, + "-192" + ], + [ + 147, + "-192" + ], + [ + 148, + "192" + ], + [ + 149, + "192" + ], + [ + 157, + "192" + ], + [ + 158, + "192" + ], + [ + 159, + "384" + ], + [ + 163, + "-192" + ], + [ + 164, + "-384" + ], + [ + 165, + "-192" + ], + [ + 166, + "-192" + ], + [ + 167, + "-192" + ], + [ + 168, + "-192" + ], + [ + 169, + "-192" + ], + [ + 170, + "192" + ], + [ + 171, + "192" + ], + [ + 172, + "384" + ], + [ + 173, + "-96" + ], + [ + 179, + "192" + ], + [ + 180, + "192" + ], + [ + 181, + "192" + ], + [ + 182, + "192" + ], + [ + 183, + "192" + ], + [ + 184, + "192" + ], + [ + 190, + "-192" + ], + [ + 192, + "192" + ], + [ + 197, + "-192" + ], + [ + 199, + "192" + ], + [ + 204, + "-192" + ], + [ + 206, + "-192" + ], + [ + 207, + "192" + ], + [ + 208, + "192" + ], + [ + 209, + "192" + ], + [ + 210, + "192" + ], + [ + 215, + "192" + ], + [ + 216, + "-192" + ], + [ + 217, + "-192" + ], + [ + 218, + "-192" + ], + [ + 228, + "-96" + ], + [ + 230, + "96" + ], + [ + 235, + "-192" + ], + [ + 244, + "-96" + ], + [ + 250, + "-3120" + ], + [ + 252, + "192" + ], + [ + 266, + "-96" + ], + [ + 273, + "-5856" + ], + [ + 299, + "192" + ], + [ + 302, + "384" + ], + [ + 315, + "384" + ], + [ + 322, + "-96" + ], + [ + 328, + "960" + ], + [ + 332, + "-96" + ], + [ + 338, + "384" + ], + [ + 343, + "192" + ], + [ + 347, + "192" + ], + [ + 349, + "96" + ], + [ + 350, + "192" + ], + [ + 356, + "-96" + ], + [ + 375, + "3120" + ], + [ + 401, + "960" + ], + [ + 402, + "384" + ], + [ + 408, + "192" + ], + [ + 409, + "192" + ], + [ + 411, + "192" + ], + [ + 412, + "-1560" + ], + [ + 413, + "5856" + ], + [ + 416, + "384" + ], + [ + 420, + "-384" + ], + [ + 421, + "384" + ], + [ + 424, + "384" + ], + [ + 428, + "-192" + ], + [ + 429, + "-192" + ], + [ + 436, + "384" + ], + [ + 437, + "384" + ], + [ + 442, + "192" + ], + [ + 444, + "-12480" + ], + [ + 445, + "-384" + ], + [ + 447, + "-384" + ], + [ + 448, + "96" + ], + [ + 451, + "-96" + ], + [ + 452, + "384" + ], + [ + 454, + "-192" + ], + [ + 456, + "192" + ], + [ + 459, + "192" + ], + [ + 460, + "3120" + ], + [ + 461, + "192" + ], + [ + 463, + "192" + ], + [ + 479, + "-384" + ], + [ + 481, + "-96" + ], + [ + 483, + "-192" + ], + [ + 484, + "-192" + ], + [ + 485, + "384" + ], + [ + 486, + "-384" + ], + [ + 490, + "-192" + ], + [ + 491, + "384" + ], + [ + 496, + "-96" + ], + [ + 497, + "-96" + ], + [ + 504, + "-3120" + ], + [ + 505, + "3120" + ], + [ + 508, + "384" + ], + [ + 509, + "384" + ], + [ + 510, + "384" + ], + [ + 514, + "384" + ], + [ + 516, + "-192" + ], + [ + 519, + "-384" + ], + [ + 522, + "96" + ], + [ + 523, + "-5856" + ], + [ + 524, + "5460" + ], + [ + 526, + "2049" + ], + [ + 546, + "192" + ], + [ + 547, + "-192" + ], + [ + 552, + "-384" + ], + [ + 553, + "384" + ], + [ + 561, + "-192" + ], + [ + 565, + "-192" + ], + [ + 566, + "192" + ], + [ + 568, + "-192" + ], + [ + 572, + "192" + ], + [ + 578, + "192" + ], + [ + 579, + "768" + ], + [ + 588, + "-768" + ], + [ + 595, + "-192" + ], + [ + 602, + "96" + ], + [ + 609, + "192" + ], + [ + 610, + "-192" + ], + [ + 617, + "192" + ], + [ + 624, + "96" + ], + [ + 630, + "-96" + ], + [ + 645, + "384" + ], + [ + 650, + "-1170" + ], + [ + 651, + "-816" + ], + [ + 696, + "-192" + ], + [ + 700, + "-384" + ], + [ + 888, + "-192" + ], + [ + 891, + "768" + ], + [ + 893, + "-3120" + ], + [ + 919, + "384" + ], + [ + 921, + "576" + ], + [ + 927, + "96" + ], + [ + 931, + "640" + ], + [ + 933, + "48" + ], + [ + 934, + "384" + ], + [ + 937, + "-192" + ], + [ + 949, + "-768" + ], + [ + 956, + "-192" + ], + [ + 962, + "-192" + ], + [ + 964, + "-192" + ], + [ + 965, + "-192" + ], + [ + 973, + "384" + ], + [ + 979, + "-192" + ], + [ + 988, + "192" + ], + [ + 992, + "384" + ], + [ + 996, + "384" + ], + [ + 1001, + "-480" + ], + [ + 1003, + "-384" + ], + [ + 1009, + "288" + ], + [ + 1019, + "384" + ], + [ + 1022, + "-384" + ], + [ + 1025, + "-960" + ], + [ + 1026, + "-384" + ], + [ + 1037, + "-1024" + ], + [ + 1040, + "1024" + ], + [ + 1052, + "960" + ], + [ + 1057, + "-24" + ], + [ + 1082, + "-96" + ], + [ + 1088, + "-96" + ], + [ + 1090, + "-96" + ], + [ + 1094, + "-384" + ], + [ + 1096, + "-24" + ], + [ + 1097, + "-640" + ], + [ + 1098, + "192" + ], + [ + 1102, + "-48" + ], + [ + 1108, + "192" + ], + [ + 1111, + "-480" + ], + [ + 1114, + "96" + ], + [ + 1117, + "192" + ], + [ + 1118, + "-96" + ], + [ + 1121, + "96" + ], + [ + 1126, + "96" + ], + [ + 1141, + "-96" + ], + [ + 1154, + "-192" + ] + ], + "return_direction": [ + [ + 236, + "2" + ], + [ + 315, + "2" + ] + ], + "role": 236, + "source_chart": 127, + "source_covector": [ + [ + 18, + "96" + ], + [ + 19, + "-192" + ], + [ + 40, + "-192" + ], + [ + 173, + "24" + ], + [ + 228, + "24" + ], + [ + 235, + "36" + ], + [ + 236, + "-96" + ], + [ + 240, + "48" + ], + [ + 244, + "-24" + ], + [ + 248, + "12" + ], + [ + 262, + "48" + ], + [ + 266, + "12" + ], + [ + 270, + "-16" + ], + [ + 273, + "96" + ], + [ + 274, + "48" + ], + [ + 276, + "24" + ], + [ + 302, + "-48" + ], + [ + 304, + "-24" + ], + [ + 307, + "24" + ], + [ + 310, + "-96" + ], + [ + 315, + "-96" + ], + [ + 317, + "-48" + ], + [ + 318, + "-144" + ], + [ + 320, + "48" + ], + [ + 321, + "48" + ], + [ + 322, + "24" + ], + [ + 328, + "144" + ], + [ + 333, + "-12" + ], + [ + 335, + "12" + ], + [ + 336, + "12" + ], + [ + 338, + "-96" + ], + [ + 343, + "-72" + ], + [ + 347, + "-48" + ], + [ + 348, + "96" + ], + [ + 349, + "-24" + ], + [ + 350, + "-48" + ], + [ + 368, + "-12" + ], + [ + 376, + "-96" + ], + [ + 381, + "12" + ], + [ + 389, + "12" + ], + [ + 401, + "96" + ], + [ + 408, + "-48" + ], + [ + 410, + "72" + ], + [ + 411, + "-24" + ], + [ + 413, + "-96" + ], + [ + 416, + "-96" + ], + [ + 419, + "48" + ], + [ + 424, + "-48" + ], + [ + 425, + "-48" + ], + [ + 426, + "48" + ], + [ + 427, + "-48" + ], + [ + 428, + "-24" + ], + [ + 429, + "24" + ], + [ + 430, + "-24" + ], + [ + 432, + "24" + ], + [ + 433, + "-48" + ], + [ + 434, + "48" + ], + [ + 437, + "96" + ], + [ + 442, + "-48" + ], + [ + 443, + "-48" + ], + [ + 445, + "96" + ], + [ + 448, + "-24" + ], + [ + 451, + "24" + ], + [ + 452, + "-96" + ], + [ + 454, + "48" + ], + [ + 456, + "-48" + ], + [ + 459, + "-48" + ], + [ + 461, + "36" + ], + [ + 463, + "-48" + ], + [ + 467, + "-24" + ], + [ + 468, + "24" + ], + [ + 469, + "-24" + ], + [ + 476, + "-24" + ], + [ + 477, + "24" + ], + [ + 479, + "48" + ], + [ + 481, + "12" + ], + [ + 485, + "-96" + ], + [ + 486, + "48" + ], + [ + 487, + "24" + ], + [ + 490, + "12" + ], + [ + 491, + "-96" + ], + [ + 492, + "-96" + ], + [ + 494, + "48" + ], + [ + 498, + "-12" + ], + [ + 499, + "12" + ], + [ + 508, + "-96" + ], + [ + 509, + "-96" + ], + [ + 510, + "-144" + ], + [ + 511, + "24" + ], + [ + 512, + "-48" + ], + [ + 513, + "-48" + ], + [ + 514, + "-48" + ], + [ + 515, + "-48" + ], + [ + 516, + "48" + ], + [ + 518, + "-72" + ], + [ + 524, + "36" + ], + [ + 525, + "-42" + ], + [ + 526, + "15" + ], + [ + 528, + "-12" + ], + [ + 529, + "36" + ], + [ + 534, + "-48" + ], + [ + 535, + "-96" + ], + [ + 537, + "24" + ], + [ + 539, + "-12" + ], + [ + 540, + "12" + ], + [ + 546, + "-24" + ], + [ + 547, + "48" + ], + [ + 552, + "-48" + ], + [ + 553, + "48" + ], + [ + 555, + "24" + ], + [ + 565, + "24" + ], + [ + 568, + "48" + ], + [ + 572, + "-48" + ], + [ + 579, + "-192" + ], + [ + 588, + "168" + ], + [ + 590, + "-8" + ], + [ + 595, + "24" + ], + [ + 596, + "12" + ], + [ + 602, + "12" + ], + [ + 608, + "-24" + ], + [ + 609, + "-24" + ], + [ + 610, + "24" + ], + [ + 616, + "12" + ], + [ + 623, + "24" + ], + [ + 624, + "-12" + ], + [ + 634, + "-96" + ], + [ + 645, + "-96" + ], + [ + 649, + "24" + ], + [ + 650, + "18" + ], + [ + 651, + "102" + ], + [ + 660, + "-48" + ], + [ + 680, + "-24" + ], + [ + 692, + "-48" + ], + [ + 696, + "48" + ], + [ + 700, + "48" + ], + [ + 811, + "-84" + ], + [ + 876, + "45" + ], + [ + 888, + "-48" + ], + [ + 891, + "-168" + ], + [ + 906, + "-8" + ], + [ + 917, + "-96" + ], + [ + 919, + "-96" + ], + [ + 921, + "-144" + ], + [ + 923, + "-6" + ], + [ + 927, + "-12" + ], + [ + 931, + "-148" + ], + [ + 933, + "-12" + ], + [ + 934, + "-48" + ], + [ + 935, + "-48" + ], + [ + 947, + "-84" + ], + [ + 949, + "192" + ], + [ + 952, + "-96" + ], + [ + 956, + "96" + ], + [ + 957, + "-24" + ], + [ + 958, + "45" + ], + [ + 965, + "48" + ], + [ + 968, + "-48" + ], + [ + 973, + "-192" + ], + [ + 974, + "-48" + ], + [ + 975, + "48" + ], + [ + 980, + "-48" + ], + [ + 984, + "48" + ], + [ + 988, + "-48" + ], + [ + 989, + "96" + ], + [ + 992, + "-48" + ], + [ + 994, + "96" + ], + [ + 996, + "-96" + ], + [ + 997, + "24" + ], + [ + 999, + "-6" + ], + [ + 1001, + "120" + ], + [ + 1005, + "-48" + ], + [ + 1019, + "-96" + ], + [ + 1025, + "-96" + ], + [ + 1033, + "-16" + ], + [ + 1037, + "232" + ], + [ + 1038, + "6" + ], + [ + 1040, + "-232" + ], + [ + 1051, + "-24" + ], + [ + 1052, + "48" + ], + [ + 1054, + "-9" + ], + [ + 1067, + "24" + ], + [ + 1070, + "-36" + ], + [ + 1073, + "-48" + ], + [ + 1078, + "3" + ], + [ + 1085, + "96" + ], + [ + 1087, + "12" + ], + [ + 1088, + "-12" + ], + [ + 1089, + "-8" + ], + [ + 1090, + "24" + ], + [ + 1092, + "-288" + ], + [ + 1094, + "96" + ], + [ + 1096, + "48" + ], + [ + 1097, + "148" + ], + [ + 1098, + "-48" + ], + [ + 1104, + "-3" + ], + [ + 1108, + "24" + ], + [ + 1111, + "132" + ], + [ + 1112, + "-12" + ], + [ + 1117, + "-24" + ], + [ + 1118, + "24" + ], + [ + 1122, + "96" + ], + [ + 1125, + "-24" + ], + [ + 1126, + "-12" + ], + [ + 1127, + "48" + ], + [ + 1131, + "-12" + ], + [ + 1138, + "-3" + ], + [ + 1139, + "48" + ], + [ + 1141, + "24" + ], + [ + 1142, + "-48" + ], + [ + 1144, + "12" + ], + [ + 1154, + "24" + ], + [ + 1173, + "48" + ] + ], + "source_direction": [ + [ + 236, + "2" + ], + [ + 315, + "2" + ] + ], + "split_chart": 234 + }, + "max_changed_coefficient_bits": 14, + "native_delta": { + "paid": { + "1": 1, + "5": 1, + "6": -1 + }, + "targets": { + "4": 1, + "5": 1, + "9": -1 + } + }, + "new_paid": 67, + "old_paid_charts": [ + 127, + 722 + ], + "paid_daughter_ranks": [ + 5, + 1 + ], + "replay": { + "affected_rows": 616, + "expected_fresh_input_row": { + "1275": "1" + }, + "literal_row_delta_sha256": "03a03cbc706421e1b9a2103ca1094ff5c147f5fae56e2cf5eead4f060a40826f", + "new_owner_label": 1528, + "omitted_fresh_input_row": { + "1001": "-240", + "1003": "-384", + "1005": "-96", + "1009": "288", + "1019": "192", + "1022": "-384", + "1025": "-1152", + "1026": "-384", + "1033": "-32", + "1037": "-560", + "1038": "12", + "1040": "560", + "1051": "-48", + "1052": "1056", + "1054": "-18", + "1057": "-24", + "1067": "48", + "1070": "-72", + "1073": "-96", + "1078": "6", + "1082": "-96", + "1085": "192", + "1087": "24", + "1088": "-120", + "1089": "-16", + "1090": "-48", + "1092": "-576", + "1094": "-192", + "1096": "72", + "1097": "-344", + "1098": "96", + "1102": "-48", + "1104": "-6", + "1108": "240", + "1111": "-216", + "1112": "-24", + "1114": "96", + "1117": "144", + "1118": "-48", + "1121": "96", + "1122": "192", + "1125": "-48", + "1126": "72", + "1127": "96", + "113": "-192", + "1131": "-24", + "1138": "-6", + "1139": "96", + "1141": "-48", + "1142": "-96", + "1144": "24", + "1154": "-144", + "1173": "96", + "118": "192", + "120": "192", + "121": "-192", + "122": "-192", + "123": "-192", + "128": "-192", + "129": "192", + "130": "192", + "131": "192", + "137": "192", + "139": "192", + "140": "192", + "141": "192", + "142": "192", + "143": "-192", + "147": "-192", + "148": "192", + "149": "192", + "157": "192", + "158": "192", + "159": "192", + "163": "-192", + "164": "-192", + "165": "-192", + "166": "-192", + "167": "-192", + "168": "-192", + "169": "-192", + "17": "-384", + "170": "192", + "171": "192", + "172": "192", + "173": "-48", + "179": "192", + "18": "192", + "180": "192", + "181": "192", + "182": "192", + "183": "192", + "184": "192", + "19": "-768", + "190": "-192", + "192": "192", + "197": "-192", + "199": "192", + "204": "-192", + "206": "-192", + "207": "192", + "208": "192", + "209": "192", + "210": "192", + "215": "192", + "216": "-192", + "217": "-192", + "218": "-192", + "228": "-48", + "230": "96", + "235": "-120", + "236": "-2", + "240": "96", + "244": "-144", + "248": "24", + "250": "-3120", + "252": "192", + "262": "96", + "266": "-72", + "270": "-32", + "273": "-5664", + "274": "96", + "276": "48", + "299": "192", + "30": "-384", + "302": "288", + "304": "-48", + "307": "48", + "310": "-192", + "315": "192", + "317": "-96", + "318": "-288", + "320": "96", + "321": "96", + "322": "-48", + "328": "1248", + "332": "-96", + "333": "-24", + "335": "24", + "336": "24", + "338": "192", + "343": "48", + "347": "96", + "348": "192", + "349": "48", + "350": "96", + "356": "-96", + "368": "-24", + "375": "3120", + "376": "-192", + "381": "24", + "389": "24", + "40": "-384", + "401": "1152", + "402": "384", + "408": "96", + "409": "192", + "410": "144", + "411": "144", + "412": "-1560", + "413": "5664", + "416": "192", + "419": "96", + "420": "-384", + "421": "384", + "424": "288", + "425": "-96", + "426": "96", + "427": "-96", + "428": "-240", + "429": "-144", + "430": "-48", + "432": "48", + "433": "-96", + "434": "96", + "436": "384", + "437": "576", + "442": "96", + "443": "-96", + "444": "-12480", + "445": "-192", + "447": "-384", + "448": "48", + "451": "-48", + "452": "192", + "454": "-96", + "456": "96", + "459": "96", + "460": "3120", + "461": "264", + "463": "96", + "467": "-48", + "468": "48", + "469": "-48", + "47": "-384", + "476": "-48", + "477": "48", + "479": "-288", + "481": "-72", + "483": "-192", + "484": "-192", + "485": "192", + "486": "-288", + "487": "48", + "490": "-168", + "491": "192", + "492": "-192", + "494": "96", + "496": "-96", + "497": "-96", + "498": "-24", + "499": "24", + "504": "-3120", + "505": "3120", + "508": "192", + "509": "192", + "510": "96", + "511": "48", + "512": "-96", + "513": "-96", + "514": "288", + "515": "-96", + "516": "-96", + "518": "-144", + "519": "-384", + "52": "384", + "522": "96", + "523": "-5856", + "524": "5532", + "525": "-84", + "526": "2079", + "528": "-24", + "529": "72", + "534": "-96", + "535": "-192", + "537": "48", + "539": "-24", + "540": "24", + "546": "144", + "547": "-96", + "552": "-480", + "553": "480", + "555": "48", + "561": "-192", + "565": "-144", + "566": "192", + "568": "-96", + "572": "96", + "578": "192", + "579": "384", + "588": "-432", + "590": "-16", + "595": "-144", + "596": "24", + "60": "-384", + "602": "120", + "608": "-48", + "609": "144", + "610": "-144", + "616": "24", + "617": "192", + "623": "48", + "624": "72", + "630": "-96", + "634": "-192", + "645": "192", + "649": "48", + "650": "-1134", + "651": "-612", + "660": "-96", + "680": "-48", + "692": "-96", + "696": "-96", + "700": "-288", + "811": "-168", + "876": "90", + "888": "-288", + "891": "432", + "893": "-3120", + "906": "-16", + "917": "-192", + "919": "192", + "921": "288", + "923": "-12", + "927": "72", + "931": "344", + "933": "24", + "934": "288", + "935": "-96", + "937": "-192", + "947": "-168", + "949": "-384", + "952": "-192", + "957": "-48", + "958": "90", + "962": "-192", + "964": "-192", + "965": "-96", + "968": "-96", + "974": "-96", + "975": "96", + "979": "-192", + "980": "-96", + "984": "96", + "988": "96", + "989": "192", + "992": "288", + "994": "192", + "996": "192", + "997": "48", + "999": "-12" + }, + "original_oriented_paid_row": [ + [ + -1174, + "-1" + ], + [ + -1155, + "-1/2" + ], + [ + -1145, + "-1/4" + ], + [ + -1143, + "1" + ], + [ + -1142, + "-1/2" + ], + [ + -1140, + "-1" + ], + [ + -1139, + "1/16" + ], + [ + -1132, + "1/4" + ], + [ + -1128, + "-1" + ], + [ + -1127, + "1/4" + ], + [ + -1126, + "1/2" + ], + [ + -1123, + "-2" + ], + [ + -1119, + "-1/2" + ], + [ + -1118, + "1/2" + ], + [ + -1113, + "1/4" + ], + [ + -1112, + "-11/4" + ], + [ + -1109, + "-1/2" + ], + [ + -1105, + "1/16" + ], + [ + -1099, + "1" + ], + [ + -1098, + "-37/12" + ], + [ + -1097, + "-1" + ], + [ + -1095, + "-2" + ], + [ + -1093, + "6" + ], + [ + -1091, + "-1/2" + ], + [ + -1090, + "1/6" + ], + [ + -1089, + "1/4" + ], + [ + -1088, + "-1/4" + ], + [ + -1086, + "-2" + ], + [ + -1079, + "-1/16" + ], + [ + -1074, + "1" + ], + [ + -1071, + "3/4" + ], + [ + -1068, + "-1/2" + ], + [ + -1055, + "3/16" + ], + [ + -1053, + "1" + ], + [ + -1052, + "1/2" + ], + [ + -1041, + "29/6" + ], + [ + -1039, + "-1/8" + ], + [ + -1038, + "-29/6" + ], + [ + -1034, + "1/3" + ], + [ + -1020, + "2" + ], + [ + -1006, + "1" + ], + [ + -1002, + "-5/2" + ], + [ + -1000, + "1/8" + ], + [ + -998, + "-1/2" + ], + [ + -997, + "2" + ], + [ + -995, + "-2" + ], + [ + -993, + "1" + ], + [ + -990, + "-2" + ], + [ + -989, + "1" + ], + [ + -985, + "-1" + ], + [ + -981, + "1" + ], + [ + -976, + "-1" + ], + [ + -975, + "1" + ], + [ + -974, + "4" + ], + [ + -966, + "-1" + ], + [ + -959, + "-15/16" + ], + [ + -958, + "1/2" + ], + [ + -957, + "-2" + ], + [ + -953, + "2" + ], + [ + -950, + "-4" + ], + [ + -948, + "7/4" + ], + [ + -936, + "1" + ], + [ + -935, + "1" + ], + [ + -934, + "1/4" + ], + [ + -932, + "37/12" + ], + [ + -928, + "1/4" + ], + [ + -924, + "1/8" + ], + [ + -922, + "3" + ], + [ + -920, + "2" + ], + [ + -918, + "2" + ], + [ + -907, + "1/6" + ], + [ + -892, + "7/2" + ], + [ + -877, + "-15/16" + ], + [ + -812, + "7/4" + ], + [ + -760, + "1/2" + ], + [ + -716, + "-1/2" + ], + [ + -701, + "-1" + ], + [ + -697, + "-1" + ], + [ + -693, + "1" + ], + [ + -681, + "1/2" + ], + [ + -661, + "1" + ], + [ + -652, + "-17/8" + ], + [ + -650, + "-1/2" + ], + [ + -646, + "2" + ], + [ + -635, + "2" + ], + [ + -625, + "1/4" + ], + [ + -624, + "-1/2" + ], + [ + -617, + "-1/4" + ], + [ + -611, + "-1/2" + ], + [ + -610, + "1/2" + ], + [ + -609, + "1/2" + ], + [ + -603, + "-1/4" + ], + [ + -597, + "-1/4" + ], + [ + -596, + "-1/2" + ], + [ + -591, + "1/6" + ], + [ + -589, + "-7/2" + ], + [ + -580, + "4" + ], + [ + -573, + "1" + ], + [ + -569, + "-1" + ], + [ + -566, + "-1/2" + ], + [ + -556, + "-1/2" + ], + [ + -554, + "-1" + ], + [ + -553, + "1" + ], + [ + -548, + "-1" + ], + [ + -547, + "1/2" + ], + [ + -541, + "-1/4" + ], + [ + -540, + "1/4" + ], + [ + -538, + "-1/2" + ], + [ + -536, + "2" + ], + [ + -535, + "1" + ], + [ + -530, + "-3/4" + ], + [ + -529, + "1/4" + ], + [ + -527, + "-1/2" + ], + [ + -526, + "1/2" + ], + [ + -519, + "3/2" + ], + [ + -517, + "-1" + ], + [ + -516, + "1" + ], + [ + -515, + "1" + ], + [ + -514, + "1" + ], + [ + -513, + "1" + ], + [ + -512, + "-1/2" + ], + [ + -511, + "3" + ], + [ + -510, + "2" + ], + [ + -509, + "2" + ], + [ + -500, + "-1/4" + ], + [ + -499, + "1/4" + ], + [ + -495, + "-1" + ], + [ + -493, + "2" + ], + [ + -492, + "2" + ], + [ + -491, + "-1/4" + ], + [ + -488, + "-1/2" + ], + [ + -487, + "-1" + ], + [ + -486, + "2" + ], + [ + -482, + "-1/4" + ], + [ + -480, + "-1" + ], + [ + -478, + "-1/2" + ], + [ + -477, + "1/2" + ], + [ + -470, + "1/2" + ], + [ + -469, + "-1/2" + ], + [ + -468, + "1/2" + ], + [ + -464, + "1" + ], + [ + -462, + "-3/4" + ], + [ + -460, + "1" + ], + [ + -457, + "1" + ], + [ + -455, + "-1" + ], + [ + -453, + "2" + ], + [ + -452, + "-1/2" + ], + [ + -449, + "1/2" + ], + [ + -446, + "-2" + ], + [ + -444, + "1" + ], + [ + -443, + "1" + ], + [ + -437, + "2" + ], + [ + -435, + "-1" + ], + [ + -434, + "1" + ], + [ + -433, + "-1/2" + ], + [ + -431, + "1/2" + ], + [ + -430, + "-1/2" + ], + [ + -429, + "1/2" + ], + [ + -428, + "1" + ], + [ + -427, + "-1" + ], + [ + -426, + "1" + ], + [ + -425, + "1" + ], + [ + -420, + "-1" + ], + [ + -417, + "2" + ], + [ + -412, + "1/2" + ], + [ + -411, + "-3/2" + ], + [ + -409, + "1" + ], + [ + -390, + "-1/4" + ], + [ + -382, + "-1/4" + ], + [ + -377, + "2" + ], + [ + -369, + "1/4" + ], + [ + -357, + "-1/2" + ], + [ + -351, + "1" + ], + [ + -350, + "1/2" + ], + [ + -349, + "-2" + ], + [ + -348, + "1" + ], + [ + -344, + "3/2" + ], + [ + -339, + "2" + ], + [ + -337, + "-1/4" + ], + [ + -336, + "-1/4" + ], + [ + -334, + "1/4" + ], + [ + -329, + "-1" + ], + [ + -323, + "-1/2" + ], + [ + -322, + "-1" + ], + [ + -321, + "-1" + ], + [ + -319, + "3" + ], + [ + -318, + "1" + ], + [ + -316, + "2" + ], + [ + -311, + "2" + ], + [ + -308, + "-1/2" + ], + [ + -305, + "1/2" + ], + [ + -303, + "1" + ], + [ + -277, + "-1/2" + ], + [ + -275, + "-1" + ], + [ + -271, + "1/3" + ], + [ + -267, + "-1/4" + ], + [ + -263, + "-1" + ], + [ + -249, + "-1/4" + ], + [ + -241, + "-1" + ], + [ + -237, + "2" + ], + [ + -236, + "-3/4" + ], + [ + -229, + "-1/2" + ], + [ + -174, + "-1/2" + ], + [ + -102, + "-1" + ], + [ + -56, + "1" + ] + ], + "original_owner_label": 237, + "parent_sha256": "435df671ca10eab6c28a2dc2b0f51f174871e9a97a297f465348d732634bb601", + "result_sha256": "9d2532de1a5b388c16f1ec0f0313d604f6eac51a6f1f89ff6759e460aa731da2" + }, + "source_paid": 104234, + "target_daughter_ranks": [ + 5, + 4 + ] + }, + { + "allocated_role": 1276, + "chart": 306, + "credit": [ + "0.476008453890899681095839", + "0.476008453890899681095840" + ], + "descending": false, + "event": { + "calibration": [ + [ + 68, + "-4" + ], + [ + 90122, + "-8" + ], + [ + 90124, + "4" + ], + [ + 90126, + "8" + ], + [ + 90129, + "-8" + ], + [ + 90130, + "4" + ], + [ + 90131, + "-16" + ], + [ + 94336, + "8" + ], + [ + 96307, + "-8" + ], + [ + 96330, + "-8" + ] + ], + "pulse": [ + [ + 96016, + "-1" + ], + [ + 97129, + "1" + ], + [ + 103327, + "1" + ] + ], + "readout": [ + [ + 68, + "4" + ], + [ + 90122, + "-8" + ], + [ + 90130, + "-4" + ] + ], + "return_chart": 127, + "return_covector": [ + [ + 89, + "8" + ], + [ + 94, + "-8" + ], + [ + 229, + "4" + ], + [ + 245, + "6" + ], + [ + 256, + "2" + ], + [ + 303, + "8" + ], + [ + 306, + "-8" + ], + [ + 899, + "16" + ], + [ + 943, + "-16" + ], + [ + 948, + "-20" + ], + [ + 1254, + "1" + ] + ], + "return_direction": [ + [ + 1254, + "4" + ] + ], + "role": 1254, + "source_chart": 2, + "source_covector": [ + [ + 2, + "8" + ], + [ + 1254, + "-1" + ] + ], + "source_direction": [ + [ + 1254, + "4" + ] + ], + "split_chart": 306 + }, + "max_changed_coefficient_bits": 5, + "native_delta": { + "paid": { + "1": 1, + "5": 1, + "6": -1 + }, + "targets": { + "3": 1, + "5": 1, + "8": -1 + } + }, + "new_paid": 68, + "old_paid_charts": [ + 299, + 127 + ], + "paid_daughter_ranks": [ + 1, + 5 + ], + "replay": { + "affected_rows": 9, + "expected_fresh_input_row": { + "1276": "1" + }, + "literal_row_delta_sha256": "9558f2a4fbe1fb26f9168018610605ef13070d67fa13eda96bc7eea40e40013c", + "new_owner_label": 1529, + "omitted_fresh_input_row": {}, + "original_oriented_paid_row": [ + [ + 90081, + "1" + ], + [ + 90082, + "1" + ], + [ + 94318, + "-1/2" + ] + ], + "original_owner_label": 1501, + "parent_sha256": "9d2532de1a5b388c16f1ec0f0313d604f6eac51a6f1f89ff6759e460aa731da2", + "result_sha256": "3785d35782396c6ac5d098b60d27fa5afab0576f9d3c10e5afe64503822e44a6" + }, + "source_paid": 96016, + "target_daughter_ranks": [ + 3, + 5 + ] + }, + { + "allocated_role": 1277, + "chart": 498, + "credit": [ + "0.366309340489631854952117", + "0.366309340489631854952118" + ], + "descending": true, + "event": { + "calibration": [ + [ + 66, + "-48" + ], + [ + 69, + "288" + ], + [ + 92636, + "384" + ], + [ + 94005, + "384" + ], + [ + 95658, + "204" + ], + [ + 103595, + "96" + ], + [ + 103933, + "-312" + ], + [ + 104021, + "108" + ], + [ + 104022, + "-102" + ], + [ + 104376, + "-1176" + ], + [ + 104384, + "1008" + ], + [ + 104418, + "72" + ] + ], + "pulse": [ + [ + 92454, + "-8" + ], + [ + 92458, + "-16" + ], + [ + 92464, + "-8" + ], + [ + 92471, + "8" + ], + [ + 92667, + "8" + ], + [ + 92669, + "16" + ], + [ + 92677, + "-16" + ], + [ + 92689, + "-8" + ], + [ + 92690, + "16" + ] + ], + "readout": [ + [ + 66, + "16" + ] + ], + "return_chart": 3, + "return_covector": [ + [ + 21, + "-192" + ], + [ + 112, + "192" + ], + [ + 114, + "192" + ], + [ + 116, + "192" + ], + [ + 117, + "192" + ], + [ + 118, + "192" + ], + [ + 120, + "192" + ], + [ + 121, + "-384" + ], + [ + 122, + "-192" + ], + [ + 123, + "-192" + ], + [ + 125, + "192" + ], + [ + 126, + "-3264" + ], + [ + 128, + "-192" + ], + [ + 130, + "192" + ], + [ + 131, + "384" + ], + [ + 134, + "-192" + ], + [ + 135, + "-192" + ], + [ + 137, + "192" + ], + [ + 139, + "192" + ], + [ + 140, + "384" + ], + [ + 141, + "192" + ], + [ + 142, + "384" + ], + [ + 143, + "-192" + ], + [ + 144, + "192" + ], + [ + 147, + "-192" + ], + [ + 148, + "192" + ], + [ + 149, + "192" + ], + [ + 150, + "384" + ], + [ + 153, + "-192" + ], + [ + 154, + "-192" + ], + [ + 156, + "-192" + ], + [ + 161, + "192" + ], + [ + 162, + "192" + ], + [ + 163, + "-192" + ], + [ + 166, + "-192" + ], + [ + 167, + "-192" + ], + [ + 169, + "-384" + ], + [ + 170, + "192" + ], + [ + 171, + "384" + ], + [ + 172, + "768" + ], + [ + 173, + "-192" + ], + [ + 174, + "-192" + ], + [ + 175, + "-192" + ], + [ + 178, + "192" + ], + [ + 179, + "192" + ], + [ + 180, + "384" + ], + [ + 181, + "384" + ], + [ + 182, + "192" + ], + [ + 183, + "192" + ], + [ + 184, + "384" + ], + [ + 187, + "192" + ], + [ + 191, + "-192" + ], + [ + 192, + "384" + ], + [ + 193, + "-192" + ], + [ + 195, + "192" + ], + [ + 196, + "192" + ], + [ + 198, + "192" + ], + [ + 199, + "384" + ], + [ + 200, + "192" + ], + [ + 202, + "192" + ], + [ + 203, + "192" + ], + [ + 204, + "-192" + ], + [ + 206, + "-192" + ], + [ + 208, + "192" + ], + [ + 209, + "192" + ], + [ + 210, + "192" + ], + [ + 212, + "-192" + ], + [ + 215, + "192" + ], + [ + 216, + "-384" + ], + [ + 217, + "-192" + ], + [ + 218, + "-192" + ], + [ + 219, + "-192" + ], + [ + 222, + "-192" + ], + [ + 223, + "-192" + ], + [ + 228, + "-192" + ], + [ + 230, + "96" + ], + [ + 235, + "-288" + ], + [ + 241, + "-192" + ], + [ + 244, + "-96" + ], + [ + 249, + "192" + ], + [ + 250, + "-3120" + ], + [ + 252, + "384" + ], + [ + 254, + "-192" + ], + [ + 255, + "-384" + ], + [ + 260, + "-384" + ], + [ + 261, + "-384" + ], + [ + 266, + "-192" + ], + [ + 272, + "192" + ], + [ + 273, + "-5472" + ], + [ + 276, + "192" + ], + [ + 278, + "-192" + ], + [ + 279, + "-192" + ], + [ + 299, + "384" + ], + [ + 302, + "768" + ], + [ + 304, + "384" + ], + [ + 307, + "192" + ], + [ + 308, + "-384" + ], + [ + 309, + "-384" + ], + [ + 314, + "-384" + ], + [ + 322, + "-192" + ], + [ + 328, + "960" + ], + [ + 332, + "-192" + ], + [ + 333, + "60" + ], + [ + 335, + "-96" + ], + [ + 338, + "384" + ], + [ + 342, + "192" + ], + [ + 343, + "192" + ], + [ + 347, + "192" + ], + [ + 349, + "96" + ], + [ + 350, + "192" + ], + [ + 356, + "-96" + ], + [ + 362, + "-960" + ], + [ + 364, + "-1728" + ], + [ + 375, + "3120" + ], + [ + 384, + "-3168" + ], + [ + 388, + "240" + ], + [ + 390, + "2112" + ], + [ + 391, + "-36" + ], + [ + 401, + "960" + ], + [ + 402, + "480" + ], + [ + 406, + "-384" + ], + [ + 408, + "384" + ], + [ + 409, + "384" + ], + [ + 410, + "192" + ], + [ + 411, + "384" + ], + [ + 412, + "-1560" + ], + [ + 413, + "5856" + ], + [ + 414, + "-624" + ], + [ + 416, + "384" + ], + [ + 417, + "-384" + ], + [ + 418, + "-192" + ], + [ + 420, + "-384" + ], + [ + 421, + "768" + ], + [ + 424, + "384" + ], + [ + 428, + "-192" + ], + [ + 429, + "-192" + ], + [ + 431, + "96" + ], + [ + 433, + "384" + ], + [ + 435, + "240" + ], + [ + 436, + "384" + ], + [ + 437, + "384" + ], + [ + 440, + "-96" + ], + [ + 442, + "192" + ], + [ + 443, + "384" + ], + [ + 444, + "-12480" + ], + [ + 445, + "-384" + ], + [ + 447, + "-384" + ], + [ + 448, + "96" + ], + [ + 451, + "-96" + ], + [ + 452, + "384" + ], + [ + 453, + "384" + ], + [ + 454, + "-192" + ], + [ + 456, + "192" + ], + [ + 458, + "192" + ], + [ + 459, + "192" + ], + [ + 460, + "3120" + ], + [ + 461, + "960" + ], + [ + 463, + "192" + ], + [ + 464, + "192" + ], + [ + 465, + "192" + ], + [ + 470, + "-60" + ], + [ + 474, + "384" + ], + [ + 479, + "-768" + ], + [ + 481, + "-96" + ], + [ + 483, + "-312" + ], + [ + 485, + "384" + ], + [ + 486, + "-768" + ], + [ + 490, + "-192" + ], + [ + 491, + "-96" + ], + [ + 496, + "-156" + ], + [ + 504, + "-3120" + ], + [ + 505, + "3120" + ], + [ + 508, + "384" + ], + [ + 509, + "384" + ], + [ + 511, + "192" + ], + [ + 512, + "384" + ], + [ + 518, + "-384" + ], + [ + 519, + "-144" + ], + [ + 521, + "-60" + ], + [ + 522, + "96" + ], + [ + 523, + "-5856" + ], + [ + 524, + "5460" + ], + [ + 526, + "2049" + ], + [ + 527, + "-384" + ], + [ + 528, + "60" + ], + [ + 529, + "-96" + ], + [ + 535, + "-384" + ], + [ + 537, + "-96" + ], + [ + 546, + "-576" + ], + [ + 547, + "-288" + ], + [ + 552, + "312" + ], + [ + 553, + "72" + ], + [ + 555, + "-348" + ], + [ + 559, + "732" + ], + [ + 565, + "-924" + ], + [ + 566, + "384" + ], + [ + 568, + "-288" + ], + [ + 572, + "192" + ], + [ + 574, + "312" + ], + [ + 578, + "384" + ], + [ + 579, + "768" + ], + [ + 581, + "60" + ], + [ + 588, + "-864" + ], + [ + 603, + "-1536" + ], + [ + 608, + "1728" + ], + [ + 609, + "192" + ], + [ + 610, + "-384" + ], + [ + 623, + "96" + ], + [ + 624, + "192" + ], + [ + 630, + "-96" + ], + [ + 638, + "384" + ], + [ + 645, + "384" + ], + [ + 650, + "-1170" + ], + [ + 651, + "-1632" + ], + [ + 666, + "-192" + ], + [ + 679, + "960" + ], + [ + 696, + "-1272" + ], + [ + 700, + "-396" + ], + [ + 811, + "180" + ], + [ + 874, + "-1920" + ], + [ + 876, + "192" + ], + [ + 879, + "-456" + ], + [ + 888, + "-192" + ], + [ + 890, + "768" + ], + [ + 891, + "648" + ], + [ + 893, + "-3120" + ], + [ + 905, + "30" + ], + [ + 921, + "576" + ], + [ + 927, + "141" + ], + [ + 931, + "580" + ], + [ + 933, + "48" + ], + [ + 934, + "648" + ], + [ + 935, + "-576" + ], + [ + 937, + "-960" + ], + [ + 946, + "192" + ], + [ + 949, + "-1536" + ], + [ + 956, + "-384" + ], + [ + 958, + "192" + ], + [ + 963, + "-384" + ], + [ + 964, + "-504" + ], + [ + 965, + "-192" + ], + [ + 970, + "-384" + ], + [ + 973, + "384" + ], + [ + 981, + "-384" + ], + [ + 988, + "192" + ], + [ + 989, + "-768" + ], + [ + 992, + "768" + ], + [ + 996, + "384" + ], + [ + 1001, + "-480" + ], + [ + 1003, + "-384" + ], + [ + 1009, + "288" + ], + [ + 1011, + "516" + ], + [ + 1019, + "384" + ], + [ + 1022, + "-384" + ], + [ + 1024, + "90" + ], + [ + 1025, + "-960" + ], + [ + 1026, + "-504" + ], + [ + 1029, + "-384" + ], + [ + 1031, + "-438" + ], + [ + 1037, + "-1090" + ], + [ + 1038, + "-864" + ], + [ + 1040, + "1120" + ], + [ + 1045, + "1728" + ], + [ + 1051, + "192" + ], + [ + 1052, + "960" + ], + [ + 1054, + "120" + ], + [ + 1057, + "-24" + ], + [ + 1070, + "96" + ], + [ + 1073, + "-192" + ], + [ + 1080, + "-48" + ], + [ + 1082, + "-384" + ], + [ + 1088, + "366" + ], + [ + 1090, + "-192" + ], + [ + 1094, + "-384" + ], + [ + 1096, + "-24" + ], + [ + 1097, + "-688" + ], + [ + 1098, + "192" + ], + [ + 1100, + "-1920" + ], + [ + 1101, + "72" + ], + [ + 1102, + "-96" + ], + [ + 1106, + "-240" + ], + [ + 1108, + "-192" + ], + [ + 1111, + "-384" + ], + [ + 1115, + "384" + ], + [ + 1117, + "192" + ], + [ + 1118, + "-96" + ], + [ + 1123, + "888" + ], + [ + 1124, + "168" + ], + [ + 1126, + "96" + ], + [ + 1132, + "192" + ], + [ + 1138, + "-69" + ], + [ + 1139, + "-384" + ], + [ + 1140, + "-1536" + ], + [ + 1141, + "-96" + ], + [ + 1145, + "-192" + ], + [ + 1146, + "192" + ], + [ + 1148, + "192" + ], + [ + 1154, + "960" + ] + ], + "return_direction": [ + [ + 126, + "1" + ], + [ + 390, + "4" + ], + [ + 879, + "-32" + ], + [ + 1011, + "16" + ], + [ + 1024, + "-16" + ], + [ + 1123, + "-28" + ], + [ + 1124, + "-24" + ] + ], + "role": 126, + "source_chart": 127, + "source_covector": [ + [ + 16, + "-48" + ], + [ + 333, + "36" + ], + [ + 384, + "192" + ], + [ + 386, + "-3" + ], + [ + 388, + "144" + ], + [ + 391, + "36" + ], + [ + 414, + "-144" + ], + [ + 435, + "144" + ], + [ + 470, + "-36" + ], + [ + 483, + "-72" + ], + [ + 496, + "-36" + ], + [ + 519, + "144" + ], + [ + 521, + "-36" + ], + [ + 528, + "36" + ], + [ + 552, + "72" + ], + [ + 553, + "-72" + ], + [ + 555, + "-36" + ], + [ + 559, + "36" + ], + [ + 565, + "-36" + ], + [ + 574, + "72" + ], + [ + 581, + "36" + ], + [ + 678, + "8" + ], + [ + 696, + "-72" + ], + [ + 700, + "108" + ], + [ + 705, + "8" + ], + [ + 706, + "24" + ], + [ + 712, + "-32" + ], + [ + 736, + "-24" + ], + [ + 757, + "-80" + ], + [ + 762, + "-48" + ], + [ + 811, + "-180" + ], + [ + 879, + "36" + ], + [ + 891, + "-72" + ], + [ + 905, + "18" + ], + [ + 927, + "27" + ], + [ + 931, + "-36" + ], + [ + 934, + "-72" + ], + [ + 964, + "-72" + ], + [ + 1024, + "-78" + ], + [ + 1026, + "-72" + ], + [ + 1031, + "-18" + ], + [ + 1037, + "18" + ], + [ + 1080, + "16" + ], + [ + 1088, + "18" + ], + [ + 1101, + "-72" + ], + [ + 1106, + "-144" + ], + [ + 1123, + "-72" + ], + [ + 1124, + "72" + ], + [ + 1138, + "-27" + ] + ], + "source_direction": [ + [ + 126, + "1" + ], + [ + 390, + "4" + ], + [ + 879, + "-32" + ], + [ + 1011, + "16" + ], + [ + 1024, + "-16" + ], + [ + 1123, + "-28" + ], + [ + 1124, + "-24" + ] + ], + "split_chart": 498 + }, + "max_changed_coefficient_bits": 15, + "native_delta": { + "paid": { + "2": 1, + "5": 1, + "7": -1 + }, + "targets": { + "4": 1, + "5": 1, + "9": -1 + } + }, + "new_paid": 69, + "old_paid_charts": [ + 127, + 488 + ], + "paid_daughter_ranks": [ + 5, + 2 + ], + "replay": { + "affected_rows": 395, + "expected_fresh_input_row": { + "1277": "1" + }, + "literal_row_delta_sha256": "4229b34cf8d4d71f4cf10f2e3c151535a69efdb3934a9f127b1f81fbd3ac1dd6", + "new_owner_label": 1530, + "omitted_fresh_input_row": { + "16": "-288", + "19": "-384", + "21": "-192", + "30": "-384", + "38": "-384", + "60": "-768", + "112": "192", + "114": "192", + "116": "192", + "117": "192", + "118": "192", + "120": "192", + "121": "-384", + "122": "-192", + "123": "-192", + "125": "192", + "126": "-6", + "128": "-192", + "130": "192", + "131": "192", + "134": "-192", + "135": "-192", + "137": "192", + "139": "192", + "140": "384", + "141": "192", + "142": "192", + "143": "-192", + "144": "192", + "147": "-192", + "148": "192", + "149": "192", + "150": "192", + "153": "-192", + "154": "-192", + "156": "-192", + "161": "192", + "162": "192", + "163": "-192", + "166": "-192", + "167": "-192", + "169": "-384", + "170": "192", + "171": "384", + "172": "384", + "173": "-192", + "174": "-192", + "175": "-192", + "178": "192", + "179": "192", + "180": "384", + "181": "384", + "182": "192", + "183": "192", + "184": "384", + "187": "192", + "191": "-192", + "192": "384", + "193": "-192", + "195": "192", + "196": "192", + "198": "192", + "199": "384", + "200": "192", + "202": "192", + "203": "192", + "204": "-192", + "206": "-192", + "208": "192", + "209": "192", + "210": "192", + "212": "-192", + "215": "192", + "216": "-384", + "217": "-192", + "218": "-192", + "219": "-192", + "222": "-192", + "223": "-192", + "228": "-192", + "230": "96", + "235": "-288", + "241": "-192", + "244": "-96", + "249": "192", + "250": "-3120", + "252": "384", + "254": "-192", + "255": "-384", + "260": "-384", + "261": "-384", + "266": "-192", + "272": "192", + "273": "-5472", + "276": "192", + "278": "-192", + "279": "-192", + "299": "384", + "302": "768", + "304": "384", + "307": "192", + "308": "-384", + "309": "-384", + "314": "-384", + "322": "-192", + "328": "960", + "332": "-192", + "333": "276", + "335": "-96", + "338": "384", + "342": "192", + "343": "192", + "347": "192", + "349": "96", + "350": "192", + "356": "-96", + "362": "-960", + "364": "-1728", + "375": "3120", + "384": "-2016", + "386": "-18", + "388": "1104", + "390": "2112", + "391": "180", + "401": "960", + "402": "480", + "406": "-384", + "408": "384", + "409": "384", + "410": "192", + "411": "384", + "412": "-1560", + "413": "5856", + "414": "-1488", + "416": "384", + "417": "-384", + "418": "-192", + "420": "-384", + "421": "768", + "424": "384", + "428": "-192", + "429": "-192", + "431": "96", + "433": "384", + "435": "1104", + "436": "384", + "437": "384", + "440": "-96", + "442": "192", + "443": "384", + "444": "-12480", + "445": "-384", + "447": "-384", + "448": "96", + "451": "-96", + "452": "384", + "453": "384", + "454": "-192", + "456": "192", + "458": "192", + "459": "192", + "460": "3120", + "461": "960", + "463": "192", + "464": "192", + "465": "192", + "470": "-276", + "474": "384", + "479": "-768", + "481": "-96", + "483": "-744", + "485": "384", + "486": "-768", + "490": "-192", + "491": "-96", + "496": "-372", + "504": "-3120", + "505": "3120", + "508": "384", + "509": "384", + "511": "192", + "512": "384", + "518": "-384", + "519": "720", + "521": "-276", + "522": "96", + "523": "-5856", + "524": "5460", + "526": "2049", + "527": "-384", + "528": "276", + "529": "-96", + "535": "-384", + "537": "-96", + "546": "-576", + "547": "-288", + "552": "744", + "553": "-360", + "555": "-564", + "559": "948", + "565": "-1140", + "566": "384", + "568": "-288", + "572": "192", + "574": "744", + "578": "384", + "579": "768", + "581": "276", + "588": "-864", + "603": "-1536", + "608": "1728", + "609": "192", + "610": "-384", + "623": "96", + "624": "192", + "630": "-96", + "638": "384", + "645": "384", + "650": "-1170", + "651": "-1632", + "666": "-192", + "678": "48", + "679": "960", + "696": "-1704", + "700": "252", + "705": "48", + "706": "144", + "712": "-192", + "736": "-144", + "757": "-480", + "762": "-288", + "811": "-900", + "874": "-1920", + "876": "192", + "879": "-240", + "888": "-192", + "890": "768", + "891": "216", + "893": "-3120", + "905": "138", + "921": "576", + "927": "303", + "931": "364", + "933": "48", + "934": "216", + "935": "-576", + "937": "-960", + "946": "192", + "949": "-1536", + "956": "-384", + "958": "192", + "963": "-384", + "964": "-936", + "965": "-192", + "970": "-384", + "973": "384", + "981": "-384", + "988": "192", + "989": "-768", + "992": "768", + "996": "384", + "1001": "-480", + "1003": "-384", + "1009": "288", + "1011": "516", + "1019": "384", + "1022": "-384", + "1024": "-378", + "1025": "-960", + "1026": "-936", + "1029": "-384", + "1031": "-546", + "1037": "-982", + "1038": "-864", + "1040": "1120", + "1045": "1728", + "1051": "192", + "1052": "960", + "1054": "120", + "1057": "-24", + "1070": "96", + "1073": "-192", + "1080": "48", + "1082": "-384", + "1088": "474", + "1090": "-192", + "1094": "-384", + "1096": "-24", + "1097": "-688", + "1098": "192", + "1100": "-1920", + "1101": "-360", + "1102": "-96", + "1106": "-1104", + "1108": "-192", + "1111": "-384", + "1115": "384", + "1117": "192", + "1118": "-96", + "1123": "456", + "1124": "600", + "1126": "96", + "1132": "192", + "1138": "-231", + "1139": "-384", + "1140": "-1536", + "1141": "-96", + "1145": "-192", + "1146": "192", + "1148": "192", + "1154": "960" + }, + "original_oriented_paid_row": [ + [ + -763, + "1/2" + ], + [ + -706, + "-1/2" + ] + ], + "original_owner_label": 126, + "parent_sha256": "3785d35782396c6ac5d098b60d27fa5afab0576f9d3c10e5afe64503822e44a6", + "result_sha256": "46420023b4846fb287f6ea8088d7a375f8997aabc8310f3f54583d563e7cf79b" + }, + "source_paid": 97908, + "target_daughter_ranks": [ + 5, + 4 + ] + } + ] +} diff --git a/research/p104-subdivided-helper-births/complex/FINAL-BIRTH.json b/research/p104-subdivided-helper-births/complex/FINAL-BIRTH.json new file mode 100644 index 0000000000..18d111866b --- /dev/null +++ b/research/p104-subdivided-helper-births/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-subdivided-helper-births/complex/INDEPENDENT.json b/research/p104-subdivided-helper-births/complex/INDEPENDENT.json new file mode 100644 index 0000000000..f6e74f3ee8 --- /dev/null +++ b/research/p104-subdivided-helper-births/complex/INDEPENDENT.json @@ -0,0 +1,2486 @@ +{ + "base": { + "adjoint_rows": 1264, + "adjoint_sha256": "a86b681a0cc0f5eb08d15ad0778e0b702f1d4a7c0eb2adbdd22f6d0654ae7fa9", + "content_sha256": "934b7d4d792a5771bbcd28053d7797a9938f6b23faddaafe46451158eec81849", + "forms": 6965, + "forward_rows": 1264, + "forward_sha256": "443f93ec7d06ea2c86c2b650e04cfae50af728e88c9fd71025572c4c8d1a7b52", + "helpers": 864, + "main": 400, + "native_paid": { + "1": 3835, + "2": 797, + "3": 489, + "4": 223, + "5": 295, + "6": 55, + "7": 5, + "8": 2 + }, + "native_productive": { + "1": 18, + "2": 7, + "3": 7, + "4": 220, + "5": 11, + "7": 15, + "8": 35, + "9": 551 + }, + "paid_moves": 5701, + "public": 1264, + "rational_literals": 204869 + }, + "base_layout": { + "content_sha256": "d233f9ba1fc39c4be51685a45da1940fe43dc3a3fd7699a8b27339e1e063b489" + }, + "candidate": { + "adjoint_rows": 1279, + "adjoint_sha256": "b1e6c29feaf1a5b77580265507ed85b7b903f670ba98673158e09c8ff5da61be", + "content_sha256": "03ef8f6cc9ebb7394b5c7f8da70d44df965659ae4ff361bbc8d32c7a12121445", + "forms": 6993, + "forward_rows": 1279, + "forward_sha256": "a3b9d6bc44d5ee8b8c19772dde94b53e197f2457b8d6e84d69d93b8070b81748", + "helpers": 879, + "main": 400, + "native_paid": { + "1": 3850, + "2": 795, + "3": 489, + "4": 222, + "5": 307, + "6": 45, + "7": 4, + "8": 2 + }, + "native_productive": { + "1": 18, + "2": 7, + "3": 8, + "4": 235, + "5": 25, + "7": 15, + "8": 33, + "9": 538 + }, + "paid_moves": 5714, + "public": 1279, + "rational_literals": 211660 + }, + "candidate_layout": { + "content_sha256": "37c04b0a349c1b7f7ada22533d3e4e6bacb42e4c6549f4257f4cbcae189a0275" + }, + "checker_sha256": "0b428bc6fac4dc6ec014114bf4119782553fbb58d92b2a632b51629f4abe563b", + "closed_caller": { + "exact_local_operators": { + "A": { + "exponent_bits": 4, + "maximum_stage_occurrences": 15, + "minimum_grid": 4, + "peak_mass": "256", + "peak_native_entrance_mass": "26", + "preproduct_divisions": 2686, + "separate_component_divisions": 9904 + }, + "rotated": { + "exponent_bits": 4, + "maximum_stage_occurrences": 15, + "minimum_grid": 8, + "peak_mass": "212", + "peak_native_entrance_mass": "91/2", + "preproduct_divisions": 8308, + "separate_component_divisions": 17868 + } + }, + "finite_binding": { + "ambient": 137, + "calls": 48, + "helper_label_sha256": "a556892af9b70ab70ddf7383e3d93a1df87c60eefbf105b704b35ae2c016f16d", + "local_colors": 16, + "native_main_bindings": 19200, + "physical_port_contacts": 4992, + "root_owners": 9840, + "stage_binding_sha256": "b97fe2d7a114d8dc85629ce3a486443d7bf59c7f757c5e6fa2258548e2f51afd", + "stage_helper_owners": 42192, + "template_roots": { + "A": 120, + "rotated": 192 + } + }, + "fixed_paid": { + "1": 480, + "8": 1248, + "16": 1248, + "24": 1248, + "32": 1248, + "40": 1248, + "48": 1248, + "56": 1248 + }, + "fixed_targets": { + "9": 480, + "17": 1248, + "25": 1248, + "33": 1248, + "41": 1248, + "49": 1248, + "57": 1248, + "65": 1248, + "129": 624 + }, + "readback": { + "event_stream_sha256": "156fdf3a4a129b39225fd6ca51011de27974d7f104e8b04907c17ed5344bc858", + "events": 840912, + "op_counts": { + "ADD": 575856, + "IDLE_ONE": 8736, + "LAMBDA": 30000, + "NATIVE": 48, + "PORT_VIEWS": 96, + "QUERY": 480, + "SCALE": 128688, + "SWAP": 97008 + } + } + }, + "fault_controls": { + "changed_paid_signs": { + "all_rows_directly_replayed_after_sign_mutations": [ + { + "mutated_adjoint_sha256": "5dc3afe258e51666ef87897f41a37f5570c6e9c0a4ab07dd6baed383f3a7c132", + "mutated_forward_sha256": "c1d34b796a7738cd14866b6bfd5a37d30e26f9d87c03458ad4f1ddfc0fe5eaeb", + "paid_key": 58 + }, + { + "mutated_adjoint_sha256": "973300ab5e0f728201b35e3a3a289232577dfa93569aea80b3dd0429bc9f74df", + "mutated_forward_sha256": "1f09352451fab4b58188eaa5eb0b596dac67acafab0d6d1345968b03d0f8abba", + "paid_key": 70 + }, + { + "mutated_adjoint_sha256": "25581630f794f74b6606962d541ed6015f341ccdace434db1d72330b6e7e2693", + "mutated_forward_sha256": "d4033cb1839028a180bcee09d61a4c4ae228a1590e96ed635c7f8cc7e95a53b9", + "paid_key": 71 + } + ], + "nonzero_rank_one_witnesses": [ + { + "faulty_coefficient": "-2", + "first_changed_terminal": 30, + "original_coefficient": "0", + "paid_input_coefficient": "-1/2", + "paid_key": 14, + "source_address": 29, + "terminal_pulse_coefficient": "-2" + }, + { + "faulty_coefficient": "-2", + "first_changed_terminal": 38, + "original_coefficient": "0", + "paid_input_coefficient": "1/10", + "paid_key": 35, + "source_address": 3, + "terminal_pulse_coefficient": "10" + }, + { + "faulty_coefficient": "7/2", + "first_changed_terminal": 17, + "original_coefficient": "0", + "paid_input_coefficient": "7/40", + "paid_key": 57, + "source_address": 3, + "terminal_pulse_coefficient": "-10" + }, + { + "faulty_coefficient": "-4", + "first_changed_terminal": 296, + "original_coefficient": "0", + "paid_input_coefficient": "2", + "paid_key": 58, + "source_address": 2, + "terminal_pulse_coefficient": "1" + }, + { + "faulty_coefficient": "10", + "first_changed_terminal": 40, + "original_coefficient": "0", + "paid_input_coefficient": "1/2", + "paid_key": 59, + "source_address": 21, + "terminal_pulse_coefficient": "-10" + }, + { + "faulty_coefficient": "-1/2", + "first_changed_terminal": 297, + "original_coefficient": "0", + "paid_input_coefficient": "1/4", + "paid_key": 60, + "source_address": 3, + "terminal_pulse_coefficient": "1" + }, + { + "faulty_coefficient": "-2", + "first_changed_terminal": 38, + "original_coefficient": "0", + "paid_input_coefficient": "-1/10", + "paid_key": 61, + "source_address": 3, + "terminal_pulse_coefficient": "-10" + }, + { + "faulty_coefficient": "0", + "first_changed_terminal": 3, + "original_coefficient": "1", + "paid_input_coefficient": "1", + "paid_key": 62, + "source_address": 3, + "terminal_pulse_coefficient": "1/2" + }, + { + "faulty_coefficient": "1", + "first_changed_terminal": 28, + "original_coefficient": "0", + "paid_input_coefficient": "1", + "paid_key": 63, + "source_address": 1, + "terminal_pulse_coefficient": "-1/2" + }, + { + "faulty_coefficient": "-1/2", + "first_changed_terminal": 715, + "original_coefficient": "0", + "paid_input_coefficient": "1/2", + "paid_key": 64, + "source_address": 18, + "terminal_pulse_coefficient": "1/2" + }, + { + "faulty_coefficient": "-2", + "first_changed_terminal": 52, + "original_coefficient": "0", + "paid_input_coefficient": "1/2", + "paid_key": 65, + "source_address": 15, + "terminal_pulse_coefficient": "2" + }, + { + "faulty_coefficient": "1/16", + "first_changed_terminal": 126, + "original_coefficient": "0", + "paid_input_coefficient": "-1/2", + "paid_key": 66, + "source_address": 16, + "terminal_pulse_coefficient": "1/16" + }, + { + "faulty_coefficient": "-2", + "first_changed_terminal": 18, + "original_coefficient": "0", + "paid_input_coefficient": "1/2", + "paid_key": 67, + "source_address": 55, + "terminal_pulse_coefficient": "2" + }, + { + "faulty_coefficient": "-4", + "first_changed_terminal": 297, + "original_coefficient": "0", + "paid_input_coefficient": "-1", + "paid_key": 68, + "source_address": 2, + "terminal_pulse_coefficient": "-2" + }, + { + "faulty_coefficient": "-1/8", + "first_changed_terminal": 705, + "original_coefficient": "0", + "paid_input_coefficient": "-1/8", + "paid_key": 69, + "source_address": 3, + "terminal_pulse_coefficient": "-1/2" + }, + { + "faulty_coefficient": "-8", + "first_changed_terminal": 19, + "original_coefficient": "0", + "paid_input_coefficient": "-8", + "paid_key": 70, + "source_address": 1, + "terminal_pulse_coefficient": "-1/2" + }, + { + "faulty_coefficient": "4", + "first_changed_terminal": 93, + "original_coefficient": "0", + "paid_input_coefficient": "-8", + "paid_key": 71, + "source_address": 331, + "terminal_pulse_coefficient": "1/4" + }, + { + "faulty_coefficient": "-16", + "first_changed_terminal": 19, + "original_coefficient": "0", + "paid_input_coefficient": "-8", + "paid_key": 20000, + "source_address": 1, + "terminal_pulse_coefficient": "-1" + }, + { + "faulty_coefficient": "-1", + "first_changed_terminal": 472, + "original_coefficient": "0", + "paid_input_coefficient": "-1/2", + "paid_key": 20004, + "source_address": 22, + "terminal_pulse_coefficient": "-1" + }, + { + "faulty_coefficient": "2", + "first_changed_terminal": 19, + "original_coefficient": "1", + "paid_input_coefficient": "1/4", + "paid_key": 20008, + "source_address": 19, + "terminal_pulse_coefficient": "-2" + }, + { + "faulty_coefficient": "8", + "first_changed_terminal": 19, + "original_coefficient": "0", + "paid_input_coefficient": "4", + "paid_key": 20009, + "source_address": 1, + "terminal_pulse_coefficient": "-1" + }, + { + "faulty_coefficient": "-4", + "first_changed_terminal": 296, + "original_coefficient": "0", + "paid_input_coefficient": "2", + "paid_key": 91128, + "source_address": 2, + "terminal_pulse_coefficient": "1" + }, + { + "faulty_coefficient": "2", + "first_changed_terminal": 19, + "original_coefficient": "0", + "paid_input_coefficient": "-1/2", + "paid_key": 91933, + "source_address": 16, + "terminal_pulse_coefficient": "2" + }, + { + "faulty_coefficient": "1", + "first_changed_terminal": 138, + "original_coefficient": "0", + "paid_input_coefficient": "-1/2", + "paid_key": 94072, + "source_address": 299, + "terminal_pulse_coefficient": "1" + }, + { + "faulty_coefficient": "-1/4", + "first_changed_terminal": 47, + "original_coefficient": "0", + "paid_input_coefficient": "1/16", + "paid_key": 95397, + "source_address": 3, + "terminal_pulse_coefficient": "2" + }, + { + "faulty_coefficient": "-4", + "first_changed_terminal": 30, + "original_coefficient": "0", + "paid_input_coefficient": "1", + "paid_key": 95398, + "source_address": 835, + "terminal_pulse_coefficient": "2" + }, + { + "faulty_coefficient": "-1/4", + "first_changed_terminal": 47, + "original_coefficient": "0", + "paid_input_coefficient": "1/16", + "paid_key": 95845, + "source_address": 3, + "terminal_pulse_coefficient": "2" + }, + { + "faulty_coefficient": "1/3444", + "first_changed_terminal": 40, + "original_coefficient": "0", + "paid_input_coefficient": "1/68880", + "paid_key": 95923, + "source_address": 1272, + "terminal_pulse_coefficient": "-10" + }, + { + "faulty_coefficient": "4", + "first_changed_terminal": 297, + "original_coefficient": "0", + "paid_input_coefficient": "1", + "paid_key": 96016, + "source_address": 2, + "terminal_pulse_coefficient": "-2" + }, + { + "faulty_coefficient": "-3/4", + "first_changed_terminal": 19, + "original_coefficient": "0", + "paid_input_coefficient": "-3/16", + "paid_key": 96075, + "source_address": 3, + "terminal_pulse_coefficient": "-2" + }, + { + "faulty_coefficient": "-1/2", + "first_changed_terminal": 173, + "original_coefficient": "0", + "paid_input_coefficient": "1", + "paid_key": 96076, + "source_address": 774, + "terminal_pulse_coefficient": "1/4" + }, + { + "faulty_coefficient": "4", + "first_changed_terminal": 19, + "original_coefficient": "0", + "paid_input_coefficient": "1", + "paid_key": 96082, + "source_address": 774, + "terminal_pulse_coefficient": "-2" + }, + { + "faulty_coefficient": "3/8", + "first_changed_terminal": 117, + "original_coefficient": "0", + "paid_input_coefficient": "-3/16", + "paid_key": 96270, + "source_address": 3, + "terminal_pulse_coefficient": "1" + }, + { + "faulty_coefficient": "-3/4", + "first_changed_terminal": 17, + "original_coefficient": "0", + "paid_input_coefficient": "3/16", + "paid_key": 96271, + "source_address": 3, + "terminal_pulse_coefficient": "2" + }, + { + "faulty_coefficient": "-3/4", + "first_changed_terminal": 17, + "original_coefficient": "0", + "paid_input_coefficient": "-3/16", + "paid_key": 96283, + "source_address": 3, + "terminal_pulse_coefficient": "-2" + }, + { + "faulty_coefficient": "-4", + "first_changed_terminal": 297, + "original_coefficient": "0", + "paid_input_coefficient": "2", + "paid_key": 96518, + "source_address": 9, + "terminal_pulse_coefficient": "1" + }, + { + "faulty_coefficient": "8", + "first_changed_terminal": 30, + "original_coefficient": "0", + "paid_input_coefficient": "1", + "paid_key": 97730, + "source_address": 794, + "terminal_pulse_coefficient": "-4" + }, + { + "faulty_coefficient": "-1/8", + "first_changed_terminal": 705, + "original_coefficient": "0", + "paid_input_coefficient": "-1/8", + "paid_key": 97908, + "source_address": 3, + "terminal_pulse_coefficient": "-1/2" + }, + { + "faulty_coefficient": "-5/4", + "first_changed_terminal": 38, + "original_coefficient": "0", + "paid_input_coefficient": "-1/16", + "paid_key": 98406, + "source_address": 3, + "terminal_pulse_coefficient": "-10" + }, + { + "faulty_coefficient": "1/2", + "first_changed_terminal": 38, + "original_coefficient": "0", + "paid_input_coefficient": "-1/40", + "paid_key": 98411, + "source_address": 3, + "terminal_pulse_coefficient": "10" + }, + { + "faulty_coefficient": "3", + "first_changed_terminal": 17, + "original_coefficient": "0", + "paid_input_coefficient": "3/20", + "paid_key": 98796, + "source_address": 3, + "terminal_pulse_coefficient": "-10" + }, + { + "faulty_coefficient": "-4", + "first_changed_terminal": 30, + "original_coefficient": "0", + "paid_input_coefficient": "1", + "paid_key": 99468, + "source_address": 835, + "terminal_pulse_coefficient": "2" + }, + { + "faulty_coefficient": "-1", + "first_changed_terminal": 28, + "original_coefficient": "0", + "paid_input_coefficient": "1", + "paid_key": 99514, + "source_address": 1, + "terminal_pulse_coefficient": "1/2" + }, + { + "faulty_coefficient": "8", + "first_changed_terminal": 19, + "original_coefficient": "0", + "paid_input_coefficient": "-1", + "paid_key": 99516, + "source_address": 1, + "terminal_pulse_coefficient": "4" + }, + { + "faulty_coefficient": "3", + "first_changed_terminal": 28, + "original_coefficient": "0", + "paid_input_coefficient": "3/4", + "paid_key": 99518, + "source_address": 1, + "terminal_pulse_coefficient": "-2" + }, + { + "faulty_coefficient": "-2", + "first_changed_terminal": 19, + "original_coefficient": "0", + "paid_input_coefficient": "1", + "paid_key": 99623, + "source_address": 1, + "terminal_pulse_coefficient": "1" + }, + { + "faulty_coefficient": "1/4", + "first_changed_terminal": 185, + "original_coefficient": "0", + "paid_input_coefficient": "-1/8", + "paid_key": 99737, + "source_address": 3, + "terminal_pulse_coefficient": "1" + }, + { + "faulty_coefficient": "-2", + "first_changed_terminal": 47, + "original_coefficient": "0", + "paid_input_coefficient": "-1/2", + "paid_key": 99738, + "source_address": 22, + "terminal_pulse_coefficient": "-2" + }, + { + "faulty_coefficient": "0", + "first_changed_terminal": 3, + "original_coefficient": "1", + "paid_input_coefficient": "1", + "paid_key": 99767, + "source_address": 3, + "terminal_pulse_coefficient": "1/2" + }, + { + "faulty_coefficient": "2", + "first_changed_terminal": 19, + "original_coefficient": "0", + "paid_input_coefficient": "-1/2", + "paid_key": 101037, + "source_address": 1, + "terminal_pulse_coefficient": "2" + }, + { + "faulty_coefficient": "1/4", + "first_changed_terminal": 185, + "original_coefficient": "0", + "paid_input_coefficient": "-1/8", + "paid_key": 101106, + "source_address": 3, + "terminal_pulse_coefficient": "1" + }, + { + "faulty_coefficient": "-1/2", + "first_changed_terminal": 117, + "original_coefficient": "0", + "paid_input_coefficient": "1/4", + "paid_key": 101126, + "source_address": 19, + "terminal_pulse_coefficient": "1" + }, + { + "faulty_coefficient": "1", + "first_changed_terminal": 28, + "original_coefficient": "0", + "paid_input_coefficient": "1", + "paid_key": 103583, + "source_address": 1, + "terminal_pulse_coefficient": "-1/2" + }, + { + "faulty_coefficient": "-1/2", + "first_changed_terminal": 715, + "original_coefficient": "0", + "paid_input_coefficient": "1/2", + "paid_key": 103820, + "source_address": 18, + "terminal_pulse_coefficient": "1/2" + }, + { + "faulty_coefficient": "-4", + "first_changed_terminal": 17, + "original_coefficient": "0", + "paid_input_coefficient": "1/2", + "paid_key": 104234, + "source_address": 55, + "terminal_pulse_coefficient": "4" + }, + { + "faulty_coefficient": "-4", + "first_changed_terminal": 52, + "original_coefficient": "0", + "paid_input_coefficient": "1", + "paid_key": 104442, + "source_address": 15, + "terminal_pulse_coefficient": "2" + } + ], + "recharted_paid_keys_with_zero_public_impulse": [] + }, + "occupied_public_owner_label_rejected": true + }, + "free_productive_subdivision": { + "common_paid_move_count": 5714, + "common_paid_moves_sha256": "b96ab569eca5626a2c3babbfc0b0029d580e16f11133bcbf137f1942a544c7b9", + "complete_target_delta": { + "4": 96, + "8": -48 + }, + "full_signed_credit": [ + "1.021560744930218243078566317169008625353446922936648665655", + "1.021560744930218243078566317169008625353446922936648665656" + ], + "literal_coefficient_count_delta": -992, + "literal_paid_delta": {}, + "owners": [ + { + "fresh_address": 1278, + "fresh_charts": [ + 232, + 517 + ], + "fresh_label": 1531, + "matching_chart_pairs_remaining": 1, + "old_charts": [ + 3, + 517 + ], + "original_address": 1164, + "original_charts": [ + 3, + 232 + ], + "original_label": 1307, + "ranks": [ + 8, + 4, + 4 + ] + } + ], + "predecessor": { + "content_sha256": "6eba6bb65015df98cf103ce6d12fdd982ba4dcd24a69000bcc58e05477b17c19" + }, + "removal_controls": [ + { + "changed_form_keys": [ + 155932 + ], + "mutated_adjoint_sha256": "cf64ffb4238e46ff4c77a4204411cbead1afe5d7d17a935c3124190e8ed2e6c5", + "mutated_coefficient": "0", + "mutated_forward_sha256": "d13dd65e8501dc18c824726004a0a45e596ea35ccc93b2959d9c23c2e7589dd0", + "normal_coefficient": "1", + "operation": "original_projection", + "source_address": 1164, + "terminal_address": 1164 + }, + { + "changed_form_keys": [ + 156046 + ], + "mutated_adjoint_sha256": "2c4a182864452a5429213d083acf981b4f9a53b72a311ad4cd728d58c64f6fff", + "mutated_coefficient": "0", + "mutated_forward_sha256": "b7f6c21f1301b72f16c0ce69706f8215003bcb3e8a9cf9c9cb1ac7f6cad1c136", + "normal_coefficient": "1", + "operation": "fresh_projection", + "source_address": 1278, + "terminal_address": 1278 + }, + { + "changed_form_keys": [ + 92740, + 98411, + 98796 + ], + "mutated_adjoint_sha256": "2c4a182864452a5429213d083acf981b4f9a53b72a311ad4cd728d58c64f6fff", + "mutated_coefficient": "0", + "mutated_forward_sha256": "b7f6c21f1301b72f16c0ce69706f8215003bcb3e8a9cf9c9cb1ac7f6cad1c136", + "normal_coefficient": "1", + "operation": "fresh_input_pulse", + "source_address": 1278, + "terminal_address": 1278 + } + ] + }, + "full_invoice": { + "additional_candidate_margins": { + "0.00386896184248": [ + "0.8688467449517522707643439024162297189713590983560831017149", + "0.8688467449517522707643439024162297189713590983560831017150" + ], + "0.00386969950": [ + "0.1154855949300981406777876972171817132705911877109805192512", + "0.1154855949300981406777876972171817132705911877109805192513" + ] + }, + "base": { + "paid": { + "1": 184560, + "2": 38256, + "3": 23472, + "4": 10704, + "5": 14160, + "6": 2640, + "7": 240, + "8": 1344, + "16": 1248, + "24": 1248, + "32": 1248, + "40": 1248, + "48": 1248, + "56": 1248 + }, + "targets": { + "1": 864, + "2": 336, + "3": 336, + "4": 10560, + "5": 528, + "7": 720, + "8": 1680, + "9": 26928, + "17": 1248, + "25": 1248, + "33": 1248, + "41": 1248, + "49": 1248, + "57": 1248, + "65": 1248, + "129": 624 + } + }, + "base_margin": [ + "-4.590079866111177038591549125631653695235302259430325717010", + "-4.590079866111177038591549125631653695235302259430325717009" + ], + "candidate": { + "paid": { + "1": 185280, + "2": 38160, + "3": 23472, + "4": 10656, + "5": 14736, + "6": 2160, + "7": 192, + "8": 1344, + "16": 1248, + "24": 1248, + "32": 1248, + "40": 1248, + "48": 1248, + "56": 1248 + }, + "targets": { + "1": 864, + "2": 336, + "3": 384, + "4": 11280, + "5": 1200, + "7": 720, + "8": 1584, + "9": 26304, + "17": 1248, + "25": 1248, + "33": 1248, + "41": 1248, + "49": 1248, + "57": 1248, + "65": 1248, + "129": 624 + } + }, + "candidate_margin": [ + "6.135683366630429532171595212612438785407584024092883936916", + "6.135683366630429532171595212612438785407584024092883936917" + ], + "paid_delta": { + "1": 720, + "2": -96, + "4": -48, + "5": 576, + "6": -480, + "7": -48 + }, + "saving": [ + "10.72576323274160657076314433824409248064288628352320965392", + "10.72576323274160657076314433824409248064288628352320965393" + ], + "target_delta": { + "3": 48, + "4": 720, + "5": 672, + "8": -96, + "9": -624 + } + }, + "held_owner_clear": { + "addressed_cells_cleared": 61112, + "guards_preserved": true, + "homes": 8273, + "occupied_sender_rejected_at": [ + 71, + 59, + 65, + 68, + 58, + 57, + 35, + 64, + 61, + 67, + 62, + 60, + 66, + 69, + 70, + 63 + ], + "partially_cleared_sender_rejected_at": [ + 71, + 59, + 65, + 68, + 58, + 57, + 35, + 64, + 61, + 67, + 62, + 60, + 66, + 69, + 70, + 63 + ], + "same_owner_returns": 1279, + "scope": "normalized rational held-home fixture, four independent components" + }, + "original_and_fresh_owners": [ + { + "fresh_address": 1274, + "fresh_charts": [ + 3, + 498 + ], + "fresh_label": 1527, + "matching_chart_pairs_remaining": 2, + "old_charts": [ + 3, + 127 + ], + "original_address": 126, + "original_charts": [ + 498, + 127 + ], + "original_label": 126, + "ranks": [ + 9, + 5, + 4 + ] + }, + { + "fresh_address": 1264, + "fresh_charts": [ + 232, + 127 + ], + "fresh_label": 1517, + "matching_chart_pairs_remaining": 3, + "old_charts": [ + 3, + 127 + ], + "original_address": 133, + "original_charts": [ + 3, + 232 + ], + "original_label": 133, + "ranks": [ + 9, + 4, + 5 + ] + }, + { + "fresh_address": 1275, + "fresh_charts": [ + 3, + 234 + ], + "fresh_label": 1528, + "matching_chart_pairs_remaining": 1, + "old_charts": [ + 3, + 127 + ], + "original_address": 236, + "original_charts": [ + 234, + 127 + ], + "original_label": 237, + "ranks": [ + 9, + 5, + 4 + ] + }, + { + "fresh_address": 1270, + "fresh_charts": [ + 243, + 127 + ], + "fresh_label": 1523, + "matching_chart_pairs_remaining": 1, + "old_charts": [ + 3, + 127 + ], + "original_address": 258, + "original_charts": [ + 3, + 243 + ], + "original_label": 262, + "ranks": [ + 9, + 4, + 5 + ] + }, + { + "fresh_address": 1267, + "fresh_charts": [ + 234, + 127 + ], + "fresh_label": 1520, + "matching_chart_pairs_remaining": 2, + "old_charts": [ + 3, + 127 + ], + "original_address": 324, + "original_charts": [ + 3, + 234 + ], + "original_label": 338, + "ranks": [ + 9, + 4, + 5 + ] + }, + { + "fresh_address": 1272, + "fresh_charts": [ + 234, + 127 + ], + "fresh_label": 1525, + "matching_chart_pairs_remaining": 1, + "old_charts": [ + 3, + 127 + ], + "original_address": 326, + "original_charts": [ + 3, + 234 + ], + "original_label": 340, + "ranks": [ + 9, + 4, + 5 + ] + }, + { + "fresh_address": 1277, + "fresh_charts": [ + 3, + 498 + ], + "fresh_label": 1530, + "matching_chart_pairs_remaining": 1, + "old_charts": [ + 3, + 127 + ], + "original_address": 386, + "original_charts": [ + 498, + 127 + ], + "original_label": 411, + "ranks": [ + 9, + 5, + 4 + ] + }, + { + "fresh_address": 1265, + "fresh_charts": [ + 232, + 127 + ], + "fresh_label": 1518, + "matching_chart_pairs_remaining": 2, + "old_charts": [ + 3, + 127 + ], + "original_address": 683, + "original_charts": [ + 3, + 232 + ], + "original_label": 793, + "ranks": [ + 9, + 4, + 5 + ] + }, + { + "fresh_address": 1273, + "fresh_charts": [ + 1090, + 127 + ], + "fresh_label": 1526, + "matching_chart_pairs_remaining": 1, + "old_charts": [ + 3, + 127 + ], + "original_address": 878, + "original_charts": [ + 3, + 1090 + ], + "original_label": 992, + "ranks": [ + 9, + 4, + 5 + ] + }, + { + "fresh_address": 1269, + "fresh_charts": [ + 232, + 127 + ], + "fresh_label": 1522, + "matching_chart_pairs_remaining": 1, + "old_charts": [ + 3, + 127 + ], + "original_address": 892, + "original_charts": [ + 3, + 232 + ], + "original_label": 1007, + "ranks": [ + 9, + 4, + 5 + ] + }, + { + "fresh_address": 1266, + "fresh_charts": [ + 306, + 127 + ], + "fresh_label": 1519, + "matching_chart_pairs_remaining": 3, + "old_charts": [ + 3, + 127 + ], + "original_address": 942, + "original_charts": [ + 3, + 306 + ], + "original_label": 1058, + "ranks": [ + 9, + 4, + 5 + ] + }, + { + "fresh_address": 1271, + "fresh_charts": [ + 240, + 127 + ], + "fresh_label": 1524, + "matching_chart_pairs_remaining": 1, + "old_charts": [ + 3, + 127 + ], + "original_address": 959, + "original_charts": [ + 3, + 240 + ], + "original_label": 1075, + "ranks": [ + 9, + 4, + 5 + ] + }, + { + "fresh_address": 1268, + "fresh_charts": [ + 306, + 127 + ], + "fresh_label": 1521, + "matching_chart_pairs_remaining": 2, + "old_charts": [ + 3, + 127 + ], + "original_address": 990, + "original_charts": [ + 3, + 306 + ], + "original_label": 1106, + "ranks": [ + 9, + 4, + 5 + ] + }, + { + "fresh_address": 1278, + "fresh_charts": [ + 232, + 517 + ], + "fresh_label": 1531, + "matching_chart_pairs_remaining": 1, + "old_charts": [ + 3, + 517 + ], + "original_address": 1164, + "original_charts": [ + 3, + 232 + ], + "original_label": 1307, + "ranks": [ + 8, + 4, + 4 + ] + }, + { + "fresh_address": 1276, + "fresh_charts": [ + 306, + 127 + ], + "fresh_label": 1529, + "matching_chart_pairs_remaining": 1, + "old_charts": [ + 2, + 127 + ], + "original_address": 1254, + "original_charts": [ + 2, + 306 + ], + "original_label": 1501, + "ranks": [ + 8, + 3, + 5 + ] + } + ], + "other_paid_changes": { + "other_new_keys": { + "70": [ + 712, + 867 + ], + "71": [ + 3, + 240 + ] + }, + "other_recharted_keys": { + "14": [ + [ + 411, + 1061 + ], + [ + 411, + 796 + ] + ], + "20000": [ + [ + 712, + 127 + ], + [ + 867, + 127 + ] + ], + "20004": [ + [ + 1063, + 127 + ], + [ + 798, + 127 + ] + ], + "20008": [ + [ + 1040, + 127 + ], + [ + 585, + 127 + ] + ], + "20009": [ + [ + 1061, + 127 + ], + [ + 796, + 127 + ] + ], + "94072": [ + [ + 3, + 712 + ], + [ + 3, + 867 + ] + ], + "95397": [ + [ + 735, + 1063 + ], + [ + 735, + 798 + ] + ], + "95398": [ + [ + 412, + 1063 + ], + [ + 412, + 798 + ] + ], + "95845": [ + [ + 1063, + 1079 + ], + [ + 798, + 1079 + ] + ], + "96075": [ + [ + 571, + 1040 + ], + [ + 571, + 585 + ] + ], + "96076": [ + [ + 450, + 1040 + ], + [ + 450, + 585 + ] + ], + "96082": [ + [ + 1040, + 930 + ], + [ + 585, + 930 + ] + ], + "96270": [ + [ + 450, + 1040 + ], + [ + 450, + 585 + ] + ], + "96271": [ + [ + 571, + 1040 + ], + [ + 571, + 585 + ] + ], + "96283": [ + [ + 1040, + 1044 + ], + [ + 585, + 1044 + ] + ], + "97730": [ + [ + 3, + 1061 + ], + [ + 3, + 796 + ] + ], + "99468": [ + [ + 1063, + 922 + ], + [ + 798, + 922 + ] + ], + "99514": [ + [ + 739, + 1061 + ], + [ + 739, + 796 + ] + ], + "99516": [ + [ + 739, + 1061 + ], + [ + 739, + 796 + ] + ], + "99518": [ + [ + 1061, + 127 + ], + [ + 796, + 127 + ] + ], + "99623": [ + [ + 1061, + 1070 + ], + [ + 796, + 1070 + ] + ], + "99737": [ + [ + 412, + 1063 + ], + [ + 412, + 798 + ] + ], + "99738": [ + [ + 735, + 1063 + ], + [ + 735, + 798 + ] + ], + "101037": [ + [ + 1061, + 920 + ], + [ + 796, + 920 + ] + ], + "101106": [ + [ + 1063, + 922 + ], + [ + 798, + 922 + ] + ], + "101126": [ + [ + 1040, + 930 + ], + [ + 585, + 930 + ] + ] + }, + "other_retired_keys": { + "93982": [ + 3, + 394 + ], + "96857": [ + 394, + 240 + ], + "99806": [ + 712, + 867 + ] + }, + "same_chart_changed_form_keys": [ + 5, + 15, + 16, + 17, + 53, + 54, + 55, + 34006, + 88451, + 88453, + 88457, + 88475, + 88477, + 88479, + 88481, + 88487, + 88499, + 88505, + 88526, + 88528, + 88532, + 88534, + 88536, + 88551, + 88572, + 88578, + 88599, + 88601, + 88603, + 88607, + 88609, + 88613, + 88615, + 88702, + 88720, + 88732, + 88738, + 88753, + 88755, + 88759, + 88763, + 88800, + 88804, + 88806, + 88808, + 88823, + 88831, + 88836, + 88857, + 88859, + 88869, + 88874, + 88880, + 88885, + 88898, + 88913, + 88962, + 88964, + 88966, + 88968, + 88970, + 88972, + 88975, + 88979, + 88983, + 88990, + 88993, + 89005, + 89008, + 89012, + 89014, + 89019, + 89021, + 89027, + 89175, + 89320, + 89336, + 89338, + 89342, + 89344, + 89346, + 89348, + 89350, + 89352, + 89356, + 89359, + 89362, + 89374, + 89385, + 89387, + 89402, + 89407, + 89496, + 89498, + 89505, + 89627, + 89742, + 89745, + 89791, + 89794, + 89841, + 89843, + 89845, + 89848, + 89866, + 89890, + 89892, + 89894, + 89919, + 89921, + 89923, + 89925, + 89929, + 89931, + 89933, + 89958, + 89960, + 89964, + 89966, + 89968, + 89970, + 89983, + 89987, + 89989, + 89993, + 89995, + 89997, + 90003, + 90005, + 90007, + 90011, + 90013, + 90015, + 90030, + 90034, + 90036, + 90038, + 90050, + 90052, + 90054, + 90072, + 90081, + 90084, + 90094, + 90096, + 90098, + 90101, + 90132, + 90135, + 90141, + 90265, + 90271, + 90273, + 90277, + 90279, + 90281, + 90283, + 90285, + 90287, + 90307, + 90311, + 90319, + 90334, + 90336, + 90342, + 90344, + 90346, + 90348, + 90352, + 90354, + 90356, + 90369, + 90393, + 90402, + 90540, + 90542, + 90551, + 90553, + 90555, + 90557, + 90563, + 90565, + 90567, + 90569, + 90582, + 90584, + 90586, + 90588, + 90590, + 90592, + 90613, + 90623, + 90630, + 90688, + 90694, + 90696, + 90906, + 90908, + 90910, + 90913, + 90915, + 90919, + 90921, + 90923, + 90925, + 90927, + 90929, + 90931, + 90935, + 90937, + 90945, + 90947, + 90949, + 91075, + 91077, + 91079, + 91087, + 91089, + 91114, + 91148, + 91153, + 91161, + 91163, + 91165, + 91169, + 91172, + 91174, + 91178, + 91209, + 91211, + 91213, + 91220, + 91228, + 91235, + 91237, + 91240, + 91242, + 91248, + 91250, + 91259, + 91261, + 91263, + 91265, + 91269, + 91282, + 91291, + 91294, + 91296, + 91298, + 91301, + 91312, + 91314, + 91316, + 91324, + 91327, + 91338, + 91363, + 91401, + 91403, + 91411, + 91413, + 91415, + 91417, + 91419, + 91423, + 91437, + 91439, + 91441, + 91443, + 91445, + 91447, + 91463, + 91467, + 91473, + 91475, + 91488, + 91490, + 91522, + 91527, + 91687, + 91705, + 91707, + 91709, + 91718, + 91720, + 91734, + 91745, + 91755, + 91889, + 91891, + 91893, + 91896, + 91905, + 91909, + 91913, + 91925, + 91927, + 91943, + 91964, + 91986, + 92024, + 92030, + 92063, + 92111, + 92215, + 92261, + 92263, + 92300, + 92302, + 92312, + 92315, + 92321, + 92323, + 92328, + 92343, + 92347, + 92349, + 92351, + 92353, + 92355, + 92357, + 92363, + 92367, + 92369, + 92378, + 92380, + 92382, + 92388, + 92394, + 92484, + 92486, + 92501, + 92507, + 92509, + 92521, + 92636, + 92637, + 92641, + 92643, + 92740, + 92744, + 92746, + 92748, + 92750, + 92864, + 92868, + 92870, + 92883, + 92885, + 92897, + 92917, + 92922, + 92954, + 92973, + 92985, + 92987, + 92991, + 93014, + 93035, + 93037, + 93041, + 93043, + 93045, + 93047, + 93058, + 93089, + 93093, + 93171, + 93181, + 93193, + 93199, + 93215, + 93221, + 93365, + 93369, + 93371, + 93373, + 93375, + 93378, + 93400, + 93417, + 93427, + 93429, + 93523, + 93526, + 93528, + 93540, + 93547, + 93654, + 93658, + 93670, + 93677, + 93763, + 94005, + 94007, + 94008, + 94009, + 94011, + 94015, + 94017, + 94019, + 94048, + 94050, + 94061, + 94094, + 94101, + 94112, + 94158, + 94161, + 94166, + 94168, + 94170, + 94172, + 94174, + 94178, + 94180, + 94184, + 94283, + 94287, + 94289, + 94291, + 94295, + 94313, + 94318, + 94344, + 94350, + 94448, + 94452, + 94455, + 94457, + 94602, + 94630, + 94683, + 94852, + 94870, + 94872, + 94887, + 94889, + 94923, + 94937, + 94951, + 94958, + 94995, + 94997, + 94999, + 95028, + 95035, + 95042, + 95044, + 95061, + 95062, + 95067, + 95082, + 95227, + 95262, + 95318, + 95336, + 95488, + 95493, + 95658, + 95681, + 95730, + 95769, + 95771, + 95773, + 95776, + 95777, + 95779, + 95798, + 95823, + 95825, + 95853, + 95857, + 95884, + 95889, + 95955, + 95958, + 95975, + 95980, + 95982, + 96061, + 96065, + 96067, + 96073, + 96090, + 96092, + 96095, + 96097, + 96103, + 96105, + 96107, + 96115, + 96117, + 96148, + 96150, + 96155, + 96185, + 96191, + 96227, + 96288, + 96297, + 96301, + 96698, + 96752, + 96764, + 96765, + 96847, + 96944, + 96955, + 96968, + 97129, + 97135, + 97353, + 97390, + 97441, + 97587, + 97589, + 97591, + 97606, + 97725, + 97728, + 97734, + 97744, + 97746, + 97748, + 97751, + 97758, + 97771, + 97773, + 97791, + 97827, + 97855, + 97942, + 97995, + 97997, + 98080, + 98082, + 98084, + 98086, + 98091, + 98195, + 98202, + 98204, + 98210, + 98330, + 98362, + 98407, + 98420, + 98424, + 98427, + 98438, + 98514, + 98842, + 98902, + 99020, + 99022, + 99064, + 99330, + 99333, + 99631, + 99766, + 100072, + 100126, + 100176, + 100178, + 100180, + 100182, + 100184, + 100189, + 100560, + 102512, + 102548, + 103236, + 103244, + 103324, + 103327, + 103595, + 103722, + 103823, + 103891, + 103933, + 103996, + 104021, + 104022, + 104033, + 104169, + 104217, + 104246, + 104254, + 104376, + 104383, + 104384, + 104408, + 104410, + 104418 + ] + }, + "paid_subdivisions": [ + { + "interior_chart": 306, + "matching_chart_pairs_remaining": 1, + "new_leg_charts": [ + 300, + 306 + ], + "new_paid_key": 58, + "old_charts": [ + 300, + 127 + ], + "old_paid_key": 91128, + "ranks": [ + 6, + 5, + 1 + ], + "retained_leg_charts": [ + 306, + 127 + ] + }, + { + "interior_chart": 498, + "matching_chart_pairs_remaining": 2, + "new_leg_charts": [ + 498, + 127 + ], + "new_paid_key": 66, + "old_charts": [ + 494, + 127 + ], + "old_paid_key": 91933, + "ranks": [ + 6, + 1, + 5 + ], + "retained_leg_charts": [ + 494, + 498 + ] + }, + { + "interior_chart": 234, + "matching_chart_pairs_remaining": 1, + "new_leg_charts": [ + 344, + 234 + ], + "new_paid_key": 59, + "old_charts": [ + 344, + 127 + ], + "old_paid_key": 95923, + "ranks": [ + 6, + 5, + 1 + ], + "retained_leg_charts": [ + 234, + 127 + ] + }, + { + "interior_chart": 306, + "matching_chart_pairs_remaining": 1, + "new_leg_charts": [ + 299, + 306 + ], + "new_paid_key": 68, + "old_charts": [ + 299, + 127 + ], + "old_paid_key": 96016, + "ranks": [ + 6, + 5, + 1 + ], + "retained_leg_charts": [ + 306, + 127 + ] + }, + { + "interior_chart": 306, + "matching_chart_pairs_remaining": 1, + "new_leg_charts": [ + 298, + 306 + ], + "new_paid_key": 60, + "old_charts": [ + 298, + 127 + ], + "old_paid_key": 96518, + "ranks": [ + 6, + 5, + 1 + ], + "retained_leg_charts": [ + 306, + 127 + ] + }, + { + "interior_chart": 498, + "matching_chart_pairs_remaining": 1, + "new_leg_charts": [ + 498, + 127 + ], + "new_paid_key": 69, + "old_charts": [ + 488, + 127 + ], + "old_paid_key": 97908, + "ranks": [ + 7, + 2, + 5 + ], + "retained_leg_charts": [ + 488, + 498 + ] + }, + { + "interior_chart": 232, + "matching_chart_pairs_remaining": 1, + "new_leg_charts": [ + 324, + 232 + ], + "new_paid_key": 61, + "old_charts": [ + 324, + 127 + ], + "old_paid_key": 98406, + "ranks": [ + 6, + 5, + 1 + ], + "retained_leg_charts": [ + 232, + 127 + ] + }, + { + "interior_chart": 232, + "matching_chart_pairs_remaining": 1, + "new_leg_charts": [ + 325, + 232 + ], + "new_paid_key": 35, + "old_charts": [ + 325, + 517 + ], + "old_paid_key": 98411, + "ranks": [ + 5, + 4, + 1 + ], + "retained_leg_charts": [ + 232, + 517 + ] + }, + { + "interior_chart": 232, + "matching_chart_pairs_remaining": 1, + "new_leg_charts": [ + 326, + 232 + ], + "new_paid_key": 57, + "old_charts": [ + 326, + 517 + ], + "old_paid_key": 98796, + "ranks": [ + 5, + 4, + 1 + ], + "retained_leg_charts": [ + 232, + 517 + ] + }, + { + "interior_chart": 243, + "matching_chart_pairs_remaining": 1, + "new_leg_charts": [ + 432, + 243 + ], + "new_paid_key": 62, + "old_charts": [ + 432, + 127 + ], + "old_paid_key": 99767, + "ranks": [ + 6, + 5, + 1 + ], + "retained_leg_charts": [ + 243, + 127 + ] + }, + { + "interior_chart": 240, + "matching_chart_pairs_remaining": 1, + "new_leg_charts": [ + 739, + 240 + ], + "new_paid_key": 63, + "old_charts": [ + 739, + 127 + ], + "old_paid_key": 103583, + "ranks": [ + 6, + 5, + 1 + ], + "retained_leg_charts": [ + 240, + 127 + ] + }, + { + "interior_chart": 234, + "matching_chart_pairs_remaining": 1, + "new_leg_charts": [ + 722, + 234 + ], + "new_paid_key": 64, + "old_charts": [ + 722, + 127 + ], + "old_paid_key": 103820, + "ranks": [ + 6, + 5, + 1 + ], + "retained_leg_charts": [ + 234, + 127 + ] + }, + { + "interior_chart": 234, + "matching_chart_pairs_remaining": 1, + "new_leg_charts": [ + 234, + 127 + ], + "new_paid_key": 67, + "old_charts": [ + 722, + 127 + ], + "old_paid_key": 104234, + "ranks": [ + 6, + 1, + 5 + ], + "retained_leg_charts": [ + 722, + 234 + ] + }, + { + "interior_chart": 1090, + "matching_chart_pairs_remaining": 1, + "new_leg_charts": [ + 476, + 1090 + ], + "new_paid_key": 65, + "old_charts": [ + 476, + 127 + ], + "old_paid_key": 104442, + "ranks": [ + 6, + 5, + 1 + ], + "retained_leg_charts": [ + 1090, + 127 + ] + } + ], + "schema": "p104-subdivided-independent-rational-replay/v1", + "target": "0.00386380485468" +} diff --git a/research/p104-subdivided-helper-births/complex/LAYOUT.json.gz b/research/p104-subdivided-helper-births/complex/LAYOUT.json.gz new file mode 100644 index 0000000000..b35dc96caa Binary files /dev/null and b/research/p104-subdivided-helper-births/complex/LAYOUT.json.gz differ diff --git a/research/p104-subdivided-helper-births/complex/OVERLAY.json.gz b/research/p104-subdivided-helper-births/complex/OVERLAY.json.gz new file mode 100644 index 0000000000..c3a9132e70 Binary files /dev/null and b/research/p104-subdivided-helper-births/complex/OVERLAY.json.gz differ diff --git a/research/p104-subdivided-helper-births/complex/PROOF.md b/research/p104-subdivided-helper-births/complex/PROOF.md new file mode 100644 index 0000000000..3f821272e6 --- /dev/null +++ b/research/p104-subdivided-helper-births/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-subdivided-helper-births/complex/REFINEMENTS.md b/research/p104-subdivided-helper-births/complex/REFINEMENTS.md new file mode 100644 index 0000000000..e7bbb5bb5b --- /dev/null +++ b/research/p104-subdivided-helper-births/complex/REFINEMENTS.md @@ -0,0 +1,37 @@ +# Changes between the fourteen subdivisions and the final productive split + +Starting from the fourteen-subdivision word, three entire banks move from charts 1061, 1063 and 1040 to charts 796, 798 and 585 respectively. A fourth bank moves the three ports 94072, 20000 and 99806 from chart 712 to chart 867. The last move collapses paid leg 99806. New leg 70 carries the one shared subtotal available when slot 20000 reads. The four edits save 0.6995634410096856 signed units across 48 calls at the fixed round target. The bank journal gives the donor and reader clocks, chart frames, signed ranks and the common subtotal. Its output is the input to the sparse projection below. [Bank journal](BANKS.json) · [Joint literal replay](overlay.py) + +## Sparse source projection after 14 subdivisions and four chart edits + +The exact parent is `d8f7a310dee37764336019dc3ff099be2ec0d2cf39f6bc318b0fac502a705495`. The layout hash is `60ced30a6d7b69c580c8822756f38c11c0d2a904e3ed1235fbbfd176419e36d3`. Applying the source projection after the subdivisions and chart edits gives `6eba6bb65015df98cf103ce6d12fdd982ba4dcd24a69000bcc58e05477b17c19`. Rational replay compares all 1,278 output rows and all 1,278 adjoint rows on arbitrary independent inputs. [Complete literal edits](OVERLAY.json.gz) · [Intermediate operator and price](../evidence/overlay-operator.json) · [Final operator and price](INDEPENDENT.json) + +Use the transposed scalar graph. Let $V_j$ denote the original value at slot $j$, and let $V_{-1-r}$ denote independent public input $r$. The source chart is 240. The receiving chart is 394 and the only terminal chart carrying a response is 3. The local source form is + +$$ +g=f(V)=V_{-960}-(V_{-638}+V_{-637})/16-(V_{-636}+V_{-332})/8-V_{-324}/4+V_{-94}/4. +$$ + +On every original input column, the receiving-bank form $h_B$ and the terminal-bank form $h_C$ independently give the same $g$. + +$$ +\begin{aligned} +h_B(V)&=-V_5/16-V_{96857}/4-V_{96968}/32-V_{99020}/4+V_{99022}/4+V_{99766}/4,\\ +h_C(V)&=-(V_{90540}+V_{90542}+V_{93982})/8+V_{96847}/2. +\end{aligned} +$$ + +The change injects $v_{93997}=4$, $v_{96857}=-4$, and $v_{103019}=-8$ into the corresponding original producer forms, with all public input responses zero. Write $P$ for the propagated response. Direct rational replay gives $f(P)=0$ and $h_B(P)=h_C(P)=1$. Its only nonzero terminal response is $P_{155099}=-8$. + +Define $V_j'=V_j-P_jg$ on every original slot. The source remains $f(V')=g$. If the original producer at $j$ is $F_j$, then $P_j=F_j(P)+v_j$ and $V_j'=F_j(V')-v_jg$. Both $h_B(V')$ and $h_C(V')$ vanish. The elimination substitutes the following local expressions for the two surrendered slots on every surviving producer and terminal row, including the producer of the new restoration slot. + +$$ +\begin{aligned} +V'_{96857}&=-V'_5/4-V'_{96968}/8-V'_{99020}+V'_{99022}+V'_{99766},\\ +V'_{93982}&=-V'_{90540}-V'_{90542}+4V'_{96847}. +\end{aligned} +$$ + +The edited rows form an acyclic local graph. Induction on its regenerated schedule gives the claimed projected values on every surviving row. Slot 71 sends $g$ from chart 240 to chart 3, and its only terminal correction is $-8g$ at row 155099. This restores the complete transposed map. Returning to the forward orientation transposes the restored map. The separate endpoint computations check both maps directly. + +The two removed transfers cost ranks 1 and 3. The new transfer costs rank 4. All productive counts survive, so the exact credit across the caller is $48(H_1+H_3-H_4)$. At κ `0.00386380485468` the mixed increment exceeds `0.415714729509591692126890039165450543` and the full signed margin exceeds `5.114122621700211289093028895443430160`. At κ `0.00386896184248` the mixed increment exceeds `0.416267641476530766634368243983996571` and the full signed shortfall lies between `0.154068328120620816710055508254842724` and `0.154068328120620816710055508254842725`. The maximum coefficient size in the changed scalar rows is 13 bits. The rational row and price replay are evidence for the combined physical and ordinary qualification. diff --git a/research/p104-subdivided-helper-births/complex/WORD.json.gz b/research/p104-subdivided-helper-births/complex/WORD.json.gz new file mode 100644 index 0000000000..f4368731b6 Binary files /dev/null and b/research/p104-subdivided-helper-births/complex/WORD.json.gz differ diff --git a/research/p104-subdivided-helper-births/complex/birth_replay.py b/research/p104-subdivided-helper-births/complex/birth_replay.py new file mode 100644 index 0000000000..df0f49de32 --- /dev/null +++ b/research/p104-subdivided-helper-births/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-subdivided-helper-births/complex/final_birth.py b/research/p104-subdivided-helper-births/complex/final_birth.py new file mode 100644 index 0000000000..85baca8ef2 --- /dev/null +++ b/research/p104-subdivided-helper-births/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-subdivided-helper-births/complex/independent.py b/research/p104-subdivided-helper-births/complex/independent.py new file mode 100644 index 0000000000..44d1073e18 --- /dev/null +++ b/research/p104-subdivided-helper-births/complex/independent.py @@ -0,0 +1,720 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Independently replay a frozen subdivided P104 word and its 48-call invoice. + +The rational-graph representation follows PR #7774. No builder, subdivision +journal evaluator, or native bound calculator participates in this check. +""" + +import argparse +from collections import Counter, defaultdict +from dataclasses import dataclass, replace +from decimal import Decimal, ROUND_CEILING, ROUND_FLOOR, localcontext +from fractions import Fraction +from hashlib import sha256 +from itertools import chain +from math import gcd, lcm +from pathlib import Path +import gzip +import json +import sys + + +BASE_NATIVE = "934b7d4d792a5771bbcd28053d7797a9938f6b23faddaafe46451158eec81849" +BASE_LAYOUT = "d233f9ba1fc39c4be51685a45da1940fe43dc3a3fd7699a8b27339e1e063b489" +PUBLIC_STREAM = "156fdf3a4a129b39225fd6ca51011de27974d7f104e8b04907c17ed5344bc858" +HOMOGENEOUS = "d889996a337f648087208ab51c98eaf052705d4fca88b5d01b6e9257a829897a" +MIXED = "80009663da460229a57f09bde90e35294329a210ae7fc7ef6d1f05b61ffccbf4" +ORACLE = "52b20f41fd0bb55fa88dccd6015af2ce358917817b9506720f3e60ce681cc3ad" +NATIVE_CALLS = 48 +TARGET = "0.00386380485468" +COMPARATOR_PLUS_GAIN = "0.00386896184248" +ADMITTED_BINARY = "0.00386969950" +COMPONENTS = 4 +CHECKER_SHA256 = sha256(Path(__file__).read_bytes()).hexdigest() + + +def need(condition, reason): + if not condition: + raise ValueError(reason) + + +def encoded(value): + return json.dumps(value, sort_keys=True, separators=(",", ":")).encode() + + +def digest(value): + return sha256(encoded(value)).hexdigest() + + +def read(path, expected): + raw = path.read_bytes() + payload = gzip.decompress(raw) if raw[:2] == b"\x1f\x8b" else raw + value = json.loads(payload) + actual = digest(value) + need(actual == expected, f"canonical content mismatch for {path.name}") + return value, {"content_sha256": actual} + + +def span(frame): + points = {0} + for axis in frame: + need(type(axis) is int and 0 < axis < 512 and axis not in points, "independent native chart axes") + points |= {x ^ axis for x in points} + return frozenset(points) + + +@dataclass(frozen=True) +class Graph: + frames: list + initial: tuple + final: tuple + first: int + moves: dict + forms: dict + order: tuple + + @property + def size(self): + return len(self.initial) + + @property + def terminals(self): + return range(self.first, self.first + self.size) + + def source_chart(self, node): + return self.moves[node][0] if node in self.moves else self.final[node - self.first] + + @classmethod + def parse(cls, raw): + frames = raw["frames"] + initial, final = tuple(raw["initial"]), tuple(raw["final"]) + first = raw["first_output"] + + def valid_chart(chart): + return type(chart) is int and 0 <= chart < len(frames) + + need(len(initial) == len(final) and type(first) is int and first > 0, "public graph census") + need(all(map(valid_chart, chain(initial, final))), "all public chart IDs") + moves = {} + for k, a, b in raw["moves"]: + need(type(k) is int and 0 <= k < first and k not in moves and valid_chart(a) and valid_chart(b), + "unique paid route with valid directed charts") + moves[k] = a, b + forms = {} + for node, terms in raw["forms"]: + need(type(node) is int and node not in forms and terms, "unique nonempty rational form") + parsed = {} + for donor, text in terms: + need(type(donor) is int and donor not in parsed and type(text) is str, "unique literal donor") + coefficient = Fraction(text) + need(coefficient and str(coefficient) == text, "canonical nonzero rational literal") + parsed[donor] = coefficient + forms[node] = tuple(parsed.items()) + order = tuple(raw["schedule"]) + need(forms.keys() == moves.keys() | set(range(first, first + len(initial))), + "every paid arrival and terminal has an actual form") + need(len(order) == len(forms) and set(order) == forms.keys(), "complete literal chronology") + graph = cls(frames, initial, final, first, moves, forms, order) + graph.validate_causality() + return graph + + def validate_causality(self): + available = {~i: c for i, c in enumerate(self.initial)} + for node in self.order: + source = self.source_chart(node) + for donor, _ in self.forms[node]: + need(donor in available, f"use before completed arrival at {node} from {donor}") + need(available[donor] == source, f"wrong source chart at {node} from {donor}") + if node in self.moves: + available[node] = self.moves[node][1] + + +def public_operator(graph, layout, spans): + labels, h = layout["source_labels"], layout["hosted"] + need(layout["frames"] == graph.frames and layout["public"] == graph.size == len(labels), + "layout and graph public chart inventory") + need(len(set(labels)) == len(labels), "duplicate public owner label") + need(tuple(Fraction(h[k]) for k in ("alpha", "beta", "alpha2", "beta2")) == + (-1, Fraction(1, 2), -1, 0), "signed port constants") + secondary = dict(zip(h["Dports"], zip(h["X2"], h["Y2"], strict=True), strict=True)) + live, axes = layout["live"], layout["ports"] + need(len(live) == len(axes) == len(set(axes)) == 104 and + len(secondary) == 96 and secondary.keys() <= set(range(104)), "physical 96 A and 8 B ports") + ports, endpoints = {}, [{i: Fraction(1)} for i in range(graph.size)] + for p, (x, head) in enumerate(zip(live, axes, strict=True)): + y = x + 112 + group = (x, y) + secondary.get(p, ()) + need(all(type(i) is int and 0 <= i < graph.size for i in group), "physical port address range") + need(graph.frames[graph.initial[x]] == [head] and graph.frames[graph.initial[y]] == [] and + spans[graph.final[x]] == frozenset(range(512)) and + spans[graph.final[y]] == frozenset(v for v in range(512) if (v & head).bit_count() % 2 == 0), + f"absolute primary port boundary {p}") + if p in secondary: + u, v = secondary[p] + need(all(d[a] == d[b] for d in (graph.initial, graph.final) + for a, b in ((u, x), (v, y))), f"absolute secondary port boundary {p}") + endpoints[y][x] = Fraction(1) + endpoints[u][v] = Fraction(-1) + else: + endpoints[x][y] = Fraction(-1) + endpoints[y] = {x: Fraction(1, 2), y: Fraction(1, 2)} + ports[p] = group + mains = {i for group in ports.values() for i in group} + need(len(mains) == sum(map(len, ports.values())) == 400, "400 distinct main owners") + return endpoints, mains + + +def rational_sum(terms): + """One exact integer denominator per stored sparse forward row.""" + nonzero = [(row, q.numerator, denominator * q.denominator) + for (denominator, row), q in terms if row] + denominator = lcm(*(d for _, _, d in nonzero)) + numerators = defaultdict(int) + for row, n, d in nonzero: + multiplier = n * (denominator // d) + for address, value in row.items(): + numerators[address] += multiplier * value + result = {k: v for k, v in numerators.items() if v} + common = gcd(denominator, *result.values()) + return denominator // common, {k: v // common for k, v in result.items()} + + +def unpack(row): + denominator, values = row + return {k: Fraction(v, denominator) for k, v in values.items()} + + +def forward(graph, watch=()): + rows = {~i: (1, {i: 1}) for i in range(graph.size)} + outputs = [None] * graph.size + for node in graph.order: + row = rational_sum((rows[donor], q) for donor, q in graph.forms[node]) + if node in graph.moves: + rows[node] = row + else: + outputs[node - graph.first] = unpack(row) + return outputs, {key: unpack(rows[key]) for key in watch} + + +def adjoint(graph, watch=()): + """Pull each terminal covector backward through the literal directed tape.""" + pending = {node: [((1, {i: 1}), Fraction(1))] for i, node in enumerate(graph.terminals)} + watched = {} + for node in reversed(graph.order): + influence = rational_sum(pending.pop(node, ())) + if node in watch: + watched[node] = unpack(influence) + if influence[1]: + for donor, coefficient in graph.forms[node]: + pending.setdefault(donor, []).append((influence, coefficient)) + return [unpack(rational_sum(pending.pop(~i, ()))) for i in range(graph.size)], watched + + +def transpose(rows): + columns = [{} for _ in rows] + for output, row in enumerate(rows): + for donor, coefficient in row.items(): + columns[donor][output] = coefficient + return columns + + +def row_digest(rows): + return digest([[[j, str(v)] for j, v in sorted(row.items())] for row in rows]) + + +def ranks(graph, mains, spans): + paid, productive = Counter(), Counter() + for source, destination in graph.moves.values(): + need(spans[source] < spans[destination] or spans[destination] < spans[source], + "every paid route has strictly nested charts") + paid[abs(len(graph.frames[source]) - len(graph.frames[destination]))] += 1 + for owner, (source, destination) in enumerate(zip(graph.initial, graph.final, strict=True)): + if owner not in mains: + need(spans[source] < spans[destination], "every productive helper is a strict positive owner return") + productive[len(graph.frames[destination]) - len(graph.frames[source])] += 1 + return paid, productive + + +def public_boundaries(base, base_layout, candidate, layout, mains, spans): + need(candidate.size > base.size and candidate.first == base.first, "new owners use the original terminal namespace") + need(layout["source_labels"][:base.size] == base_layout["source_labels"], "all original public labels retained") + changed = {} + for owner in range(base.size): + a, b = base.initial[owner], base.final[owner] + x, y = candidate.initial[owner], candidate.final[owner] + if (a, b) != (x, y): + need(owner not in mains and ((x == a) != (y == b)), "exactly one changed endpoint on an original helper") + center = y if x == a else x + need(spans[a] < spans[center] < spans[b], "strictly interior original retirement/entrance") + daughter = (center, b) if x == a else (a, center) + changed[owner] = (a, b), (x, y), daughter + remaining = set(range(base.size, candidate.size)) + need(len(remaining) == len(changed), "one fresh helper per split original") + records = [] + for owner, (old, kept, expected) in changed.items(): + candidates = [i for i in sorted(remaining) if (candidate.initial[i], candidate.final[i]) == expected] + need(bool(candidates), "complementary new independent owner charts") + fresh = candidates[0] + remaining.remove(fresh) + records.append({ + "original_address": owner, + "original_label": layout["source_labels"][owner], + "fresh_address": fresh, + "fresh_label": layout["source_labels"][fresh], + "old_charts": old, + "original_charts": kept, + "fresh_charts": expected, + "matching_chart_pairs_remaining": len(candidates), + "ranks": [len(base.frames[b]) - len(base.frames[a]) for a, b in (old, kept, expected)], + }) + return records + + +def paid_boundaries(base, candidate, spans, productive_interiors): + unmatched = set(candidate.moves) - set(base.moves) + changed = [k for k, charts in base.moves.items() if k in candidate.moves and candidate.moves[k] != charts] + records = [] + remaining_interiors = productive_interiors.copy() + for key in sorted(changed): + a, b = base.moves[key] + x, y = candidate.moves[key] + if (x == a) == (y == b): + continue + middle = y if x == a else x + if not ((spans[a] < spans[middle] < spans[b]) or (spans[b] < spans[middle] < spans[a])): + continue + if not remaining_interiors[middle]: + continue + other = (middle, b) if x == a else (a, middle) + matches = [k for k in sorted(unmatched) if candidate.moves[k] == other] + if not matches: + continue + new = matches[0] + unmatched.remove(new) + remaining_interiors[middle] -= 1 + records.append({"old_paid_key": key, "new_paid_key": new, "old_charts": (a, b), + "retained_leg_charts": (x, y), "new_leg_charts": other, + "interior_chart": middle, "matching_chart_pairs_remaining": len(matches), + "ranks": [abs(len(base.frames[i]) - len(base.frames[j])) + for i, j in ((a, b), (x, y), other)]}) + need(not +remaining_interiors, "all productive birth interiors carry a paid subdivision") + retimed = set(changed) - {r["old_paid_key"] for r in records} + return records, { + "other_retired_keys": {k: base.moves[k] for k in sorted(base.moves.keys() - candidate.moves.keys())}, + "other_new_keys": {k: candidate.moves[k] for k in sorted(unmatched)}, + "other_recharted_keys": {k: [base.moves[k], candidate.moves[k]] for k in sorted(retimed)}, + "same_chart_changed_form_keys": [k for k in sorted(base.moves.keys() & candidate.moves.keys()) + if k not in changed and base.forms[k] != candidate.forms[k]], + } + + +def reject(operation, reason): + try: + operation() + except ValueError as error: + need(str(error).startswith(reason), f"control rejected for wrong reason: {error}") + else: + raise ValueError(f"counterfactual accepted: {reason}") + + +def fault_paid(candidate, records, other_paid, expected, inputs, outputs): + """A one-node sign change has exact endpoint difference -2*output*input.""" + split = {key for r in records for key in (r["new_paid_key"], r["old_paid_key"])} + other_new = set(other_paid["other_new_keys"]) + faults, zero_impulse = [], [] + for key in sorted(inputs): + input_row, output_column = inputs[key], outputs[key] + if not input_row or not output_column: + need(key not in split | other_new, "the new or subdivided paid leg has an observable public pulse") + zero_impulse.append(key) + continue + source, terminal = min(input_row), min(output_column) + old = expected[terminal].get(source, 0) + delta = -2 * output_column[terminal] * input_row[source] + need(delta, "nonzero exact paid sign defect") + faults.append({"paid_key": key, "first_changed_terminal": terminal, "source_address": source, + "original_coefficient": str(old), "faulty_coefficient": str(old + delta), + "paid_input_coefficient": str(input_row[source]), + "terminal_pulse_coefficient": str(output_column[terminal])}) + direct = [] + for key in [records[0]["new_paid_key"], *sorted(other_new)]: + replaced = tuple((donor, -coefficient) for donor, coefficient in candidate.forms[key]) + faulty = replace(candidate, forms={**candidate.forms, key: replaced}) + faulty.validate_causality() + actual, _ = forward(faulty) + actual_t, _ = adjoint(faulty) + predicted = [row.copy() for row in expected] + for terminal, influence in outputs[key].items(): + for source, coefficient in inputs[key].items(): + row = predicted[terminal] + value = row.get(source, 0) - 2 * influence * coefficient + if value: + row[source] = value + else: + row.pop(source, None) + need(actual == predicted and actual != expected and actual_t == transpose(predicted), + "actual mutated forward and adjoint match the exact signed pulse") + direct.append({"paid_key": key, "mutated_forward_sha256": row_digest(actual), + "mutated_adjoint_sha256": row_digest(actual_t)}) + return {"nonzero_rank_one_witnesses": faults, + "recharted_paid_keys_with_zero_public_impulse": zero_impulse, + "all_rows_directly_replayed_after_sign_mutations": direct} + + +def fault_free(candidate, records, expected): + """Remove the observed original return, the fresh return, and its input pulse.""" + cases = [] + for event in records: + original, fresh = event["original_address"], event["fresh_address"] + for operation in ("original_projection", "fresh_projection", "fresh_input_pulse"): + erased = original if operation == "original_projection" else fresh + if operation == "fresh_input_pulse": + updates = { + key: tuple((donor, coefficient) for donor, coefficient in form if donor != ~fresh) + for key, form in candidate.forms.items() + if any(donor == ~fresh for donor, _ in form) + } + need(updates, "literal independent fresh input pulse is present") + else: + updates = {candidate.first + erased: ()} + faulty = replace(candidate, forms={**candidate.forms, **updates}) + faulty.validate_causality() + claimed = expected.copy() + claimed[erased] = {} + rows, _ = forward(faulty) + columns, _ = adjoint(faulty) + need(expected[erased] == {erased: 1} and rows == claimed and columns == transpose(claimed), + f"removing {operation} erases exactly one independent unit terminal") + cases.append({"operation": operation, "changed_form_keys": sorted(updates), + "source_address": erased, "terminal_address": erased, + "normal_coefficient": "1", "mutated_coefficient": "0", + "mutated_forward_sha256": row_digest(rows), + "mutated_adjoint_sha256": row_digest(columns)}) + return cases + + +def free_parent(args, candidate, records): + if not records: + need(not args.free_parent and not args.free_parent_sha, "a free-parent pin needs a declared free split") + return None, None + need(args.free_parent and args.free_parent_sha, "supply exact predecessor for a productive-only split") + payload, pin = read(args.free_parent, args.free_parent_sha) + earlier = Graph.parse(payload) + originals = {r["original_address"]: r for r in records} + fresh = {r["fresh_address"] for r in records} + need(earlier.frames == candidate.frames and earlier.first == candidate.first + and fresh == set(range(earlier.size, candidate.size)), "all and only declared free helpers appended") + for i in range(earlier.size): + prior = earlier.initial[i], earlier.final[i] + if i in originals: + need(prior == originals[i]["old_charts"], "the final split shortens this exact predecessor owner") + else: + need(prior == (candidate.initial[i], candidate.final[i]), "every other predecessor boundary preserved") + need(earlier.moves == candidate.moves, "literal paid chart keys and endpoints preserved across free split") + result = { + "predecessor": pin, + "common_paid_moves_sha256": digest([[key, *earlier.moves[key]] for key in sorted(earlier.moves)]), + "common_paid_move_count": len(earlier.moves), + "literal_paid_delta": {}, + "literal_coefficient_count_delta": + sum(map(len, candidate.forms.values())) - sum(map(len, earlier.forms.values())), + "owners": records, + } + return earlier, result + + +@dataclass(frozen=True) +class Held: + owner: int | None + chart: int | None + values: tuple + + +EMPTY = Held(None, None, (0,) * COMPONENTS) + + +class GuardedBank: + def __init__(self, distinct_homes): + self.slots = {k: EMPTY for k in distinct_homes} + self.count = 0 + self.guard = (object(), object()) + + def load(self, key, owner, chart): + state = self.slots[key] + need((state.owner, state.chart) == (owner, chart), "held source owner and chart") + return state.values + + def install(self, key, item): + need(self.slots[key] == EMPTY, "install in occupied or dirty home") + self.slots[key] = item + + def clear(self, key, cells=COMPONENTS): + old = self.slots[key].values + self.slots[key] = Held(None, None, (0,) * cells + old[cells:]) + self.count += cells + + +def held_control(graph, expected, subdivisions, other_paid): + """Exercise preserved source values, a live split sender, and exact clearing.""" + source_keys = {~i for i in range(graph.size)} + bank = GuardedBank(source_keys | set(graph.order) | {"sender"}) + guards = bank.guard + samples = { + ~i: tuple((-1) ** (i + j) * (31 * i + 7 * j + 1) for j in range(COMPONENTS)) + for i in range(graph.size) + } + for key, value in samples.items(): + bank.install(key, Held(key, graph.initial[~key], value)) + partial, alias = [], [] + new_keys = {record["new_paid_key"] for record in subdivisions} | set(other_paid["other_new_keys"]) + for node in graph.order: + chart = graph.source_chart(node) + addends = [(coefficient, bank.load(donor, donor, chart)) + for donor, coefficient in graph.forms[node]] + cells = tuple(sum(coefficient * values[j] for coefficient, values in addends) + for j in range(COMPONENTS)) + if node in graph.moves: + bank.install("sender", Held(node, chart, cells)) + returned = bank.load("sender", node, chart) + if node in new_keys: + reject(lambda: bank.install("sender", Held(-1, chart, cells)), "install in occupied or dirty home") + alias.append(node) + if cells[-1]: + bank.clear("sender", COMPONENTS - 1) + reject(lambda: bank.install("sender", Held(node, chart, cells)), + "install in occupied or dirty home") + partial.append(node) + bank.install(node, Held(node, graph.moves[node][1], returned)) + bank.clear("sender") + else: + bank.install(node, Held(node, chart, cells)) + need(all(bank.load(k, k, graph.initial[~k]) == v for k, v in samples.items()), + "old and added independent inputs preserved until public return") + for i, row in enumerate(expected): + want = tuple(sum(coefficient * samples[~j][k] for j, coefficient in row.items()) + for k in range(COMPONENTS)) + staged = bank.load(graph.first + i, graph.first + i, graph.final[i]) + bank.clear(~i) + bank.install(~i, Held(~i, graph.final[i], staged)) + need(bank.load(~i, ~i, graph.final[i]) == want, + f"install the same independent public owner {i} in the declared terminal chart") + for key in bank.slots: + bank.clear(key) + need(bank.guard is guards and all(item == EMPTY for item in bank.slots.values()), + "complete addressed clearing and guard preservation") + need(alias and partial, "live-candidate dirty-tail and occupied sender controls") + return {"scope": "normalized rational held-home fixture, four independent components", + "homes": len(bank.slots), "addressed_cells_cleared": bank.count, + "same_owner_returns": graph.size, "guards_preserved": True, + "occupied_sender_rejected_at": alias, "partially_cleared_sender_rejected_at": partial} + + +def signed_caller(supplier, graph, layout): + source = supplier / "complex" + retained = source / "retained" + sys.path[:0] = [str(source), str(retained), str(retained / "vendor")] + from closed_application import readback + from closed_caller import placement, templates + from mixed_caller import layout_bindings + from mixed_grid import census, exact + + caller_data = (retained / "data/CALLER.json.gz").read_bytes() + mixed_data = (retained / "data/CONJUGATE-CALLER.json.gz").read_bytes() + need(sha256(caller_data).hexdigest() == HOMOGENEOUS and sha256(mixed_data).hexdigest() == MIXED, + "pinned canonical caller inputs") + caller = json.loads(gzip.decompress(caller_data)) + words = templates(caller) + roots = placement(caller) + bindings, offsets, census_record = layout_bindings(words, roots, layout, NATIVE_CALLS) + need(census_record["template_roots"] == {"A": 120, "rotated": 192} and + census_record["stage_helper_owners"] == NATIVE_CALLS * (graph.size - 400), + "all independent main roots and every new per-call helper included") + tape = readback(words, roots, bindings, offsets) + need(tape["event_stream_sha256"] == PUBLIC_STREAM and tape["events"] == 840912, + "independent native helper births preserve the signed caller word") + paid, productive, grids = Counter(), Counter(), {} + for kind, (events, targets) in words.items(): + grams = exact(events, targets, 2025 << 9) + grids[kind] = grams + t, p, *_ = census(events, targets) + count = census_record["template_roots"][kind] + paid.update({rank: count * n for rank, n in p.items()}) + productive.update({rank: count * n for rank, n in t.items()}) + return paid, productive, {"finite_binding": census_record, "readback": tape, + "exact_local_operators": grids} + + +def invoice(graph_ranks, closed_ranks): + return tuple(Counter({rank: NATIVE_CALLS * n for rank, n in native.items()}) + caller + for native, caller in zip(graph_ranks, closed_ranks, strict=True)) + + +def interval(paid, productive, bounds, kappa=TARGET): + lower = upper = Fraction(0) + exponent = 1 - Fraction(kappa) + for rank in sorted(paid.keys() | productive.keys()): + n = productive[rank] - paid[rank] + a, b = bounds(rank, exponent, 256) + lower += n * (a if n >= 0 else b) + upper += n * (b if n >= 0 else a) + return lower, upper + + +def decimal_bounds(values): + out = [] + for value, rounding in zip(values, (ROUND_FLOOR, ROUND_CEILING), strict=True): + with localcontext() as ctx: + ctx.prec = 58 + ctx.rounding = rounding + out.append(str(Decimal(value.numerator) / Decimal(value.denominator))) + return out + + +def overview(graph, ids, rows, columns, own_ranks): + paid, productive = own_ranks + return {**ids, "public": graph.size, "main": 400, "helpers": graph.size - 400, + "forms": len(graph.forms), "paid_moves": len(graph.moves), + "rational_literals": sum(map(len, graph.forms.values())), + "forward_rows": len(rows), "adjoint_rows": len(columns), + "forward_sha256": row_digest(rows), "adjoint_sha256": row_digest(columns), + "native_paid": dict(paid), "native_productive": dict(productive)} + + +def verify(args): + base_data, base_id = read(args.base_graph, BASE_NATIVE) + base_layout, base_layout_id = read(args.base_layout, BASE_LAYOUT) + new_data, new_id = read(args.candidate, args.sha) + new_layout, layout_id = read(args.layout, args.layout_sha) + base, candidate = Graph.parse(base_data), Graph.parse(new_data) + need(base.size == 1264 and len(base.moves) == 5701, "literal #7776 graph census") + need(base.frames == candidate.frames and all(base_layout[k] == new_layout[k] for k in ("ports", "live", "hosted")), + "all original charts, port addresses and native coefficients") + spans = [span(frame) for frame in base.frames] + expected_base, base_main = public_operator(base, base_layout, spans) + expected, mains = public_operator(candidate, new_layout, spans) + need(base_main == mains and expected[:base.size] == expected_base and + all(row == {i: 1} for i, row in enumerate(expected[base.size:], start=base.size)), + "all original operator rows and one fresh independent unit row per added owner") + changed_owners = public_boundaries(base, base_layout, candidate, new_layout, mains, spans) + declared_free = set(args.free_split) + free_records = [r for r in changed_owners if (r["original_address"], r["fresh_address"]) in declared_free] + need(len(free_records) == len(declared_free), "every declared free split pairs the exact original and fresh address") + paid_births = [r for r in changed_owners if r not in free_records] + interiors = Counter(next(c for c in r["original_charts"] if c not in r["old_charts"]) for r in paid_births) + changed_paid, other_paid = paid_boundaries(base, candidate, spans, interiors) + need(len(paid_births) == len(changed_paid) > 0, "complete paid and productive subdivision counts") + need(Counter(r["interior_chart"] for r in changed_paid) == interiors, + "every paid interior chart supports a productive birth") + earlier, free_result = free_parent(args, candidate, free_records) + print("Checking all exact rational public rows and independent adjoints.", flush=True) + old_rows, _ = forward(base) + old_cols, _ = adjoint(base) + watch = ({key for record in changed_paid for key in (record["new_paid_key"], record["old_paid_key"])} + | set(other_paid["other_new_keys"]) | set(other_paid["other_recharted_keys"])) + rows, inputs = forward(candidate, watch) + columns, outputs = adjoint(candidate, watch) + expected_t = transpose(expected) + need(old_rows == expected_base and old_cols == transpose(expected_base), "pinned source orientations") + need(rows == expected and columns == expected_t, "complete independent candidate orientations") + need([dict((j, q) for j, q in col.items() if j < base.size) for col in columns[:base.size]] == old_cols and + all(columns[i] == {i: 1} for i in range(base.size, candidate.size)), + "no arbitrary fresh input perturbs an original terminal") + print("Checking subdivided paid signs, address aliasing, and live partial CLEAR.", flush=True) + faulty_layout = {**new_layout, "source_labels": new_layout["source_labels"].copy()} + first = changed_owners[0] + faulty_layout["source_labels"][first["fresh_address"]] = first["original_label"] + reject(lambda: public_operator(candidate, faulty_layout, spans), "duplicate public owner label") + faults = fault_paid(candidate, changed_paid, other_paid, expected, inputs, outputs) + held = held_control(candidate, expected, changed_paid, other_paid) + if free_records: + print("Checking the free retirement, fresh terminal projection, and independent input pulse.", flush=True) + free_result["removal_controls"] = fault_free(candidate, free_records, expected) + base_ranks = ranks(base, mains, spans) + new_ranks = ranks(candidate, mains, spans) + print("Checking the 48-call signed caller and directed recursive price.", flush=True) + caller_paid, caller_productive, caller = signed_caller(args.supplier.resolve(), candidate, new_layout) + paid0, target0 = invoice(base_ranks, (caller_paid, caller_productive)) + paid1, target1 = invoice(new_ranks, (caller_paid, caller_productive)) + scripts = args.upstream.resolve() / "scripts" + need(sha256((scripts / "evaluate_recursive_power.py").read_bytes()).hexdigest() == ORACLE, + "pinned directed power checker") + sys.path.insert(0, str(scripts)) + from evaluate_recursive_power import power_bounds + original = interval(paid0, target0, power_bounds) + updated = interval(paid1, target1, power_bounds) + credit = updated[0] - original[1], updated[1] - original[0] + if free_records: + paid_earlier, target_earlier = invoice(ranks(earlier, mains, spans), (caller_paid, caller_productive)) + need(paid_earlier == paid1, "free target split has zero complete paid rank delta") + delta = Counter() + for event in free_records: + old, first, second = event["ranks"] + delta[old] -= NATIVE_CALLS + delta[first] += NATIVE_CALLS + delta[second] += NATIVE_CALLS + observed = {r: target1[r] - target_earlier[r] for r in target1.keys() | target_earlier.keys() + if target1[r] != target_earlier[r]} + need(observed == {r: amount for r, amount in delta.items() if amount}, + "the only productive change is both exact daughters against their retired original target") + a, b = interval(paid_earlier, target_earlier, power_bounds) + free_result["full_signed_credit"] = decimal_bounds((updated[0] - b, updated[1] - a)) + free_result["complete_target_delta"] = {r: n for r, n in delta.items() if n} + need(updated[0] - b > 0, "directed positive paid-null productive split") + need(original[1] < 0 < updated[0], "full candidate signed invoice clears the target") + return { + "schema": "p104-subdivided-independent-rational-replay/v1", + "checker_sha256": CHECKER_SHA256, + "target": TARGET, + "base": overview(base, base_id, old_rows, old_cols, base_ranks), + "candidate": overview(candidate, new_id, rows, columns, new_ranks), + "base_layout": base_layout_id, + "candidate_layout": layout_id, + "original_and_fresh_owners": changed_owners, + "paid_subdivisions": changed_paid, + "free_productive_subdivision": free_result, + "other_paid_changes": other_paid, + "held_owner_clear": held, + "fault_controls": {"occupied_public_owner_label_rejected": True, "changed_paid_signs": faults}, + "closed_caller": {**caller, "fixed_paid": dict(caller_paid), "fixed_targets": dict(caller_productive)}, + "full_invoice": {"base": {"paid": dict(paid0), "targets": dict(target0)}, + "candidate": {"paid": dict(paid1), "targets": dict(target1)}, + "paid_delta": {r: paid1[r] - paid0[r] for r in sorted(paid0.keys() | paid1.keys()) + if paid1[r] != paid0[r]}, + "target_delta": {r: target1[r] - target0[r] for r in sorted(target0.keys() | target1.keys()) + if target1[r] != target0[r]}, + "base_margin": decimal_bounds(original), "candidate_margin": decimal_bounds(updated), + "additional_candidate_margins": { + k: decimal_bounds(interval(paid1, target1, power_bounds, k)) + for k in (COMPARATOR_PLUS_GAIN, ADMITTED_BINARY) + }, + "saving": decimal_bounds(credit)}, + } + + +def main(): + def free_pair(value): + try: + a, b = map(int, value.split(":")) + except ValueError as error: + raise argparse.ArgumentTypeError("use original-address:fresh-address") from error + if not 0 <= a < b: + raise argparse.ArgumentTypeError("the fresh address follows the original address") + return a, b + + parser = argparse.ArgumentParser(description=__doc__) + for name in ("base-graph", "base-layout", "candidate", "layout", "supplier", "upstream", "out"): + parser.add_argument("--" + name, type=Path, required=True) + parser.add_argument("--sha", required=True) + parser.add_argument("--layout-sha", required=True) + parser.add_argument("--free-split", type=free_pair, action="append", default=[]) + parser.add_argument("--free-parent", type=Path) + parser.add_argument("--free-parent-sha") + args = parser.parse_args() + report = verify(args) + args.out.write_text(json.dumps(report, sort_keys=True, indent=2) + "\n") + print("Independent signed margin:", *report["full_invoice"]["candidate_margin"], flush=True) + + +if __name__ == "__main__": + main() diff --git a/research/p104-subdivided-helper-births/complex/overlay.py b/research/p104-subdivided-helper-births/complex/overlay.py new file mode 100644 index 0000000000..7049b0904a --- /dev/null +++ b/research/p104-subdivided-helper-births/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-subdivided-helper-births/evidence/application.json b/research/p104-subdivided-helper-births/evidence/application.json new file mode 100644 index 0000000000..f7750d08a0 --- /dev/null +++ b/research/p104-subdivided-helper-births/evidence/application.json @@ -0,0 +1,778 @@ +{ + "application": { + "bracket": [ + "0.00386981257852", + "0.00386981257853" + ], + "claim": "0.00386969949992", + "common_root": { + "H_guard": "bit_length(context_c*1920*153**1920*(H+1)**2) < H for each actual compiler bound H", + "caller_odd": 2025, + "context_binary_bits": 136, + "context_c": 802, + "context_mass_bits": 401, + "context_mass_bound": "3758113486959709855379843550725103032753616956262976486259319500828221209574753836146176007629545139030540873303204326000", + "exact_grid": "2^(-p-D)", + "native_binary": { + "candidate": 18 + }, + "native_odd": { + "candidate": 71282950812497579480325 + }, + "signed_width": "W=p+h+2D+3", + "temporary_width": "W+26" + }, + "compiler": { + "BIT_margin": "1/100000000000000", + "BIT_pin": "7739399/2000000000", + "H": "15132200000000000000", + "alpha": [ + 0.9999998434687777, + 0.9999998434687777 + ], + "claim": "48371243749/12500000000000", + "compiler_gap": "1/100000000000000", + "delta": [ + 0.8384844462816743, + 0.8384844462816743 + ], + "derivative_upper": -1005981.5894620527, + "gamma": [ + 0.9399130126337303, + 0.9399130126337303 + ], + "input_lift": { + "absolute_curvature_upper": "2355391845541459904210316251401050062978110588940190425603051116764979485783867649/25000000000000000000000000000000000000000000000000000000000000000000000000000000", + "derivative_upper_on_required_interval": "-197393444866547341726216840920961795174396270784530640052544207873039578249865804250287/1250000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "interval_kappa_cap": "7739399/2000000000", + "margins": { + "386969949999/100000000000000": [ + "131678873577095408185038036661592180432878106599417274704568232377176842034477/100000000000000000000000000000000000000000000000000000000000000000000000000000000", + "32919718394273852046259509165398045108219526649854318676142058094294210509101/25000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "48371243749/12500000000000": [ + "65839436787410776608984910601863524439403261604278222473061812021591608366553/50000000000000000000000000000000000000000000000000000000000000000000000000000000", + "131678873574821553217969821203727048878806523208556444946123624043183216735063/100000000000000000000000000000000000000000000000000000000000000000000000000000000" + ] + }, + "signed_curvature_upper": "31960881757465108748156055549877382773720954815102950527044995237546502905778087/625000000000000000000000000000000000000000000000000000000000000000000000000000", + "signed_derivative_ceiling": "17790058447175641876263482763505090461437978190383344010344228678780469811693673/2556870540597208699852484443990190621897676385208236042163599619003720232462246960" + }, + "minimum_log_power": 2374, + "moment_margin_float": { + "386969949999/100000000000000": [ + 0.11548560514296766, + 0.11548560514296766 + ], + "386981257853/100000000000000": [ + -5.301116162417366e-09, + -5.301116162417366e-09 + ], + "96745314463/25000000000000": [ + 4.911748579752208e-09, + 4.911748579752208e-09 + ] + }, + "moment_margins": { + "386969949999/100000000000000": [ + "360892516071773942039138456156994777098756074707507769001365221406758895015683/3125000000000000000000000000000000000000000000000000000000000000000000000000000", + "721785032143547884078276912313989554197512149415015538002730442813517796073117/6250000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "386981257853/100000000000000": [ + "-33131976015108540215407345559466071985044661298186392725901591812982321/6250000000000000000000000000000000000000000000000000000000000000000000000000000", + "-33131976015108540215407345559466071985044661298186392725901591806807547/6250000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "96745314463/25000000000000": [ + "15349214311725649600412453399360565570527389951186416828168828487554609/3125000000000000000000000000000000000000000000000000000000000000000000000000000", + "7674607155862824800206226699680282785263694975593208414084414245299263/1562500000000000000000000000000000000000000000000000000000000000000000000000000" + ] + }, + "outer": { + "BIT_just_below_effective_rejected": true, + "functional_count": 4, + "minimum_margin": "1/1000000000000000", + "strict_count": 54 + }, + "raw_bracket": [ + "96745314463/25000000000000", + "386981257853/100000000000000" + ], + "tested": "386969949999/100000000000000", + "written_log_power": 2375 + }, + "depth_guard": { + "argument_bit_length": 14083, + "compiler_H": 15132200000000000000, + "strict_guard_passed": true + }, + "invoice": { + "paid": { + "1": 185280, + "2": 38160, + "3": 23472, + "4": 10656, + "5": 14736, + "6": 2160, + "7": 192, + "8": 1344, + "16": 1248, + "24": 1248, + "32": 1248, + "40": 1248, + "48": 1248, + "56": 1248 + }, + "targets": { + "1": 864, + "2": 336, + "3": 384, + "4": 11280, + "5": 1200, + "7": 720, + "8": 1584, + "9": 26304, + "17": 1248, + "25": 1248, + "33": 1248, + "41": 1248, + "49": 1248, + "57": 1248, + "65": 1248, + "129": 624 + } + }, + "ordinary": { + "native_numeric_homes": 8277, + "native_paid_wrappers": 274272, + "odd_conversions": 142464, + "ordinary_elementary_record_upper": 151885612032, + "ordinary_main_pair_slots": 19200, + "ordinary_map_slots": 1601088, + "port_view_permutations": 38400, + "port_view_routing_legs": 76800, + "port_view_translations": 38400, + "raw_numeric_homes": 397296, + "raw_numeric_homes_plus_dummy": 397344, + "raw_paid_positions": 283488, + "raw_productive_targets": 52032, + "raw_scalar_incidence_allowance_before_factor_32": { + "additional_odd_factor_steps": 427392, + "boundary_installations": 122784, + "caller_slots": 840768, + "extra_gaussian_component_slots": 26299392, + "native_products_and_accumulations": 10159680, + "native_row_lifecycles": 1342656, + "odd_conversions": 142464, + "private_home_flags": 397296, + "sender_lifecycles": 548544 + }, + "reset_services_all_native_stages": 85551456, + "root_negative_q_translations": 4080, + "scalar_services": 1288991232, + "scalar_step_rate": 4294967296, + "selected_total_steps_raw_L_and_constant": [ + 12569114920704, + 56593844724960 + ], + "separate_guarded_guide_tracks_raw": 48, + "separate_guarded_streams_raw": 192, + "serial_caller_real_component_arrays": 16, + "typed_selected_transfer_legs_all_native_stages": 22881888 + } + }, + "binary_word_sha256": "861f5181e4f34db638ab0c573c319fe26ff034d63b21242d67220a4a5d6433ff", + "caller": { + "calls": 48, + "dyadic_height": 9, + "finite_binding": { + "ambient": 137, + "calls": 48, + "helper_label_sha256": "a556892af9b70ab70ddf7383e3d93a1df87c60eefbf105b704b35ae2c016f16d", + "local_colors": 16, + "native_main_bindings": 19200, + "physical_port_contacts": 4992, + "root_owners": 9840, + "stage_binding_sha256": "b97fe2d7a114d8dc85629ce3a486443d7bf59c7f757c5e6fa2258548e2f51afd", + "stage_helper_owners": 42192, + "template_roots": { + "A": 120, + "rotated": 192 + } + }, + "fixed_caller_paid": { + "1": 480, + "8": 1248, + "16": 1248, + "24": 1248, + "32": 1248, + "40": 1248, + "48": 1248, + "56": 1248 + }, + "fixed_root_targets": { + "9": 480, + "17": 1248, + "25": 1248, + "33": 1248, + "41": 1248, + "49": 1248, + "57": 1248, + "65": 1248, + "129": 624 + }, + "gaussian_literal_uses": 380928, + "odd_scale": 2025, + "root_negative_q": 4080, + "root_owners": 9840, + "uses": { + "ADD": 575856, + "IDLE_ONE": 8736, + "LAMBDA": 30000, + "QUERY": 480, + "SCALE": 128688, + "SWAP": 97008 + } + }, + "caller_guard": { + "binary_height_at_all_completed_cuts_and_products": 121, + "binary_height_at_native_entrances": 118, + "normalized_bound_uses_no_cancellation_or_commutation": true, + "records": 840816, + "scaled_mass_at_all_cuts_and_products": "656748561411873243374784920314099202170021168343855390762992218430222204214651876734183800", + "scaled_mass_at_native_entrances": "8021485807695018873068752913970712173859043099335691185530999769142044976724999146587200", + "stages": 48, + "uses": { + "ADD": 575856, + "IDLE_ONE": 8736, + "LAMBDA": 30000, + "QUERY": 480, + "SCALE": 128688, + "SWAP": 97008 + } + }, + "caller_proof": { + "common_head_and_masks": { + "absolute_native_boundaries": 6656, + "atlas_sha256": "bc28417912a4dcc1a949990776163791f772d9dace2254af8090dac32c9f6930", + "body_axis_masks": [ + "0x1fe00", + "0x1fe0000", + "0x1fe000000", + "0x1fe00000000", + "0x1fe0000000000", + "0x1fe000000000000", + "0x1fe00000000000000", + "0x1fe0000000000000000", + "0x1fe000000000000000000", + "0x1fe00000000000000000000", + "0x1fe0000000000000000000000", + "0x1fe000000000000000000000000", + "0x1fe00000000000000000000000000", + "0x1fe0000000000000000000000000000", + "0x1fe000000000000000000000000000000", + "0x1fe00000000000000000000000000000000" + ], + "canonical_head_axis": 1, + "canonical_normalizers": 30000, + "central_bases": 104, + "central_characters_per_phase": 512, + "distinct_contact_colors": 1664, + "distinct_signed_target_masks": 330, + "native_phase_omission_rejected": true, + "nonzero_forward_rehead_shifts": 104, + "ordinary_head_summands_sha256": "f8d21adc6858079ca47ab01fabd247f8a7ba15b6c79c304dceaf531e19e1e454", + "used_paid_masks": 9216, + "used_targets": 9840, + "whole_axis_sets_sha256": "0f5a943a67864f8acc555cb9ad0ba27059de430462f268d3666eb050aa02f2af" + }, + "component_divisions": 4619136, + "insufficient_grid_rejected": true, + "missing_add_rejected": true, + "readback": { + "event_stream_sha256": "156fdf3a4a129b39225fd6ca51011de27974d7f104e8b04907c17ed5344bc858", + "events": 840912, + "op_counts": { + "ADD": 575856, + "IDLE_ONE": 8736, + "LAMBDA": 30000, + "NATIVE": 48, + "PORT_VIEWS": 96, + "QUERY": 480, + "SCALE": 128688, + "SWAP": 97008 + } + }, + "repeated_color_rejected": true, + "shared_main_rejected": true, + "template_bounds": { + "A": { + "entrance_height": 41, + "entrance_mass": "6387240302828290182224875", + "height": 43, + "mass": "65863546575277432099681500" + }, + "rotated": { + "entrance_height": 118, + "entrance_mass": "3961227559355564875589507611837388727831626221894168486681975194638046902086419331648", + "height": 121, + "mass": "324320277240431231296190084105728001071615391774743402845922083175418372451679939127992" + } + }, + "template_grids": { + "A": { + "exponent_bits": 4, + "maximum_stage_occurrences": 15, + "minimum_grid": 4, + "peak_mass": "256", + "peak_native_entrance_mass": "26", + "preproduct_divisions": 2686, + "separate_component_divisions": 9904 + }, + "rotated": { + "exponent_bits": 4, + "maximum_stage_occurrences": 15, + "minimum_grid": 8, + "peak_mass": "212", + "peak_native_entrance_mass": "91/2", + "preproduct_divisions": 8308, + "separate_component_divisions": 17868 + } + } + }, + "common_root": { + "H_guard": "bit_length(context_c*1920*153**1920*(H+1)**2) < H for each actual compiler bound H", + "caller_odd": 2025, + "context_binary_bits": 136, + "context_c": 802, + "context_mass_bits": 401, + "context_mass_bound": "3758113486959709855379843550725103032753616956262976486259319500828221209574753836146176007629545139030540873303204326000", + "exact_grid": "2^(-p-D)", + "native_binary": { + "candidate": 18, + "comparator": 18 + }, + "native_odd": { + "candidate": 71282950812497579480325, + "comparator": 71282950812497579480325 + }, + "signed_width": "W=p+h+2D+3", + "temporary_width": "W+26" + }, + "comparator_joint_upper": "0.00385896184248", + "complex_crossing": [ + "0.00386981257852", + "0.00386981257853" + ], + "conversion": { + "odd_factors": [ + 15658669, + 13190315, + 12782385, + 27 + ], + "partial_clear": { + "dirty_unaddressed_last_cell_rejected": true, + "neighbor_unchanged": true + }, + "round_trips": 5116, + "scalar_cases": { + "coefficient_bits": 24, + "component_padding": 26, + "distinct_scalar_and_conversion_factors": 5248, + "rejected_one_tick_denominators": [ + 2, + 3, + 5, + 7 + ], + "retained_max_bits": 24, + "signed_bit_transducer_cases": 31488 + } + }, + "finite_lower": "0.00386969949992", + "gain_above_upper": "67110359/6250000000000", + "joint_depth_guards": { + "candidate": { + "argument_bit_length": 14083, + "compiler_H": 15132200000000000000, + "strict_guard_passed": true + }, + "comparator": { + "argument_bit_length": 14083, + "compiler_H": 15086600000000000000, + "strict_guard_passed": true + } + }, + "layout_sha256": "37c04b0a349c1b7f7ada22533d3e4e6bacb42e4c6549f4257f4cbcae189a0275", + "native": { + "additional_independent_guarded_streams": 4, + "all_public_inputs_preserved_until_final_installs": true, + "checked_nontrivial_divisions": 7476454, + "coefficient_products": 12785992, + "declared_senders": 1, + "deferred_terminal_banks": 1279, + "exact_all_public_rows": 1279, + "exact_odd_unscale_outputs": 1279, + "exact_source_columns": 1279, + "fixture_addressed_cells_overwritten": { + "clear_full_sender_after_return": 22856, + "initialize_complete_dirty_home": 33108, + "initialize_empty_sender_before_departure": 22856, + "retire_complete_home": 33108 + }, + "fixture_addressed_cells_per_home": 4, + "guarded_dummy_slots": 1, + "immutable_entry_banks": 1279, + "immutable_paid_return_banks": 5714, + "live_sender_alias_control_rejected": true, + "live_sender_control_slot": 104442, + "max_outstanding_native_senders": 1, + "maximum_exact_row_prefix_mass_scaled": "5730190684160421769998764272608892500", + "minimum_product_grid": 18686397857791365475290316800, + "minimum_snapshot_grid": 53132341176725690880, + "native_scalar_scratch_homes": 4, + "numerical_homes": 8277, + "paid_native_ranks": { + "1": 3850, + "2": 795, + "3": 489, + "4": 222, + "5": 307, + "6": 45, + "7": 4, + "8": 2 + }, + "path_grid": 18686397857791365475290316800, + "path_grid_height": 18, + "path_grid_odd": 71282950812497579480325, + "path_only_grid": 561847661669784544018649013288960000, + "positive_helper_ranks": { + "1": 18, + "2": 7, + "3": 8, + "4": 235, + "5": 25, + "7": 15, + "8": 33, + "9": 538 + }, + "positive_path_mass_bound_unscaled": "481500027485689/73260", + "positive_path_mass_peak_node": 156041, + "product_gcd_witnesses": [ + { + "coefficient": "-1/4", + "donor": -1174, + "gcd": 140461915417446136004662253322240000, + "input_owner": 1173, + "previous_gcd": 561847661669784544018649013288960000, + "row": 89742, + "scaled_product": -140461915417446136004662253322240000 + }, + { + "coefficient": "8/3", + "donor": -1123, + "gcd": 46820638472482045334887417774080000, + "input_owner": 1122, + "previous_gcd": 140461915417446136004662253322240000, + "row": 89742, + "scaled_product": 1498260431119425450716397368770560000 + }, + { + "coefficient": "-1/16", + "donor": -502, + "gcd": 11705159618120511333721854443520000, + "input_owner": 501, + "previous_gcd": 46820638472482045334887417774080000, + "row": 89742, + "scaled_product": -35115478854361534001165563330560000 + }, + { + "coefficient": "-151/2296", + "donor": -405, + "gcd": 40784528286134185831783464960000, + "input_owner": 404, + "previous_gcd": 11705159618120511333721854443520000, + "row": 89742, + "scaled_product": -36950782627237572363595819253760000 + }, + { + "coefficient": "-1/32", + "donor": -261, + "gcd": 20392264143067092915891732480000, + "input_owner": 260, + "previous_gcd": 40784528286134185831783464960000, + "row": 89742, + "scaled_product": -17557739427180767000582781665280000 + }, + { + "coefficient": "61/64", + "donor": -1133, + "gcd": 10196132071533546457945866240000, + "input_owner": 1132, + "previous_gcd": 20392264143067092915891732480000, + "row": 94174, + "scaled_product": 535511052529013393517774840791040000 + }, + { + "coefficient": "-21/128", + "donor": -1120, + "gcd": 5098066035766773228972933120000, + "input_owner": 1119, + "previous_gcd": 10196132071533546457945866240000, + "row": 94174, + "scaled_product": -92178131992699026753059603742720000 + }, + { + "coefficient": "97/2895", + "donor": -1148, + "gcd": 5282969985250542206189568000, + "input_owner": 1147, + "previous_gcd": 5098066035766773228972933120000, + "row": 53, + "scaled_product": 18825292981681900093198257094656000 + }, + { + "coefficient": "5984/8685", + "donor": -1123, + "gcd": 1760989995083514068729856000, + "input_owner": 1122, + "previous_gcd": 5282969985250542206189568000, + "row": 53, + "scaled_product": 387115303100977629407898180255744000 + }, + { + "coefficient": "7/22", + "donor": -652, + "gcd": 160089999553046733520896000, + "input_owner": 651, + "previous_gcd": 1760989995083514068729856000, + "row": 92991, + "scaled_product": 178769710531295082187751958773760000 + }, + { + "coefficient": "24/17", + "donor": -1146, + "gcd": 9417058797238043148288000, + "input_owner": 1145, + "previous_gcd": 160089999553046733520896000, + "row": 90906, + "scaled_product": 793196698827931120967504489349120000 + }, + { + "coefficient": "37522/1377", + "donor": -1146, + "gcd": 1046339866359782572032000, + "input_owner": 1145, + "previous_gcd": 9417058797238043148288000, + "row": 90908, + "scaled_product": 15309838751760098519003448276418560000 + }, + { + "coefficient": "17249/4131", + "donor": -1123, + "gcd": 348779955453260857344000, + "input_owner": 1122, + "previous_gcd": 1046339866359782572032000, + "row": 90908, + "scaled_product": 2345996203374997240323814289571840000 + }, + { + "coefficient": "27/512", + "donor": -1120, + "gcd": 87194988863315214336000, + "input_owner": 1119, + "previous_gcd": 348779955453260857344000, + "row": 88528, + "scaled_product": 29628685283367544313483444060160000 + }, + { + "coefficient": "7/74", + "donor": -1264, + "gcd": 2356621320630140928000, + "input_owner": 1263, + "previous_gcd": 87194988863315214336000, + "row": 88869, + "scaled_product": 53147751779574213623385717473280000 + }, + { + "coefficient": "64/79", + "donor": -1185, + "gcd": 29830649628229632000, + "input_owner": 1184, + "previous_gcd": 2356621320630140928000, + "row": 8, + "scaled_product": 455167725909698871103715656335360000 + }, + { + "coefficient": "-1/16", + "donor": 88885, + "gcd": 14915324814114816000, + "input_owner": 1119, + "previous_gcd": 29830649628229632000, + "row": 89183, + "scaled_product": 31274723354665741219788079841280000 + }, + { + "coefficient": "-27/32", + "donor": 93761, + "gcd": 7457662407057408000, + "input_owner": 321, + "previous_gcd": 14915324814114816000, + "row": 95793, + "scaled_product": -2469057106947295359456953671680000 + }, + { + "coefficient": "-363/188", + "donor": 8, + "gcd": 158673668235264000, + "input_owner": 1184, + "previous_gcd": 7457662407057408000, + "row": 34008, + "scaled_product": -878861087793727075588557357711360000 + }, + { + "coefficient": "-1/28", + "donor": 91794, + "gcd": 22667666890752000, + "input_owner": 683, + "previous_gcd": 158673668235264000, + "row": 98406, + "scaled_product": -66208649815152899077570560000 + }, + { + "coefficient": "-115/62", + "donor": 89190, + "gcd": 731215060992000, + "input_owner": 70, + "previous_gcd": 22667666890752000, + "row": 36, + "scaled_product": -1042136791806858428421687685939200000 + }, + { + "coefficient": "19/160", + "donor": 91110, + "gcd": 365607530496000, + "input_owner": 1119, + "previous_gcd": 731215060992000, + "row": 104459, + "scaled_product": -14073625509599583548904635928576000 + }, + { + "coefficient": "-20/37", + "donor": 91110, + "gcd": 9881284608000, + "input_owner": 1263, + "previous_gcd": 365607530496000, + "row": 156006, + "scaled_product": 295493291747439643311488158924800000 + }, + { + "coefficient": "-23/64", + "donor": 91110, + "gcd": 4940642304000, + "input_owner": 1119, + "previous_gcd": 9881284608000, + "row": 156030, + "scaled_product": 42591235094840844950632450836480000 + }, + { + "coefficient": "-32/223665", + "donor": -933, + "gcd": 380049408000, + "input_owner": 932, + "previous_gcd": 4940642304000, + "row": 34, + "scaled_product": -80384169062808688925834477568000 + }, + { + "coefficient": "-2/5", + "donor": 98470, + "gcd": 76009881600, + "input_owner": 348, + "previous_gcd": 380049408000, + "row": 155944, + "scaled_product": 157317345267539672325221723720908800 + }, + { + "coefficient": "-74/79", + "donor": 102948, + "gcd": 962150400, + "input_owner": 1185, + "previous_gcd": 76009881600, + "row": 155935, + "scaled_product": 333093470305752733995994447872000000 + }, + { + "coefficient": "145037/663040", + "donor": 37, + "gcd": 481075200, + "input_owner": 288, + "previous_gcd": 962150400, + "row": 155691, + "scaled_product": 75836624456474558489793162783744000 + }, + { + "coefficient": "1475669/1326080", + "donor": 37, + "gcd": 240537600, + "input_owner": 288, + "previous_gcd": 481075200, + "row": 155822, + "scaled_product": 385797264749896079111104706840064000 + }, + { + "coefficient": "6169895/530432", + "donor": 37, + "gcd": 120268800, + "input_owner": 288, + "previous_gcd": 240537600, + "row": 155292, + "scaled_product": 4032626244086682157426918528492800000 + }, + { + "coefficient": "-6309957/4243456", + "donor": 36, + "gcd": 60134400, + "input_owner": 404, + "previous_gcd": 120268800, + "row": 155294, + "scaled_product": -2666097408319634398486492817260416000 + }, + { + "coefficient": "-6830953/10608640", + "donor": 37, + "gcd": 30067200, + "input_owner": 288, + "previous_gcd": 60134400, + "row": 155294, + "scaled_product": -223234595887958010171339069813696000 + } + ], + "public": 1279, + "retired_and_guards_restored": true, + "same_owner_complete_fixture_outputs": 1279, + "selected_logical_operations": { + "clear_full_sender_after_return": 5714, + "initialize_complete_dirty_home": 8277, + "initialize_empty_sender_before_departure": 5714, + "read_immutable_donor": 211660, + "read_parked_sender": 5714, + "read_terminal_for_same_owner_install": 1279, + "retire_complete_home": 8277, + "stage_full_sender": 5714, + "write_complete_return": 5714, + "write_entrance": 1279, + "write_terminal": 1279 + }, + "separate_guide_tracks": 1, + "slots": 5714, + "terms": 211660, + "trace_sha256": "e5304596dcfd23ad9c7f49ab44d8ac1c0c7282f3c97725ab87e9d7b4925fc0a1", + "tracked_stream_reset_visits": 641973 + }, + "native_sha256": "03ef8f6cc9ebb7394b5c7f8da70d44df965659ae4ff361bbc8d32c7a12121445", + "ordinary_binary": "7739399/2000000000", + "remaining_to_target": "0", + "schema": "p104-subdivided-joint-application/v1", + "target": "0.00386380485468" +} diff --git a/research/p104-subdivided-helper-births/evidence/binary-independent-finite.json b/research/p104-subdivided-helper-births/evidence/binary-independent-finite.json new file mode 100644 index 0000000000..1a0e91d935 --- /dev/null +++ b/research/p104-subdivided-helper-births/evidence/binary-independent-finite.json @@ -0,0 +1,191 @@ +{ + "above_frozen_target": [ + "0.000005894845320000", + "0.000005894845320000" + ], + "above_previous_ordinary": [ + "0.000010738210000000", + "0.000010738210000000" + ], + "above_public_7776_joint_raw_upper": [ + "0.000010737857520000", + "0.000010737857520000" + ], + "after_delayed_cover": "19348499/5000000000", + "after_uniform": "38696999/10000000000", + "binary_signed_gain": [ + "4.282431719690384673905899675777127807141", + "4.282431719690384673905899675777127807142" + ], + "candidate_canonical_sha256": "861f5181e4f34db638ab0c573c319fe26ff034d63b21242d67220a4a5d6433ff", + "compiler": { + "H": 297620000000000, + "N": "2^297620000000000", + "ambient_base": 134, + "cutoff": 15, + "eta": [ + "0.000000475018405997932847886160808975467", + "0.000000475018405997932847886160808975468" + ], + "logarithm_power": 619, + "lost_low_targets": "charged owned zero specializations", + "maximum_productive_rank": "127^768", + "normalized_separation_slack": [ + "0.000347020485272205", + "0.000347020485272206" + ], + "paid_offset": "1/5", + "preceding_grid_failed": true, + "previous_power_failed": true, + "product_exponent": 768, + "productive_floor": 16, + "ratio_intervals": [ + [ + "0.999999547993554305662725571461467239275", + "0.999999547993554305662725571461467239276" + ], + [ + "0.872798544807909232716151613943320380977", + "0.872798544807909232716151613943320380978" + ], + [ + "0.950920668515790232689013357229871973148", + "0.950920668515790232689013357229871973149" + ] + ], + "target_offset": "1/5", + "theta": "42/43", + "trial": "38697/10000000", + "upper_ratios": [ + "2499998869983885764157/2500000000000000000000", + "4363992724039546163581/5000000000000000000000", + "9509206685157902326891/10000000000000000000000" + ], + "working_ambient": "134^768" + }, + "complete_binary_paid": { + "1": 50340, + "2": 45828, + "3": 2016, + "4": 1512, + "5": 324, + "6": 3960, + "7": 444, + "14": 444, + "21": 444, + "28": 444, + "35": 444, + "42": 444, + "49": 444, + "56": 444 + }, + "complete_productive": { + "1": 288, + "2": 36, + "4": 1548, + "6": 36, + "7": 288, + "8": 14448, + "15": 444, + "22": 444, + "29": 444, + "36": 444, + "43": 444, + "50": 444, + "57": 444, + "64": 444, + "127": 222 + }, + "independent_literal_receipt_sha256": "d447a00f9de0bca1d3a49faa73a020b5b619ead8ca5ade951d2f794cebffe3cf", + "margin_at_finite_trial": [ + "0.130782551544995351273835757774925302681", + "0.130782551544995351273835757774925302682" + ], + "new_binary_signed_margin": [ + "2.407057091843059813136877472966788264495", + "2.407057091843059813136877472966788264496" + ], + "old_7776_binary_margin": [ + "-1.875374627847324860769022202810339542646", + "-1.875374627847324860769022202810339542645" + ], + "old_conditional_lower": "0.00385896148992", + "old_joint_raw_upper": "0.00385896184248", + "old_public_binary_bracket": [ + "0.00385896184247", + "0.00385896184248" + ], + "old_public_complex_bracket": [ + "0.00385932267587", + "0.00385932267588" + ], + "old_source_head": "4f7c67ae387cc91580f469aeda4d508b372b9ec1", + "ordinary_admitted": "0.00386969970", + "ordinary_stages": [ + { + "claim": "0.00386963090", + "envelope": [ + "0.003869630920800000", + "0.003869630920800000" + ], + "previous": "12039/3125000", + "slack": [ + "0.000000000020800000", + "0.000000000020800000" + ] + }, + { + "claim": "0.00386969950", + "envelope": [ + "0.003869699524400000", + "0.003869699524400000" + ], + "previous": "38696309/10000000000", + "slack": [ + "0.000000000024400000", + "0.000000000024400000" + ] + }, + { + "claim": "0.00386969970", + "envelope": [ + "0.003869699798800000", + "0.003869699798800000" + ], + "previous": "7739399/2000000000", + "slack": [ + "0.000000000098800000", + "0.000000000098800000" + ] + } + ], + "per_phase_uniform_and_cover_loss": "1/10000000000", + "published_ordinary_admitted": "0.00386969950", + "raw_crossing": { + "bracket": [ + "0.003870038707744", + "0.003870038707745" + ], + "derivative_upper": "-379907.633855757858", + "endpoint_margins": [ + [ + "0.000000000067477903775342347085990636132", + "0.000000000067477903775342347085990636133" + ], + [ + "-0.000000000318643951093138800761855050442", + "-0.000000000318643951093138800761855050441" + ] + ] + }, + "record_scope": "Conditional ordinary BIT under inherited physical, finite compiler, cover and stock theorems.", + "status": "PASS_INDEPENDENT_BINARY_FINITE_AND_ORDINARY", + "stock": { + "D": "2+ceil(log_N(max(1,ceil(e/w))))", + "high_digit_backing": "O_fixed(w log e)", + "rho": "1/250", + "small_width_backing": "W(w)^D * predecessor", + "w": "ceil(e^rho)" + }, + "target": "0.00386380485468" +} diff --git a/research/p104-subdivided-helper-births/evidence/binary-independent-native.json b/research/p104-subdivided-helper-births/evidence/binary-independent-native.json new file mode 100644 index 0000000000..4d2dddcec1 --- /dev/null +++ b/research/p104-subdivided-helper-births/evidence/binary-independent-native.json @@ -0,0 +1,177 @@ +{ + "birth_composition": { + "native_paid_delta": { + "1": 8, + "2": 20, + "3": 2, + "4": -5, + "6": 6, + "7": -10 + }, + "native_target_delta": { + "1": 8, + "4": 26, + "7": 8, + "8": -21 + }, + "parent_native_paid": { + "1": 1378, + "2": 1253, + "3": 54, + "4": 47, + "5": 9, + "6": 104, + "7": 10 + }, + "parent_native_targets": { + "2": 1, + "4": 17, + "6": 1, + "8": 410 + }, + "split_roles": [ + 237, + 241, + 249, + 250, + 258, + 264, + 274, + 293, + 297, + 315, + 318, + 351, + 355, + 383, + 387, + 391, + 411, + 420, + 432, + 433, + 435 + ] + }, + "caller_events": { + "ADD": 362, + "IDLE_ONE": 32, + "LOCAL": 36, + "QUERY": 4, + "SWAP": 364 + }, + "caller_polynomial_coefficients_each_way": 1444, + "caller_sha256": "757b3523798f840bdb02028b23708c3416627a99ea09e7a3c4bcdc5cd0c7ce4b", + "candidate_canonical_sha256": "861f5181e4f34db638ab0c573c319fe26ff034d63b21242d67220a4a5d6433ff", + "candidate_file_sha256": "e5871a4cf87d62aa90e6660d351636aa5ca47f50239916a0943cd433c7f3d323", + "candidate_gzip_sha256": "a63f07a5f5ac4aa28b5b635c7836f36efafd03b735ab13f24c8b481d137d54e8", + "dual_nonzero_retirement": 3548, + "forward_peak_owned": 3548, + "frames": 636, + "held_out_controls": { + "changed_coefficients": 1, + "changed_input_columns": [ + 671 + ], + "changed_output_rows": [ + 671 + ], + "dirty_CLEAR_control": "rejected at terminal retirement", + "helper": 671, + "omitted_ADD_clock": 371, + "omitted_CLEAR_clock": 38911, + "operation": [ + "ADD", + 776, + 671, + 0 + ] + }, + "instruction_counts": { + "ADD": 32486, + "CLEAR": 3548, + "INIT": 3548, + "MOVE": 2876, + "SWAP": 672 + }, + "main_ports": 111, + "native_calls": 36, + "native_paid": { + "1": 1386, + "2": 1273, + "3": 56, + "4": 42, + "5": 9, + "6": 110 + }, + "native_scalar_coefficients_each_way": 451584, + "native_targets": { + "1": 8, + "2": 1, + "4": 43, + "6": 1, + "7": 8, + "8": 389 + }, + "ordinary": { + "caller_bank_transits": 3507600, + "native_bank_transits_per_call": 2914897920, + "native_banks_and_scratch": 4224, + "ordinary_records": 933004517520, + "owned_backing": 6998328, + "raw_ordinary_allowance": 1000000000000, + "raw_owned_allowance": 10000000, + "route_groups": 572184, + "route_records": 828064684800 + }, + "owned_nonzero_CLEAR": 3548, + "paid": { + "1": 50340, + "2": 45828, + "3": 2016, + "4": 1512, + "5": 324, + "6": 3960, + "7": 444, + "14": 444, + "21": 444, + "28": 444, + "35": 444, + "42": 444, + "49": 444, + "56": 444 + }, + "public": 672, + "raw_prime_exclusion_factors": [ + 1, + 2, + 4, + 16, + 64 + ], + "reverse_peak_owned": 3548, + "signed_rank_surplus": 1506, + "source_head": "4f7c67ae387cc91580f469aeda4d508b372b9ec1", + "source_pr": 7776, + "source_residual_native_sha256": "07f5fe923b50ecc26983054cf8f462b1a2b4a008a5e2c7a472209363abaaa35c", + "source_word_sha256": "51203e7fc75ba10bd3ac3f8e675759f47e13d262bea66b6600d1e515095cad78", + "status": "PASS_INDEPENDENT_LITERAL_BINARY_BIRTHS", + "targets": { + "1": 288, + "2": 36, + "4": 1548, + "6": 36, + "7": 288, + "8": 14448, + "15": 444, + "22": 444, + "29": 444, + "36": 444, + "43": 444, + "50": 444, + "57": 444, + "64": 444, + "127": 222 + }, + "witnessed_input_sha256": "9cdb651f7166c01abb9027535d36424da71944932f3b6f84057a12ae12ba6ad2" +} diff --git a/research/p104-subdivided-helper-births/evidence/binary-independent.json b/research/p104-subdivided-helper-births/evidence/binary-independent.json new file mode 100644 index 0000000000..7b40e201bd --- /dev/null +++ b/research/p104-subdivided-helper-births/evidence/binary-independent.json @@ -0,0 +1,371 @@ +{ + "finite": { + "above_frozen_target": [ + "0.000005894845320000", + "0.000005894845320000" + ], + "above_previous_ordinary": [ + "0.000010738210000000", + "0.000010738210000000" + ], + "above_public_7776_joint_raw_upper": [ + "0.000010737857520000", + "0.000010737857520000" + ], + "after_delayed_cover": "19348499/5000000000", + "after_uniform": "38696999/10000000000", + "binary_signed_gain": [ + "4.282431719690384673905899675777127807141", + "4.282431719690384673905899675777127807142" + ], + "candidate_canonical_sha256": "861f5181e4f34db638ab0c573c319fe26ff034d63b21242d67220a4a5d6433ff", + "compiler": { + "H": 297620000000000, + "N": "2^297620000000000", + "ambient_base": 134, + "cutoff": 15, + "eta": [ + "0.000000475018405997932847886160808975467", + "0.000000475018405997932847886160808975468" + ], + "logarithm_power": 619, + "lost_low_targets": "charged owned zero specializations", + "maximum_productive_rank": "127^768", + "normalized_separation_slack": [ + "0.000347020485272205", + "0.000347020485272206" + ], + "paid_offset": "1/5", + "preceding_grid_failed": true, + "previous_power_failed": true, + "product_exponent": 768, + "productive_floor": 16, + "ratio_intervals": [ + [ + "0.999999547993554305662725571461467239275", + "0.999999547993554305662725571461467239276" + ], + [ + "0.872798544807909232716151613943320380977", + "0.872798544807909232716151613943320380978" + ], + [ + "0.950920668515790232689013357229871973148", + "0.950920668515790232689013357229871973149" + ] + ], + "target_offset": "1/5", + "theta": "42/43", + "trial": "38697/10000000", + "upper_ratios": [ + "2499998869983885764157/2500000000000000000000", + "4363992724039546163581/5000000000000000000000", + "9509206685157902326891/10000000000000000000000" + ], + "working_ambient": "134^768" + }, + "complete_binary_paid": { + "1": 50340, + "2": 45828, + "3": 2016, + "4": 1512, + "5": 324, + "6": 3960, + "7": 444, + "14": 444, + "21": 444, + "28": 444, + "35": 444, + "42": 444, + "49": 444, + "56": 444 + }, + "complete_productive": { + "1": 288, + "2": 36, + "4": 1548, + "6": 36, + "7": 288, + "8": 14448, + "15": 444, + "22": 444, + "29": 444, + "36": 444, + "43": 444, + "50": 444, + "57": 444, + "64": 444, + "127": 222 + }, + "independent_literal_receipt_sha256": "d447a00f9de0bca1d3a49faa73a020b5b619ead8ca5ade951d2f794cebffe3cf", + "margin_at_finite_trial": [ + "0.130782551544995351273835757774925302681", + "0.130782551544995351273835757774925302682" + ], + "new_binary_signed_margin": [ + "2.407057091843059813136877472966788264495", + "2.407057091843059813136877472966788264496" + ], + "old_7776_binary_margin": [ + "-1.875374627847324860769022202810339542646", + "-1.875374627847324860769022202810339542645" + ], + "old_conditional_lower": "0.00385896148992", + "old_joint_raw_upper": "0.00385896184248", + "old_public_binary_bracket": [ + "0.00385896184247", + "0.00385896184248" + ], + "old_public_complex_bracket": [ + "0.00385932267587", + "0.00385932267588" + ], + "old_source_head": "4f7c67ae387cc91580f469aeda4d508b372b9ec1", + "ordinary_admitted": "0.00386969970", + "ordinary_stages": [ + { + "claim": "0.00386963090", + "envelope": [ + "0.003869630920800000", + "0.003869630920800000" + ], + "previous": "12039/3125000", + "slack": [ + "0.000000000020800000", + "0.000000000020800000" + ] + }, + { + "claim": "0.00386969950", + "envelope": [ + "0.003869699524400000", + "0.003869699524400000" + ], + "previous": "38696309/10000000000", + "slack": [ + "0.000000000024400000", + "0.000000000024400000" + ] + }, + { + "claim": "0.00386969970", + "envelope": [ + "0.003869699798800000", + "0.003869699798800000" + ], + "previous": "7739399/2000000000", + "slack": [ + "0.000000000098800000", + "0.000000000098800000" + ] + } + ], + "per_phase_uniform_and_cover_loss": "1/10000000000", + "published_ordinary_admitted": "0.00386969950", + "raw_crossing": { + "bracket": [ + "0.003870038707744", + "0.003870038707745" + ], + "derivative_upper": "-379907.633855757858", + "endpoint_margins": [ + [ + "0.000000000067477903775342347085990636132", + "0.000000000067477903775342347085990636133" + ], + [ + "-0.000000000318643951093138800761855050442", + "-0.000000000318643951093138800761855050441" + ] + ] + }, + "record_scope": "Conditional ordinary BIT under inherited physical, finite compiler, cover and stock theorems.", + "status": "PASS_INDEPENDENT_BINARY_FINITE_AND_ORDINARY", + "stock": { + "D": "2+ceil(log_N(max(1,ceil(e/w))))", + "high_digit_backing": "O_fixed(w log e)", + "rho": "1/250", + "small_width_backing": "W(w)^D * predecessor", + "w": "ceil(e^rho)" + }, + "target": "0.00386380485468" + }, + "native": { + "birth_composition": { + "native_paid_delta": { + "1": 8, + "2": 20, + "3": 2, + "4": -5, + "6": 6, + "7": -10 + }, + "native_target_delta": { + "1": 8, + "4": 26, + "7": 8, + "8": -21 + }, + "parent_native_paid": { + "1": 1378, + "2": 1253, + "3": 54, + "4": 47, + "5": 9, + "6": 104, + "7": 10 + }, + "parent_native_targets": { + "2": 1, + "4": 17, + "6": 1, + "8": 410 + }, + "split_roles": [ + 237, + 241, + 249, + 250, + 258, + 264, + 274, + 293, + 297, + 315, + 318, + 351, + 355, + 383, + 387, + 391, + 411, + 420, + 432, + 433, + 435 + ] + }, + "caller_events": { + "ADD": 362, + "IDLE_ONE": 32, + "LOCAL": 36, + "QUERY": 4, + "SWAP": 364 + }, + "caller_polynomial_coefficients_each_way": 1444, + "caller_sha256": "757b3523798f840bdb02028b23708c3416627a99ea09e7a3c4bcdc5cd0c7ce4b", + "candidate_canonical_sha256": "861f5181e4f34db638ab0c573c319fe26ff034d63b21242d67220a4a5d6433ff", + "candidate_file_sha256": "e5871a4cf87d62aa90e6660d351636aa5ca47f50239916a0943cd433c7f3d323", + "candidate_gzip_sha256": "a63f07a5f5ac4aa28b5b635c7836f36efafd03b735ab13f24c8b481d137d54e8", + "dual_nonzero_retirement": 3548, + "forward_peak_owned": 3548, + "frames": 636, + "held_out_controls": { + "changed_coefficients": 1, + "changed_input_columns": [ + 671 + ], + "changed_output_rows": [ + 671 + ], + "dirty_CLEAR_control": "rejected at terminal retirement", + "helper": 671, + "omitted_ADD_clock": 371, + "omitted_CLEAR_clock": 38911, + "operation": [ + "ADD", + 776, + 671, + 0 + ] + }, + "instruction_counts": { + "ADD": 32486, + "CLEAR": 3548, + "INIT": 3548, + "MOVE": 2876, + "SWAP": 672 + }, + "main_ports": 111, + "native_calls": 36, + "native_paid": { + "1": 1386, + "2": 1273, + "3": 56, + "4": 42, + "5": 9, + "6": 110 + }, + "native_scalar_coefficients_each_way": 451584, + "native_targets": { + "1": 8, + "2": 1, + "4": 43, + "6": 1, + "7": 8, + "8": 389 + }, + "ordinary": { + "caller_bank_transits": 3507600, + "native_bank_transits_per_call": 2914897920, + "native_banks_and_scratch": 4224, + "ordinary_records": 933004517520, + "owned_backing": 6998328, + "raw_ordinary_allowance": 1000000000000, + "raw_owned_allowance": 10000000, + "route_groups": 572184, + "route_records": 828064684800 + }, + "owned_nonzero_CLEAR": 3548, + "paid": { + "1": 50340, + "2": 45828, + "3": 2016, + "4": 1512, + "5": 324, + "6": 3960, + "7": 444, + "14": 444, + "21": 444, + "28": 444, + "35": 444, + "42": 444, + "49": 444, + "56": 444 + }, + "public": 672, + "raw_prime_exclusion_factors": [ + 1, + 2, + 4, + 16, + 64 + ], + "reverse_peak_owned": 3548, + "signed_rank_surplus": 1506, + "source_head": "4f7c67ae387cc91580f469aeda4d508b372b9ec1", + "source_pr": 7776, + "source_residual_native_sha256": "07f5fe923b50ecc26983054cf8f462b1a2b4a008a5e2c7a472209363abaaa35c", + "source_word_sha256": "51203e7fc75ba10bd3ac3f8e675759f47e13d262bea66b6600d1e515095cad78", + "status": "PASS_INDEPENDENT_LITERAL_BINARY_BIRTHS", + "targets": { + "1": 288, + "2": 36, + "4": 1548, + "6": 36, + "7": 288, + "8": 14448, + "15": 444, + "22": 444, + "29": 444, + "36": 444, + "43": 444, + "50": 444, + "57": 444, + "64": 444, + "127": 222 + }, + "witnessed_input_sha256": "9cdb651f7166c01abb9027535d36424da71944932f3b6f84057a12ae12ba6ad2" + }, + "status": "PASS_INDEPENDENT_BINARY_BIRTHS_AND_FINITE_ORDINARY" +} diff --git a/research/p104-subdivided-helper-births/evidence/charts-0.json b/research/p104-subdivided-helper-births/evidence/charts-0.json new file mode 100644 index 0000000000..e483462238 --- /dev/null +++ b/research/p104-subdivided-helper-births/evidence/charts-0.json @@ -0,0 +1,23 @@ +{ + "charts": { + "checked_pairs": 985, + "contacts": 560, + "contacts_sha256": "48e85c514d93eb66a5690de05819acf9c6c0a6aa7906ff8eb7c55a2e8344f200", + "dense_pairs": [ + [ + 0, + 249 + ], + [ + 3, + 288 + ] + ], + "forward_and_adjoint_columns": 2048, + "ports": 35, + "recipes_sha256": "92309782a255940a23045edb3981de28fc984533fc7875d7317a0febd08bac5a", + "shard": 0, + "total_pairs": 2953 + }, + "native_sha256": "03ef8f6cc9ebb7394b5c7f8da70d44df965659ae4ff361bbc8d32c7a12121445" +} diff --git a/research/p104-subdivided-helper-births/evidence/charts-1.json b/research/p104-subdivided-helper-births/evidence/charts-1.json new file mode 100644 index 0000000000..3f936e8dcc --- /dev/null +++ b/research/p104-subdivided-helper-births/evidence/charts-1.json @@ -0,0 +1,19 @@ +{ + "charts": { + "checked_pairs": 984, + "contacts": 560, + "contacts_sha256": "367465c30dcb2c26380faa45f3c25475e07853afb37032fe72516ea7ccb62f40", + "dense_pairs": [ + [ + 0, + 250 + ] + ], + "forward_and_adjoint_columns": 1024, + "ports": 35, + "recipes_sha256": "27cda72b0c80961465bf7e585292182fdc1fc5e4c7a66d0b7ddd84a02a6ae2d2", + "shard": 1, + "total_pairs": 2953 + }, + "native_sha256": "03ef8f6cc9ebb7394b5c7f8da70d44df965659ae4ff361bbc8d32c7a12121445" +} diff --git a/research/p104-subdivided-helper-births/evidence/charts-2.json b/research/p104-subdivided-helper-births/evidence/charts-2.json new file mode 100644 index 0000000000..c809e466ad --- /dev/null +++ b/research/p104-subdivided-helper-births/evidence/charts-2.json @@ -0,0 +1,23 @@ +{ + "charts": { + "checked_pairs": 984, + "contacts": 544, + "contacts_sha256": "35d2dc786a977215dba2264b899ff1b4f77b8cbb9a88e4b0e30cc658edaf79a8", + "dense_pairs": [ + [ + 0, + 251 + ], + [ + 767, + 127 + ] + ], + "forward_and_adjoint_columns": 2048, + "ports": 34, + "recipes_sha256": "ef86941e8d222532c64f5189a7e2173c080b5306a4a19dd6ec4a825d747f3daa", + "shard": 2, + "total_pairs": 2953 + }, + "native_sha256": "03ef8f6cc9ebb7394b5c7f8da70d44df965659ae4ff361bbc8d32c7a12121445" +} diff --git a/research/p104-subdivided-helper-births/evidence/overlay-operator.json b/research/p104-subdivided-helper-births/evidence/overlay-operator.json new file mode 100644 index 0000000000..cff3d5fe63 --- /dev/null +++ b/research/p104-subdivided-helper-births/evidence/overlay-operator.json @@ -0,0 +1,2098 @@ +{ + "base": { + "adjoint_rows": 1264, + "adjoint_sha256": "a86b681a0cc0f5eb08d15ad0778e0b702f1d4a7c0eb2adbdd22f6d0654ae7fa9", + "content_sha256": "934b7d4d792a5771bbcd28053d7797a9938f6b23faddaafe46451158eec81849", + "file_sha256": "db8219bc0b861ab12de077d3d80ee337b28380c50aa30ca8d29629ee7eac931e", + "forms": 6965, + "forward_rows": 1264, + "forward_sha256": "443f93ec7d06ea2c86c2b650e04cfae50af728e88c9fd71025572c4c8d1a7b52", + "helpers": 864, + "main": 400, + "native_paid": { + "1": 3835, + "2": 797, + "3": 489, + "4": 223, + "5": 295, + "6": 55, + "7": 5, + "8": 2 + }, + "native_productive": { + "1": 18, + "2": 7, + "3": 7, + "4": 220, + "5": 11, + "7": 15, + "8": 35, + "9": 551 + }, + "paid_moves": 5701, + "public": 1264, + "rational_literals": 204869 + }, + "base_layout": { + "content_sha256": "d233f9ba1fc39c4be51685a45da1940fe43dc3a3fd7699a8b27339e1e063b489", + "file_sha256": "ee0d19052d407703baa024de706fc43e14f092af53763c4e7d6a9762a5e151f9" + }, + "candidate": { + "adjoint_rows": 1278, + "adjoint_sha256": "649ed502129a7ff7ff99a43b8aa30d6343502a6f9db013e8c04a73f0b1f39920", + "content_sha256": "6eba6bb65015df98cf103ce6d12fdd982ba4dcd24a69000bcc58e05477b17c19", + "file_sha256": "b3578494d577c44b869823ea22a99e641f58ca45105cb6629e8d7f88d9c96d96", + "forms": 6992, + "forward_rows": 1278, + "forward_sha256": "4a996cf2bc4bb7db3b3a9673aede04f4b5317989384bd098104a7fc561b42ccb", + "helpers": 878, + "main": 400, + "native_paid": { + "1": 3850, + "2": 795, + "3": 489, + "4": 222, + "5": 307, + "6": 45, + "7": 4, + "8": 2 + }, + "native_productive": { + "1": 18, + "2": 7, + "3": 8, + "4": 233, + "5": 25, + "7": 15, + "8": 34, + "9": 538 + }, + "paid_moves": 5714, + "public": 1278, + "rational_literals": 212652 + }, + "candidate_layout": { + "content_sha256": "60ced30a6d7b69c580c8822756f38c11c0d2a904e3ed1235fbbfd176419e36d3", + "file_sha256": "5f44174899e3179ae27a4801c81177ddcdb049f8fd20b40e52773fdb35bf59dc" + }, + "checker_sha256": "c21f8ab26b4a3b9d045fc15d008d93e30d51c3fadad81ef4c87103c14569f997", + "closed_caller": { + "exact_local_operators": { + "A": { + "exponent_bits": 4, + "maximum_stage_occurrences": 15, + "minimum_grid": 4, + "peak_mass": "256", + "peak_native_entrance_mass": "26", + "preproduct_divisions": 2686, + "separate_component_divisions": 9904 + }, + "rotated": { + "exponent_bits": 4, + "maximum_stage_occurrences": 15, + "minimum_grid": 8, + "peak_mass": "212", + "peak_native_entrance_mass": "91/2", + "preproduct_divisions": 8308, + "separate_component_divisions": 17868 + } + }, + "finite_binding": { + "ambient": 137, + "calls": 48, + "helper_label_sha256": "783037b06ce54e905782bc769f4b5c38457101adddfd32c657808fefecfd9435", + "local_colors": 16, + "native_main_bindings": 19200, + "physical_port_contacts": 4992, + "root_owners": 9840, + "stage_binding_sha256": "63f377afa2afe07ec5e13ffbe516daf049524a665b0468ca42ed245de5e00762", + "stage_helper_owners": 42144, + "template_roots": { + "A": 120, + "rotated": 192 + } + }, + "fixed_paid": { + "1": 480, + "8": 1248, + "16": 1248, + "24": 1248, + "32": 1248, + "40": 1248, + "48": 1248, + "56": 1248 + }, + "fixed_targets": { + "9": 480, + "17": 1248, + "25": 1248, + "33": 1248, + "41": 1248, + "49": 1248, + "57": 1248, + "65": 1248, + "129": 624 + }, + "readback": { + "event_stream_sha256": "156fdf3a4a129b39225fd6ca51011de27974d7f104e8b04907c17ed5344bc858", + "events": 840912, + "op_counts": { + "ADD": 575856, + "IDLE_ONE": 8736, + "LAMBDA": 30000, + "NATIVE": 48, + "PORT_VIEWS": 96, + "QUERY": 480, + "SCALE": 128688, + "SWAP": 97008 + } + } + }, + "fault_controls": { + "changed_paid_signs": { + "all_rows_directly_replayed_after_sign_mutation": 58, + "mutated_adjoint_sha256": "0055f9f5224157584cea483c2e73d36677a9fb1dab8173684e35c6e017337635", + "mutated_forward_sha256": "de8fbaaf2b198ecb0bc9c9ab14d5f774b4971383d8985d31447c0ce71ce58916", + "nonzero_rank_one_witnesses": [ + { + "faulty_coefficient": "-4", + "first_changed_terminal": 296, + "original_coefficient": "0", + "paid_input_coefficient": "2", + "paid_key": 58, + "source_address": 2, + "terminal_pulse_coefficient": "1" + }, + { + "faulty_coefficient": "-4", + "first_changed_terminal": 296, + "original_coefficient": "0", + "paid_input_coefficient": "2", + "paid_key": 91128, + "source_address": 2, + "terminal_pulse_coefficient": "1" + }, + { + "faulty_coefficient": "1/16", + "first_changed_terminal": 126, + "original_coefficient": "0", + "paid_input_coefficient": "-1/2", + "paid_key": 66, + "source_address": 16, + "terminal_pulse_coefficient": "1/16" + }, + { + "faulty_coefficient": "2", + "first_changed_terminal": 19, + "original_coefficient": "0", + "paid_input_coefficient": "-1/2", + "paid_key": 91933, + "source_address": 16, + "terminal_pulse_coefficient": "2" + }, + { + "faulty_coefficient": "10", + "first_changed_terminal": 40, + "original_coefficient": "0", + "paid_input_coefficient": "1/2", + "paid_key": 59, + "source_address": 21, + "terminal_pulse_coefficient": "-10" + }, + { + "faulty_coefficient": "1/3444", + "first_changed_terminal": 40, + "original_coefficient": "0", + "paid_input_coefficient": "1/68880", + "paid_key": 95923, + "source_address": 1272, + "terminal_pulse_coefficient": "-10" + }, + { + "faulty_coefficient": "-4", + "first_changed_terminal": 297, + "original_coefficient": "0", + "paid_input_coefficient": "-1", + "paid_key": 68, + "source_address": 2, + "terminal_pulse_coefficient": "-2" + }, + { + "faulty_coefficient": "4", + "first_changed_terminal": 297, + "original_coefficient": "0", + "paid_input_coefficient": "1", + "paid_key": 96016, + "source_address": 2, + "terminal_pulse_coefficient": "-2" + }, + { + "faulty_coefficient": "-1/2", + "first_changed_terminal": 297, + "original_coefficient": "0", + "paid_input_coefficient": "1/4", + "paid_key": 60, + "source_address": 3, + "terminal_pulse_coefficient": "1" + }, + { + "faulty_coefficient": "-4", + "first_changed_terminal": 297, + "original_coefficient": "0", + "paid_input_coefficient": "2", + "paid_key": 96518, + "source_address": 9, + "terminal_pulse_coefficient": "1" + }, + { + "faulty_coefficient": "-1/8", + "first_changed_terminal": 705, + "original_coefficient": "0", + "paid_input_coefficient": "-1/8", + "paid_key": 69, + "source_address": 3, + "terminal_pulse_coefficient": "-1/2" + }, + { + "faulty_coefficient": "-1/8", + "first_changed_terminal": 705, + "original_coefficient": "0", + "paid_input_coefficient": "-1/8", + "paid_key": 97908, + "source_address": 3, + "terminal_pulse_coefficient": "-1/2" + }, + { + "faulty_coefficient": "-5/4", + "first_changed_terminal": 38, + "original_coefficient": "0", + "paid_input_coefficient": "-1/16", + "paid_key": 61, + "source_address": 3, + "terminal_pulse_coefficient": "-10" + }, + { + "faulty_coefficient": "-5/4", + "first_changed_terminal": 38, + "original_coefficient": "0", + "paid_input_coefficient": "-1/16", + "paid_key": 98406, + "source_address": 3, + "terminal_pulse_coefficient": "-10" + }, + { + "faulty_coefficient": "1/4", + "first_changed_terminal": 38, + "original_coefficient": "0", + "paid_input_coefficient": "-1/80", + "paid_key": 35, + "source_address": 3, + "terminal_pulse_coefficient": "10" + }, + { + "faulty_coefficient": "1/2", + "first_changed_terminal": 38, + "original_coefficient": "0", + "paid_input_coefficient": "-1/40", + "paid_key": 98411, + "source_address": 3, + "terminal_pulse_coefficient": "10" + }, + { + "faulty_coefficient": "11/4", + "first_changed_terminal": 17, + "original_coefficient": "0", + "paid_input_coefficient": "11/80", + "paid_key": 57, + "source_address": 3, + "terminal_pulse_coefficient": "-10" + }, + { + "faulty_coefficient": "3", + "first_changed_terminal": 17, + "original_coefficient": "0", + "paid_input_coefficient": "3/20", + "paid_key": 98796, + "source_address": 3, + "terminal_pulse_coefficient": "-10" + }, + { + "faulty_coefficient": "0", + "first_changed_terminal": 3, + "original_coefficient": "1", + "paid_input_coefficient": "1", + "paid_key": 62, + "source_address": 3, + "terminal_pulse_coefficient": "1/2" + }, + { + "faulty_coefficient": "0", + "first_changed_terminal": 3, + "original_coefficient": "1", + "paid_input_coefficient": "1", + "paid_key": 99767, + "source_address": 3, + "terminal_pulse_coefficient": "1/2" + }, + { + "faulty_coefficient": "1", + "first_changed_terminal": 28, + "original_coefficient": "0", + "paid_input_coefficient": "1", + "paid_key": 63, + "source_address": 1, + "terminal_pulse_coefficient": "-1/2" + }, + { + "faulty_coefficient": "1", + "first_changed_terminal": 28, + "original_coefficient": "0", + "paid_input_coefficient": "1", + "paid_key": 103583, + "source_address": 1, + "terminal_pulse_coefficient": "-1/2" + }, + { + "faulty_coefficient": "-1/2", + "first_changed_terminal": 715, + "original_coefficient": "0", + "paid_input_coefficient": "1/2", + "paid_key": 64, + "source_address": 18, + "terminal_pulse_coefficient": "1/2" + }, + { + "faulty_coefficient": "-1/2", + "first_changed_terminal": 715, + "original_coefficient": "0", + "paid_input_coefficient": "1/2", + "paid_key": 103820, + "source_address": 18, + "terminal_pulse_coefficient": "1/2" + }, + { + "faulty_coefficient": "-2", + "first_changed_terminal": 18, + "original_coefficient": "0", + "paid_input_coefficient": "1/2", + "paid_key": 67, + "source_address": 55, + "terminal_pulse_coefficient": "2" + }, + { + "faulty_coefficient": "-4", + "first_changed_terminal": 17, + "original_coefficient": "0", + "paid_input_coefficient": "1/2", + "paid_key": 104234, + "source_address": 55, + "terminal_pulse_coefficient": "4" + }, + { + "faulty_coefficient": "-2", + "first_changed_terminal": 52, + "original_coefficient": "0", + "paid_input_coefficient": "1/2", + "paid_key": 65, + "source_address": 15, + "terminal_pulse_coefficient": "2" + }, + { + "faulty_coefficient": "-4", + "first_changed_terminal": 52, + "original_coefficient": "0", + "paid_input_coefficient": "1", + "paid_key": 104442, + "source_address": 15, + "terminal_pulse_coefficient": "2" + } + ] + }, + "occupied_public_owner_label_rejected": true + }, + "full_invoice": { + "base": { + "paid": { + "1": 184560, + "2": 38256, + "3": 23472, + "4": 10704, + "5": 14160, + "6": 2640, + "7": 240, + "8": 1344, + "16": 1248, + "24": 1248, + "32": 1248, + "40": 1248, + "48": 1248, + "56": 1248 + }, + "targets": { + "1": 864, + "2": 336, + "3": 336, + "4": 10560, + "5": 528, + "7": 720, + "8": 1680, + "9": 26928, + "17": 1248, + "25": 1248, + "33": 1248, + "41": 1248, + "49": 1248, + "57": 1248, + "65": 1248, + "129": 624 + } + }, + "base_margin": [ + "-4.590079866111177038591549125631653695235302259430325717010", + "-4.590079866111177038591549125631653695235302259430325717009" + ], + "candidate": { + "paid": { + "1": 185280, + "2": 38160, + "3": 23472, + "4": 10656, + "5": 14736, + "6": 2160, + "7": 192, + "8": 1344, + "16": 1248, + "24": 1248, + "32": 1248, + "40": 1248, + "48": 1248, + "56": 1248 + }, + "targets": { + "1": 864, + "2": 336, + "3": 384, + "4": 11184, + "5": 1200, + "7": 720, + "8": 1632, + "9": 26304, + "17": 1248, + "25": 1248, + "33": 1248, + "41": 1248, + "49": 1248, + "57": 1248, + "65": 1248, + "129": 624 + } + }, + "candidate_margin": [ + "5.114122621700211289093028895443430160054137101156235271260", + "5.114122621700211289093028895443430160054137101156235271261" + ], + "paid_delta": { + "1": 720, + "2": -96, + "4": -48, + "5": 576, + "6": -480, + "7": -48 + }, + "saving": [ + "9.704202487811388327684578021075083855289439360586560988270", + "9.704202487811388327684578021075083855289439360586560988271" + ], + "target_delta": { + "3": 48, + "4": 624, + "5": 672, + "8": -48, + "9": -624 + } + }, + "held_owner_clear": { + "addressed_cells_cleared": 61094, + "guards_preserved": true, + "homes": 8271, + "occupied_sender_rejected_at": [ + 59, + 65, + 68, + 58, + 57, + 35, + 64, + 61, + 67, + 62, + 60, + 66, + 69, + 63 + ], + "partially_cleared_sender_rejected_at": [ + 59, + 65, + 68, + 58, + 57, + 35, + 64, + 61, + 67, + 62, + 60, + 66, + 69, + 63 + ], + "same_owner_returns": 1278, + "scope": "normalized rational held-home fixture, four independent components" + }, + "original_and_fresh_owners": [ + { + "fresh_address": 1274, + "fresh_charts": [ + 3, + 498 + ], + "fresh_label": 1527, + "matching_chart_pairs_remaining": 2, + "old_charts": [ + 3, + 127 + ], + "original_address": 126, + "original_charts": [ + 498, + 127 + ], + "original_label": 126, + "ranks": [ + 9, + 5, + 4 + ] + }, + { + "fresh_address": 1264, + "fresh_charts": [ + 232, + 127 + ], + "fresh_label": 1517, + "matching_chart_pairs_remaining": 3, + "old_charts": [ + 3, + 127 + ], + "original_address": 133, + "original_charts": [ + 3, + 232 + ], + "original_label": 133, + "ranks": [ + 9, + 4, + 5 + ] + }, + { + "fresh_address": 1275, + "fresh_charts": [ + 3, + 234 + ], + "fresh_label": 1528, + "matching_chart_pairs_remaining": 1, + "old_charts": [ + 3, + 127 + ], + "original_address": 236, + "original_charts": [ + 234, + 127 + ], + "original_label": 237, + "ranks": [ + 9, + 5, + 4 + ] + }, + { + "fresh_address": 1270, + "fresh_charts": [ + 243, + 127 + ], + "fresh_label": 1523, + "matching_chart_pairs_remaining": 1, + "old_charts": [ + 3, + 127 + ], + "original_address": 258, + "original_charts": [ + 3, + 243 + ], + "original_label": 262, + "ranks": [ + 9, + 4, + 5 + ] + }, + { + "fresh_address": 1267, + "fresh_charts": [ + 234, + 127 + ], + "fresh_label": 1520, + "matching_chart_pairs_remaining": 2, + "old_charts": [ + 3, + 127 + ], + "original_address": 324, + "original_charts": [ + 3, + 234 + ], + "original_label": 338, + "ranks": [ + 9, + 4, + 5 + ] + }, + { + "fresh_address": 1272, + "fresh_charts": [ + 234, + 127 + ], + "fresh_label": 1525, + "matching_chart_pairs_remaining": 1, + "old_charts": [ + 3, + 127 + ], + "original_address": 326, + "original_charts": [ + 3, + 234 + ], + "original_label": 340, + "ranks": [ + 9, + 4, + 5 + ] + }, + { + "fresh_address": 1277, + "fresh_charts": [ + 3, + 498 + ], + "fresh_label": 1530, + "matching_chart_pairs_remaining": 1, + "old_charts": [ + 3, + 127 + ], + "original_address": 386, + "original_charts": [ + 498, + 127 + ], + "original_label": 411, + "ranks": [ + 9, + 5, + 4 + ] + }, + { + "fresh_address": 1265, + "fresh_charts": [ + 232, + 127 + ], + "fresh_label": 1518, + "matching_chart_pairs_remaining": 2, + "old_charts": [ + 3, + 127 + ], + "original_address": 683, + "original_charts": [ + 3, + 232 + ], + "original_label": 793, + "ranks": [ + 9, + 4, + 5 + ] + }, + { + "fresh_address": 1273, + "fresh_charts": [ + 1090, + 127 + ], + "fresh_label": 1526, + "matching_chart_pairs_remaining": 1, + "old_charts": [ + 3, + 127 + ], + "original_address": 878, + "original_charts": [ + 3, + 1090 + ], + "original_label": 992, + "ranks": [ + 9, + 4, + 5 + ] + }, + { + "fresh_address": 1269, + "fresh_charts": [ + 232, + 127 + ], + "fresh_label": 1522, + "matching_chart_pairs_remaining": 1, + "old_charts": [ + 3, + 127 + ], + "original_address": 892, + "original_charts": [ + 3, + 232 + ], + "original_label": 1007, + "ranks": [ + 9, + 4, + 5 + ] + }, + { + "fresh_address": 1266, + "fresh_charts": [ + 306, + 127 + ], + "fresh_label": 1519, + "matching_chart_pairs_remaining": 3, + "old_charts": [ + 3, + 127 + ], + "original_address": 942, + "original_charts": [ + 3, + 306 + ], + "original_label": 1058, + "ranks": [ + 9, + 4, + 5 + ] + }, + { + "fresh_address": 1271, + "fresh_charts": [ + 240, + 127 + ], + "fresh_label": 1524, + "matching_chart_pairs_remaining": 1, + "old_charts": [ + 3, + 127 + ], + "original_address": 959, + "original_charts": [ + 3, + 240 + ], + "original_label": 1075, + "ranks": [ + 9, + 4, + 5 + ] + }, + { + "fresh_address": 1268, + "fresh_charts": [ + 306, + 127 + ], + "fresh_label": 1521, + "matching_chart_pairs_remaining": 2, + "old_charts": [ + 3, + 127 + ], + "original_address": 990, + "original_charts": [ + 3, + 306 + ], + "original_label": 1106, + "ranks": [ + 9, + 4, + 5 + ] + }, + { + "fresh_address": 1276, + "fresh_charts": [ + 306, + 127 + ], + "fresh_label": 1529, + "matching_chart_pairs_remaining": 1, + "old_charts": [ + 2, + 127 + ], + "original_address": 1254, + "original_charts": [ + 2, + 306 + ], + "original_label": 1501, + "ranks": [ + 8, + 3, + 5 + ] + } + ], + "other_paid_changes": { + "other_new_keys": { + "70": [ + 712, + 867 + ], + "71": [ + 3, + 240 + ] + }, + "other_recharted_keys": { + "14": [ + [ + 411, + 1061 + ], + [ + 411, + 796 + ] + ], + "20000": [ + [ + 712, + 127 + ], + [ + 867, + 127 + ] + ], + "20004": [ + [ + 1063, + 127 + ], + [ + 798, + 127 + ] + ], + "20008": [ + [ + 1040, + 127 + ], + [ + 585, + 127 + ] + ], + "20009": [ + [ + 1061, + 127 + ], + [ + 796, + 127 + ] + ], + "94072": [ + [ + 3, + 712 + ], + [ + 3, + 867 + ] + ], + "95397": [ + [ + 735, + 1063 + ], + [ + 735, + 798 + ] + ], + "95398": [ + [ + 412, + 1063 + ], + [ + 412, + 798 + ] + ], + "95845": [ + [ + 1063, + 1079 + ], + [ + 798, + 1079 + ] + ], + "96075": [ + [ + 571, + 1040 + ], + [ + 571, + 585 + ] + ], + "96076": [ + [ + 450, + 1040 + ], + [ + 450, + 585 + ] + ], + "96082": [ + [ + 1040, + 930 + ], + [ + 585, + 930 + ] + ], + "96270": [ + [ + 450, + 1040 + ], + [ + 450, + 585 + ] + ], + "96271": [ + [ + 571, + 1040 + ], + [ + 571, + 585 + ] + ], + "96283": [ + [ + 1040, + 1044 + ], + [ + 585, + 1044 + ] + ], + "97730": [ + [ + 3, + 1061 + ], + [ + 3, + 796 + ] + ], + "99468": [ + [ + 1063, + 922 + ], + [ + 798, + 922 + ] + ], + "99514": [ + [ + 739, + 1061 + ], + [ + 739, + 796 + ] + ], + "99516": [ + [ + 739, + 1061 + ], + [ + 739, + 796 + ] + ], + "99518": [ + [ + 1061, + 127 + ], + [ + 796, + 127 + ] + ], + "99623": [ + [ + 1061, + 1070 + ], + [ + 796, + 1070 + ] + ], + "99737": [ + [ + 412, + 1063 + ], + [ + 412, + 798 + ] + ], + "99738": [ + [ + 735, + 1063 + ], + [ + 735, + 798 + ] + ], + "101037": [ + [ + 1061, + 920 + ], + [ + 796, + 920 + ] + ], + "101106": [ + [ + 1063, + 922 + ], + [ + 798, + 922 + ] + ], + "101126": [ + [ + 1040, + 930 + ], + [ + 585, + 930 + ] + ] + }, + "other_retired_keys": { + "93982": [ + 3, + 394 + ], + "96857": [ + 394, + 240 + ], + "99806": [ + 712, + 867 + ] + }, + "same_chart_changed_form_keys": [ + 5, + 15, + 16, + 17, + 53, + 54, + 55, + 34006, + 88451, + 88453, + 88457, + 88475, + 88477, + 88479, + 88481, + 88487, + 88499, + 88505, + 88526, + 88528, + 88532, + 88534, + 88536, + 88551, + 88572, + 88578, + 88599, + 88601, + 88603, + 88607, + 88609, + 88613, + 88615, + 88702, + 88720, + 88732, + 88738, + 88753, + 88755, + 88759, + 88763, + 88800, + 88804, + 88806, + 88808, + 88823, + 88831, + 88836, + 88857, + 88859, + 88869, + 88874, + 88880, + 88885, + 88898, + 88913, + 88962, + 88964, + 88966, + 88968, + 88970, + 88972, + 88975, + 88979, + 88983, + 88990, + 88993, + 89005, + 89008, + 89012, + 89014, + 89019, + 89021, + 89027, + 89175, + 89320, + 89336, + 89338, + 89342, + 89344, + 89346, + 89348, + 89350, + 89352, + 89356, + 89359, + 89362, + 89374, + 89385, + 89387, + 89402, + 89407, + 89496, + 89498, + 89505, + 89627, + 89742, + 89745, + 89791, + 89794, + 89841, + 89843, + 89845, + 89848, + 89866, + 89890, + 89892, + 89894, + 89919, + 89921, + 89923, + 89925, + 89929, + 89931, + 89933, + 89958, + 89960, + 89964, + 89966, + 89968, + 89970, + 89983, + 89987, + 89989, + 89993, + 89995, + 89997, + 90003, + 90005, + 90007, + 90011, + 90013, + 90015, + 90030, + 90034, + 90036, + 90038, + 90050, + 90052, + 90054, + 90072, + 90081, + 90084, + 90094, + 90096, + 90098, + 90101, + 90132, + 90135, + 90141, + 90265, + 90271, + 90273, + 90277, + 90279, + 90281, + 90283, + 90285, + 90287, + 90307, + 90311, + 90319, + 90334, + 90336, + 90342, + 90344, + 90346, + 90348, + 90352, + 90354, + 90356, + 90369, + 90393, + 90402, + 90540, + 90542, + 90551, + 90553, + 90555, + 90557, + 90563, + 90565, + 90567, + 90569, + 90582, + 90584, + 90586, + 90588, + 90590, + 90592, + 90613, + 90623, + 90630, + 90688, + 90694, + 90696, + 90906, + 90908, + 90910, + 90913, + 90915, + 90919, + 90921, + 90923, + 90925, + 90927, + 90929, + 90931, + 90935, + 90937, + 90945, + 90947, + 90949, + 91075, + 91077, + 91079, + 91087, + 91089, + 91114, + 91148, + 91153, + 91161, + 91163, + 91165, + 91169, + 91172, + 91174, + 91178, + 91209, + 91211, + 91213, + 91220, + 91228, + 91235, + 91237, + 91240, + 91242, + 91248, + 91250, + 91259, + 91261, + 91263, + 91265, + 91269, + 91282, + 91291, + 91294, + 91296, + 91298, + 91301, + 91312, + 91314, + 91316, + 91324, + 91327, + 91338, + 91363, + 91401, + 91403, + 91411, + 91413, + 91415, + 91417, + 91419, + 91423, + 91437, + 91439, + 91441, + 91443, + 91445, + 91447, + 91463, + 91467, + 91473, + 91475, + 91488, + 91490, + 91522, + 91527, + 91687, + 91705, + 91707, + 91709, + 91718, + 91720, + 91734, + 91745, + 91755, + 91889, + 91891, + 91893, + 91896, + 91905, + 91909, + 91913, + 91925, + 91927, + 91943, + 91964, + 91986, + 92024, + 92030, + 92063, + 92111, + 92215, + 92261, + 92263, + 92300, + 92302, + 92315, + 92323, + 92343, + 92347, + 92349, + 92351, + 92353, + 92355, + 92357, + 92363, + 92367, + 92369, + 92378, + 92380, + 92382, + 92388, + 92394, + 92484, + 92486, + 92501, + 92507, + 92509, + 92521, + 92636, + 92637, + 92641, + 92643, + 92744, + 92746, + 92748, + 92750, + 92864, + 92868, + 92870, + 92883, + 92885, + 92897, + 92917, + 92922, + 92954, + 92973, + 92985, + 92987, + 92991, + 93014, + 93035, + 93037, + 93041, + 93043, + 93045, + 93047, + 93058, + 93089, + 93093, + 93171, + 93181, + 93193, + 93199, + 93215, + 93221, + 93365, + 93369, + 93371, + 93373, + 93375, + 93378, + 93400, + 93417, + 93427, + 93429, + 93523, + 93526, + 93528, + 93540, + 93547, + 93654, + 93658, + 93670, + 93677, + 93763, + 94005, + 94007, + 94008, + 94009, + 94011, + 94015, + 94017, + 94019, + 94048, + 94050, + 94061, + 94094, + 94101, + 94112, + 94158, + 94161, + 94166, + 94168, + 94170, + 94172, + 94174, + 94178, + 94180, + 94184, + 94283, + 94287, + 94289, + 94291, + 94295, + 94313, + 94318, + 94344, + 94350, + 94448, + 94452, + 94455, + 94457, + 94602, + 94630, + 94683, + 94852, + 94870, + 94872, + 94887, + 94889, + 94923, + 94937, + 94951, + 94958, + 94995, + 94997, + 94999, + 95028, + 95035, + 95042, + 95044, + 95061, + 95062, + 95067, + 95082, + 95227, + 95262, + 95318, + 95336, + 95488, + 95493, + 95658, + 95681, + 95730, + 95769, + 95771, + 95773, + 95776, + 95777, + 95779, + 95798, + 95823, + 95825, + 95853, + 95857, + 95884, + 95889, + 95955, + 95958, + 95975, + 95980, + 95982, + 96061, + 96065, + 96067, + 96073, + 96090, + 96092, + 96095, + 96097, + 96103, + 96105, + 96107, + 96115, + 96117, + 96148, + 96150, + 96155, + 96185, + 96191, + 96227, + 96288, + 96297, + 96301, + 96698, + 96752, + 96764, + 96765, + 96847, + 96944, + 96955, + 96968, + 97129, + 97135, + 97353, + 97390, + 97441, + 97587, + 97589, + 97591, + 97606, + 97725, + 97728, + 97734, + 97744, + 97746, + 97748, + 97751, + 97758, + 97771, + 97773, + 97791, + 97827, + 97855, + 97942, + 97995, + 97997, + 98080, + 98082, + 98084, + 98086, + 98091, + 98195, + 98202, + 98204, + 98210, + 98330, + 98362, + 98407, + 98420, + 98424, + 98427, + 98438, + 98514, + 98842, + 98902, + 99020, + 99022, + 99064, + 99330, + 99333, + 99631, + 99766, + 100072, + 100126, + 100176, + 100178, + 100180, + 100182, + 100184, + 100189, + 100560, + 102512, + 102548, + 103236, + 103244, + 103324, + 103327, + 103595, + 103722, + 103823, + 103891, + 103933, + 103996, + 104021, + 104022, + 104033, + 104169, + 104217, + 104246, + 104254, + 104376, + 104383, + 104384, + 104408, + 104410, + 104418 + ] + }, + "paid_subdivisions": [ + { + "interior_chart": 306, + "matching_chart_pairs_remaining": 1, + "new_leg_charts": [ + 300, + 306 + ], + "new_paid_key": 58, + "old_charts": [ + 300, + 127 + ], + "old_paid_key": 91128, + "ranks": [ + 6, + 5, + 1 + ], + "retained_leg_charts": [ + 306, + 127 + ] + }, + { + "interior_chart": 498, + "matching_chart_pairs_remaining": 2, + "new_leg_charts": [ + 498, + 127 + ], + "new_paid_key": 66, + "old_charts": [ + 494, + 127 + ], + "old_paid_key": 91933, + "ranks": [ + 6, + 1, + 5 + ], + "retained_leg_charts": [ + 494, + 498 + ] + }, + { + "interior_chart": 234, + "matching_chart_pairs_remaining": 1, + "new_leg_charts": [ + 344, + 234 + ], + "new_paid_key": 59, + "old_charts": [ + 344, + 127 + ], + "old_paid_key": 95923, + "ranks": [ + 6, + 5, + 1 + ], + "retained_leg_charts": [ + 234, + 127 + ] + }, + { + "interior_chart": 306, + "matching_chart_pairs_remaining": 1, + "new_leg_charts": [ + 299, + 306 + ], + "new_paid_key": 68, + "old_charts": [ + 299, + 127 + ], + "old_paid_key": 96016, + "ranks": [ + 6, + 5, + 1 + ], + "retained_leg_charts": [ + 306, + 127 + ] + }, + { + "interior_chart": 306, + "matching_chart_pairs_remaining": 1, + "new_leg_charts": [ + 298, + 306 + ], + "new_paid_key": 60, + "old_charts": [ + 298, + 127 + ], + "old_paid_key": 96518, + "ranks": [ + 6, + 5, + 1 + ], + "retained_leg_charts": [ + 306, + 127 + ] + }, + { + "interior_chart": 498, + "matching_chart_pairs_remaining": 1, + "new_leg_charts": [ + 498, + 127 + ], + "new_paid_key": 69, + "old_charts": [ + 488, + 127 + ], + "old_paid_key": 97908, + "ranks": [ + 7, + 2, + 5 + ], + "retained_leg_charts": [ + 488, + 498 + ] + }, + { + "interior_chart": 232, + "matching_chart_pairs_remaining": 1, + "new_leg_charts": [ + 324, + 232 + ], + "new_paid_key": 61, + "old_charts": [ + 324, + 127 + ], + "old_paid_key": 98406, + "ranks": [ + 6, + 5, + 1 + ], + "retained_leg_charts": [ + 232, + 127 + ] + }, + { + "interior_chart": 232, + "matching_chart_pairs_remaining": 1, + "new_leg_charts": [ + 325, + 232 + ], + "new_paid_key": 35, + "old_charts": [ + 325, + 517 + ], + "old_paid_key": 98411, + "ranks": [ + 5, + 4, + 1 + ], + "retained_leg_charts": [ + 232, + 517 + ] + }, + { + "interior_chart": 232, + "matching_chart_pairs_remaining": 1, + "new_leg_charts": [ + 326, + 232 + ], + "new_paid_key": 57, + "old_charts": [ + 326, + 517 + ], + "old_paid_key": 98796, + "ranks": [ + 5, + 4, + 1 + ], + "retained_leg_charts": [ + 232, + 517 + ] + }, + { + "interior_chart": 243, + "matching_chart_pairs_remaining": 1, + "new_leg_charts": [ + 432, + 243 + ], + "new_paid_key": 62, + "old_charts": [ + 432, + 127 + ], + "old_paid_key": 99767, + "ranks": [ + 6, + 5, + 1 + ], + "retained_leg_charts": [ + 243, + 127 + ] + }, + { + "interior_chart": 240, + "matching_chart_pairs_remaining": 1, + "new_leg_charts": [ + 739, + 240 + ], + "new_paid_key": 63, + "old_charts": [ + 739, + 127 + ], + "old_paid_key": 103583, + "ranks": [ + 6, + 5, + 1 + ], + "retained_leg_charts": [ + 240, + 127 + ] + }, + { + "interior_chart": 234, + "matching_chart_pairs_remaining": 1, + "new_leg_charts": [ + 722, + 234 + ], + "new_paid_key": 64, + "old_charts": [ + 722, + 127 + ], + "old_paid_key": 103820, + "ranks": [ + 6, + 5, + 1 + ], + "retained_leg_charts": [ + 234, + 127 + ] + }, + { + "interior_chart": 234, + "matching_chart_pairs_remaining": 1, + "new_leg_charts": [ + 234, + 127 + ], + "new_paid_key": 67, + "old_charts": [ + 722, + 127 + ], + "old_paid_key": 104234, + "ranks": [ + 6, + 1, + 5 + ], + "retained_leg_charts": [ + 722, + 234 + ] + }, + { + "interior_chart": 1090, + "matching_chart_pairs_remaining": 1, + "new_leg_charts": [ + 476, + 1090 + ], + "new_paid_key": 65, + "old_charts": [ + 476, + 127 + ], + "old_paid_key": 104442, + "ranks": [ + 6, + 5, + 1 + ], + "retained_leg_charts": [ + 1090, + 127 + ] + } + ], + "schema": "p104-subdivided-independent-rational-replay/v1", + "target": "0.00386380485468" +} diff --git a/research/p104-subdivided-helper-births/evidence/unchanged-complex-application.json b/research/p104-subdivided-helper-births/evidence/unchanged-complex-application.json new file mode 100644 index 0000000000..1f907d65f9 --- /dev/null +++ b/research/p104-subdivided-helper-births/evidence/unchanged-complex-application.json @@ -0,0 +1,787 @@ +{ + "application": { + "bracket": [ + "0.00385932267587", + "0.00385932267588" + ], + "claim": "0.00385932267579", + "common_root": { + "H_guard": "bit_length(context_c*1920*153**1920*(H+1)**2) < H for each actual compiler bound H", + "caller_odd": 2025, + "context_binary_bits": 136, + "context_c": 790, + "context_mass_bits": 395, + "context_mass_bound": "863184179573638032415038870317841328258513872976462813196662146758793943092459917515146069114149354264159032188928891575/16", + "exact_grid": "2^(-p-D)", + "native_binary": { + "candidate": 18 + }, + "native_odd": { + "candidate": 71282950812497579480325 + }, + "signed_width": "W=p+h+2D+3", + "temporary_width": "W+26" + }, + "compiler": { + "BIT_margin": "518841207/50000000000000", + "BIT_pin": "7739399/2000000000", + "H": "15093100000000000000", + "alpha": [ + 0.9999999999999803, + 0.9999999999999803 + ], + "claim": "385932267579/100000000000000", + "compiler_gap": "1/100000000000000", + "delta": [ + 0.8268938747715768, + 0.8268938747715768 + ], + "derivative_upper": -1008688.6760678379, + "gamma": [ + 0.9401714685511754, + 0.9401714685511754 + ], + "input_lift": { + "absolute_curvature_upper": "2355391845541459904210316251401050062978110588940190425603051116764979485783867649/25000000000000000000000000000000000000000000000000000000000000000000000000000000", + "derivative_upper_on_required_interval": "-197393444866547341726216840920961795174396270784530640052544207873039578249865804250287/1250000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "interval_kappa_cap": "7739399/2000000000", + "margins": { + "192966133793/50000000000000": [ + "131341753758409270469173942311710663510484412594662913752668762972768747637969/100000000000000000000000000000000000000000000000000000000000000000000000000000000", + "131341753758409270469173942311710663510484412594662913752668762972768747639897/100000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "385932267579/100000000000000": [ + "16417719219516854800161733031971662684667088818355613578518327383992067655437/12500000000000000000000000000000000000000000000000000000000000000000000000000000", + "65670876878067419200646932127886650738668355273422454314073309535968270622711/50000000000000000000000000000000000000000000000000000000000000000000000000000000" + ] + }, + "signed_curvature_upper": "31960881757465108748156055549877382773720954815102950527044995237546502905778087/625000000000000000000000000000000000000000000000000000000000000000000000000000", + "signed_derivative_ceiling": "17790058447175641876263482763505090461437978190383344010344228678780469811693673/2556870540597208699852484443990190621897676385208236042163599619003720232462246960" + }, + "minimum_log_power": 2368, + "moment_margin_float": { + "192966133793/50000000000000": [ + 1.4486854966536585e-08, + 1.4486854966536585e-08 + ], + "385932267587/100000000000000": [ + 4.246026476973356e-09, + 4.246026476973356e-09 + ], + "96483066897/25000000000000": [ + -5.994802012589449e-09, + -5.994802012589449e-09 + ] + }, + "moment_margins": { + "192966133793/50000000000000": [ + "90542843540853658043615685414604119367721217500596124967285968058054453/6250000000000000000000000000000000000000000000000000000000000000000000000000000", + "90542843540853658043615685414604119367721217500596124967285968064130869/6250000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "385932267587/100000000000000": [ + "13268832740541738037657310438774197754707629820072652422368008955949641/3125000000000000000000000000000000000000000000000000000000000000000000000000000", + "26537665481083476075314620877548395509415259640145304844736017918049753/6250000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "96483066897/25000000000000": [ + "-4683439072335507106878127422976003198179897855642557232878345157191757/781250000000000000000000000000000000000000000000000000000000000000000000000000", + "-37467512578684056855025019383808025585439182845140457863026761251384089/6250000000000000000000000000000000000000000000000000000000000000000000000000000" + ] + }, + "outer": { + "BIT_just_below_effective_rejected": true, + "functional_count": 4, + "minimum_margin": "1/1000000000000000", + "strict_count": 54 + }, + "raw_bracket": [ + "385932267587/100000000000000", + "96483066897/25000000000000" + ], + "tested": "192966133793/50000000000000", + "written_log_power": 2369 + }, + "depth_guard": { + "argument_bit_length": 14083, + "compiler_H": 15093100000000000000, + "strict_guard_passed": true + }, + "invoice": { + "paid": { + "1": 184560, + "2": 38256, + "3": 23472, + "4": 10704, + "5": 14160, + "6": 2640, + "7": 240, + "8": 1344, + "16": 1248, + "24": 1248, + "32": 1248, + "40": 1248, + "48": 1248, + "56": 1248 + }, + "targets": { + "1": 864, + "2": 336, + "3": 336, + "4": 10560, + "5": 528, + "7": 720, + "8": 1680, + "9": 26928, + "17": 1248, + "25": 1248, + "33": 1248, + "41": 1248, + "49": 1248, + "57": 1248, + "65": 1248, + "129": 624 + } + }, + "ordinary": { + "native_numeric_homes": 8234, + "native_paid_wrappers": 273648, + "odd_conversions": 141024, + "ordinary_elementary_record_upper": 151630617600, + "ordinary_main_pair_slots": 19200, + "ordinary_map_slots": 1598400, + "port_view_permutations": 38400, + "port_view_routing_legs": 76800, + "port_view_translations": 38400, + "raw_numeric_homes": 395232, + "raw_numeric_homes_plus_dummy": 395280, + "raw_paid_positions": 282864, + "raw_productive_targets": 51312, + "raw_scalar_incidence_allowance_before_factor_32": { + "additional_odd_factor_steps": 423072, + "boundary_installations": 121344, + "caller_slots": 840768, + "extra_gaussian_component_slots": 26299392, + "native_products_and_accumulations": 9833712, + "native_row_lifecycles": 1337280, + "odd_conversions": 141024, + "private_home_flags": 395232, + "sender_lifecycles": 547296 + }, + "reset_services_all_native_stages": 82924704, + "root_negative_q_translations": 4080, + "scalar_services": 1278051840, + "scalar_step_rate": 4294967296, + "selected_total_steps_raw_L_and_constant": [ + 12124691074368, + 54593669861856 + ], + "separate_guarded_guide_tracks_raw": 48, + "separate_guarded_streams_raw": 192, + "serial_caller_real_component_arrays": 16, + "typed_selected_transfer_legs_all_native_stages": 22220640 + } + }, + "binary_word_sha256": "861f5181e4f34db638ab0c573c319fe26ff034d63b21242d67220a4a5d6433ff", + "caller": { + "calls": 48, + "dyadic_height": 9, + "finite_binding": { + "ambient": 137, + "calls": 48, + "helper_label_sha256": "bf1da7ff60ab190cb64091a8264f3eb8a48eff1a906f96ccb3a6fd56f671b6b9", + "local_colors": 16, + "native_main_bindings": 19200, + "physical_port_contacts": 4992, + "root_owners": 9840, + "stage_binding_sha256": "c5b4e7f8af8576d8edb63d43a9a04b4f27329502e5bbd41b4ecd02741f80c2f9", + "stage_helper_owners": 41472, + "template_roots": { + "A": 120, + "rotated": 192 + } + }, + "fixed_caller_paid": { + "1": 480, + "8": 1248, + "16": 1248, + "24": 1248, + "32": 1248, + "40": 1248, + "48": 1248, + "56": 1248 + }, + "fixed_root_targets": { + "9": 480, + "17": 1248, + "25": 1248, + "33": 1248, + "41": 1248, + "49": 1248, + "57": 1248, + "65": 1248, + "129": 624 + }, + "gaussian_literal_uses": 380928, + "odd_scale": 2025, + "root_negative_q": 4080, + "root_owners": 9840, + "uses": { + "ADD": 575856, + "IDLE_ONE": 8736, + "LAMBDA": 30000, + "QUERY": 480, + "SCALE": 128688, + "SWAP": 97008 + } + }, + "caller_guard": { + "binary_height_at_all_completed_cuts_and_products": 121, + "binary_height_at_native_entrances": 118, + "normalized_bound_uses_no_cancellation_or_commutation": true, + "records": 840816, + "scaled_mass_at_all_cuts_and_products": "656748561411873243374784920314099202170021168343855390762992218430222204214651876734183800", + "scaled_mass_at_native_entrances": "8021485807695018873068752913970712173859043099335691185530999769142044976724999146587200", + "stages": 48, + "uses": { + "ADD": 575856, + "IDLE_ONE": 8736, + "LAMBDA": 30000, + "QUERY": 480, + "SCALE": 128688, + "SWAP": 97008 + } + }, + "caller_proof": { + "common_head_and_masks": { + "absolute_native_boundaries": 6656, + "atlas_sha256": "bc28417912a4dcc1a949990776163791f772d9dace2254af8090dac32c9f6930", + "body_axis_masks": [ + "0x1fe00", + "0x1fe0000", + "0x1fe000000", + "0x1fe00000000", + "0x1fe0000000000", + "0x1fe000000000000", + "0x1fe00000000000000", + "0x1fe0000000000000000", + "0x1fe000000000000000000", + "0x1fe00000000000000000000", + "0x1fe0000000000000000000000", + "0x1fe000000000000000000000000", + "0x1fe00000000000000000000000000", + "0x1fe0000000000000000000000000000", + "0x1fe000000000000000000000000000000", + "0x1fe00000000000000000000000000000000" + ], + "canonical_head_axis": 1, + "canonical_normalizers": 30000, + "central_bases": 104, + "central_characters_per_phase": 512, + "distinct_contact_colors": 1664, + "distinct_signed_target_masks": 330, + "native_phase_omission_rejected": true, + "nonzero_forward_rehead_shifts": 104, + "ordinary_head_summands_sha256": "f8d21adc6858079ca47ab01fabd247f8a7ba15b6c79c304dceaf531e19e1e454", + "used_paid_masks": 9216, + "used_targets": 9840, + "whole_axis_sets_sha256": "0f5a943a67864f8acc555cb9ad0ba27059de430462f268d3666eb050aa02f2af" + }, + "component_divisions": 4619136, + "insufficient_grid_rejected": true, + "missing_add_rejected": true, + "readback": { + "event_stream_sha256": "156fdf3a4a129b39225fd6ca51011de27974d7f104e8b04907c17ed5344bc858", + "events": 840912, + "op_counts": { + "ADD": 575856, + "IDLE_ONE": 8736, + "LAMBDA": 30000, + "NATIVE": 48, + "PORT_VIEWS": 96, + "QUERY": 480, + "SCALE": 128688, + "SWAP": 97008 + } + }, + "repeated_color_rejected": true, + "shared_main_rejected": true, + "template_bounds": { + "A": { + "entrance_height": 41, + "entrance_mass": "6387240302828290182224875", + "height": 43, + "mass": "65863546575277432099681500" + }, + "rotated": { + "entrance_height": 118, + "entrance_mass": "3961227559355564875589507611837388727831626221894168486681975194638046902086419331648", + "height": 121, + "mass": "324320277240431231296190084105728001071615391774743402845922083175418372451679939127992" + } + }, + "template_grids": { + "A": { + "exponent_bits": 4, + "maximum_stage_occurrences": 15, + "minimum_grid": 4, + "peak_mass": "256", + "peak_native_entrance_mass": "26", + "preproduct_divisions": 2686, + "separate_component_divisions": 9904 + }, + "rotated": { + "exponent_bits": 4, + "maximum_stage_occurrences": 15, + "minimum_grid": 8, + "peak_mass": "212", + "peak_native_entrance_mass": "91/2", + "preproduct_divisions": 8308, + "separate_component_divisions": 17868 + } + } + }, + "common_root": { + "H_guard": "bit_length(context_c*1920*153**1920*(H+1)**2) < H for each actual compiler bound H", + "caller_odd": 2025, + "context_binary_bits": 136, + "context_c": 790, + "context_mass_bits": 395, + "context_mass_bound": "863184179573638032415038870317841328258513872976462813196662146758793943092459917515146069114149354264159032188928891575/16", + "exact_grid": "2^(-p-D)", + "native_binary": { + "candidate": 18, + "comparator": 18 + }, + "native_odd": { + "candidate": 71282950812497579480325, + "comparator": 71282950812497579480325 + }, + "signed_width": "W=p+h+2D+3", + "temporary_width": "W+26" + }, + "comparator_joint_upper": "0.00385896184248", + "complex_crossing": [ + "0.00385932267587", + "0.00385932267588" + ], + "conversion": { + "odd_factors": [ + 15658669, + 13190315, + 12782385, + 27 + ], + "partial_clear": { + "dirty_unaddressed_last_cell_rejected": true, + "neighbor_unchanged": true + }, + "round_trips": 5056, + "scalar_cases": { + "coefficient_bits": 24, + "component_padding": 26, + "distinct_scalar_and_conversion_factors": 4789, + "rejected_one_tick_denominators": [ + 2, + 3, + 5, + 7 + ], + "retained_max_bits": 24, + "signed_bit_transducer_cases": 28734 + } + }, + "finite_lower": "0.00385932267579", + "gain_above_upper": "36083331/100000000000000", + "joint_depth_guards": { + "candidate": { + "argument_bit_length": 14083, + "compiler_H": 15093100000000000000, + "strict_guard_passed": true + }, + "comparator": { + "argument_bit_length": 14083, + "compiler_H": 15086600000000000000, + "strict_guard_passed": true + } + }, + "layout_sha256": "d233f9ba1fc39c4be51685a45da1940fe43dc3a3fd7699a8b27339e1e063b489", + "native": { + "additional_independent_guarded_streams": 4, + "all_public_inputs_preserved_until_final_installs": true, + "checked_nontrivial_divisions": 7482747, + "coefficient_products": 12705790, + "declared_senders": 1, + "deferred_terminal_banks": 1264, + "exact_all_public_rows": 1264, + "exact_odd_unscale_outputs": 1264, + "exact_source_columns": 1264, + "fixture_addressed_cells_overwritten": { + "clear_full_sender_after_return": 22804, + "initialize_complete_dirty_home": 32936, + "initialize_empty_sender_before_departure": 22804, + "retire_complete_home": 32936 + }, + "fixture_addressed_cells_per_home": 4, + "guarded_dummy_slots": 1, + "immutable_entry_banks": 1264, + "immutable_paid_return_banks": 5701, + "live_sender_alias_control_rejected": true, + "live_sender_control_slot": 104442, + "max_outstanding_native_senders": 1, + "maximum_exact_row_prefix_mass_scaled": "16166506038558007028113108095238125/4", + "minimum_product_grid": 18686397857791365475290316800, + "minimum_snapshot_grid": 53132341176725690880, + "native_scalar_scratch_homes": 4, + "numerical_homes": 8234, + "paid_native_ranks": { + "1": 3835, + "2": 797, + "3": 489, + "4": 223, + "5": 295, + "6": 55, + "7": 5, + "8": 2 + }, + "path_grid": 18686397857791365475290316800, + "path_grid_height": 18, + "path_grid_odd": 71282950812497579480325, + "path_only_grid": 561847661669784544018649013288960000, + "positive_helper_ranks": { + "1": 18, + "2": 7, + "3": 7, + "4": 220, + "5": 11, + "7": 15, + "8": 35, + "9": 551 + }, + "positive_path_mass_bound_unscaled": "3663255060065668695790454011/38826134763769267200", + "positive_path_mass_peak_node": 154808, + "product_gcd_witnesses": [ + { + "coefficient": "-1/4", + "donor": -1174, + "gcd": 140461915417446136004662253322240000, + "input_owner": 1173, + "previous_gcd": 561847661669784544018649013288960000, + "row": 89742, + "scaled_product": -140461915417446136004662253322240000 + }, + { + "coefficient": "8/3", + "donor": -1123, + "gcd": 46820638472482045334887417774080000, + "input_owner": 1122, + "previous_gcd": 140461915417446136004662253322240000, + "row": 89742, + "scaled_product": 1498260431119425450716397368770560000 + }, + { + "coefficient": "-1/16", + "donor": -502, + "gcd": 11705159618120511333721854443520000, + "input_owner": 501, + "previous_gcd": 46820638472482045334887417774080000, + "row": 89742, + "scaled_product": -35115478854361534001165563330560000 + }, + { + "coefficient": "-151/2296", + "donor": -405, + "gcd": 40784528286134185831783464960000, + "input_owner": 404, + "previous_gcd": 11705159618120511333721854443520000, + "row": 89742, + "scaled_product": -36950782627237572363595819253760000 + }, + { + "coefficient": "-1/32", + "donor": -261, + "gcd": 20392264143067092915891732480000, + "input_owner": 260, + "previous_gcd": 40784528286134185831783464960000, + "row": 89742, + "scaled_product": -17557739427180767000582781665280000 + }, + { + "coefficient": "-5/22", + "donor": -652, + "gcd": 1853842194824281174171975680000, + "input_owner": 651, + "previous_gcd": 20392264143067092915891732480000, + "row": 93982, + "scaled_product": -127692650379496487276965684838400000 + }, + { + "coefficient": "61/64", + "donor": -1133, + "gcd": 926921097412140587085987840000, + "input_owner": 1132, + "previous_gcd": 1853842194824281174171975680000, + "row": 94174, + "scaled_product": 535511052529013393517774840791040000 + }, + { + "coefficient": "-21/128", + "donor": -1120, + "gcd": 463460548706070293542993920000, + "input_owner": 1119, + "previous_gcd": 926921097412140587085987840000, + "row": 94174, + "scaled_product": -92178131992699026753059603742720000 + }, + { + "coefficient": "97/2895", + "donor": -1148, + "gcd": 480269998659140200562688000, + "input_owner": 1147, + "previous_gcd": 463460548706070293542993920000, + "row": 53, + "scaled_product": 18825292981681900093198257094656000 + }, + { + "coefficient": "-388/8685", + "donor": -1125, + "gcd": 160089999553046733520896000, + "input_owner": 1124, + "previous_gcd": 480269998659140200562688000, + "row": 53, + "scaled_product": -25100390642242533457597676126208000 + }, + { + "coefficient": "-32/27", + "donor": -1125, + "gcd": 53363333184348911173632000, + "input_owner": 1124, + "previous_gcd": 160089999553046733520896000, + "row": 98080, + "scaled_product": -665893524941966866985065497231360000 + }, + { + "coefficient": "24/17", + "donor": -1146, + "gcd": 3139019599079347716096000, + "input_owner": 1145, + "previous_gcd": 53363333184348911173632000, + "row": 90906, + "scaled_product": 793196698827931120967504489349120000 + }, + { + "coefficient": "37522/1377", + "donor": -1146, + "gcd": 1046339866359782572032000, + "input_owner": 1145, + "previous_gcd": 3139019599079347716096000, + "row": 90908, + "scaled_product": 15309838751760098519003448276418560000 + }, + { + "coefficient": "17249/4131", + "donor": -1123, + "gcd": 348779955453260857344000, + "input_owner": 1122, + "previous_gcd": 1046339866359782572032000, + "row": 90908, + "scaled_product": 2345996203374997240323814289571840000 + }, + { + "coefficient": "27/512", + "donor": -1120, + "gcd": 87194988863315214336000, + "input_owner": 1119, + "previous_gcd": 348779955453260857344000, + "row": 88528, + "scaled_product": 29628685283367544313483444060160000 + }, + { + "coefficient": "7/74", + "donor": -1264, + "gcd": 2356621320630140928000, + "input_owner": 1263, + "previous_gcd": 87194988863315214336000, + "row": 88869, + "scaled_product": 53147751779574213623385717473280000 + }, + { + "coefficient": "64/79", + "donor": -1185, + "gcd": 29830649628229632000, + "input_owner": 1184, + "previous_gcd": 2356621320630140928000, + "row": 8, + "scaled_product": 455167725909698871103715656335360000 + }, + { + "coefficient": "-1/16", + "donor": 88885, + "gcd": 14915324814114816000, + "input_owner": 1119, + "previous_gcd": 29830649628229632000, + "row": 89183, + "scaled_product": 31274723354665741219788079841280000 + }, + { + "coefficient": "-27/32", + "donor": 93761, + "gcd": 7457662407057408000, + "input_owner": 321, + "previous_gcd": 14915324814114816000, + "row": 95793, + "scaled_product": -2469057106947295359456953671680000 + }, + { + "coefficient": "-363/188", + "donor": 8, + "gcd": 158673668235264000, + "input_owner": 1184, + "previous_gcd": 7457662407057408000, + "row": 34008, + "scaled_product": -878861087793727075588557357711360000 + }, + { + "coefficient": "-115/62", + "donor": 89190, + "gcd": 5118505426944000, + "input_owner": 70, + "previous_gcd": 158673668235264000, + "row": 36, + "scaled_product": -1042136791806858428421687685939200000 + }, + { + "coefficient": "19/160", + "donor": 91110, + "gcd": 2559252713472000, + "input_owner": 1119, + "previous_gcd": 5118505426944000, + "row": 104459, + "scaled_product": -14073625509599583548904635928576000 + }, + { + "coefficient": "-20/37", + "donor": 91110, + "gcd": 69168992256000, + "input_owner": 1263, + "previous_gcd": 2559252713472000, + "row": 156006, + "scaled_product": 295493291747439643311488158924800000 + }, + { + "coefficient": "-23/64", + "donor": 91110, + "gcd": 34584496128000, + "input_owner": 1119, + "previous_gcd": 69168992256000, + "row": 156030, + "scaled_product": 42591235094840844950632450836480000 + }, + { + "coefficient": "-32/223665", + "donor": -933, + "gcd": 2660345856000, + "input_owner": 932, + "previous_gcd": 34584496128000, + "row": 34, + "scaled_product": -80384169062808688925834477568000 + }, + { + "coefficient": "-1/56", + "donor": 36, + "gcd": 380049408000, + "input_owner": 404, + "previous_gcd": 2660345856000, + "row": 154778, + "scaled_product": -32017048168922326440530811813888000 + }, + { + "coefficient": "-2/5", + "donor": 98470, + "gcd": 76009881600, + "input_owner": 348, + "previous_gcd": 380049408000, + "row": 155944, + "scaled_product": 157317345267539672325221723720908800 + }, + { + "coefficient": "-74/79", + "donor": 102948, + "gcd": 962150400, + "input_owner": 1185, + "previous_gcd": 76009881600, + "row": 155935, + "scaled_product": 333093470305752733995994447872000000 + }, + { + "coefficient": "145037/663040", + "donor": 37, + "gcd": 481075200, + "input_owner": 288, + "previous_gcd": 962150400, + "row": 155691, + "scaled_product": 75836624456474558489793162783744000 + }, + { + "coefficient": "1475669/1326080", + "donor": 37, + "gcd": 240537600, + "input_owner": 288, + "previous_gcd": 481075200, + "row": 155822, + "scaled_product": 385797264749896079111104706840064000 + }, + { + "coefficient": "6169895/530432", + "donor": 37, + "gcd": 120268800, + "input_owner": 288, + "previous_gcd": 240537600, + "row": 155292, + "scaled_product": 4032626244086682157426918528492800000 + }, + { + "coefficient": "-6309957/4243456", + "donor": 36, + "gcd": 60134400, + "input_owner": 404, + "previous_gcd": 120268800, + "row": 155294, + "scaled_product": -2666097408319634398486492817260416000 + }, + { + "coefficient": "-6830953/10608640", + "donor": 37, + "gcd": 30067200, + "input_owner": 288, + "previous_gcd": 60134400, + "row": 155294, + "scaled_product": -223234595887958010171339069813696000 + } + ], + "public": 1264, + "retired_and_guards_restored": true, + "same_owner_complete_fixture_outputs": 1264, + "selected_logical_operations": { + "clear_full_sender_after_return": 5701, + "initialize_complete_dirty_home": 8234, + "initialize_empty_sender_before_departure": 5701, + "read_immutable_donor": 204869, + "read_parked_sender": 5701, + "read_terminal_for_same_owner_install": 1264, + "retire_complete_home": 8234, + "stage_full_sender": 5701, + "write_complete_return": 5701, + "write_entrance": 1264, + "write_terminal": 1264 + }, + "separate_guide_tracks": 1, + "slots": 5701, + "terms": 204869, + "trace_sha256": "3e8cd8a0e202592e1c8dd8d9a8fa1dbe25f8977deab56f79b7bdcb61728799c3", + "tracked_stream_reset_visits": 621572 + }, + "native_sha256": "934b7d4d792a5771bbcd28053d7797a9938f6b23faddaafe46451158eec81849", + "ordinary_binary": "7739399/2000000000", + "remaining_to_target": "448217889/100000000000000", + "schema": "p104-subdivided-joint-application/v1", + "target": "0.00386380485468" +} diff --git a/research/p104-subdivided-helper-births/prepare_sources.py b/research/p104-subdivided-helper-births/prepare_sources.py new file mode 100644 index 0000000000..0511286ba3 --- /dev/null +++ b/research/p104-subdivided-helper-births/prepare_sources.py @@ -0,0 +1,71 @@ +"""Fetch or verify the pinned public inputs. Adapted from PR 7774 (Apache-2.0).""" + +import argparse +from concurrent.futures import ThreadPoolExecutor +import hashlib +import json +from pathlib import Path +from tempfile import NamedTemporaryFile +from time import sleep +from urllib.error import HTTPError, URLError +from urllib.parse import quote +from urllib.request import Request, urlopen + + +HERE = Path(__file__).resolve().parent + + +def verify(data, pin, label): + blob_header = b"blob " + str(len(data)).encode() + b"\0" + if (hashlib.sha256(data).hexdigest() != pin["sha256"] + or hashlib.sha1(blob_header + data).hexdigest() != pin["blob"]): + raise ValueError(f"source digest mismatch for {label}") + + +def materialize(job): + path, url, pin, fetch = job + if path.exists(): + verify(path.read_bytes(), pin, path) + return + if not fetch: + raise FileNotFoundError(path) + for attempt in range(3): + try: + with urlopen(Request(url, headers={"User-Agent": "P104-source-replay"}), timeout=45) as response: + data = response.read() + break + except (HTTPError, URLError, TimeoutError) as exc: + if attempt == 2 or isinstance(exc, HTTPError) and exc.code not in (429, 500, 502, 503, 504): + raise + sleep(2 ** attempt) + verify(data, pin, url) + path.parent.mkdir(parents=True, exist_ok=True) + with NamedTemporaryFile(dir=path.parent, delete=False) as temporary: + temporary.write(data) + name = Path(temporary.name) + try: + name.replace(path) + finally: + name.unlink(missing_ok=True) + + +def sources(cache, fetch=False): + manifest = json.loads((HERE / "SOURCE-LOCK.json").read_bytes()) + jobs = [] + for label, source in manifest["sources"].items(): + prefix = f"https://raw.githubusercontent.com/{source['repository']}/{source['commit']}" + for filename, pin in source["files"].items(): + remote_name = "/".join(filter(None, (source["path"], filename))) + jobs.append((cache / label / filename, prefix + "/" + quote(remote_name), pin, fetch)) + with ThreadPoolExecutor(max_workers=4) as pool: + for _ in pool.map(materialize, jobs): + pass + return len(jobs) + + +if __name__ == "__main__": + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("cache", type=Path) + parser.add_argument("--fetch", action="store_true", help="download missing files from the pinned public commits") + args = parser.parse_args() + print(f"Verified {sources(args.cache, args.fetch)} source files.") diff --git a/research/p104-subdivided-helper-births/qualify_complex.py b/research/p104-subdivided-helper-births/qualify_complex.py new file mode 100644 index 0000000000..06a3a44553 --- /dev/null +++ b/research/p104-subdivided-helper-births/qualify_complex.py @@ -0,0 +1,164 @@ +"""Qualify the complex application with a completed ordinary BIT supplier. + +The pinned PR 7776 scalar, caller, chart and compiler engines are used unchanged. +PR 7774 supplies its independent directed-root and exact product-grid routines. +""" +import argparse +from collections import Counter +from fractions import Fraction +from hashlib import sha256 +import gzip +import importlib.util +import json +from pathlib import Path +import sys + +BASE_NATIVE = "934b7d4d792a5771bbcd28053d7797a9938f6b23faddaafe46451158eec81849" +BASE_LAYOUT = "d233f9ba1fc39c4be51685a45da1940fe43dc3a3fd7699a8b27339e1e063b489" +BINARY_WORD = "861f5181e4f34db638ab0c573c319fe26ff034d63b21242d67220a4a5d6433ff" +BASE_UPPER = "0.00385896184248" +GOAL = "0.00386380485468" +TICKS = 10**14 +HERE = Path(__file__).resolve().parent + + +def need(ok, text): + if not ok: + raise ValueError(text) + + +def json_file(path): + raw = path.read_bytes() + return json.loads(gzip.decompress(raw) if raw[:2] == b"\x1f\x8b" else raw) + + +def digest(item): + return sha256(json.dumps(item, sort_keys=True, separators=(",", ":")).encode()).hexdigest() + + +def historical_checker(path): + spec = importlib.util.spec_from_file_location("p7774_product_grid", path / "qualification.py") + need(spec and spec.loader, "PR 7774 product-grid and directed-root source") + module = importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + return module + + +def histogram(rows): + return {int(rank): count for rank, count in rows.items()} + + +def tick(n): + return f"{n // TICKS}.{n % TICKS:014d}" + + +def price(program, weights, bit_cap): + def signed(i): + return program.dyadic_price(weights, tick(i)) + + left, right = 1, 690000000000 + need(signed(left)[0] > 0 and signed(right)[1] < 0, "bracket endpoints") + while right - left > 1: + mid = (left + right) // 2 + lo, hi = signed(mid) + if lo > 0: + left = mid + else: + need(hi < 0, "directed root sign") + right = mid + k = min(left, int(bit_cap * TICKS)) - 8 + need(signed(k + 7)[0] > 0 and k > 0, "finite slack") + return tick(k), tick(k + 7), tick(left), tick(right) + + +def owners(layout): + h = layout["hosted"] + main = set(layout["live"]) | {r + 112 for r in layout["live"]} | set(h["X2"]) | set(h["Y2"]) + need(len(main) == 400 and len(set(layout["source_labels"])) == layout["public"], "independent owners") + return main, set(h["Dports"]), list(zip(h["X2"], h["Y2"], strict=True)) + + +def command(args): + need(__debug__, "run with Python assertions enabled") + reference = historical_checker(args.peer.resolve()) + supplier_dir = args.supplier.resolve() / "complex" + sys.path.insert(0, str(supplier_dir)) + import supplier + import supplier_gate + from closed_application import apply, main_boundary, verify_caller + + base, layout = (json_file(args.base_graph), json_file(args.base_layout)) if args.base_graph else supplier.build()[:2] + need(digest(base) == BASE_NATIVE and digest(layout) == BASE_LAYOUT, "exact published base") + graph = json_file(args.candidate) if args.candidate else base + candidate_layout = json_file(args.layout) if args.layout else layout + if args.candidate: + need(digest(graph) == args.sha, "canonical candidate pin") + for key in ("ports", "live", "hosted"): + need(layout[key] == candidate_layout[key], "same native main bindings") + main_boundary(graph, candidate_layout) + role_sets = owners(candidate_layout) + caller = supplier.read(supplier.SOURCE / "data/CALLER.json.gz") + moves, rows = reference.graph_inputs(graph) + if args.chart is not None: + sys.path.insert(0, str(args.upstream.resolve() / "research/shared-wire-split-composition/frozen")) + import catalogue + from network import Network + net = Network(graph["first_output"], graph["initial"], graph["final"], moves, {i:dict(row) for i,row in rows.items()}) + catalogue.build = lambda: (graph, candidate_layout, net) + result = catalogue.verify(args.chart) + if digest(graph) == BASE_NATIVE: + need(result == json_file(supplier_dir / f"CHARTS-{args.chart}.json"), "published physical charts") + return {"native_sha256":digest(graph), "charts":result} + need(args.binary_finite, "supply the completed binary finite certificate") + bits = json_file(args.binary_finite) + bit_cap = Fraction(bits["ordinary_admitted"]) + need(bits["word_sha256"] == BINARY_WORD and Fraction(BASE_UPPER) < bit_cap < Fraction("0.0069"), + "completed ordinary BIT receipt and its frozen native") + native = supplier.physical.graph_bounds(graph, moves, rows, role_sets[0]) + fixed = reference.count_caller(caller) + weights = reference.invoice(native, fixed) + claim, tested, lo, hi = price(reference, weights, bit_cap) + need(Fraction(claim) > Fraction(BASE_UPPER), "candidate below conservative joint comparator") + print("directed complex crossing",lo,hi,"finite claim",claim,flush=True) + signed, guard, proof, coefficients = verify_caller(caller, graph, candidate_layout, supplier.read(supplier.SOURCE / "data/CALLER-PHASE-BASES.json")) + need(histogram(signed["fixed_root_targets"]) == dict(fixed[0]) and + histogram(signed["fixed_caller_paid"]) == dict(fixed[1]) and signed["calls"] == 48, + "regenerated signed caller") + conversion = reference.native_replay(supplier, graph, candidate_layout, role_sets, moves, rows, native, caller) + # The retained gate's old public BIT ceiling is the only input replaced. + # Read the new ceiling from the completed finite ordinary construction. + old_cap = supplier_gate.BIT_PIN + try: + supplier_gate.BIT_PIN = str(bit_cap) + application = apply(native,signed,guard,coefficients,conversion,supplier.physical,claim,tested,lo,hi,bit_cap) + finally: + supplier_gate.BIT_PIN = old_cap + need(application["invoice"] == {"paid":weights["P"],"targets":weights["T"]}, "physical signed invoice") + base_data = json_file(supplier_dir / "RESULT.json") + common = supplier.physical.root_envelope({"candidate":native,"comparator":base_data["native"]},guard) + guards = {key:supplier.physical.check_depth_guard(common,int(app["compiler"]["H"])) + for key,app in (("candidate",application),("comparator",base_data["application"]))} + return {"schema":"p104-subdivided-joint-application/v1", "native_sha256":digest(graph), + "layout_sha256":digest(candidate_layout),"binary_word_sha256":BINARY_WORD, + "ordinary_binary":str(bit_cap),"finite_lower":claim,"complex_crossing":[lo,hi], + "comparator_joint_upper":BASE_UPPER,"target":GOAL, + "gain_above_upper":str(Fraction(claim)-Fraction(BASE_UPPER)), + "remaining_to_target":str(max(Fraction(0),Fraction(GOAL)-Fraction(claim))), + "native":native,"conversion":conversion,"caller":signed,"caller_proof":proof, + "caller_guard":guard,"application":application,"common_root":common,"joint_depth_guards":guards} + + +if __name__ == "__main__": + parser = argparse.ArgumentParser(description=__doc__) + for name in ("upstream","supplier","peer","out"): + parser.add_argument("--"+name,type=Path,required=True) + for name in ("base-graph","base-layout","candidate","layout","binary-finite"): + parser.add_argument("--"+name,type=Path) + parser.add_argument("--sha") + parser.add_argument("--chart",type=int,choices=(0,1,2)) + args = parser.parse_args() + need(bool(args.base_graph)==bool(args.base_layout) and bool(args.candidate)==bool(args.sha), "paired pins") + result = command(args) + args.out.parent.mkdir(parents=True,exist_ok=True) + args.out.write_text(json.dumps(result,indent=2,sort_keys=True)+"\n") + print("PASS", result.get("finite_lower", "physical chart shard")) diff --git a/research/p104-subdivided-helper-births/verify.py b/research/p104-subdivided-helper-births/verify.py new file mode 100644 index 0000000000..3517ca3a0d --- /dev/null +++ b/research/p104-subdivided-helper-births/verify.py @@ -0,0 +1,95 @@ +"""Re-run one part of the pinned dual-supplier qualification.""" +import argparse +from fractions import Fraction +import gzip +from hashlib import sha256 +import json +from pathlib import Path +import subprocess +import sys + +HERE = Path(__file__).resolve().parent +sys.path.insert(0,str(HERE)) +from prepare_sources import sources +from qualify_complex import digest, json_file, need + + +def run(script,*args): + subprocess.run([sys.executable,"-I","-B",str(script),*map(str,args)],check=True) + + +def main(args): + cache,out = args.cache.resolve(),args.out.resolve() + out.mkdir(parents=True,exist_ok=True) + sources(cache) + source = cache / "source" + supplier = source / "research/p104-dual-supplier-lift" + peer = cache / "peer" + claim = json_file(HERE / "CLAIM.json") + binary, complex_ = HERE / "binary", HERE / "complex" + if args.part == "binary": + unpacked,finite,review = out/"native.json",out/"finite.json",out/"independent.json" + run(binary/"replay.py","--source-root",source,"--write-json",unpacked) + run(binary/"finite.py","--upstream",source,"--supplier",supplier,"--native-report",unpacked,"--out",finite) + run(binary/"independent/verify.py","--source-root",source,"--word",binary/"WORD.json.gz","--out",review) + need(json_file(unpacked)==json_file(binary/"REPLAY.json"),"archived complete binary native receipt") + need(json_file(finite)==json_file(binary/"FINITE.json"),"archived finite binary receipt") + independent = json_file(review) + need(independent == json_file(HERE / "evidence/binary-independent.json"), + "published independent binary operator and finite price") + need(independent["finite"]["published_ordinary_admitted"] == json_file(finite)["ordinary_admitted"] + == claim["binary_ordinary"], "same published two-stage ordinary BIT service") + return + if args.part == "construction": + run(complex_/"birth_replay.py","--source-root",source,"--out",out) + for name in ("WORD.json.gz","LAYOUT.json.gz"): + need(digest(json_file(out/name))==digest(json_file(complex_/name)),"replayed pure birth "+name) + intermediate = out / "intermediate.json.gz" + run(complex_ / "overlay.py", complex_ / "WORD.json.gz", complex_ / "OVERLAY.json.gz", intermediate) + frozen_parent = claim.get("free_birth_parent") + candidate, candidate_layout = intermediate, complex_ / "LAYOUT.json.gz" + extra = [] + if frozen_parent: + need(digest(json_file(intermediate)) == frozen_parent, "fixed-boundary overlay pin") + free = out / "free" + run(complex_ / "final_birth.py", "--source-root", source, "--word", intermediate, + "--layout", candidate_layout, "--out", free) + candidate, candidate_layout = free / "WORD.json.gz", free / "LAYOUT.json.gz" + extra = ["--free-parent", intermediate, "--free-parent-sha", frozen_parent, + "--free-split", claim["free_split"]] + need(digest(json_file(candidate)) == claim["complex_word"], "final candidate") + need(digest(json_file(candidate_layout)) == claim["layout"], "final layout and public owners") + if args.part == "construction": + return + sys.path.insert(0,str(supplier/"complex")) + import supplier as original + graph,layout,_ = original.build() + base,layout_path = out/"base.json.gz",out/"base-layout.json.gz" + for path,item in ((base,graph),(layout_path,layout)): + path.write_bytes(gzip.compress(original.encoded(item),mtime=0)) + common = ["--supplier",supplier,"--upstream",source,"--base-graph",base,"--base-layout",layout_path, + "--candidate",candidate,"--layout",candidate_layout,"--sha",claim["complex_word"]] + result=out/(args.part+".json") + if args.part=="operator": + run(complex_/"independent.py",*common,"--layout-sha",claim["layout"],"--out",result,*extra) + need(json_file(result)==json_file(complex_/"INDEPENDENT.json"),"published independent operator receipt") + return + shard=["--chart",args.part[-1]] if args.part.startswith("charts-") else [] + run(HERE/"qualify_complex.py",*common,"--peer",peer,"--binary-finite",binary/"FINITE.json","--out",result,*shard) + expected=HERE/"evidence"/(args.part+".json") + replay = json_file(result) + need(replay == json_file(expected), "published " + args.part + " receipt") + if args.part == "application": + for field, measured in (("conditional_lower", "finite_lower"), ("complex_raw_bracket", "complex_crossing"), + ("target", "target"), ("gain", "gain_above_upper"), + ("comparator_raw_joint_upper", "comparator_joint_upper")): + need(claim[field] == replay[measured], "application and published claim agree on " + field) + need(Fraction(replay["finite_lower"]) >= Fraction(replay["target"]), "finite application clears target") + + +if __name__ == "__main__": + p=argparse.ArgumentParser(description=__doc__) + p.add_argument("--cache",type=Path,required=True) + p.add_argument("--out",type=Path,required=True) + p.add_argument("--part",choices=["binary","construction","operator","application","charts-0","charts-1","charts-2"],required=True) + main(p.parse_args())