diff --git a/research/native-retimed-helper-split/ADAPTERS.md b/research/native-retimed-helper-split/ADAPTERS.md new file mode 100644 index 0000000000..9e81915f6b --- /dev/null +++ b/research/native-retimed-helper-split/ADAPTERS.md @@ -0,0 +1,48 @@ +# Explicit adapters to retained sources + +All files under `retained/caller`, `retained/runtime` and `retained/native` +are byte-identical to their pinned originals. Their assertions and scientific +checks have not been edited in place. + +- `split.py` adapts Ali Romman's `construct.py`: the eight historical owned + slots become the literal `word['owned_fields']`, the local helper module is + `native`, and the old unchanged-paid batch wrapper is omitted. The basis + construction and independent prefix/suffix identities are unchanged. +- `construct.py` is the new explicit retiming, source-event/no-contact guard, + witness application and optional canonical-word exporter. +- `native.py` adapts the retained local checker to the counted current public + and owned inventory, records all CLEAR observations, and enforces pre-COPY + zero. The physical-map function uses the pinned local compiler/interpreter. + Both independent replay and complete pricing enforce the exact new census; + an old historical 750-public/8-owned bound is not treated as this source's + contract. +- `pricing.py` adapts retained #6726 pricing. Only the declared native + histograms/census, claim/tested/root endpoints, status and explanatory text + change, together with the explicitly decomposed canonical-job adapter + charges from #6763. The invoice construction, ordinary envelope, both rational interval + engines, strictification, compiler threshold, retained BIT input and outer + ledger retain their full checks. +- `context.py` maps the six historical runtime paths to explicitly pinned + self-contained files. It provides no fallback network fetch or PASS cache. +- `verify.py` regenerates the literal words and composes the complete checks. + It adds explicit helper allocation and all 512 columns of each of the three + changed native boundary pairs, beyond the signed-Pauli/global-phase checks + on every used map. +- `independent/check_native.py` was written separately without importing the + constructor, primary replay or price. `independent/check_invoice.py` uses + its chronological counts and a separately written Laurent adjoint. Its + initial development-only file paths were replaced by explicit arguments; + the scientific calculations and controls are unchanged. Container hashes + are removed only from regenerated combined receipts; canonical complete + word identity remains checked. + +The independent reviews are AI-assisted source reviews, not human acceptance. +None of these changes discharges the five retained framework assumptions. + +The exact #6763 physical audit is retained under `retained/physical-review/`. +The driver invokes its generic native, physical, allocation, invoice and +canonical-adapter functions on the actual new word, with data supplied locally. +Its old frozen standalone `run()` is not invoked. The 286,728 fixed elementary +canonical maps are charged separately; full 153-axis permutations are never +assigned a single 1000-unit route charge. This corrects the predecessor price +driver’s partial 252,223,008 estimate to the sufficient 535,415,008 envelope. diff --git a/research/native-retimed-helper-split/EXPECTED.json b/research/native-retimed-helper-split/EXPECTED.json new file mode 100644 index 0000000000..60407f8153 --- /dev/null +++ b/research/native-retimed-helper-split/EXPECTED.json @@ -0,0 +1,3 @@ +{ + "native_payload_sha256": "292b3ab3afb74e87deffd7770e5627e94debd610459221686c05ca04b8885d3f" +} diff --git a/research/native-retimed-helper-split/LICENSE b/research/native-retimed-helper-split/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/native-retimed-helper-split/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/native-retimed-helper-split/NOTICE b/research/native-retimed-helper-split/NOTICE new file mode 100644 index 0000000000..96a23587a0 --- /dev/null +++ b/research/native-retimed-helper-split/NOTICE @@ -0,0 +1,3 @@ +Native main-retiming/helper retirement extension by Jerry Chen / @CubeJerry, with substantial OpenAI Codex assistance and separate source-bound review. Apache-2.0. + +Original retained headers, licenses and notices remain unchanged. See retained/caller/NOTICE for the full native/caller/compiler/interval lineage; Ali Romman supplies the helper-basis mechanism, DreamingOfClouds the #6702 native source, and zxv the #6726 caller. diff --git a/research/native-retimed-helper-split/PROOF.md b/research/native-retimed-helper-split/PROOF.md new file mode 100644 index 0000000000..f2fc271309 --- /dev/null +++ b/research/native-retimed-helper-split/PROOF.md @@ -0,0 +1,223 @@ +# Paid retiming and independent-helper retirement + +## Claim + +Under the five retained framework assumptions, the supplied construction gives +`T(n)=O(n (log n)^(1−κ))` with **κ = 0.00330814**, improving the pending +#6726 claim 0.00330720. This is a proposed conditional result; the independently +selected frontier remains unchanged. Favorable local accounting alone would +not establish this claim: the native identity, actual caller, complete invoice +and parameter qualification are checked separately below. + +## Chronology and arbitrary inputs + +Indices are zero-based in the pinned native word. Frames 3, 749, 243 and 127 +have dimensions 0, 3, 4 and 9, with strictly nested spans `E⊂A⊂F⊂V`. +Source event 14088 is `MOVE(80,749,127,False)`. No event from 12372 through +14087 reads or writes role 80. Advance that move to immediately before old +event 12372 and subdivide it as `749→243→127`, paying ranks one and five. +Skipped events act on other registers, and the two physical chart changes +compose to the original change. Thus the retiming preserves the old endpoint. +The new cut is between those two requests. + +Let P be the normalized prefix on valid public inputs, with explicit owned initialization, and S the suffix. Neither is assumed invertible. The exact witness is: + +\[ +\begin{aligned} +a&=e_{80}^{T}+\tfrac12e_{26}^{T}-\tfrac12e_{368}^{T} + -\tfrac12e_{95}^{T}+2e_{381}^{T},\\ +b&=-2e_{95},\\ +c&=2e_{383}^{T}-2e_{372}^{T}-2e_{382}^{T}-2e_{3}^{T},\\ +d&=\tfrac12(e_{379}+e_{377}-e_{368}-e_{146}+e_{374} + -e_{375}-e_{382}+e_{188}+e_{126}). +\end{aligned} +\] + +Direct rational replay proves `aP=c`, `Sb=d`, and `ab=cd=1`. The supports +of c and d consist only of independent helpers with entry E and exit V. +All roles in a and b, and pivot p=368, are at F at the cut. These are actual +source identities, not inferences from a pairing rank or sampled inputs. + +The retained dyadic basis construction produces G and J with row p of G +equal to c, `Gd=e_p`, row p of J equal to a, and `Jb=e_p`. Therefore +`Q=JPG^-1` has row p equal to `e_p^T`, and `R=GSJ^-1` has column p equal +to `e_p`. G acts among equal-boundary helpers and commutes with the old +normalized endpoint, which is identity on those helpers. Replacing the old +p value at the cut by a fresh independent input z changes only the returned +p value, from the old input to z. All other outputs are preserved. + +The emitted word applies `G^-1` at E, the prefix, J at F, then `J^-1` and +the suffix with p renamed to fresh role 771, and the renamed G at V. Old p +returns at F; fresh role 771 starts at F and returns at V. The rank-nine helper +is thereby replaced by independent rank-four and rank-five helpers. The new +input is arbitrary, never presumed zero. All scalar coefficients are legal +dyadics; no broader cross-role SWAP lemma is needed. + +All 29 owned labels shift by one to accommodate the public input. The +47 lifetimes and peak 14 are unchanged. Source and candidate have the same +45 nonzero pre-CLEAR observations among 47 clears, with the same owned labels, +charts and zero/nonzero pattern. The erased functionals can change under the +bases; their legality remains conditional on `owned_erasure`. The one COPY +is monitored before overwrite and its destination is zero. Full primary and +independent adjoint replays check all 641,601 candidate endpoint coefficients. + +## Strict gain + +Writing `H_r=r^t`, the literal per-call deltas are + +\[ +\Delta P=H_1+H_5-H_6,\qquad +\Delta T=H_4+H_5-H_9. +\] + +Hence `Δ(T−P)=H4+H6−H1−H9`. For `f(x)=x^t`, `00. +\] + +Both rank masses remain unchanged. More generally, a legally splittable +helper E→V and a contact-free donor A→V, with nested dimensions e0. +\] + +This compares equal-length increments of a strictly concave function. It pays +the donor subdivision; it does not supply the independent-channel identities +or legal physical frames for any untested application. + +The recounted local target profile is +`{1:14,2:8,3:4,4:109,5:17,6:3,7:9,8:40,9:360}` and paid profile is +`{1:2232,2:454,3:490,4:109,5:153,6:7,7:9,8:1}`. + +## Physical maps and complete consumer + +All 2,940 distinct used native maps, 208 main adapters and 1,128 helper +normalizers are checked by signed Pauli action and exact absolute phase. +The changed pairs `(749,243)`, `(3,243)` and `(243,127)` additionally receive +all 512 explicit Gaussian-column checks each. Phase-only corruptions reject. +Common-frame scalar identities act componentwise, with scalar coefficients +outside tensor powers. Factorwise maps and frame induction give the same +interface at positive tensor widths within the retained native/precision +contracts. + +The unchanged #6726 caller is rebuilt with both retirements: 34 main roles, +606 instructions, 18 distinct native stages, 15 thin queries, 12 IDLE events, +six IDLE_ONE events and 100 ordinary normalizations. Independent Laurent-ring +replays check all caller entries. The new native retains precisely the main +interface each LOCAL event consumes. Physical replay checks 7,488 contacts, +53,248 central-square columns and all whole-idle/output phases. + +Allocate 3,536 main fields and eighteen disjoint blocks of 564 arbitrary +native helpers: 13,688 productive fields. The 29 owned labels and one reused +thin-query scratch field are separate and uncredited. The eighteen additional +helper inputs are not shared. Their complete boundary normalizer count is +20,304, an increase of 36. + +| Rank | Productive T | Paid P | +|---:|---:|---:| +| 1 | 356 | 41,736 | +| 2 | 144 | 8,172 | +| 3 | 72 | 8,820 | +| 4 | 1,962 | 1,962 | +| 5 | 306 | 2,754 | +| 6 | 54 | 126 | +| 7 | 162 | 162 | +| 8 | 720 | 226 | +| 9 | 6,688 | 0 | +| 16 | 0 | 1,664 | +| 17 | 1,664 | 0 | +| 32 | 208 | 1,040 | +| 33 | 832 | 0 | +| 40 | 0 | 208 | +| 41 | 208 | 0 | +| 73 | 208 | 0 | +| 145 | 104 | 0 | + +There are 66,870 paid requests, paid rank mass 178,080 and surplus 760. +The signed improvement over the identical #6726 caller is exactly eighteen +times the local gain. Native scalar allowance rises by 384 to 138,374. +Including every charged request, normalizer, main adapter, lifetime, fixed +route rate and caller scalar gate gives 5,533,374 units per native call, +below 10⁷, and a complete ordinary upper envelope 535,415,008 below 10⁹. +The route/precision rates remain framework contracts; all multiplicities +and coefficient heights are freshly checked. + +Both canonical-job boundaries are charged using the explicit decomposition +from the pinned #6763 audit. A scattered set of r axes is sent to the first r +axes by pairing selected indices outside that set with missing indices inside +it. These two-axis exchanges form an actual involutive permutation. Main jobs +also receive both nine-axis q-basis changes and their required translations; +whole idles receive both canonicalizing maps; thin queries receive both q-basis +maps and their inverse-Gaussian phase translation. The actual inventory is: + +| Fixed elementary map | Count | +|---|---:| +| Main input/output two-axis exchanges | 144,768 | +| Main input/output q-basis maps | 6,656 | +| Main endpoint translations | 3,328 | +| Whole-idle input/output two-axis exchanges | 127,296 | +| Thin-query input/output q-basis maps | 3,120 | +| Thin-query translations | 1,560 | + +Thus 286,728 maps are charged at 1,000 units each. The complete envelope is +`18·10^7 + 68,570,112 + 24,960 + 91,936 + 286,728,000 = 535,415,008`. +The fixed-map rate is applied to each at-most-nine-axis map separately; +native contacts satisfy their separate 17-axis bound. It is not applied once +to an arbitrary 153-axis transformation. Input adapters on fresh fields are +scheduled before their first use; output adapters on retired fields can be +deferred to the final output boundary, preserving the checked retention. +This closes the additional routing bill identified in the earlier physical +audit. It replaces the predecessor driver's partial 252,223,008 estimate; +the complete bill still fits the unchanged 10^9 budget used by the compiler. + +For coordinate sup norms, the charged scalar macros have elementary +majorants, monomial routes have norm one, and a rank-r Gaussian is bounded +by `2^(rf)`. The conservative envelope `2^(10^9+178080f)` therefore controls +every prefix, suffix and subinterval. COPY is physically an ADD into owned +zero; approximate residual errors still propagate as ADD errors, rather than +being discarded by its ideal overwrite notation. INIT/CLEAR retain their +explicit owned-erasure premise. Summing propagated defects gives finite +precision choices under the inherited implementation contract. Storage counts +all productive fields and disjoint owned/query slots, plus movement scratch +under the retained tape contract. Fixed descriptor/precision constants are +absorbed at fresh outer thresholds using strict exponent gaps, not presumed +absorbed at the displayed finite supplier threshold. + +## Exact qualification + +Two separately implemented rational interval engines certify opposite signs +at 0.0033081451891 and 0.0033081451892 and a positive margin at tested saving +0.003308145. A rational derivative upper bound is negative through the retained +BIT cap. The claim 0.00330814 is strictly lower; the compiler gap is +`g=(0.003308145−0.00330814)/7=1/1,400,000,000`. +The next eight-decimal value 0.00330815 already exceeds this fixed invoice's +certified raw crossing. + +Strictification uses power 1920, cutoff/floor 11/12, offset 1/7, reserve +10⁻²⁷ and decay 31/32. Fresh moments verify alpha, gamma and completion-delta +bounds, counting all 13,688 targets. Exact normalized contraction is below +one and `11^64<12^63`. The compiler checks shifted exits, complement capacity +and initial range using theta 63/64, logarithm power 2100 and maximum target +rank 145. It finds an explicit finite `N=2^H` by integer inequalities and +checks the adjacent grid point; this enormous word is not materialized. + +The retained BIT construction supplies saving 17/5000, strictly above the +tested complex saving, with its stock and ordinary savings inequalities +recounted. Set complex-uniform saving `κ+6g`, `b=κ+5g`, `a=κ+4g`, `q=κ+3g`, +epsilon `1−g`, beta `1−3g`, `r0=g/10`, and stop/layout/d all g. All 54 strict +and four functional outer inequalities pass. An insufficient BIT budget +rejects. Exact fractions, margins and threshold are in `RESULT.json`. + +## Qualification and credit + +The finite identities and inequalities support the proposed conditional +construction. They do not independently verify the full rounded multiplier, +eliminate analytic/precision assumptions, establish admission of pending +predecessors, or certify optimality. The five named assumptions remain. +Separate AI-assisted review provides implementation diversity, not human +or proof-kernel acceptance. Credit is retained as listed in the README and +original source notices; this extension is by @CubeJerry with OpenAI assistance. diff --git a/research/native-retimed-helper-split/README.md b/research/native-retimed-helper-split/README.md new file mode 100644 index 0000000000..fff4fa8f3e --- /dev/null +++ b/research/native-retimed-helper-split/README.md @@ -0,0 +1,133 @@ +# Conditional κ = 0.00330814 from a retimed native helper split + +Advance a paid main-register move to a contact-free interval, subdivide it, +and use the new common frame to retire one independent helper. The complete +18-call construction supports **κ = 0.00330814**, up from the pending +**0.00330720** in [#6726](https://github.com/CrocSwap/integer-mult-bounds/pull/6726). +The increase is **0.00000094**, about **0.0284%**. This is a small positive +construction result, not a claim of a large advance or global optimality. + +The exact local signed saving is + +\[ +\Delta(T-P)=H_4+H_6-H_1-H_9>0,\qquad H_r=r^t,\quad 0 2^26*N^5 avoiding all fixed denominators and rank witnesses" + }, + "outer": { + "functional_checks": { + "actual_new_BIT_stock_sublinear": "348599999253/350000000000", + "fixed_halo_explicit_metadata_branch": "26950000001/350000000", + "new_BIT_row_stock_sublinear_in_active_group": "1395799997009/1400000000000", + "new_semantic_group_guard": "3/1400000000" + }, + "margins": { + "boundary_algebraic_matrix": "6483959995368601/1960000000000000000", + "fused_gaussian": "6483959986105803/1960000000000000000", + "global_coordinate_router": "23157/7000000", + "group_bit_router": "32419806930529/9800000000000000", + "group_scans": "699999999/700000000", + "main_transform": "6483958595368601/1960000000000000000", + "microbox_face_corrections": "26950000001/350000000", + "polynomial_products": "1399999999/1400000000", + "sparse_union_movement": "802733959995368601/1960000000000000000" + }, + "parameters": { + "a": "23157/7000000", + "b": "4631401/1400000000", + "beta": "1399999997/1400000000", + "bit_saving": "17/5000", + "cap_xi": "1782733958595368601/1960000000000000000", + "complex_uniform_saving": "2315701/700000000", + "d": "1/1400000000", + "epsilon": "1399999999/1400000000", + "kappa": "165407/50000000", + "lambda_": "398676743/400000000", + "lambda_prime": "1395368601/1400000000", + "layout": "1/1400000000", + "q": "4631399/1400000000", + "r0": "1/14000000000", + "stop": "1/1400000000", + "tested_saving": "661629/200000000" + }, + "strict_checks": { + "actual_bit_above_effective": "643/7000000", + "actual_logarithmic_gamma_guard": "1/1400000000", + "actual_logarithmic_group_guard": "177266043504631399/980000000000000000", + "alpha_logarithm_absorption": "1/14000000000", + "boundary_algebraic_matrix_above_kappa": "5595368601/1960000000000000000", + "cap_above_band": "802733958595368601/1960000000000000000", + "cap_below_cell": "177266040004631399/1960000000000000000", + "cap_below_phase_cell_power": "2137266041404631399/1960000000000000000", + "complex_above_effective": "1/1400000000", + "complex_below_one_over_32": "39118599/1400000000", + "complex_endpoint": "1/700000000", + "epsilon_below_one": "1/1400000000", + "epsilon_positive": "1399999999/1400000000", + "fine_prime_halo_umbrella": "7/2", + "fused_gaussian_above_kappa": "5586105803/1960000000000000000", + "gaussian_above_main": "695368601/980000000000000000", + "global_coordinate_router_above_kappa": "1/350000000", + "global_gamma_power_slack": "9/14000000000", + "group_below_dimension": "1/700000000", + "group_bit_router_above_kappa": "34930529/9800000000000000", + "group_gauge_power_slack": "177266043434631399/980000000000000000", + "group_key_fits_record": "1/700000000", + "group_positive": "1399999997/1400000000", + "group_scans_above_kappa": "697684301/700000000", + "halo_covers_generic_inverse_radius": "5", + "improvement_over_user_baseline": "788584790400418148631/500000000000000000000000", + "lambda_above_internal": "1/2800000000", + "lambda_above_sigma": "3/2800000000", + "lambda_above_tau": "1/2800000000", + "lambda_prime_above_lambda": "1/2800000000", + "lambda_prime_above_leaf": "2795368599/1960000000000000000", + "leaf_saving_above_effective": "1395368599/1960000000000000000", + "main_transform_above_kappa": "4195368601/1960000000000000000", + "membership_arithmetic_fits_record": "1/1400000000", + "microbox_face_corrections_above_kappa": "3368605269/43750000", + "microbox_halo_volume": "110600000003/1400000000", + "new_complex_uniform_saving_above_b": "1/1400000000", + "new_semantic_guard_with_C1_one": "1/1400000000", + "polynomial_products_above_kappa": "1395368603/1400000000", + "positive_layout_slack": "1/1400000000", + "q_below_effective": "1/1400000000", + "q_below_internal": "1/1400000000", + "q_below_leaf": "2795368599/1960000000000000000", + "q_positive": "4631399/1400000000", + "short_record_fallback": "1395368599/1400000000", + "source_axis_superpolynomial": "1/1400000000", + "sparse_union_movement_above_kappa": "796250005595368601/1960000000000000000", + "stop_below_one": "1399999999/1400000000", + "stop_positive": "1/1400000000", + "strassen_integer_power_gap": "1951441519231", + "support_router_span": "3/1400000000", + "theta_positive_polynomial_power": "2", + "union_header_fits_record": "3/1400000000", + "union_tag_work_per_visit_fits_record": "3/1400000000" + } + }, + "paid": { + "1": 41736, + "16": 1664, + "2": 8172, + "3": 8820, + "32": 1040, + "4": 1962, + "40": 208, + "5": 2754, + "6": 126, + "7": 162, + "8": 226 + }, + "paid_calls": 66870, + "productive_fields": 13688, + "rank_mass_surplus": 760, + "raw_endpoint_margins": { + "lower": { + "first": { + "lower": "0.000000009756156009235365099032", + "upper": "0.000000009756156009235365099033" + }, + "second": { + "lower": "0.000000009756156009235365099032", + "upper": "0.000000009756156009235365099033" + } + }, + "tested": { + "first": { + "lower": "0.000043164272593392920133476725", + "upper": "0.000043164272593392920133476726" + }, + "second": { + "lower": "0.000043164272593392920133476725", + "upper": "0.000043164272593392920133476726" + } + }, + "upper": { + "first": { + "lower": "-0.000000013064846857477763529648", + "upper": "-0.000000013064846857477763529647" + }, + "second": { + "lower": "-0.000000013064846857477763529648", + "upper": "-0.000000013064846857477763529647" + } + } + }, + "raw_root_interval": [ + "33081451891/10000000000000", + "8270362973/2500000000000" + ], + "scope": "Complete conditional price, requiring the supplied caller/native/physical inputs to be independently verified by the package. Does not itself verify those scientific inputs, discharge inherited assumptions, establish scientific admission, or change selected kappa.", + "source_assumptions": [ + "native_all_columns", + "owned_erasure", + "compiler", + "precision_tape", + "analytic_recovery" + ], + "status": "PASS_RETIMED_NATIVE_HELPER_COMPLETE_PRICE", + "strictification": { + "alpha": { + "lower": "0.999999999756258028427083440787", + "upper": "0.999999999756258028427083440788" + }, + "alternative_12_13_delta": { + "lower": "0.996596032660289039291648603988", + "upper": "0.996596032660289039291648603989" + }, + "cutoff": 11, + "decay": "31/32", + "delta": { + "lower": "0.920199637277036317011011997284", + "upper": "0.920199637277036317011011997285" + }, + "floor": 12, + "gamma": { + "lower": "0.919352242668807180050568237347", + "upper": "0.919352242668807180050568237348" + }, + "normalized_upper": "3017994256268166165656485281090535833916725756249835826793168925266538363332959118393649803728007713071868113265307008106165392759140166602231276176491193525838475223532850199880731698633371358238213826956369837083963326200431097200800059212002041494173164580120900614899652164774721219753022318014007470888704725853928034427162119973960367601209478471989008174546718847765864454317363747477784577139342980703179986004309023923501151623437162530359093275767500999488838821346878653618781517869929465644907239975200419119984961970595462459526672982124367238370081601117105862824672041626753878830761254937716087757500154780588952387888909545290321227690737337524636932986557487436400373746205087976939900823213412721260929246663645454333225533573417873878270966410674662217721400378580963662781229070699131856088606565064212802338219990676288305134052916065084223147113356681924295487922738831215975490003477881714792514602632531440142922321624246055420491548898870125266739034093403593861141750778390494324332020450631341177712407686809708639299932057929638453229385512844824477732475692497750505444293920505764644542985604027374525776713590758593290162240025857956398750701666193022661852817667334597363657250589474692558349187489784467784534308731452271464397192747555883724086986777180899255693019165197216450482165724399715348781376527863867611187937883511375183145576545939665590528177825191075315987382691696850289161949978761392853761291967438188096278517378245173041891296537114442099549460376841596189745440833356287809630492771955137857634049834843653214091059292899519993358715592551812122459678957257644252935128182771018674930860159078110203035231337278094843484497916736350269707423093669550405734836572742921142951535393569858677867578133947031681172583200575479732465576021412092436521998625141581486036597822439583555666166745205320062026011722745440952026157246983262052059609825801393194410107883674103170530206478790180680714175502948412787907330283634638118487371874649400893019006973397690500854473558401410620066158504863840613720936860712364614948768923065861574183333307699013929391851014406823186488763212430120437839480440610837443358734496436725017143197692415864041146359723246618363560963819742888006979937806707306886174644458636649893987953661905408261128055990516804739016024589981864256774788678522533600952517642689837813239015716470408358110154664695932620834322254734702246799101912684700303071151259570508727219713769405640694001219420631583405431371328147136055604276355342139039717035227877070657992677340778068793172328267591969261818125572871429869776365422773264912163077459311734702664754097848257207856647246563827576845151038301927915239078395646743310244244155118166302363634508949033003228555802638863720922802000624281277831431518083189590917186076428068361094207669086175823390707236441303930595597471590743181212100815143003489643346003177743777109770019130060803/3017994256268166165656491035063231693978398198787662079292383856990261666407268875266242316574304537824977438191233479479458365031897378910971682146847445831720529072444214239168813318361621021406537946333680719615698024395371618102654358301049375281526841923857353573281673124064137091623117665711938327458485803660406333782965399496384383273095619410140572062880895086412530676628570584973212341168338281143028843950725406810633018143519244412367157868500306391027430062953886066530011236452104054839696367657745585918153885105780436048055657351661582204778498269871018672509355754914642085687953169998781802659556167514409844216442138601869761940829666175939688866382484459348199377852059421048193136784272717556196313275587819271746647782752170997852125936391824736948646408133578263515625097682264701444334863759885223671808566007730417996869975879739069454556143502120678264337509191926420012606685608884721586159182735130329668235415015963539054143635378351553686650970085356070224050653205542765090703090192316158855819021850534846977519598595533227830830246675689299329067321128120764882495087257572668033863484660711961342702904922213132750672072529152647888921228554709611752116990888073427706144475582044612115354682916594199797791656758577997812612859332705485501315354164119374880954187452894641323180493161306005328627998639574009593540018002942935225879243521624482714761491136882238301907421656901587458169137534644297058714160255428538828222202270811680920184952032574111855818083323277337278951405159580396757098165528221317354723301942624608396313954059588718689633657419267824337962870655097477792938701413070284409091728049161298086123657787538745786057964843136234985017216030339846107466138423974925847895769642910846794142281362603017916752544796963565984849849769996708882692849515677511148222363661619367929957200111877107796960360666023556235009225611283531158403466647070581796672289974955924592777874597248446634937752574338785626877802036415577528724311421788748071123754637157691654232143301862938534179856363952063049872889542807412729837987869412746960678402767893645902016662880136171621266241700457558973760850667075103664334887633217911261504764438100508653101640059777972182615479323091990380294461729182853447358074876266516119635874601565061925989878395715844229089983460650371889224631036383672785343069536106257115040353041502759057432703560960094331869105852264578209033293234613213545309635230759049012769406664208577367799088589327982198040102650366683636258605290168036200739803674673414801290054883467223756247682810755116873536560345525083453513230497496834726668274182638946137769521096245230638941858893368170523070080321656837850831035321029960872976160298639386627768204700263664703090321168443994619637219281963172814020726543678137155435815999103603309013053863875221052240416961763005709684412496621711854336662627914279975977381641466926443784930454019244032", + "offset": "1/7", + "power": 1920, + "reserve": "1/1000000000000000000000000000" + }, + "targets": { + "1": 356, + "145": 104, + "17": 1664, + "2": 144, + "3": 72, + "32": 208, + "33": 832, + "4": 1962, + "41": 208, + "5": 306, + "6": 54, + "7": 162, + "73": 208, + "8": 720, + "9": 6688 + }, + "tested": "661629/200000000", + "thin_queries": 15, + "whole_idle_jobs": 3120 + }, + "root": { + "common_idle_pairs": 2, + "fields": 8, + "full_sites": [ + 0, + 1, + 2, + 6, + 7, + 8 + ], + "multilinear_stage_and_character_checks": 128, + "stage_ranks": [ + 2, + 4, + 4, + 4, + 4, + 2 + ] + }, + "selected_frontier_changed": false, + "status": "PASS_RETIMED_NATIVE_HELPER_SPLIT" +} diff --git a/research/native-retimed-helper-split/SOURCES.json b/research/native-retimed-helper-split/SOURCES.json new file mode 100644 index 0000000000..f07c5e3701 --- /dev/null +++ b/research/native-retimed-helper-split/SOURCES.json @@ -0,0 +1,36 @@ +{ + "schema_version": 1, + "base_commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a", + "files": [ + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "3404fbdd5e7529a0674eef26114b5071e4586cec", + "sha256": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81" + }, + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "d59b5035e7b4cbaa9d688a1d32dd0d6eb79c466a", + "sha256": "9b8d0eea95b3bf0dfcb7938a732a6439b87a2685dec2a5ab9e525b3b34debbfa" + }, + { + "path": "docs/research/pr-intake-evidence/pr6030-audit/PROOF-REVIEW.md", + "usage": "provenance", + "git_blob": "26f2f6324bce57e69e861d2aae5a27c9de325a8e", + "sha256": "8bd158b8ef68202000f167b9b78db0b31531b5b067b5cbd91b5bf35f3ddd1ab6" + }, + { + "path": "research/p104-helper-subspace-splits/search.py", + "usage": "provenance", + "git_blob": "1bf5329658683919a97430138b57860751da7ba9", + "sha256": "668022953f53929fd4d95ed1b5c01ac2ba3b4bdf6be7babae511757eb21b7e6a" + } + ], + "retained_executable_sources": "retained/SOURCE-PINS.json", + "source_availability": "Every executable pending input is a self-contained committed export authenticated by Git blob and SHA256, rather than an external head pin requiring a fetch.", + "pending_heads": { + "native_pr6702": "edd6a37a9ff87b254fb7466184348d1432d0c8c0", + "caller_pr6726": "435bbe91fb28cb1d7a569ca70c6c4e9eb302d486" + } +} diff --git a/research/native-retimed-helper-split/TASK.json b/research/native-retimed-helper-split/TASK.json new file mode 100644 index 0000000000..8081ade7be --- /dev/null +++ b/research/native-retimed-helper-split/TASK.json @@ -0,0 +1,148 @@ +{ + "schema_version": 1, + "task_id": "p104-side-correction", + "base_commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a", + "original_card": { + "id": "p104-side-correction", + "question": "Can joint helper bases and a legal causal split improve the complete P104 productive/paid invoice?", + "starting_points": [ + "docs/research/current-priorities.md", + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md", + "research/p104-helper-subspace-splits/README.md", + "research/dyadic-helper-channel-capacity/README.md" + ], + "methods": [ + "Construct and independently check one source-bound instance of the stated first experiment.", + "Seek an exact counterexample or target-specific complete-budget obstruction to that same proposed change." + ], + "acceptance_gate": "An exact arbitrary-input identity, source/target frame availability and restoration at the chosen cut, plus the complete channel+correction+idle/hosting bill or an explicit favorable bound. The native channel alone is not a supplier. A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_selected_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read revision 8, the selected review and live exact-source handoffs. Then follow this card's bounded first_experiment.", + "scope": "Source-bound orientation only, not a supplier replay or theorem proof." + }, + "first_experiment": "Start with the selected #5599 emitted word and review pending #5718 distinct input/output bases plus #5717/#5719 coverage before claiming work. Pick one uncovered source word, helper group and cut region. Prove the arbitrary-input relation and legal entry/exit corrections, then compare full target and paid profiles. Reject if completion, owned lifetimes or consumer costs repay the gain. A static pairing rank alone is not a physical split.", + "bottleneck_link": "Judge the actual current supplier contract and complete signed target/paid bill; frozen-profile ceilings require an applicability proof.", + "allowed_variations": [ + "One exact source head, helper/cut region or quantified proposition and changed hypothesis; check live handoffs first. Different seeds are not different scopes." + ], + "scope_change_triggers": [ + "Changing source head, helper/cut domain, operation alphabet or caller boundary without recording the new scope.", + "Treating an archived proposal or local numerical pass as complete supplier admission." + ], + "overlap_terms": [ + "P104", + "helper basis", + "helper split", + "5718", + "dyadic capacity" + ], + "existing_checks": [ + { + "scope": "PR #4133: literal-slot defect", + "evidence": "research/p104-literal-slot-defect/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "status": "author-checked", + "source_commit": "88666f1dee93fbd85b31fd5d6f91a219e111b5f4", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4136: uniform commutation gap", + "evidence": "research/p104-uniform-commutation-gap/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "status": "author-checked", + "source_commit": "281ce601a8be9db470de630759179c23e1dfaa88", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4140: uniform encoding gap", + "evidence": "research/p104-uniform-encoding-gap/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "status": "author-checked", + "source_commit": "de25c6525aa866962309df5d107b32d55e6e5628", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4153: source-chart shortcut exhausts its optimistic allowance", + "evidence": "research/p104-source-chart-shortcut/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "status": "author-checked", + "source_commit": "9123241fea53df77e51ffe30d9aca1625d4bf3a8", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4154: fiber-tag seam mismatch", + "evidence": "research/p104-fiber-tag-seam/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "status": "author-checked", + "source_commit": "4ffcdaee5d6255a9cea1fe53a5424435068089d0", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "Selected PR5599: complete helper-subspace construction and independent caller replay; five framework assumptions remain.", + "evidence": "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md", + "remaining": "The next experiment must identify uncovered source-specific work. Successor archive intake does not transfer this admission.", + "status": "reviewed", + "source_commit": "09dd0965711ca7eeb169057a420abab1c9052137", + "selected_record_sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5" + } + ] + }, + "scope_status": "changed", + "actual_scope": "Can paid intermediate native cuts, with boundary compensation and independent fresh inputs, improve the complete signed invoice beyond the current open candidate?", + "scope_change_reason": "Use the current pending #6702 native word and #6726 caller; allow explicitly paid main-register retiming and changed productive helper boundaries instead of the historical frozen source/card domain.", + "bottleneck_link": "docs/research/research-family-status.md; complete signed native/caller invoice and all supplier-admission gates", + "stop_rule": "Do not publish a kappa claim without a full native/caller/price/strictification check. Stop unprofitable changes at complete optimistic accounting. At most one related pivot within the same helper-splitting question.", + "evidence": "PROOF.md, WITNESS.json, RESULT.json and independent native/caller audits; exact conditional \u03ba=0.00330814.", + "author": "Jerry Chen / @CubeJerry", + "ai_assistance": "Substantial OpenAI Codex assistance, including a separately tasked implementation and mathematical reviewer for this same construction.", + "outcome": "completed", + "open_questions": [ + { + "question": "Can another legal contact-free retiming expose a helper after this split?", + "why_it_matters": "A second complete signed gain would further improve the current construction.", + "first_step": "Start with the exact frozen successor; test changed coframes or simultaneous paid-path supports, then emit and audit the whole word.", + "blocked_by": "A new source-bound independent channel and a favorable complete caller/completion invoice are required." + }, + { + "question": "Can several helper channels share one paid retiming?", + "why_it_matters": "Joint retirement could amortize the paid detour and increase the saving.", + "first_step": "Find a two-dimensional dual subspace at one actual cut and construct its independent chronological handoff.", + "blocked_by": "No such source witness or legal complete multi-channel consumer is established here." + } + ], + "research_context": { + "track_seed": 28, + "task": "Native helper retirement through paid interior cuts", + "base": "7c49fe32c55de02c2c873655c804b16e4c3fef0a", + "native_source": "CrocSwap/integer-mult-bounds#6702 at edd6a37a9ff87b254fb7466184348d1432d0c8c0", + "caller_source": "CrocSwap/integer-mult-bounds#6726 at 435bbe91fb28cb1d7a569ca70c6c4e9eb302d486", + "question": "Can paid intermediate native cuts, with boundary compensation and independent fresh inputs, improve the complete signed invoice beyond the current open candidate?", + "changed_premise": "Allow extra paid subdivisions and changed independent helper boundaries, rather than fixed-target carrier transport fusions or allocation-only caller extensions.", + "candidates_considered": [ + "Changed higher-arity caller: high potential, but numerous exact tariff obstructions and no feasible new word yet.", + "Paid intermediate native helper splits: positive predecessor #6702, source-bound route with immediate complete signed-moment test; SELECTED.", + "New BIT pattern-core word: would improve a nonbinding component first, and lacks a complete supplier in the research window." + ], + "methods": [ + "Exact prefix/suffix independence at native cuts", + "Paid intermediate-frame subdivision", + "Boundary basis compensation and whole-word arbitrary-input replay", + "Complete composed paid/target invoice and independent verification" + ], + "stop": "Do not publish a kappa claim without a full native/caller/price/strictification check. Stop unprofitable changes at complete optimistic accounting. At most one related pivot within the same helper-splitting question.", + "coordination": "Live open PR and public Discussion/handoff views inspected; connector does not support Discussion posting, so local claim retained. Public pagination is partial and not a novelty guarantee.", + "archive_survey": "Metadata discovery of 5000+ research entries; substantive selected6030 review, helper-subspace splits, unread-path resynthesis, G20 helper splits, R437 paid carrier exchange and batched CRT overview; not an exhaustive archive review.", + "start_utc": "2026-11-06T12:05:00Z", + "verification_cutoff_utc": "2026-11-06T13:35:00Z", + "end_target_utc": "2026-11-06T14:05:00Z" + }, + "selected_frontier_changed": false +} diff --git a/research/native-retimed-helper-split/VALIDATION.md b/research/native-retimed-helper-split/VALIDATION.md new file mode 100644 index 0000000000..2067590314 --- /dev/null +++ b/research/native-retimed-helper-split/VALIDATION.md @@ -0,0 +1,70 @@ +# Verification record + +Executed on 2026-11-06 with CPython 3.12.14 and the standard library. +The upstream publication refresh still resolved to +`7c49fe32c55de02c2c873655c804b16e4c3fef0a`. + +## Complete scientific replays + +| Run | Result | Elapsed seconds | +|---|---|---:| +| Corrected complete receipt regeneration | PASS_RETIMED_NATIVE_HELPER_SPLIT | 237.09 | +| Registered normal replay | PASS_RETIMED_NATIVE_HELPER_SPLIT | 245.32 | +| Registered optimized replay | PASS_RETIMED_NATIVE_HELPER_SPLIT | 128.62 | +| Standalone normal replay | PASS_RETIMED_NATIVE_HELPER_SPLIT | 236.23 | +| Final publication-source standalone optimized replay | PASS_RETIMED_NATIVE_HELPER_SPLIT | 132.53 | + +The registered command was: + +```sh +python3 -B scripts/research_package.py --package research/native-retimed-helper-split +``` + +It returned `PASS_REGISTERED_RESEARCH_PACKAGE` with outcome `completed`. +Both interpreters reproduced the exact complete receipt. All 60 package-file +hashes stayed unchanged. The standalone copies contained only those 60 files, +with read-only modes, outside a Git checkout. They ran from `/tmp` with the +environment cleared and `PATH=/nonexistent`, using the absolute Python +interpreter. The scientific code made no network request. + +The final standalone optimized replay used every final executable byte. The +only executable edit after the registered runs removed an extra blank line +at the end of `split.py`; its Python AST was checked unchanged. The final +standalone copy and the publication source had identical hashes for all 60 +files. This verification record is the sole additional documentation file. + +## Decisive coverage + +The replays regenerate the candidate and both caller retirements, check +arbitrary public inputs and owned storage, all signed native maps and phases, +1,536 explicit changed-pair columns, every caller contact and independent +field allocation. Separately written native and invoice implementations +agree. All three complete ordinary counts equal **535,415,008**, including +286,728 explicitly decomposed canonical adapters. + +Both exact rational interval engines, finite strictification, the retained +compiler and all 54 strict plus four functional outer inequalities pass at +conditional kappa **165407/50000000 = 0.00330814**. Semantic controls reject +wrong phases, malformed native or ownership data, missing canonical adapters, +aliased independent fields and an insufficient BIT budget. Normal and +optimized execution both retain these checks. + +The optional deterministic discovery replay also rediscovered the exact +published witness among its nine successful variants. Search-domain limits +and unsuccessful continuation experiments are in `RESEARCH-NOTES.md`; they +are not impossibility certificates. + +## Publication byte checks + +The package is additive and isolated. Reproduce the committed-byte and export +checks with: + +```sh +python3 -B scripts/check_research_commit.py --package research/native-retimed-helper-split --check-modes +python3 -B scripts/export_research_package.py export --package research/native-retimed-helper-split --ref HEAD --output /tmp/native-retimed-helper-split.tar.gz +python3 -B scripts/export_research_package.py check --check-inputs /tmp/native-retimed-helper-split.tar.gz +``` + +The five inherited framework assumptions remain. Hosted CI, a materialized +full multiplier, formal proof-kernel acceptance, human peer review and +authentication of all historical pending-commit ancestry are not claimed. diff --git a/research/native-retimed-helper-split/VERIFY.json b/research/native-retimed-helper-split/VERIFY.json new file mode 100644 index 0000000000..c64ccc8cce --- /dev/null +++ b/research/native-retimed-helper-split/VERIFY.json @@ -0,0 +1,28 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [], + "commands": [ + { + "argv": [ + "{python}", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 600, + "checks": "Cold complete native and caller identity, signed maps/phases, independent adjoints and invoice, both rational interval engines, strictification/compiler/outer bounds and negative controls." + }, + { + "argv": [ + "{python}", + "-O", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 600, + "checks": "Same full scientific replay and controls with Python assertions disabled; exact receipt agreement." + } + ] +} diff --git a/research/native-retimed-helper-split/WITNESS.json b/research/native-retimed-helper-split/WITNESS.json new file mode 100644 index 0000000000..f9e458df50 --- /dev/null +++ b/research/native-retimed-helper-split/WITNESS.json @@ -0,0 +1,98 @@ +{ + "screen_hit": { + "frame": 243, + "pivot": 368, + "cut": 12372, + "ranks": [ + 4, + 5 + ], + "gain": 0.011416915667183503, + "paths": [ + { + "role": 80, + "lo": 10112, + "hi": 14089, + "frame": 243, + "old": 749, + "new": 127, + "moves": [ + 14088 + ], + "old_paid": [ + 6 + ], + "new_paid": [ + 1, + 5 + ], + "cost": 0.008906265027938787, + "private": false + } + ], + "a": { + "80": "1", + "26": "1/2", + "368": "-1/2", + "95": "-1/2", + "381": "2" + }, + "b": { + "95": "-2" + }, + "c": { + "383": "2", + "372": "-2", + "382": "-2", + "3": "-2" + }, + "d": { + "379": "1/2", + "377": "1/2", + "368": "-1/2", + "146": "-1/2", + "374": "1/2", + "375": "-1/2", + "382": "-1/2", + "188": "1/2", + "126": "-1/2" + } + }, + "prepared_cut": 12372, + "split": { + "frame": 243, + "pivot": 368, + "ranks": [ + 4, + 5 + ], + "a": { + "80": "1", + "26": "1/2", + "368": "-1/2", + "95": "-1/2", + "381": "2" + }, + "b": { + "95": "-2" + }, + "c": { + "383": "2", + "372": "-2", + "382": "-2", + "3": "-2" + }, + "d": { + "379": "1/2", + "377": "1/2", + "368": "-1/2", + "146": "-1/2", + "374": "1/2", + "375": "-1/2", + "382": "-1/2", + "188": "1/2", + "126": "-1/2" + }, + "cut_after": 12372 + } +} diff --git a/research/native-retimed-helper-split/construct.py b/research/native-retimed-helper-split/construct.py new file mode 100644 index 0000000000..20c2d26971 --- /dev/null +++ b/research/native-retimed-helper-split/construct.py @@ -0,0 +1,34 @@ +"""One deterministic retiming and independent-helper split; no search at replay. + +Jerry Chen / @CubeJerry with substantial OpenAI assistance. Apache-2.0. +The helper-basis constructor is adapted from Ali Romman; see retained sources. +""" +from copy import deepcopy +import native as N +from split import split + +def construct(source, witness): + h=witness['screen_hit'] + N.need((h['cut'],h['frame'],h['pivot'])==(12372,243,368),'Frozen successful cut') + N.need(len(h['paths'])==1,'One genuinely paid retiming') + p=h['paths'][0] + N.need((p['role'],p['old'],p['new'],p['moves'],p['private'])==(80,749,127,[14088],False), + 'Exact advanced rank-six request') + N.need(source['program'][14088]==['MOVE',80,749,127,False],'Bound source event') + for e in source['program'][12372:14088]: + N.need(e[1]!=80 and not(e[0]in('ADD','COPY')and e[2]==80),'No intervening role80 contact') + prepared=deepcopy(source) + prepared['program']=source['program'][:12372]+[['MOVE',80,749,243,False],['MOVE',80,243,127,False]]+source['program'][12372:14088]+source['program'][14089:] + N.replay(prepared) + N.need(witness['prepared_cut']==witness['split']['cut_after']==12372,'Basis lies between paid subdivisions') + return split(prepared,witness['split']) + +if __name__=='__main__': + import argparse,gzip,json + from pathlib import Path + here=Path(__file__).resolve().parent + parser=argparse.ArgumentParser();parser.add_argument('--output',type=Path,required=True) + args=parser.parse_args() + word=construct(N.read(here/'retained/native/PR6702-WORD.json.gz'),N.read(here/'WITNESS.json')) + raw=json.dumps(word,sort_keys=True,separators=(',',':')).encode() + args.output.write_bytes(gzip.compress(raw,mtime=0)if args.output.suffix=='.gz'else raw+b'\n') diff --git a/research/native-retimed-helper-split/context.py b/research/native-retimed-helper-split/context.py new file mode 100644 index 0000000000..fce054e510 --- /dev/null +++ b/research/native-retimed-helper-split/context.py @@ -0,0 +1,18 @@ +"""Explicit path adapter for unchanged, locally retained predecessor engines.""" +from pathlib import Path +import native + +ROOT=Path(__file__).resolve().parent +need=native.need +MAP={ + 'research/higher-moment-strictification/verify.py':'intervals.py', + 'research/kappa-rebuild/architecture/mixed_target_probe.py':'second_intervals.py', + 'research/pr4359-p7-padding/dependencies/compiler-refill/endpoint.py':'endpoint.py', + 'research/pr4359-p7-padding/native_inventory.py':'native_inventory.py', + 'research/kappa-0023-productive-jobs/dependencies/kappa-next-regime/direct-decoder/sources/DATA-PHASES.json':'DATA-PHASES.json', + 'research/query-thinned-controllers/RESULT.json':'BIT-RESULT.json', +} +def resolve(path): + return ROOT/'retained/runtime'/MAP[path.relative_to(ROOT).as_posix()] +def load(path,name):return native.load(resolve(path),name) +def read(path):return native.read(resolve(path)) diff --git a/research/native-retimed-helper-split/discover.py b/research/native-retimed-helper-split/discover.py new file mode 100644 index 0000000000..9696127dbb --- /dev/null +++ b/research/native-retimed-helper-split/discover.py @@ -0,0 +1,142 @@ +"""Optional finite discovery; the verifier does not trust this search. + +Helper kernel/basis methods: Ali Romman. Paid main-path retiming extension: +Jerry Chen / @CubeJerry with substantial OpenAI Codex assistance. Apache-2.0. +Floating point only screens candidates; accepted constructions receive exact +whole-word, phase, invoice and complete conditional-parameter verification. +""" +import gzip,json,sys,time +from pathlib import Path +from fractions import Fraction as Q +from collections import defaultdict,Counter +from native import add,span +from split import basis + +def pure_combinations(rows, roles, group): + """Eliminate coordinates outside the group; retain field coefficients.""" + pivots, output = {}, [] + for role in roles: + outside = {k:v for k,v in rows[role].items() if k not in group} + inside = {k:v for k,v in rows[role].items() if k in group} + coefficients = {role:Q(1)} + while outside: + pivot = min(outside) + if pivot not in pivots: + scale = 1/outside[pivot] + pivots[pivot] = [{k:v*scale for k,v in row.items()} + for row in (outside, inside, coefficients)] + break + scale = -outside[pivot] + for target, source in zip((outside, inside, coefficients), pivots[pivot]): + add(target, source, scale) + if not outside and inside: + output.append((inside, coefficients)) + return output + + +def dyadic_program(program): + for event in program: + q = Q(event[-2]) + numerator, denominator = abs(q.numerator), q.denominator + if denominator & (denominator-1): + return False + if event[0] == 'SCALE' and numerator & (numerator-1): + return False + return True + + + +def encode(value): + if isinstance(value,Q):return str(value) + if isinstance(value,dict):return {str(k):encode(v)for k,v in value.items()} + if isinstance(value,(tuple,list)):return [encode(x)for x in value] + return value + +HERE=Path(__file__).parent +w=json.loads(gzip.decompress(((Path(sys.argv[1]) if len(sys.argv)>1 else HERE/'retained/native/PR6702-WORD.json.gz')).read_bytes())) +n=w['public'];N=n+w['owned_fields'];main=set(w['live'])|{r+112 for r in w['live']} +U,V=3,127;group={r for r in range(n)if r not in main and(w['initial'][r],w['final'][r])==(U,V)} +spans=[span(b)for b in w['frames']];dims=list(map(len,w['frames'])) +contacts=defaultdict(list);moves=defaultdict(list) +for i,e in enumerate(w['program']): + if e[0]=='MOVE':moves[e[1]].append(i) + else: + contacts[e[1]].append(i) + if e[0]in('ADD','COPY'):contacts[e[2]].append(i) +t=1-.0033072446849 +windows=[];starts=defaultdict(list);ends=defaultdict(list) +for r in range(N): + touches=[-1]+contacts[r]+[len(w['program'])] + for lo,hi in zip(touches,touches[1:]): + mi=[i for i in moves[r]if lo=maxgain-1e-12:continue + h=dict(role=r,lo=lo+1,hi=hi,frame=f,old=a,new=b,moves=mi,old_paid=paid,new_paid=[d1,d2],cost=cost,private=r>=n) + idx=len(windows);windows.append(h);starts[lo+1].append(idx);ends[hi+1].append(idx) +print('windows',len(windows),flush=True) +rows=[{r:Q(1)}if r=gain-1e-12:continue + if not dyadic_program(basis(c,d,p,U)+basis(a,b,p,f)):continue + key=(f,p,tuple(sorted(c.items())),tuple(sorted(d.items())),tuple(sorted(a.items())),tuple(sorted(b.items()))) + if key in seen:continue + seen.add(key);hits.append(dict(frame=f,pivot=p,cut=cut,ranks=[dims[f],9-dims[f]],gain=gain-cost,paths=[windows[idx]for idx in used],a=a,b=b,c=c,d=d)) + if cut: + e=w['program'][cut-1];op,r=e[:2] + if op in('INIT','CLEAR'):cols[r]={} + elif op=='SCALE':cols[r]={k:v*Q(e[2])for k,v in cols[r].items()} + elif op in('ADD','COPY'): + add(cols[e[2]],cols[r],Q(e[3])) + if op=='COPY':cols[r]={} + if cut%5000==0:print('reverse',cut,'pairs',pairs,'hits',len(hits),'sec',round(time.time()-start,2),flush=True) +hits.sort(key=lambda h:-h['gain']) +((Path(sys.argv[2]) if len(sys.argv)>2 else HERE/'DISCOVERED-HITS.json')).write_text(json.dumps(encode(hits),indent=2)+'\n') +print('paired',pairs,'hits',len(hits),'seconds',time.time()-start,flush=True) +for h in hits[:10]:print({k:v for k,v in encode(h).items()if k not in('a','b','c','d')},flush=True) diff --git a/research/native-retimed-helper-split/independent/FINAL-PROOF-REVIEW.md b/research/native-retimed-helper-split/independent/FINAL-PROOF-REVIEW.md new file mode 100644 index 0000000000..220ed38a77 --- /dev/null +++ b/research/native-retimed-helper-split/independent/FINAL-PROOF-REVIEW.md @@ -0,0 +1,199 @@ +# Final proof and README audit + +**Corrected pass within the stated conditional scope.** The earlier version +of this review missed the additional canonical-job adapter charges and +incorrectly accepted 252,223,008 as a complete ordinary bound. That statement +is withdrawn: 252,223,008 was a partial estimate. The complete independently +recounted bound is **535,415,008 < 10^9**. Existing audit #6763, pinned at +`c3e0500c7645b1bc228ebe5e5190e304a2da46ca`, supplied the explicit adapter +contract; this review's own checker independently reconstructs its counts +from the current literal caller. The Gaussian invoice, field allocation, +strict gain and final kappa qualification are unchanged. + +This audit +reads the frozen `PROOF.md`, `README.md`, relevant emitted-word/checker code, +the final combined receipt and the separately written local/invoice receipts. +It does not rerun the expensive native/physical/compiler suite or claim human +or proof-kernel acceptance. + +Reviewed document hashes: + +| File | SHA-256 | +|---|---| +| PROOF.md | `3bf08ba92bf0f878737f3bf61610e9c911d006319c1751af5b76fd1853bbe9dc` | +| README.md | `243b7f52ae54a7b8a3d93a6cc98a4cf08c87f83b77ccbe61eb8cd8ee3110dbf9` | + +The combined receipt must incorporate the updated independent invoice during +the final normal/optimized/cold replays. No earlier receipt's partial ordinary +subsection should be used as a complete-budget certificate. + +## Rectangular maps and owned domains + +The proof does not require an invertible prefix or suffix. Its precise +well-typed interpretation is as follows. Let `X = Q^771` be the original +public-input/output space and `Z = Q^800` the padded cut-state space, including +all 29 owned labels. The prefix `P: X -> Z` includes the explicit owned +initialization. The suffix `S: Z -> X` means the formal suffix followed by +projection to the public outputs. Consequently `SP = M`, where `M` is the +old public native map. Inactive owned slots may be padded with zero; they +are not additional independent public inputs. + +The boundary basis `G` is an automorphism of X, supported entirely on +equal-boundary helpers. The cut basis `J` is an automorphism of Z; it is the +identity away from the listed public roles at frame 243. Thus + +\[ +Q=JPG^{-1}:X\to Z,\qquad R=GSJ^{-1}:Z\to X +\] + +are legitimate rectangular maps. The checked identities imply + +\[ +e_p^TQ=cG^{-1}=e_p^T,\qquad +Re_p=GSb=Gd=e_p. +\] + +Since `G` acts only on an identity helper block of M, it commutes with M, +so `RQ=GMG^-1=M`. Replacing the cut coordinate by arbitrary z gives + +\[ +R\bigl(Qx+(z-x_p)e_p\bigr) +=Mx+(z-x_p)e_p. +\] + +The old role p has already returned the value `x_p` at frame 243; the suffix +coordinate p is renamed to fresh role 771 and returns z at frame 127. Every +other public output is unchanged. This explains both boundary maps and +requires neither an inverse of P/S nor a zero assumption on the fresh input. +The stronger complete local audit also verifies that final owned outputs are +zero and that no initial owned value contributes to any output. + +The channel identities alone would not prove the legality of a guarded COPY +after arbitrary cut replacement. The proof correctly cites a separate +candidate-wide pre-COPY monitor; it passes for every arbitrary public input. +The independently evaluated suffix direction b also passes its COPY-zero +guard. CLEAR functions may change under the basis. The proof explicitly +retains the owned-erasure premise instead of treating their unchanged count +as a proof of unconditional erasure. The 47 lifetimes, 45 nonzero CLEAR +observations and zero/nonzero pattern agree with the independent receipt. + +## Retiming and the general economic criterion + +The source event and contact-free interval agree with the checked witness. +The prepared path is `749 -> 243 -> 127`, with dimensions `3 -> 4 -> 9`; +the helper's entry is frame 3 of dimension zero. All required strict span +inclusions were checked by the local audit. The common intermediate chart +permits the supplied dyadic bases; there is no hidden cross-chart exchange. + +The literal deltas are correctly stated as +`delta P = H1 + H5 - H6` and `delta T = H4 + H5 - H9`. Their difference +`H4 + H6 - H1 - H9` is strictly positive throughout `0 < t < 1` by the +displayed integral. Both rank masses are unchanged. + +The proposed general economic pattern is also correct. For dimensions +`e < a < f < v`, write `u=f-a`, `h=a-e` and `s=v-f`, all positive. Its +left side equals + +\[ +\int_u^{u+h} +\left[t x^{t-1}-t(x+s)^{t-1}\right]\,dx>0. +\] + +The inequality pays for the donor subdivision. It is a sufficient accounting +pattern only when the required legal frames and independent-channel identities +exist. The proof explicitly states this limitation and makes no general +existence, optimality or second-gain claim. + +## Receipt and claim consistency + +The primary receipt and independent invoice have identical complete T/P +histograms: 13,688 productive fields, 66,870 paid requests, paid rank mass +178,080 and surplus 760. The eighteen new helper allocations, 20,304 total +helper normalizers, local scalar allowance 138,374 and per-call count 5,533,374 +all agree. The corrected complete ordinary upper bound is 535,415,008 as +derived below. The stated physical +counts match the receipt: 2,940 distinct native maps, 208 main adapters, +1,128 helper normalizers per call, 1,536 changed-pair explicit columns, +7,488 caller contacts and 53,248 central-square columns. + +The final receipt claims `165407/50000000 = 0.00330814` and tests +`661629/200000000 = 0.003308145`. Both exact engines report tested margin +in the interval +`[0.000043164272593392920133476725, + 0.000043164272593392920133476726]`. +The raw bracket and compiler gap agree with the independent final-parameter +audit. The receipt has all 54 strict and four functional outer inequalities, +the retained BIT saving 17/5000, and `word_materialized=false`. + +The README's gain 0.00000094 over the pending claim 0.00330720 is exact; +its stated approximate relative increase 0.0284% is correctly rounded. The +selected-frontier flag is false and the README explicitly retains the +selected value 0.003125804. + +## Corrected canonical adapters and ordinary budget + +The old flat allowance of 1000 units for each of the 3,536 main-output routes +did not account for every canonical-job boundary on the full 153-axis +carrier. It also omitted the explicit whole-idle and thin-query adapters. +This is an ordinary-cost omission; none of the Gaussian rank requests changes. + +For each selected coordinate set I of rank r, the independently written +checker pairs coordinates missing from the first r positions with selected +coordinates outside those positions. It constructs the actual involutive +permutation and verifies that it maps the canonical set to I. Both boundaries +pay for all resulting two-axis swaps. It separately verifies the orthonormal +q bases, maps q to coordinate zero, and reconstructs all 512 nine-bit addresses +for each of the 104 bases. Both q-basis boundaries and the `Q^2` translation +for a negative q exponent are counted. + +| Canonical adapter | Elementary maps | +|---|---:| +| Main two-axis swaps | 144,768 | +| Main q-basis maps | 6,656 | +| Main endpoint translations | 3,328 | +| Whole-idle two-axis swaps | 127,296 | +| Thin-query q-basis maps | 3,120 | +| Thin-query translations | 1,560 | +| **Total** | **286,728** | + +Every elementary map has support at most nine axes. The retained fixed-map +rate is charged separately for every map; it is not applied once to an +arbitrary full-carrier map. The previous 3,536,000 flat route units are +replaced by 286,728,000 units, a net correction of 283,192,000. Main-output +scalar work remains 91,936. The full budget is + +\[ +18\cdot10^7+68570112+24960+91936+286728000=535415008<10^9. +\] + +Using the counted native work gives 455,015,740. All helper normalizers remain +separately included in each local call. The updated independent checker passes +both normal and optimized execution with byte-identical results. The corrected +PROOF and README now state the full bound and identify the former partial +estimate. The existing compiler's one-billion envelope remains sufficient. + +The precision paragraph is properly conditional: scalar majorants, charged +Gaussian rank mass, additive COPY errors, owned erasure and movement scratch +remain within the stated implementation contracts. It does not incorrectly +identify exact overwrite notation with physical removal of approximation +errors, or assume descriptor constants are absorbed at the displayed finite +supplier threshold. + +## Attribution and limits + +Ali Romman's helper-basis mechanism, the #6702 and #6726 sources, and the +retained native, caller, compiler, interval and analytic authors are credited. +The adapter note identifies the modified drivers and preserves the distinction +between adapted code and unchanged retained sources. The claim is explicitly +author-side, conditional on the same five named assumptions, and dependent +on pinned pending predecessors. It claims neither independent human +acceptance nor a materialized full multiplier, exhaustive novelty search, +historical ancestry authentication, global optimum or selected-frontier change. + +The ordinary-accounting repair above is required and does not alter the frozen +positive native construction. After incorporating it and regenerating the +combined receipt, no further discrepancy was identified on the points reviewed +here. Separate exploratory failures do not change this verdict and are not +used as universal obstructions. + +Reviewed for @CubeJerry with substantial OpenAI assistance. Apache-2.0. diff --git a/research/native-retimed-helper-split/independent/INVOICE-RESULT.json b/research/native-retimed-helper-split/independent/INVOICE-RESULT.json new file mode 100644 index 0000000000..e2775c1660 --- /dev/null +++ b/research/native-retimed-helper-split/independent/INVOICE-RESULT.json @@ -0,0 +1,532 @@ +{ + "status": "PASS_INDEPENDENT_COMPLETE_CALLER_INVOICE", + "inputs": { + "CONTROLLER.json": "543b8728e659561b95e127dad7bd7534645996d7d2c61602bb5d89c89a73944c", + "CALLER-ONE-RETIRED.json": "8d7889e817faf1bbf81bb4ed681db039df6e26ecdab5555dff60c3d0e4309030", + "CALLER-UNRETIRED.json": "8693f74b4559c27dd670f788c6e8c7be8bc7cf9cd6a6abb80455fee86d20bc99", + "RETIREMENT-WITNESSES.json": "272534848a8fe8a9fd523f4daf2747b24a6b26eb9a848d27cafcb22a2e718136", + "DATA-PHASES.json": "c5916ff312678f12aba403847643fbbc29f643acec60bdf836fa56cd3e8251fa" + }, + "source_sha256": "e8c7a9d54d98a4cfa27e15593016b3908afed303e0f480076ed3f596192e5a4d", + "candidate_sha256": "2a9f93a82993b85625df20751cc8027d70a85e1fb4278187adbea520909a2e4e", + "correct_final_literal": "CONTROLLER.json", + "retirement_reconstruction": [ + { + "pivot": 6, + "fresh": 32, + "cut": 158, + "events": 592, + "roles": 33 + }, + { + "pivot": 4, + "fresh": 33, + "cut": 394, + "events": 606, + "roles": 34 + } + ], + "caller_all_columns": { + "inputs": 34, + "coefficients": 1156, + "direction": "reverse adjoint", + "ring": "Q(i)[q,C1,...,C18]/(q^4-1)" + }, + "counts": { + "SCALE": 86, + "ADD": 275, + "SWAP": 94, + "LAMBDA": 100, + "QUERY": 15, + "IDLE": 12, + "LOCAL": 18, + "IDLE_ONE": 6 + }, + "main_targets": { + "1": 104, + "9": 208, + "17": 1664, + "32": 208, + "33": 832, + "41": 208, + "73": 208, + "145": 104 + }, + "whole_idle_paid": { + "8": 208, + "16": 1664, + "32": 1040, + "40": 208 + }, + "targets": { + "1": 356, + "2": 144, + "3": 72, + "4": 1962, + "5": 306, + "6": 54, + "7": 162, + "8": 720, + "9": 6688, + "17": 1664, + "32": 208, + "33": 832, + "41": 208, + "73": 208, + "145": 104 + }, + "paid": { + "1": 41736, + "2": 8172, + "3": 8820, + "4": 1962, + "5": 2754, + "6": 126, + "7": 162, + "8": 226, + "16": 1664, + "32": 1040, + "40": 208 + }, + "target_count": 13688, + "paid_count": 66870, + "target_rank_mass": 178840, + "paid_rank_mass": 178080, + "surplus": 760, + "target_delta": { + "4": 18, + "5": 18, + "9": -18 + }, + "paid_delta": { + "1": 18, + "5": 18, + "6": -18 + }, + "fields": { + "main_fields": 3536, + "helper_fields": 10152, + "helpers_per_call": 564, + "public_fields": 13688, + "additional_helpers": 18, + "owned_labels": 29, + "owned_first": 13688, + "owned_last": 13716, + "thin_query_scratch": 13717, + "reserved_field_slots": 13718, + "invocations": [ + { + "stage": 1, + "src": 1, + "dst": 0, + "helper_first": 3536, + "helper_last": 4099, + "extra_helper": 4099 + }, + { + "stage": 2, + "src": 0, + "dst": 1, + "helper_first": 4100, + "helper_last": 4663, + "extra_helper": 4663 + }, + { + "stage": 3, + "src": 0, + "dst": 1, + "helper_first": 4664, + "helper_last": 5227, + "extra_helper": 5227 + }, + { + "stage": 4, + "src": 1, + "dst": 0, + "helper_first": 5228, + "helper_last": 5791, + "extra_helper": 5791 + }, + { + "stage": 5, + "src": 1, + "dst": 0, + "helper_first": 5792, + "helper_last": 6355, + "extra_helper": 6355 + }, + { + "stage": 6, + "src": 0, + "dst": 1, + "helper_first": 6356, + "helper_last": 6919, + "extra_helper": 6919 + }, + { + "stage": 7, + "src": 0, + "dst": 1, + "helper_first": 6920, + "helper_last": 7483, + "extra_helper": 7483 + }, + { + "stage": 8, + "src": 1, + "dst": 0, + "helper_first": 7484, + "helper_last": 8047, + "extra_helper": 8047 + }, + { + "stage": 9, + "src": 0, + "dst": 1, + "helper_first": 8048, + "helper_last": 8611, + "extra_helper": 8611 + }, + { + "stage": 10, + "src": 1, + "dst": 0, + "helper_first": 8612, + "helper_last": 9175, + "extra_helper": 9175 + }, + { + "stage": 11, + "src": 0, + "dst": 1, + "helper_first": 9176, + "helper_last": 9739, + "extra_helper": 9739 + }, + { + "stage": 12, + "src": 1, + "dst": 0, + "helper_first": 9740, + "helper_last": 10303, + "extra_helper": 10303 + }, + { + "stage": 13, + "src": 1, + "dst": 0, + "helper_first": 10304, + "helper_last": 10867, + "extra_helper": 10867 + }, + { + "stage": 14, + "src": 0, + "dst": 1, + "helper_first": 10868, + "helper_last": 11431, + "extra_helper": 11431 + }, + { + "stage": 15, + "src": 1, + "dst": 0, + "helper_first": 11432, + "helper_last": 11995, + "extra_helper": 11995 + }, + { + "stage": 16, + "src": 0, + "dst": 1, + "helper_first": 11996, + "helper_last": 12559, + "extra_helper": 12559 + }, + { + "stage": 17, + "src": 0, + "dst": 1, + "helper_first": 12560, + "helper_last": 13123, + "extra_helper": 13123 + }, + { + "stage": 18, + "src": 1, + "dst": 0, + "helper_first": 13124, + "helper_last": 13687, + "extra_helper": 13687 + } + ] + }, + "ordinary": { + "helper_normalizers_per_call": 1128, + "helper_normalizers_all_calls": 20304, + "main_adapters_per_call": 208, + "contact_routes_per_call": 416, + "lifetime_routes_per_call": 188, + "local_scalar": 138374, + "local_routes": 5395000, + "local_per_call": 5533374, + "local_upper_per_call": 10000000, + "caller_envelope": 68570112, + "caller_actual_work_per_port": 3526, + "caller_actual_height_per_port": 2280, + "caller_maximum_scalar": "6", + "thin_query_work": 24960, + "main_output_scalar_units": 91936, + "canonical_adapters": { + "ambient_axes": 153, + "q_bases_checked": 104, + "q_basis_address_checks": 53248, + "components": { + "idle_axis_swaps": 127296, + "idle_jobs": 3120, + "idle_phase_maps": 0, + "idle_q_basis_maps": 0, + "main_axis_swaps": 144768, + "main_jobs": 3536, + "main_phase_maps": 3328, + "main_q_basis_maps": 6656, + "query_axis_swaps": 0, + "query_jobs": 1560, + "query_phase_maps": 1560, + "query_q_basis_maps": 3120 + }, + "elementary_maps": 286728, + "profiles": [ + { + "kind": "idle", + "rank": 8, + "swaps_per_side": 8, + "central": 0, + "negative": 0, + "multiplicity": 208 + }, + { + "kind": "idle", + "rank": 16, + "swaps_per_side": 9, + "central": 0, + "negative": 0, + "multiplicity": 208 + }, + { + "kind": "idle", + "rank": 16, + "swaps_per_side": 16, + "central": 0, + "negative": 0, + "multiplicity": 1456 + }, + { + "kind": "idle", + "rank": 32, + "swaps_per_side": 9, + "central": 0, + "negative": 0, + "multiplicity": 208 + }, + { + "kind": "idle", + "rank": 32, + "swaps_per_side": 32, + "central": 0, + "negative": 0, + "multiplicity": 832 + }, + { + "kind": "idle", + "rank": 40, + "swaps_per_side": 40, + "central": 0, + "negative": 0, + "multiplicity": 208 + }, + { + "kind": "main", + "rank": 1, + "swaps_per_side": 0, + "central": 1, + "negative": 1, + "multiplicity": 104 + }, + { + "kind": "main", + "rank": 9, + "swaps_per_side": 8, + "central": 1, + "negative": 1, + "multiplicity": 208 + }, + { + "kind": "main", + "rank": 17, + "swaps_per_side": 8, + "central": 1, + "negative": 1, + "multiplicity": 208 + }, + { + "kind": "main", + "rank": 17, + "swaps_per_side": 16, + "central": 1, + "negative": 1, + "multiplicity": 1456 + }, + { + "kind": "main", + "rank": 32, + "swaps_per_side": 32, + "central": 0, + "negative": 0, + "multiplicity": 208 + }, + { + "kind": "main", + "rank": 33, + "swaps_per_side": 8, + "central": 1, + "negative": 1, + "multiplicity": 208 + }, + { + "kind": "main", + "rank": 33, + "swaps_per_side": 32, + "central": 1, + "negative": 1, + "multiplicity": 624 + }, + { + "kind": "main", + "rank": 41, + "swaps_per_side": 40, + "central": 1, + "negative": 1, + "multiplicity": 208 + }, + { + "kind": "main", + "rank": 73, + "swaps_per_side": 8, + "central": 1, + "negative": 1, + "multiplicity": 104 + }, + { + "kind": "main", + "rank": 73, + "swaps_per_side": 72, + "central": 1, + "negative": 1, + "multiplicity": 104 + }, + { + "kind": "main", + "rank": 145, + "swaps_per_side": 8, + "central": 1, + "negative": 1, + "multiplicity": 104 + }, + { + "kind": "query", + "rank": 1, + "swaps_per_side": 0, + "central": 1, + "negative": 1, + "multiplicity": 1560 + } + ], + "scope": "Exact coordinate permutations, q-basis inverses and multiplicity count. The 1000-unit rate is retained for each fixed native whole-job map or each elementary map supported on at most 17 specified axes; it is not a rate for an arbitrary 153-axis map." + }, + "canonical_adapter_units": 286728000, + "superseded_flat_main_output_routes": 3536000, + "former_partial_raw_upper": 252223008, + "full_adapter_correction": 283192000, + "raw_counted": 455015740, + "raw_upper": 535415008, + "budget": 1000000000, + "route_rate_status": "Retained physical/tape contract: 1000 per fixed native whole-job map or per <=17-axis elementary map; full 153-axis adapters are explicitly decomposed and charged." + }, + "old_diagnostic": { + "precision": 110, + "raw_root": "0.0033072446848536245973798019897684320951893194008313099306881081168110242987670300247951995194083493004969001086", + "bracket": [ + "0.0033072446848536245973798019897684320951893194008313099306881081168110242987670300247951737816204019603523094139", + "0.0033072446848536245973798019897684320951893194008313099306881081168110242987670300247952252571962966406414908034" + ], + "claim": ".00330814", + "tested": ".003308145", + "margin_claim": "-0.2043754634782513775055358284381505772433134899547131804049066723926062535046095929859019994888151751674976", + "margin_tested": "-0.2055168218817175299779210604355004841443643869846984701706433794694348274650121225994755916319846242750230", + "derivative_at_root": "-228272.50551364232502754317439341679406435622171137753573276003603178114627269027305078651341308884843816153907", + "certification": "High-precision Decimal diagnostic only; not an exact interval certificate." + }, + "new_diagnostic": { + "precision": 110, + "raw_root": "0.0033081451891427507768445384025038782466876822578664546165118237030076705500625645122183328980016024712802268546", + "bracket": [ + "0.0033081451891427507768445384025038782466876822578664546165118237030076705500625645122183071602136551311356361598", + "0.0033081451891427507768445384025038782466876822578664546165118237030076705500625645122183586357895498114248175494" + ], + "claim": ".00330814", + "tested": ".003308145", + "margin_claim": "0.0011842144282776484142703542022410909911161056750750356650284779816907229234597647258104122527716692244314", + "margin_tested": "0.0000431642725933929201334767256388110237093179609093789538301353256996984083602023582023629892805603477110", + "derivative_at_root": "-228210.02866713794398530886869762804476105165885734422556150044112011593318291806165607409836304900860426192474", + "certification": "High-precision Decimal diagnostic only; not an exact interval certificate." + }, + "raw_root_gain": "9.005042891261794647364127354461514983628570351446858237155861966462512955344874231333785932531707833E-7", + "final_claim_arithmetic": { + "claim": "165407/50000000", + "tested": "661629/200000000", + "certified_lower": "33081451891/10000000000000", + "lower_minus_tested": "1891/10000000000000", + "compiler_gap": "1/1400000000", + "strictification_reserve": "1/1000000000000000000000000000", + "strictification_power": 1920, + "exact_finite_strictification": true, + "exact_rank_rounding": true, + "alpha": "0.99999999975625802842708344078799070816915977447623495625785894864509430201254346688438507765011302988730693654", + "one_minus_alpha": "2.4374197157291655921200929183084022552376504374214105135490569798745653311561492234988697011269306346E-10", + "reserve_slack_factor": "243741971572916559.21200929183084022552376504374214105135490569798745653311561492234988697011269306346", + "gamma": "0.91935224266880718005056823734722870062655659970114927284108053039907278841533667862623235966536305081455991426", + "delta": "0.92019963727703631701101199728442349097523484323186450521207600725084692275308962653947533825574609879057475665", + "decay": "0.96875", + "eta": "1.8635150721153376243181793240153577489251559323011631964294454162468718118598498624957670765313654167916727568E-14", + "theta_power": "4.3371903853167193168739585777461573256796887604736254848253642940568612912413458446482894901339356806016540945E-15", + "certification": "Parameter inequalities are exact rationals; moments are Decimal diagnostics. The raw lower endpoint is supplied by the primary exact interval certificate." + }, + "controls": [ + { + "mutation": "price the intermediate one-retirement caller", + "rejected": "complete final caller dimensions" + }, + { + "mutation": "omit one full native call", + "rejected": "all eighteen distinct forward native calls" + }, + { + "mutation": "reverse one thin-query orientation", + "rejected": "complete arbitrary-input caller column 0" + }, + { + "mutation": "alias one native source and destination", + "rejected": "injective full native public allocation" + }, + { + "mutation": "retain the old 563-helper allocation", + "rejected": "all independent helper roles" + } + ], + "limitations": [ + "Native absolute phases and physical routes require the primary native verifier.", + "1000-unit route rate, owned erasure and other inherited framework assumptions remain.", + "No completion/compiler/outer admission is inferred from the Decimal root diagnostic." + ] +} diff --git a/research/native-retimed-helper-split/independent/INVOICE-REVIEW.md b/research/native-retimed-helper-split/independent/INVOICE-REVIEW.md new file mode 100644 index 0000000000..e15e4d3f63 --- /dev/null +++ b/research/native-retimed-helper-split/independent/INVOICE-REVIEW.md @@ -0,0 +1,276 @@ +# Independent complete caller and allocation review + +**Qualified pass.** The new native word composes with the literal final #6726 +caller after allocating and charging eighteen additional independent helper +fields. The complete price has 13,688 productive fields, 66,870 paid requests, +and rank-mass surplus 760. The corrected complete ordinary upper bound is +535,415,008, strictly below one billion. + +**Ordinary-accounting correction:** the earlier version of this review +incorrectly described 252,223,008 as complete. That was a partial estimate: +it omitted explicit full-carrier canonical-job adapters for whole idles, +main targets and thin queries. Existing audit #6763 at commit +`c3e0500c7645b1bc228ebe5e5190e304a2da46ca` identified those charges. They +have now been independently reconstructed here from the literal caller. +This correction does not change the Gaussian histogram, root diagnostic, +field allocation or the retained one-billion ordinary cap. + +`check_invoice.py` imports only the separately written `check_native.py`. +It imports no parent constructor, caller evaluator, pricing module or interval +engine. Normal Python and `python -O` produce identical results. This is a +separately written AI audit, not independent human acceptance or proof-kernel +certification. The candidate gzip SHA-256 remains +`2a9f93a82993b85625df20751cc8027d70a85e1fb4278187adbea520909a2e4e`. + +## Literal identity and full caller map + +The correct final literal is `retained/caller/CONTROLLER.json`: 34 roles, +18 stages, 606 events and ambient rank 153. `CALLER-ONE-RETIRED.json` has +33 roles and 592 events and is only an intermediate. Starting from +`CALLER-UNRETIRED.json`, this checker independently inverts the witness +bases, renames the suffix pivot, updates the declared targets, and reconstructs +both complete files exactly. It checks that each fresh caller field is +untouched before its handoff and the corresponding retired field is untouched +afterward. + +A new reverse-adjoint evaluator then reconstructs all 34 by 34 coefficients +over `Q(i)[q,C1,...,C18]/(q^4-1)`. Every arbitrary-input column equals the +declared diagonal target, including both new caller inputs. This evaluator +does not share the retained caller evaluator's forward implementation. + +The literal census is ADD 275, SCALE 86, SWAP 94, LAMBDA 100, LOCAL 18, +QUERY 15, IDLE 12 and IDLE_ONE 6. The eighteen LOCAL events use stages 1 +through 18 exactly once, in order, with distinct source and destination +roles. Each charges one complete new native word. The fifteen thin queries +charge 104 rank-one requests each. Whole idle jobs charge ranks 8, 16, 32, +40 with multiplicities 208, 1664, 1040, 208, respectively. + +All 3,536 main targets are counted directly from the 34 diagonal exponent +vectors and 104 ports. Their ranks are 1, 9, 17, 32, 33, 41, 73, 145 with +multiplicities 104, 208, 1664, 208, 832, 208, 208, 104. The old native word +with this same literal caller independently reproduces the retained #6726 +invoice exactly. + +## Complete new histogram + +| Rank | Productive targets | Paid requests | +|---:|---:|---:| +| 1 | 356 | 41736 | +| 2 | 144 | 8172 | +| 3 | 72 | 8820 | +| 4 | 1962 | 1962 | +| 5 | 306 | 2754 | +| 6 | 54 | 126 | +| 7 | 162 | 162 | +| 8 | 720 | 226 | +| 9 | 6688 | 0 | +| 16 | 0 | 1664 | +| 17 | 1664 | 0 | +| 32 | 208 | 1040 | +| 33 | 832 | 0 | +| 40 | 0 | 208 | +| 41 | 208 | 0 | +| 73 | 208 | 0 | +| 145 | 104 | 0 | + +Thus the literal complete differences are + +\[ +\Delta T=18(H_4+H_5-H_9),\qquad +\Delta P=18(H_1+H_5-H_6). +\] + +The paid rank mass is 178,080 and the target rank mass is 178,840. +Every native call contributes the independently checked strict concavity +gain from `REVIEW.md`; no other caller mechanism changes. + +## Constructive allocation and arbitrary-input compatibility + +Number the caller's main fields by `104 * role + port_index`, giving IDs +0 through 3535. List the 564 native helper roles in increasing order. In +LOCAL stage `s`, assign helper ordinal `j` the global ID + +\[ +3536+(s-1)564+j. +\] + +For the native main roles, map `live[port_index]` to the caller source and +`live[port_index]+112` to its destination. Each invocation's 772 public +roles map injectively; its helpers are disjoint from every main field and +from all other invocations' helper blocks. The checker explicitly builds +all eighteen maps. Together they use 10,152 independent helpers and 3,536 +main inputs, totaling 13,688 public inputs. This is eighteen more helpers, +not eighteen more helpers per port: the native word already contains all +104 ports. + +Reserve IDs 13688 through 13716 for the 29 owned labels and ID 13717 for +the separately uncredited thin-query scratch. Local invocations and thin +queries are sequential. All native owned lifetimes finish inside their +invocation, so these labels can be reused without aliasing any independent +input or retained output. There are 13,718 reserved field slots. All IDs +still fit in fourteen bits. + +The independent local all-column audit establishes the key substitution +contract: in native charts, the 208 main roles have the original main map, +the 564 helper roles have the identity map, and all cross terms between +the two blocks vanish. Each helper output depends on its own arbitrary +input alone. The main input need not be pristine; it may be any linear +combination supplied by the caller, because the local identity and COPY-zero +guard were checked for arbitrary public inputs. + +Consequently, after mapping a call to its disjoint global fields, its helper +block is independent of the caller's continuing main calculation. Although +the native implementation temporarily mixes roles, its returned main block +is exactly the one required by the existing LOCAL event. The complete caller +therefore extends by independent helper identities in normalized charts. +The new helper is supplied as an arbitrary input in initial chart 243 and +returns in chart 127. It is never initialized to zero, borrowed from a main +idle direction, or hidden in owned scratch. Native helper368 now returns at +chart243. The actual boundary operators for these charts still need the +native phase verifier; the normalized linear identity alone cannot replace +that check. + +## Ordinary work and normalizers + +Every invocation charges two boundary normalizers for each of its 564 +helpers: 1,128 normalizers per call, 20,304 across the caller. This includes +the new helper's two normalizers and the changed helper368 endpoint. The +total increase is 36 helper normalizers, eighteen paid MOVE jobs and +18 times 384 scalar units. + +The complete local count is + +\[ +138374+1000(3455+1128+208+416+4\cdot47)=5533374<10^7. +\] + +The summands count native paid routes, helper normalizers, 208 main adapters, +four contacts for each of 104 ports, and four routes for each owned lifetime. +The 1000-unit route rate is an inherited physical/tape contract for each +native fixed whole-job map or elementary map on at most 17 specified axes. +It does not give a single 1000-unit charge for an arbitrary permutation of +the complete 153-axis carrier. The local count above must therefore be +supplemented by the explicit full-caller adapters below. + +The complete caller's ordinary scalar calculation gives 3,526 real work +units and 2,280 coefficient-height units per port. Every actual gate fits +the 32-unit envelope; the maximum literal ADD/SCALE magnitude here is 6. +Scanning all 34 main roles at every one of 606 caller events costs at most +`32 * 34 * 104 * 606 = 68,570,112`. All fifteen thin queries charge another +24,960 units. The ordinary scalar part of all 3,536 main output normalizers +charges another `3536 * 26 = 91,936` units. + +For a job on the coordinate set I of rank r, let C be the first r coordinates. +The sets `C minus I` and `I minus C` have the same size. Pairing their elements +gives disjoint two-axis swaps; the checker explicitly constructs the resulting +permutation, verifies that it sends C to I, and verifies its inverse. Every +job pays for both boundary permutations. Each selected fresh stage contributes +coordinates `9 + 8*(stage-1)` through `9 + 8*stage - 1`. + +If the job also carries central q, a fixed map on the original nine axes sends +q to coordinate zero and its orthogonal complement to coordinates one through +eight. Its inverse is paid at the other boundary. The independent checker +checks the Gram matrix and reconstructs every one of the 512 addresses for +each of the 104 actual q bases. A negative q exponent additionally pays one +ordinary translation, since `Q^-1 = Q * Q^2` and `Q^2` is translation by q. +The same two basis maps and negative-exponent translation are charged for +each inverse thin query. + +The complete inventory derived without importing the retained physical audit is: + +| Canonical adapter | Elementary maps | +|---|---:| +| Main input/output two-axis swaps | 144,768 | +| Main input/output nine-axis q-basis maps | 6,656 | +| Main endpoint phase translations | 3,328 | +| Whole-idle input/output two-axis swaps | 127,296 | +| Thin-query input/output q-basis maps | 3,120 | +| Thin-query phase translations | 1,560 | +| **Total** | **286,728** | + +The maps have support at most nine axes each, even though their composition +can act on the full carrier. Charging the retained 1000-unit rate separately +for each map gives 286,728,000 units. This replaces the former flat +`3536 * 1000 = 3,536,000` main-output route term; it is not added on top of +that obsolete term. The net correction to the partial estimate is therefore +283,192,000. It already applies to the predecessor's same caller, rather +than arising from the new helper split. + +The conservative complete bound is therefore + +\[ +18\cdot10^7+68570112+24960+91936+286728000=535415008<10^9. +\] + +Substituting the counted local work gives 455,015,740. The native change adds +60,912 relative to the old native word under the same fully charged caller +adapter inventory. The 1,128 helper normalizers per invocation remain in the +local count and are not replaced by these main/idle/query conversions. +The Gaussian ranks and the one-billion cap are unchanged, so the earlier +exact moment and final-parameter conclusions survive the corrected invoice. + +## Independent numerical diagnostic and scope + +A separate 110-digit Decimal evaluator, with no retained interval code, +finds the raw crossing + +\[ +\kappa_{\mathrm{raw}} +\approx0.00330814518914275077684453840250387824668768225786645. +\] + +The old raw crossing is approximately +`0.00330724468485362459737980198976843209518931940083131`. +Their difference is approximately `0.0000009005042891261794647364`. +The final proposed eight-decimal claim is **0.00330814**, with tested price +**0.003308145**. The diagnostic signed margins are respectively +0.0011842144282776484 and 0.000043164272593392920. These remain diagnostics, +not exact rational interval certificates or completed compiler/outer +admission. + +The primary package's already certified raw lower endpoint is +`0.0033081451891`; the inspected receipt has positive lower-endpoint +margin `0.000000009756156009235365099032` in each exact interval engine. +Independently checked rational arithmetic gives + +\[ +0.00330814 < 0.003308145 < 0.0033081451891, +\] + +\[ +0.0033081451891-0.003308145=1891/10^{13}>0, +\qquad +\frac{0.003308145-0.00330814}{7}=1/1400000000. +\] + +Thus the tighter claim preserves the exact compiler grid gap. With the +same power 1920 and reserve `1e-27`, the finite strictification inequality +`1 / (1 + 1920 * reserve) + 4 * (31/32)^1920 < 1` and the rank-rounding +inequality `11^64 < 12^63` still hold by exact rational/integer arithmetic. + +At the tighter tested price, the separate Decimal diagnostics give +`1-alpha = 2.4374197157291656e-10`, over `2.4e17` times the reserve; +`gamma = 0.9193522426688072` and `delta = 0.9201996372770363`, both below +`31/32 = 0.96875`. The compiler complement diagnostic is +`eta = 1.8635150721153376e-14`, above +`(63/64)^2100 = 4.3371903853167193e-15`. The narrower distance to the raw +crossing therefore causes no meaningful reserve or completion concern. +There is no independent arithmetic objection to using the tighter claim, +provided the primary package reruns both exact interval engines and the +complete compiler/outer chain at these final parameters. None of the +native/caller words, histograms, allocation or ordinary invoices changes. + +Five negative controls reject the intermediate one-retirement caller, +an omitted LOCAL call, one reversed thin-query orientation, aliased native +main roles, and the obsolete 563-helper allocation. Normal and optimized +execution agree byte for byte. Native absolute phase/all-column admission, +both exact interval engines, completion tails, the compiler, BIT compatibility +and the complete outer ledger remain the primary package's responsibilities. +The inherited owned-erasure and other framework assumptions are unchanged; +this review does not establish scientific admission or change the selected +frontier. + +Reviewed for @CubeJerry with substantial OpenAI assistance. Credit Ali +Romman for the helper-basis mechanism, DreamingOfClouds for #6702, zxv for +#6726, and the retained native, caller, compiler, BIT and analytic authors. +Apache-2.0. diff --git a/research/native-retimed-helper-split/independent/REVIEW.md b/research/native-retimed-helper-split/independent/REVIEW.md new file mode 100644 index 0000000000..74dcf96470 --- /dev/null +++ b/research/native-retimed-helper-split/independent/REVIEW.md @@ -0,0 +1,118 @@ +# Independent review of the paid interior helper368 split + +**Qualified pass for the exact normalized native word, chronological interface, +and complete local invoice.** The candidate gzip SHA-256 is +`2a9f93a82993b85625df20751cc8027d70a85e1fb4278187adbea520909a2e4e`. +The #6702 source gzip SHA-256 is +`e8c7a9d54d98a4cfa27e15593016b3908afed303e0f480076ed3f596192e5a4d`. +This review imports no parent constructor, primary interpreter, or pricing +routine. It is an independently written AI review, not independent human +acceptance or a proof-kernel certificate. + +The published combined `verify.py` invokes this audit with explicit retained-source and regenerated-candidate paths. The development command below records its original independent execution. + +## Executed checks + +`python3 -B exploratory/independent/check_native.py --controls` passes. +The separately written reverse-adjoint engine reconstructs all 801 endpoint +columns, including all 641,601 candidate coefficients. It verifies identity +on every helper, the prescribed 104 main shears, and zero dependence on the +29 initial owned fields. It also adds observation outputs for every pre-COPY +destination and every pre-CLEAR value, so endpoint overwrites cannot hide a +violated COPY-zero premise. + +Independent chronological counting checks strict binary-span nesting for +every MOVE, live ownership, all common scalar charts, legal dyadic ADD and +dyadic-unit SCALE coefficients, declared final charts and the complete public +and owned inventory. There are 772 independent public inputs, 29 owned labels, +18,622 events, 47 owned lifetimes, peak 14, and one valid COPY. + +All 47 CLEAR occurrences retain the source's owned label (shifted by the one +new public input) and chart. Exactly 45 have nonzero pre-CLEAR functionals in +both source and candidate. No previously zero erasure becomes nonzero; no +owned lifetime is added. The functionals themselves can change under the +input/cut basis and are not claimed byte-identical. Their erasure remains +conditional on the inherited owned-erasure contract. + +Nine actual omitted-event mutations (covering both paid subdivisions, both +boundary bases and the cut bases) and an unearned old helper endpoint are +rejected. The checker records the specific failures in `RESULT.json`. + +## The changed chronological mechanism + +Source event 14088 is exactly `MOVE(80,749,127,public)`. Role 80 has no read +or write in source events 12372 through 14087. Its move can therefore be +advanced to immediately before old event 12372. Replace it by +`749 -> 243 -> 127`, interrupting between the two new moves for the helper +basis/handoff. The chart dimensions are 3, 4, 9, respectively; strict nested +spans pass independently. The source endpoint is unchanged by the advanced, +subdivided MOVE alone. + +The supplied vectors independently satisfy `aP=c`, `Sb=d`, and `ab=cd=1` +at that prepared cut. Both boundary vectors use only helpers with initial +chart 3 and final chart 127. Helper368 is already a public role at chart243. +Consequently this candidate uses the established same-pivot split criterion: +the broader cross-role/frame-carrying SWAP extension is unnecessary. + +The prefix checks use a reverse functional pullback. The suffix checks use +one independent exact input direction, including its COPY-zero condition. +The full candidate adjoint separately validates the emitted basis program, +fresh independent input, and every returned output. The new field is never +assumed zero; it is an independent input at chart243 and returns at chart127. + +## Invoice and strict gain + +Direct counts from the two literal words give, per native invocation: + + delta paid = H1 + H5 - H6, + delta target = H4 + H5 - H9, + delta(T-P) = H4 + H6 - H1 - H9. + +The scalar allowance rises from 137990 to 138374, an increase of 384. +Paid and target rank masses are unchanged. Both inventories have one more +job/field, so the caller must charge the extra helper's storage, two boundary +normalizers and completion obligation. + +For `f(x)=x^t`, `0 0. + +This is an all-exponent strict local gain, not a floating-point observation. +It becomes zero at t=0 and t=1. Composing with the unchanged eighteen-native +#6726 caller multiplies this exact signed difference by 18, provided the +new native interface is admitted. It predicts 18 additional paid jobs and +18 additional independent helpers with the same total rank-mass surplus. +It does not by itself certify a new outer kappa. + +## Exact remaining compatibility obligations + +The main ports, frame table, main initial/final boundaries and all normalized +main endpoint maps remain unchanged. Thus the existing caller can consume +the native word after extending its disjoint helper-input allocation and +recounting ordinary work, target normalizers, storage and completion tails. +Main forward/reverse wrappers need no new algebraic identity. + +The only paid chart pair absent from the source word is `(749,243)`; the +rank-five pair `(243,127)` already occurs. The changed helper targets are +`(3,243)` and `(243,127)` in place of `(3,127)`. Their signed native operators, +absolute phases, whole-job normalizers and physical routing still require +the actual native verifier. This review checks rational normalized maps and +binary subspaces, not those physical phase identities. + +The new public bound 772 must be an explicit counted extension of any old +verifier limit. It must not be implemented by weakening ownership, disjoint +allocation, missing-map checks or a frozen expected receipt. The full +#6726 complex invoice, both interval engines, strictification/compiler and +nine-row outer transfer must be rerun against the new source. The existing +compatible BIT bound remains a separate dependency; this edit does not +automatically improve BIT. + +The five framework assumptions remain. No full rounded multiplier, +materialized enormous uniform program, global optimality, selected-frontier +change, or complete mathematical admission is certified by this local review. + +Reviewed for @CubeJerry with substantial OpenAI assistance. Credit Ali Romman +for the independent helper-basis mechanism and cumulative P104 framework; +DreamingOfClouds for #6702; zxv for #6726; and all retained native/caller, +compiler, BIT and analytic source authors. Apache-2.0. diff --git a/research/native-retimed-helper-split/independent/check_invoice.py b/research/native-retimed-helper-split/independent/check_invoice.py new file mode 100644 index 0000000000..6a9186b9e9 --- /dev/null +++ b/research/native-retimed-helper-split/independent/check_invoice.py @@ -0,0 +1,540 @@ +"""Independent literal caller census, field allocation, and Decimal diagnostic. + +Only the separately written sibling check_native is imported. No primary +constructor, caller evaluator, pricing module, or interval engine is imported. +Jerry Chen / @CubeJerry, substantial OpenAI assistance. Apache-2.0. +""" +import argparse +from collections import Counter +from copy import deepcopy +from decimal import Decimal, localcontext +from fractions import Fraction +from hashlib import sha256 +import json +from pathlib import Path + +from check_native import chronology, require, word + + +CLAIM = '.00330814' +TESTED = '.003308145' +CERTIFIED_RAW_LOWER = '.0033081451891' + + +ROLE_SLOTS = { + 'ADD': (1, 2), 'SCALE': (1,), 'SWAP': (1, 2), 'LAMBDA': (1,), + 'QUERY': (1, 2), 'LOCAL': (2, 3), 'IDLE': (1, 2), 'IDLE_ONE': (1,), +} + + +def inverse(gates): + answer = [] + for gate in reversed(gates): + gate = gate.copy() + if gate[0] == 'ADD': + gate[-1] = str(-Fraction(gate[-1])) + elif gate[0] == 'SCALE': + gate[-1] = str(1 / Fraction(gate[-1])) + elif gate[0] == 'LAMBDA': + gate[-1] = -gate[-1] + else: + require(gate[0] == 'SWAP', 'invertible ordinary retirement gate') + answer.append(gate) + return answer + + +def rebuild_retirements(base, witnesses, first, final): + """Bind both complete literals to their declared ordinary basis edits.""" + current = deepcopy(base) + result = [] + for witness, recorded in zip(witnesses, (first, final)): + pivot, fresh = witness['pivot'], witness['fresh'] + cut = witness['cut_after'] + require(fresh == current['roles'], 'one independent new caller role') + require(current['events'][cut] == + ['IDLE_ONE', 2, witness['prefix_stages']], 'retirement cut') + before = (witness['input_basis'] + current['events'][:cut + 1] + + witness['cut_basis']) + after = inverse(witness['cut_basis']) + current['events'][cut + 1:] + inverse(witness['input_basis']) + after = deepcopy(after) + for gate in after: + for slot in ROLE_SLOTS[gate[0]]: + if gate[slot] == pivot: + gate[slot] = fresh + require(len(before) - 1 == witness['handoff_after'], 'handoff index') + require(all(fresh != gate[slot] for gate in before + for slot in ROLE_SLOTS[gate[0]]), 'fresh role untouched in prefix') + require(all(pivot != gate[slot] for gate in after + for slot in ROLE_SLOTS[gate[0]]), 'retired role untouched in suffix') + prefix = [0] * (current['stages'] + 2) + prefix[0] = -witness['head'] + for stage in witness['prefix_stages']: + prefix[stage + 1] = 1 + suffix = [a - b for a, b in zip(current['diagonal'][pivot], prefix)] + require(prefix == witness['prefix_target'] and + suffix == witness['suffix_target'], 'split target exponents') + current['events'] = before + after + current['diagonal'][pivot] = prefix + current['diagonal'].append(suffix) + current['roles'] += 1 + current['schema'] = 'two-paid-fragments-two-independent-retirements/1' + require(current == recorded, 'entire reconstructed caller literal') + result.append(dict(pivot=pivot, fresh=fresh, cut=cut, + events=len(current['events']), roles=current['roles'])) + return result + + +def caller_columns(caller): + """Exact reverse adjoint over Q(i)[q,C1,...,C18]/(q^4-1). + + A key (output, q-exponent, stage-exponents) in variable j describes the + contribution of intermediate variable j to that output. At the entry it + is precisely input column j. All initial caller variables are arbitrary. + """ + n, stages = caller['roles'], caller['stages'] + zero = (0,) * stages + variables = [{(j, 0, zero): (Fraction(1), Fraction(0))} for j in range(n)] + + def add(dst, src, real=Fraction(1), imag=Fraction(0), qshift=0, stage_shift=()): + for (output, qpower, powers), (a, b) in src.items(): + key = (output, (qpower + qshift) % 4, + tuple(v + int(j + 1 in stage_shift) for j, v in enumerate(powers))) + old_a, old_b = dst.get(key, (Fraction(0), Fraction(0))) + value = (old_a + real * a - imag * b, old_b + real * b + imag * a) + if value == (0, 0): + dst.pop(key, None) + else: + dst[key] = value + + for event in reversed(caller['events']): + operation = event[0] + if operation == 'ADD': + add(variables[event[2]], variables[event[1]], Fraction(event[3])) + elif operation == 'SCALE': + result = {} + add(result, variables[event[1]], Fraction(event[2])) + variables[event[1]] = result + elif operation == 'SWAP': + variables[event[1]], variables[event[2]] = variables[event[2]], variables[event[1]] + elif operation == 'LAMBDA': + result, sign = {}, event[2] + require(sign in (-1, 1), 'ordinary Lambda direction') + add(result, variables[event[1]], Fraction(1, 2), Fraction(sign, 2)) + add(result, variables[event[1]], Fraction(1, 2), Fraction(-sign, 2), qshift=2) + variables[event[1]] = result + elif operation == 'QUERY': + _, dst, src, power = event + require(power in (-1, 1), 'thin query orientation') + add(variables[src], variables[dst], qshift=power) + elif operation == 'LOCAL': + _, stage, src, dst = event + # Pull back both D_stage diagonal maps before the Q^-1 shear. + for role in (src, dst): + result = {} + add(result, variables[role], stage_shift=(stage,)) + variables[role] = result + add(variables[src], variables[dst], qshift=-1) + elif operation in ('IDLE', 'IDLE_ONE'): + roles = event[1:3] if operation == 'IDLE' else event[1:2] + selected = event[3] if operation == 'IDLE' else event[2] + for role in roles: + result = {} + add(result, variables[role], stage_shift=selected) + variables[role] = result + else: + raise ValueError('unknown caller opcode: ' + operation) + for role, actual in enumerate(variables): + diagonal = caller['diagonal'][role] + require(diagonal[1] == 0, 'absent old stage zero') + expected = {(role, diagonal[0] % 4, tuple(diagonal[2:])): + (Fraction(1), Fraction(0))} + require(actual == expected, 'complete arbitrary-input caller column ' + str(role)) + return dict(inputs=n, coefficients=n*n, direction='reverse adjoint', + ring='Q(i)[q,C1,...,C18]/(q^4-1)') + + +def invoice(caller, local): + target, paid, idle, main = Counter(), Counter(), Counter(), Counter() + counts, stages = Counter(), [] + require(caller['roles'] == len(caller['diagonal']) == 34 and + caller['stages'] == 18 and caller['ambient_rank'] == 153, + 'complete final caller dimensions') + for event in caller['events']: + operation = event[0] + counts[operation] += 1 + require(operation in ROLE_SLOTS, 'recognized complete caller instruction') + used = [event[slot] for slot in ROLE_SLOTS[operation]] + require(all(type(role) is int and 0 <= role < caller['roles'] for role in used), + 'actual caller role in range') + require(len(set(used)) == len(used), 'distinct source and destination roles') + if operation == 'LOCAL': + stages.append(event[1]) + target.update(local['helpers']) + paid.update(local['paid']) + elif operation == 'QUERY': + paid[1] += 104 + elif operation in ('IDLE', 'IDLE_ONE'): + selected = event[3] if operation == 'IDLE' else event[2] + require(len(selected) == len(set(selected)) and + all(1 <= stage <= 18 for stage in selected), 'whole fresh idle axes') + rank, multiplicity = 8*len(selected), 104*len(used) + require(rank > 0, 'nontrivial whole idle') + paid[rank] += multiplicity + idle[rank] += multiplicity + require(stages == list(range(1, 19)), 'all eighteen distinct forward native calls') + for diagonal in caller['diagonal']: + require(len(diagonal) == 20 and diagonal[0] in (-1, 0, 1) and + diagonal[1] == 0 and all(x in (0, 1) for x in diagonal[2:]), + 'full main target exponent format') + rank = int(bool(diagonal[0])) + 8*sum(diagonal[2:]) + require(rank > 0, 'every credited main output productive') + main[rank] += 104 + target.update(main) + require(counts == {'ADD': 275, 'SCALE': 86, 'SWAP': 94, 'LAMBDA': 100, + 'LOCAL': 18, 'QUERY': 15, 'IDLE': 12, 'IDLE_ONE': 6}, + 'complete literal caller census') + require(sum(main.values()) == 34*104, 'all main outputs exactly once') + return target, paid, main, idle, counts + + +def allocation(caller, native): + main_roles = set(native['live']) | {role+112 for role in native['live']} + helpers = sorted(set(range(native['public'])) - main_roles) + require(len(helpers) == 564, 'all independent helper roles') + main_count = 104*caller['roles'] + public_count = main_count + 18*len(helpers) + owned = set(range(public_count, public_count + native['owned_fields'])) + all_helpers, invocations = set(), [] + for _, stage, src, dst in (e for e in caller['events'] if e[0] == 'LOCAL'): + mapping = {} + for port, role in enumerate(native['live']): + mapping[role] = 104*src + port + mapping[role+112] = 104*dst + port + helper_ids = set() + for ordinal, role in enumerate(helpers): + allocated = main_count + (stage-1)*len(helpers) + ordinal + mapping[role] = allocated + helper_ids.add(allocated) + require(set(mapping) == set(range(native['public'])) and + len(set(mapping.values())) == native['public'], 'injective full native public allocation') + require(not (helper_ids & all_helpers) and min(helper_ids) >= main_count, + 'fresh helpers disjoint from other calls and all main fields') + require(not (owned & set(mapping.values())), 'owned fields disjoint from every public input') + all_helpers.update(helper_ids) + invocations.append(dict(stage=stage, src=src, dst=dst, + helper_first=min(helper_ids), helper_last=max(helper_ids), + extra_helper=mapping[771])) + require(all_helpers == set(range(main_count, public_count)), 'no unused or doubly credited helper') + require(public_count == 13688, 'exact independent public field inventory') + return dict(main_fields=main_count, helper_fields=len(all_helpers), + helpers_per_call=len(helpers), public_fields=public_count, + additional_helpers=18, owned_labels=len(owned), + owned_first=min(owned), owned_last=max(owned), + thin_query_scratch=public_count+native['owned_fields'], + reserved_field_slots=public_count+native['owned_fields']+1, + invocations=invocations) + + +def canonical_adapter_inventory(caller, native_word, phase_data): + """Derive explicit complete-caller adapters from literal job axis sets. + + Each missing desired coordinate below rank r is paired with a desired + coordinate outside 0,...,r-1. These disjoint two-coordinate swaps map the + canonical set exactly onto the desired set. Both Gaussian boundaries pay + for every swap. A q direction also pays for both fixed-nine-axis basis + maps; a negative q exponent pays for the Q^2 translation. + """ + dimension = caller['ambient_rank'] + require(dimension == 153, 'complete ambient dimension for canonical adapters') + recipes = {recipe['q']: recipe for recipe in phase_data['recipes']} + basis_checks = 0 + for q in native_word['ports']: + basis = [q] + recipes[q]['idle_children'][0]['orthogonal_axes'][:8] + require(len(basis) == 9 and all(0 < v < 512 for v in basis), 'nine-axis q basis') + require(all((a & b).bit_count() % 2 == int(i == j) + for i,a in enumerate(basis) for j,b in enumerate(basis)), + 'orthonormal q basis and complement') + # Independently form coordinates and reconstruct every nine-bit address. + for address in range(512): + coordinates = [(address & v).bit_count() % 2 for v in basis] + rebuilt = 0 + for bit,vector in zip(coordinates,basis): + if bit: + rebuilt ^= vector + require(rebuilt == address, 'full q-basis address permutation and inverse') + if address == q: + require(coordinates == [1] + [0]*8, 'q becomes canonical coordinate zero') + basis_checks += 1 + + counts, profiles = Counter(), Counter() + + def coordinates(stages): + require(len(stages) == len(set(stages)) and + all(1 <= s <= caller['stages'] for s in stages), 'fresh adapter axes') + return {coordinate for stage in stages + for coordinate in range(9+8*(stage-1), 9+8*stage)} + + def job(kind, desired, central, negative, multiplicity): + require(bool(desired) and max(desired) < dimension and + min(desired) >= 0, 'nonempty canonical target axes') + canonical = set(range(len(desired))) + missing, outside = sorted(canonical-desired), sorted(desired-canonical) + require(len(missing) == len(outside), 'equal axis-set differences') + permutation = list(range(dimension)) + for a,b in zip(missing,outside): + permutation[a],permutation[b] = permutation[b],permutation[a] + require({permutation[i] for i in canonical} == desired and + all(permutation[permutation[i]] == i for i in range(dimension)), + 'explicit two-axis-swap permutation and inverse') + require(not central or (0 in desired and permutation[0] == 0), + 'q-basis change retains the central coordinate') + require(central or not negative, 'q phase has a q direction') + counts[kind+'_jobs'] += multiplicity + counts[kind+'_axis_swaps'] += 2*len(missing)*multiplicity + counts[kind+'_q_basis_maps'] += 2*int(central)*multiplicity + counts[kind+'_phase_maps'] += int(negative)*multiplicity + profiles[(kind,len(desired),len(missing),int(central),int(negative))] += multiplicity + + for event in caller['events']: + if event[0] in ('IDLE','IDLE_ONE'): + selected = event[3] if event[0] == 'IDLE' else event[2] + job('idle',coordinates(selected),False,False,208 if event[0] == 'IDLE' else 104) + elif event[0] == 'QUERY': + require(event[3] in (-1,1), 'canonical thin-query orientation') + job('query',{0},True,event[3] == -1,104) + for term in caller['diagonal']: + require(term[1] == 0 and term[0] in (-1,0,1), 'canonical main target format') + selected = [stage+1 for stage,present in enumerate(term[2:]) if present] + desired = coordinates(selected) + if term[0]: + desired.add(0) + job('main',desired,bool(term[0]),term[0] == -1,104) + total = sum(count for key,count in counts.items() if not key.endswith('_jobs')) + require(total == 286728, 'complete literal elementary canonical-adapter census') + return dict(ambient_axes=dimension,q_bases_checked=len(native_word['ports']), + q_basis_address_checks=basis_checks,components=dict(sorted(counts.items())), + elementary_maps=total, + profiles=[dict(kind=k[0],rank=k[1],swaps_per_side=k[2],central=k[3], + negative=k[4],multiplicity=n) for k,n in sorted(profiles.items())], + scope='Exact coordinate permutations, q-basis inverses and multiplicity count. The 1000-unit rate is retained for each fixed native whole-job map or each elementary map supported on at most 17 specified axes; it is not a rate for an arbitrary 153-axis map.') + + +def ordinary(caller, native, native_word, phase_data): + total_work, total_height, maximum = 0, 0, Fraction(0) + for event in caller['events']: + operation = event[0] + if operation in ('ADD', 'SCALE'): + value = Fraction(event[-1]) + n, d = abs(value.numerator), value.denominator + require(n and d & (d-1) == 0, 'nonzero dyadic caller scalar') + require(n.bit_length() <= 8 and d.bit_length() <= 7, 'literal scalar bit envelope') + if operation == 'ADD': + work = 2*((n.bit_length()-1)+(n.bit_count()-1)+(d.bit_length()-1)+int(value < 0)+1) + else: + require(n & (n-1) == 0, 'dyadic-unit caller scale') + work = 2*(abs(n.bit_length()-d.bit_length())+int(value < 0)) + height = (n+d).bit_length()+d.bit_length() + maximum = max(maximum, abs(value)) + elif operation == 'LAMBDA': + work, height = 16, 8 + elif operation == 'SWAP': + work, height = 8, 4 + else: + work, height = 0, 0 + require(work <= 32 and height <= 32, 'complete per-gate ordinary envelope') + total_work += work + total_height += height + helper_normalizers = 2*sum(native['helpers'].values()) + main_adapters = 2*104 + contact_routes, lifetime_routes = 4*104, 4*native['lifetimes'] + routes = 1000*(sum(native['paid'].values())+helper_normalizers+main_adapters+ + contact_routes+lifetime_routes) + per_call = native['scalar']+routes + require(per_call < 10**7, 'complete recounted native bound') + caller_envelope = 32*caller['roles']*104*len(caller['events']) + require(104*total_work <= caller_envelope and 104*total_height <= caller_envelope, + 'literal ordinary caller work and height') + thin = 104*16*sum(event[0] == 'QUERY' for event in caller['events']) + # The former 1000-per-main-output allowance omitted the explicit full-axis + # whole-idle/query/main canonical adapters. Replace that flat term by the + # complete elementary inventory; keep the 26 scalar units per output. + output_scalars = 104*caller['roles']*26 + old_output_routes = 104*caller['roles']*1000 + adapters = canonical_adapter_inventory(caller,native_word,phase_data) + adapter_units = 1000*adapters['elementary_maps'] + former_partial = 18*10**7+caller_envelope+thin+output_scalars+old_output_routes + conservative = 18*10**7+caller_envelope+thin+output_scalars+adapter_units + counted = 18*per_call+caller_envelope+thin+output_scalars+adapter_units + require(conservative < 10**9 and counted <= conservative, 'complete ordinary budget') + return dict(helper_normalizers_per_call=helper_normalizers, + helper_normalizers_all_calls=18*helper_normalizers, + main_adapters_per_call=main_adapters, + contact_routes_per_call=contact_routes, + lifetime_routes_per_call=lifetime_routes, + local_scalar=native['scalar'], local_routes=routes, local_per_call=per_call, + local_upper_per_call=10**7, caller_envelope=caller_envelope, + caller_actual_work_per_port=total_work, caller_actual_height_per_port=total_height, + caller_maximum_scalar=str(maximum), thin_query_work=thin, + main_output_scalar_units=output_scalars, + canonical_adapters=adapters,canonical_adapter_units=adapter_units, + superseded_flat_main_output_routes=old_output_routes, + former_partial_raw_upper=former_partial, + full_adapter_correction=adapter_units-old_output_routes, + raw_counted=counted, + raw_upper=conservative, budget=10**9, + route_rate_status='Retained physical/tape contract: 1000 per fixed native whole-job map or per <=17-axis elementary map; full 153-axis adapters are explicitly decomposed and charged.') + + +def diagnostic(target, paid, precision=110): + with localcontext() as context: + context.prec = precision + signed = Counter(target) + signed.subtract(paid) + logs = {rank: Decimal(rank).ln() for rank in signed} + + def margin(kappa): + return sum(Decimal(count)*((1-kappa)*logs[rank]).exp() + for rank, count in signed.items()) + + left, right = Decimal('.0033'), Decimal('.0034') + require(margin(left) > 0 > margin(right), 'Decimal diagnostic bracket') + for _ in range(280): + middle = (left+right)/2 + if margin(middle) > 0: + left = middle + else: + right = middle + root = (left+right)/2 + return dict(precision=precision, raw_root=str(root), + bracket=[str(left), str(right)], + claim=CLAIM, tested=TESTED, + margin_claim=str(margin(Decimal(CLAIM))), + margin_tested=str(margin(Decimal(TESTED))), + derivative_at_root=str(-sum(Decimal(count)*logs[rank]* + ((1-root)*logs[rank]).exp() for rank, count in signed.items())), + certification='High-precision Decimal diagnostic only; not an exact interval certificate.') + + +def claim_arithmetic(target, paid): + claim, tested, lower = map(Fraction, (CLAIM, TESTED, CERTIFIED_RAW_LOWER)) + gap = (tested-claim)/7 + require(claim < tested < lower and gap == Fraction(1, 1400000000), + 'tightened claim remains strictly below certified lower crossing') + reserve, decay, power = Fraction(1, 10**27), Fraction(31, 32), 1920 + finite_upper = 1/(1+power*reserve)+4*decay**power + require(finite_upper < 1 and 11**64 < 12**63, + 'unchanged exact finite strictification and rank rounding') + with localcontext() as context: + context.prec = 110 + kappa = Decimal(TESTED) + t = 1-kappa + def moment(histogram, exponent): + return sum(Decimal(n)*(exponent*Decimal(r).ln()).exp() + for r,n in histogram.items()) + tm, pm = moment(target,t), moment(paid,t) + alpha = pm/tm + gamma = moment(paid,t+Decimal(1)/7)/((Decimal(11).ln()/7).exp()*tm) + delta = Decimal(12*sum(target.values()))/((kappa*Decimal(11).ln()).exp()*tm) + require(alpha < 1-Decimal('1e-27') and gamma < Decimal(31)/32 and delta < Decimal(31)/32, + 'tightened tested price has diagnostic completion slack') + eta = t/((Decimal(1920)*kappa*Decimal(145).ln()).exp()) + theta_power = (Decimal(63)/64)**2100 + require(eta > theta_power, 'diagnostic compiler complement capacity') + return dict(claim=str(claim),tested=str(tested),certified_lower=str(lower), + lower_minus_tested=str(lower-tested),compiler_gap=str(gap), + strictification_reserve=str(reserve),strictification_power=power, + exact_finite_strictification=True,exact_rank_rounding=True, + alpha=str(alpha),one_minus_alpha=str(1-alpha), + reserve_slack_factor=str((1-alpha)/Decimal('1e-27')), + gamma=str(gamma),delta=str(delta),decay=str(Decimal(31)/32), + eta=str(eta),theta_power=str(theta_power), + certification='Parameter inequalities are exact rationals; moments are Decimal diagnostics. The raw lower endpoint is supplied by the primary exact interval certificate.') + + +def controls(caller, first, candidate, native_word, source_word): + cases = [] + + def reject(label, operation): + try: + operation() + except ValueError as error: + cases.append(dict(mutation=label, rejected=str(error))) + else: + raise ValueError('negative control accepted: ' + label) + + reject('price the intermediate one-retirement caller', lambda: invoice(first, candidate)) + omitted = deepcopy(caller) + omitted['events'].pop(next(i for i,e in enumerate(omitted['events']) if e[0] == 'LOCAL')) + reject('omit one full native call', lambda: invoice(omitted, candidate)) + wrong = deepcopy(caller) + next(e for e in wrong['events'] if e[0] == 'QUERY')[-1] = 1 + reject('reverse one thin-query orientation', lambda: caller_columns(wrong)) + aliased = deepcopy(caller) + event = next(e for e in aliased['events'] if e[0] == 'LOCAL') + event[3] = event[2] + reject('alias one native source and destination', lambda: allocation(aliased, native_word)) + reject('retain the old 563-helper allocation', lambda: allocation(caller, source_word)) + return cases + + +def run(caller_root, source_path, candidate_path, local_receipt): + paths = {name: caller_root/name for name in ('CONTROLLER.json', 'CALLER-ONE-RETIRED.json', + 'CALLER-UNRETIRED.json', 'RETIREMENT-WITNESSES.json')} + data = {name: json.loads(path.read_text()) for name, path in paths.items()} + caller = data['CONTROLLER.json'] + retirements = rebuild_retirements(data['CALLER-UNRETIRED.json'], data['RETIREMENT-WITNESSES.json'], + data['CALLER-ONE-RETIRED.json'], caller) + symbolic = caller_columns(caller) + candidate_word = word(candidate_path) + source_word = word(source_path) + source, candidate = chronology(source_word), chronology(candidate_word) + # Full local all-column audit was independently executed in check_native.py. + for name, path, counted in [('base', source_path, source), ('candidate', candidate_path, candidate)]: + key = 'source_sha256' if name == 'base' else 'candidate_sha256' + require(sha256(path.read_bytes()).hexdigest() == local_receipt[key], 'independent local receipt binding') + for field in ('public', 'owned', 'events', 'scalar', 'peak', 'lifetimes'): + require(counted[field] == local_receipt[name][field], 'local recount: ' + field) + for field in ('paid', 'helpers'): + require(counted[field] == {int(k): v for k,v in local_receipt[name][field].items()}, + 'local histogram recount: ' + field) + old_target, old_paid, _, _, _ = invoice(caller, source) + target, paid, main, idle, counts = invoice(caller, candidate) + target_delta, paid_delta = Counter(target), Counter(paid) + target_delta.subtract(old_target) + paid_delta.subtract(old_paid) + target_delta = {r: v for r,v in target_delta.items() if v} + paid_delta = {r: v for r,v in paid_delta.items() if v} + require(target_delta == {4:18, 5:18, 9:-18} and paid_delta == {1:18, 5:18, 6:-18}, + 'entire eighteen-call target and paid deltas') + require(sum(target.values()) == 13688 and sum(paid.values()) == 66870, 'complete global census') + target_mass, paid_mass = (sum(r*n for r,n in histogram.items()) for histogram in (target, paid)) + require(target_mass-paid_mass == 760 and paid_mass == 178080, 'complete rank masses') + fields = allocation(caller, candidate_word) + phase_path = caller_root.parent/'runtime/DATA-PHASES.json' + work = ordinary(caller, candidate, candidate_word, json.loads(phase_path.read_text())) + original = json.loads((caller_root/'RESULT.json').read_text())['candidate']['complete_cost'] + require(old_target == {int(k):v for k,v in original['targets'].items()} and + old_paid == {int(k):v for k,v in original['paid'].items()}, 'retained invoice reproduced from literals') + old_root = diagnostic(old_target, old_paid) + new_root = diagnostic(target, paid) + with localcontext() as context: + context.prec = 100 + gain = str(Decimal(new_root['raw_root'])-Decimal(old_root['raw_root'])) + return dict(status='PASS_INDEPENDENT_COMPLETE_CALLER_INVOICE', + inputs={**{name:sha256(path.read_bytes()).hexdigest() for name,path in paths.items()}, + 'DATA-PHASES.json':sha256(phase_path.read_bytes()).hexdigest()}, + source_sha256=sha256(source_path.read_bytes()).hexdigest(), + candidate_sha256=sha256(candidate_path.read_bytes()).hexdigest(), + correct_final_literal='CONTROLLER.json', retirement_reconstruction=retirements, + caller_all_columns=symbolic, counts=dict(counts), main_targets=dict(sorted(main.items())), + whole_idle_paid=dict(sorted(idle.items())), targets=dict(sorted(target.items())), + paid=dict(sorted(paid.items())), target_count=sum(target.values()), paid_count=sum(paid.values()), + target_rank_mass=target_mass, paid_rank_mass=paid_mass, surplus=target_mass-paid_mass, + target_delta=target_delta, paid_delta=paid_delta, fields=fields, ordinary=work, + old_diagnostic=old_root, new_diagnostic=new_root, raw_root_gain=gain, + final_claim_arithmetic=claim_arithmetic(target, paid), + controls=controls(caller, data['CALLER-ONE-RETIRED.json'], candidate, + candidate_word, source_word), + limitations=['Native absolute phases and physical routes require the primary native verifier.', + '1000-unit route rate, owned erasure and other inherited framework assumptions remain.', + 'No completion/compiler/outer admission is inferred from the Decimal root diagnostic.']) diff --git a/research/native-retimed-helper-split/independent/check_native.py b/research/native-retimed-helper-split/independent/check_native.py new file mode 100644 index 0000000000..3118c12f06 --- /dev/null +++ b/research/native-retimed-helper-split/independent/check_native.py @@ -0,0 +1,322 @@ +"""Independent exact adjoint and chronological audit of the helper368 split. + +No constructor, primary interpreter or primary arithmetic code is imported. +Jerry Chen / @CubeJerry, substantial OpenAI assistance. Apache-2.0. +""" +import argparse +from collections import Counter +from copy import deepcopy +from fractions import Fraction +import gzip +from hashlib import sha256 +import json +from pathlib import Path + + +def require(condition, message): + if not condition: + raise ValueError(message) + + +def word(path): + return json.loads(gzip.decompress(path.read_bytes())) + + +def combination_add(target, source, factor): + for index, coefficient in source.items(): + value = target.get(index, 0) + factor * coefficient + if value: + target[index] = value + else: + target.pop(index, None) + + +def subspace(basis): + values = {0} + for vector in basis: + require(type(vector) is int and 0 < vector < 512, + 'binary vector in nine axes') + require(vector not in values, 'independent frame basis') + values.update([value ^ vector for value in values.copy()]) + return values + + +def chronology(data): + public, owned = data['public'], data['owned_fields'] + total = public + owned + require(len(data['initial']) == len(data['final']) == public, 'boundaries') + frames = [subspace(vectors) for vectors in data['frames']] + current = data['initial'].copy() + [None] * owned + alive, maximum, lifetimes, scalar = set(), 0, 0, 0 + paid, monitors, opcodes = Counter(), [], Counter() + for index, event in enumerate(data['program']): + operation, target = event[:2] + opcodes[operation] += 1 + require(type(target) is int and 0 <= target < total, 'target index') + if operation == 'MOVE': + require(len(event) == 5, 'MOVE format') + before, after, private = event[2:] + require(current[target] == before, 'MOVE incoming chart') + require(private == (target in alive), 'MOVE owner type') + require(frames[after] < frames[before] if private + else frames[before] < frames[after], 'strict nested MOVE') + paid[abs(len(data['frames'][after])-len(data['frames'][before]))] += 1 + current[target] = after + elif operation == 'INIT': + require(len(event) == 3 and target >= public and target not in alive, + 'fresh owned INIT') + alive.add(target) + current[target] = event[2] + lifetimes += 1 + maximum = max(maximum, len(alive)) + scalar += 2 + elif operation == 'CLEAR': + require(len(event) == 3 and target in alive and + current[target] == event[2], 'owned CLEAR') + monitors.append((index, operation, target, event[2])) + current[target] = None + alive.remove(target) + scalar += 2 + elif operation in ('ADD', 'COPY', 'SCALE'): + coefficient = Fraction(event[-2]) + chart = event[-1] + require(coefficient != 0 and current[target] == chart, + 'scalar coefficient/chart') + numerator, denominator = abs(coefficient.numerator), coefficient.denominator + require(denominator & (denominator-1) == 0, 'dyadic denominator') + require(abs(coefficient)+1 < 2**16, 'fixed coefficient bound') + if operation == 'SCALE': + require(len(event) == 4 and numerator & (numerator-1) == 0, + 'dyadic-unit SCALE') + scalar += 2*(abs(numerator.bit_length()-denominator.bit_length()) + + int(coefficient < 0)) + else: + require(len(event) == 5, 'ADD/COPY format') + source = event[2] + require(source != target and 0 <= source < total and + current[source] == chart, 'scalar common chart') + if operation == 'COPY': + require(target in alive, 'COPY into owned field') + monitors.append((index, operation, target, chart)) + scalar += 2*(3+numerator.bit_length()-1+numerator.bit_count()+ + denominator.bit_length()-1) + else: + raise ValueError('Unknown opcode ' + operation) + require(not alive and current[:public] == data['final'], 'complete exits') + require(all(chart is None for chart in current[public:]), 'owned exits') + main = set(data['live']) | {r+112 for r in data['live']} + require(len(main) == 208 and len(data['live']) == len(data['ports']) == 104, + 'main interface count') + helpers = Counter() + for role in range(public): + if role not in main: + before, after = data['initial'][role], data['final'][role] + require(frames[before] < frames[after], 'productive helper endpoint') + helpers[len(data['frames'][after])-len(data['frames'][before])] += 1 + return dict(public=public, owned=owned, total=total, events=len(data['program']), + paid=dict(sorted(paid.items())), helpers=dict(sorted(helpers.items())), + scalar=scalar, peak=maximum, lifetimes=lifetimes, + opcodes=dict(opcodes), monitors=monitors) + + +def adjoint(data, metadata): + """Reverse all endpoint coefficients and all pre-COPY/CLEAR functionals.""" + n, public = metadata['total'], metadata['public'] + columns = [{r: Fraction(1)} for r in range(n)] + monitor_at = {entry[0]: (n+j, entry) for j, entry in enumerate(metadata['monitors'])} + for index in range(len(data['program'])-1, -1, -1): + event = data['program'][index] + operation, target = event[:2] + if operation in ('INIT', 'CLEAR'): + columns[target] = {} + elif operation == 'SCALE': + factor = Fraction(event[2]) + columns[target] = {row: factor*value for row, value in columns[target].items()} + elif operation in ('ADD', 'COPY'): + source, factor = event[2], Fraction(event[3]) + combination_add(columns[source], columns[target], factor) + if operation == 'COPY': + columns[target] = {} + if index in monitor_at: + row, _ = monitor_at[index] + columns[target][row] = Fraction(1) + for source, column in enumerate(columns): + actual = {r: c for r, c in column.items() if r < n} + expected = {source: Fraction(1)} if source < public else {} + if source in data['live']: + expected[source+112] = Fraction(1) + require(actual == expected, 'complete endpoint column ' + str(source)) + monitor_rows = [] + for j, entry in enumerate(metadata['monitors']): + row = {source: column[n+j] for source, column in enumerate(columns) + if n+j in column} + require(all(source < public for source in row), 'owned initial values disappear') + if entry[1] == 'COPY': + require(not row, 'COPY destination exactly zero at ' + str(entry[0])) + monitor_rows.append((entry, row)) + return monitor_rows + + +def audit(data): + metadata = chronology(data) + monitors = adjoint(data, metadata) + metadata.pop('monitors') + metadata['all_coefficients'] = metadata['total'] ** 2 + metadata['copy_zero_checks'] = sum(entry[1] == 'COPY' for entry, row in monitors) + metadata['clear_nonzero'] = sum(entry[1] == 'CLEAR' and bool(row) for entry, row in monitors) + return metadata, monitors + + +def delta(after, before): + return {r: after.get(r, 0)-before.get(r, 0) + for r in sorted(set(after)|set(before)) if after.get(r, 0) != before.get(r, 0)} + + +def decode_witness(value): + return {int(k): Fraction(v) for k, v in value.items()} + + +def scalar_response(data, vector, events): + """One forward vector, used only to bind the independently stated cut.""" + values = [Fraction(0)] * (data['public']+data['owned_fields']) + for index, coefficient in vector.items(): + values[index] = coefficient + for event in events: + operation, target = event[:2] + if operation in ('INIT', 'CLEAR'): + values[target] = Fraction(0) + elif operation == 'SCALE': + values[target] *= Fraction(event[2]) + elif operation == 'ADD': + values[target] += Fraction(event[3])*values[event[2]] + elif operation == 'COPY': + require(values[target] == 0, 'witness suffix preserves COPY-zero') + values[target] = Fraction(event[3])*values[event[2]] + return {i: value for i, value in enumerate(values) if value} + + +def pullback(functional, events): + """One reverse functional; independent of the parent search's prefix rows.""" + values = dict(functional) + for event in reversed(events): + operation, target = event[:2] + coefficient = values.get(target, Fraction(0)) + if operation in ('INIT', 'CLEAR'): + values.pop(target, None) + elif operation == 'SCALE': + if coefficient: + values[target] = coefficient*Fraction(event[2]) + elif operation in ('ADD', 'COPY'): + if coefficient: + source = event[2] + value = values.get(source, 0)+coefficient*Fraction(event[3]) + if value: + values[source] = value + else: + values.pop(source, None) + if operation == 'COPY': + values.pop(target, None) + return values + + +def run(base_path, candidate_path, witness_path, controls): + baseline, candidate = word(base_path), word(candidate_path) + require(sha256(base_path.read_bytes()).hexdigest() == + 'e8c7a9d54d98a4cfa27e15593016b3908afed303e0f480076ed3f596192e5a4d', + 'pinned #6702 source word') + base, old_monitors = audit(baseline) + new, new_monitors = audit(candidate) + require(candidate['frames'] == baseline['frames'] and + candidate['live'] == baseline['live'] and candidate['ports'] == baseline['ports'], + 'unchanged frames and main ports') + require(candidate['public'] == baseline['public']+1 and + candidate['owned_fields'] == baseline['owned_fields'], 'one fresh public field') + require(candidate['initial'] == baseline['initial']+[243], 'initial boundary') + final = baseline['final'].copy() + final[368] = 243 + require(candidate['final'] == final+[127], 'only declared final boundaries') + paid_delta = delta(new['paid'], base['paid']) + target_delta = delta(new['helpers'], base['helpers']) + require(paid_delta == {1: 1, 5: 1, 6: -1}, 'exact paid delta') + require(target_delta == {4: 1, 5: 1, 9: -1}, 'exact target delta') + require(new['lifetimes'] == base['lifetimes'] == 47 and + new['peak'] == base['peak'] == 14, 'owned lifetime and peak unchanged') + old_clears = [(entry, row) for entry, row in old_monitors if entry[1] == 'CLEAR'] + new_clears = [(entry, row) for entry, row in new_monitors if entry[1] == 'CLEAR'] + require(len(old_clears) == len(new_clears) == 47, 'same CLEAR count') + for (old_event, old_row), (new_event, new_row) in zip(old_clears, new_clears): + require(old_event[2]+1 == new_event[2] and old_event[3] == new_event[3], + 'unchanged owned CLEAR labels and charts') + require(bool(old_row) == bool(new_row), 'no newly nonzero owned erasure') + # Prepare the paid path directly from the supplied old event/cut, not from + # the parent constructor, then audit its old endpoint and bind the witness. + require(baseline['program'][14088] == ['MOVE',80,749,127,False], 'old MOVE') + for event in baseline['program'][12372:14088]: + require(event[1] != 80 and not(event[0] in ('ADD','COPY') and event[2] == 80), + 'role80 inactive throughout advanced-MOVE interval') + prepared = deepcopy(baseline) + prepared['program'] = (baseline['program'][:12372]+[['MOVE',80,749,243,False]]+ + [['MOVE',80,243,127,False]]+ + baseline['program'][12372:14088]+baseline['program'][14089:]) + prepared_metadata, _ = audit(prepared) + require(delta(prepared_metadata['paid'], base['paid']) == paid_delta, + 'prepared MOVE invoice') + h = json.loads(witness_path.read_text())['split'] + a,b,c,d = (decode_witness(h[key]) for key in ('a','b','c','d')) + prefix = prepared['program'][:12373] + suffix = prepared['program'][12373:] + require(pullback(a, prefix) == c, 'complete prefix functional') + require(scalar_response(prepared,b,suffix) == d, 'complete suffix direction') + require(sum(value*b.get(i,0) for i,value in a.items()) == + sum(value*d.get(i,0) for i,value in c.items()) == 1, 'unit pairings') + main = set(baseline['live'])|{r+112 for r in baseline['live']} + require(all(i not in main and baseline['initial'][i] == 3 and + baseline['final'][i] == 127 for i in set(c)|set(d)), 'one helper group') + changed_pairs = set((e[2],e[3]) for e in candidate['program'] if e[0] == 'MOVE') - set( + (e[2],e[3]) for e in baseline['program'] if e[0] == 'MOVE') + failures = [] + if controls: + # Each mutation reaches this independent full-word interpreter. + mutation_indices = [0,12,12385,12386,12394,12395,12404,18609,18621] + for index in mutation_indices: + mutant = deepcopy(candidate) + del mutant['program'][index] + try: + audit(mutant) + except ValueError as error: + failures.append(dict(kind='omission',index=index,rejected=str(error))) + else: + raise ValueError('omission accepted at '+str(index)) + mutant = deepcopy(candidate) + mutant['final'][368] = 127 + try: + audit(mutant) + except ValueError as error: + failures.append(dict(kind='unearned old target',rejected=str(error))) + else: + raise ValueError('wrong target accepted') + return dict(status='PASS_INDEPENDENT_PAID_HELPER368_SPLIT', + source_sha256=sha256(base_path.read_bytes()).hexdigest(), + candidate_sha256=sha256(candidate_path.read_bytes()).hexdigest(), + base=base,candidate=new,paid_delta=paid_delta,target_delta=target_delta, + new_native_chart_pairs=sorted(changed_pairs), + exact_pairings=True,copy_zero_guard_checked=True, + zero_clear_pattern_preserved=True,controls=failures, + limitations=['Native phase/all-column replay not performed here.', + 'Complete caller/outer invoice and uniform admission not performed here.', + 'Exact rational normalized word and chronological interface audited.']) + + +if __name__ == '__main__': + here = Path(__file__).resolve().parent.parent + parser = argparse.ArgumentParser() + parser.add_argument('--base',type=Path,default=here/'retained/native/PR6702-WORD.json.gz') + parser.add_argument('--candidate',type=Path,required=True) + parser.add_argument('--witness',type=Path,default=here/'WITNESS.json') + parser.add_argument('--output',type=Path,default=Path(__file__).with_name('RESULT.json')) + parser.add_argument('--controls',action='store_true') + args = parser.parse_args() + result = run(args.base,args.candidate,args.witness,args.controls) + args.output.write_text(json.dumps(result,indent=2)+'\n') + print(result['status']) + print(json.dumps({key:result[key] for key in ('paid_delta','target_delta','new_native_chart_pairs')},sort_keys=True)) diff --git a/research/native-retimed-helper-split/native.py b/research/native-retimed-helper-split/native.py new file mode 100644 index 0000000000..6f36cbe80d --- /dev/null +++ b/research/native-retimed-helper-split/native.py @@ -0,0 +1,133 @@ +"""Exact native replay and signed physical maps. + +Adapted from Ali Romman's independent-helper verifier; native compiler and +Gaussian interpreter retain their source credit. Inventory, COPY monitor and +retimed helper extension by @CubeJerry with substantial OpenAI assistance. +Apache-2.0. +""" +from collections import Counter +from fractions import Fraction as Q +from functools import lru_cache +from hashlib import sha256 +from pathlib import Path +import gzip, importlib.util, json, sys +HERE=Path(__file__).resolve().parent +def need(ok, why): + if not ok: + raise ValueError(why) + +def read(path): + raw = path.read_bytes() + return json.loads(gzip.decompress(raw) if path.suffix == '.gz' else raw) + +def load(path, name): + spec = importlib.util.spec_from_file_location(name, path) + module = importlib.util.module_from_spec(spec) + sys.modules[name] = module + spec.loader.exec_module(module) + return module + +def add(dst, src, q): + for k, v in tuple(src.items()): + value = dst.get(k, 0) + q*v + if value: + dst[k] = value + else: + dst.pop(k, None) + +def span(basis): + out = {0} + for v in basis: + need(type(v) is int and 0 < v < 512 and v not in out, 'Independent binary basis') + out |= {x ^ v for x in tuple(out)} + return frozenset(out) + +def replay(w): + n=w['public'];N=n+w['owned_fields'];frames=[span(x)for x in w['frames']] + need(type(n) is int and len(w['initial'])==len(w['final'])==n, 'Public boundary size') + need(len(w['live'])==len(w['ports'])==104, 'Main port inventory') + rows=[{r:Q(1)}if r=n and r not in owned,('init',i));owned.add(r);peak=max(peak,len(owned));lifetimes+=1;rows[r]={};current[r]=e[2];scalar+=2 + elif op=='CLEAR': + need(r in owned and current[r]==e[2],('clear',i)); + if rows[r]:erased.append(dict(event=i,role=r,frame=e[2])) + rows[r]={};current[r]=None;owned.remove(r);scalar+=2 + else: + q,f=Q(e[-2]),e[-1];need(q!=0 and current[r]==f,('scalar frame',i,e,current[r]));a,d=abs(q.numerator),q.denominator + need(d&(d-1)==0 and abs(q)+1<2**16,('scalar alphabet',i)) + if op=='SCALE': + need(a&(a-1)==0,('unit',i));rows[r]={k:v*q for k,v in rows[r].items()};scalar+=2*(abs(a.bit_length()-d.bit_length())+int(q<0)) + else: + s=e[2];need(s!=r and 0<=s0 and second[0]>0, + 'Both engines prove the raw endpoint/tested signs') + endpoints[name]={'first':E.display(first),'second':E.display(second)} + signed=Counter(T);signed.subtract(P);derivative=Q(0) + for r,n in signed.items(): + log=E.log_bounds(r) + derivative-=n*(E.mul(E.power(r,1-Q('.0034')),log)[0]if n>=0 else r*log[1]) + need(derivative<0,'Unique raw crossing through the retained BIT cap') + t,offset,power,cutoff,floor=1-TESTED,Q(1,7),1920,11,12 + target,paid=E.moment(T,t),E.moment(P,t) + alpha=E.divide(paid,target) + gamma=E.divide(E.moment(P,t+offset),E.mul(E.power(cutoff,offset),target)) + delta=E.divide((Q(sum(T.values())*floor),)*2,E.mul(E.power(cutoff,TESTED),target)) + reserve,decay=Q(1,10**27),Q(31,32) + need(alpha[1]<1-reserve and gamma[1]theta**logarithm_power,'Compiler shifted exits and complement capacity') + need(factor[1]<2**logarithm_power,'Compiler initial range') + gap=(TESTED-KAPPA)/7;need(gap.numerator==1,'Exact positive compiler grid') + step=gap.denominator + def wins(j):return(step*j+1)**logarithm_power<2**j + left,right=1,2 + while not wins(right):left,right=right,2*right + while right-left>1: + middle=(left+right)//2 + if wins(middle):right=middle + else:left=middle + H=step*right + need(H>8*power and wins(right)and not wins(right-1),'Explicit uniform threshold and adjacent-grid control') + bit=L.read(L.ROOT/'research/query-thinned-controllers/RESULT.json')['ordinary_BIT'] + atom=Q(bit['atom']);ordinary_bit=(1-atom)*Q(bit['after_cover'])+atom*Q('.0000384599');admitted=Q(bit['admitted']) + need(atom>ordinary_bit>admitted>TESTED and atom<1-ordinary_bit,'Retained ordinary/admitted BIT stock and savings') + outer_module=L.load(L.ROOT/'research/pr4359-p7-padding/dependencies/compiler-refill/endpoint.py','root8_outer') + params={'kappa':KAPPA,'tested_saving':TESTED,'complex_uniform_saving':KAPPA+6*gap, + 'b':KAPPA+5*gap,'a':KAPPA+4*gap,'q':KAPPA+3*gap,'bit_saving':admitted, + 'epsilon':1-gap,'beta':1-3*gap,'r0':gap/10,'stop':gap,'layout':gap,'d':gap} + outer=outer_module.ledger(params) + outer['functional_checks']['actual_new_BIT_stock_sublinear']=params['beta']*(1-atom) + need(len(outer['strict_checks'])==54 and len(outer['functional_checks'])==4,'Complete54+4 outer inventory') + need(all(v>0 for k in('strict_checks','functional_checks')for v in outer[k].values()),'Every outer inequality is strict') + bad=outer_module.ledger(dict(params,bit_saving=Q('.0027'))) + need(any(v<=0 for v in bad['strict_checks'].values()),'Insufficient BIT budget rejected') + work['paid_rank_mass']=sum(r*n for r,n in P.items()) + return encode({'status':'PASS_RETIMED_NATIVE_HELPER_COMPLETE_PRICE','kappa':KAPPA,'tested':TESTED, + 'targets':T,'paid':P,'productive_fields':sum(T.values()),'paid_calls':sum(P.values()),'rank_mass_surplus':760, + 'full_calls':18,'thin_queries':15,'whole_idle_jobs':3120,'counts':counts,'raw_root_interval':[lower,upper], + 'raw_endpoint_margins':endpoints,'derivative_upper':derivative,'nonrecursive':work, + 'strictification':{'power':power,'cutoff':cutoff,'floor':floor,'offset':offset,'reserve':reserve,'decay':decay, + 'alpha':E.display(alpha),'gamma':E.display(gamma),'delta':E.display(delta), + 'alternative_12_13_delta':E.display(alternative_delta),'normalized_upper':normalized}, + 'compiler':{'H':H,'N':'2^'+str(H),'integer_test_exponent':right,'theta':theta,'logarithm_power':logarithm_power, + 'eta':E.display(eta),'gap':gap,'uniform_saving':params['complex_uniform_saving'],'word_materialized':False}, + 'ordinary_BIT':bit,'outer':outer,'source_assumptions':['native_all_columns','owned_erasure','compiler','precision_tape','analytic_recovery'], + 'scope':'Complete conditional price, requiring the supplied caller/native/physical inputs to be independently verified by the package. Does not itself verify those scientific inputs, discharge inherited assumptions, establish scientific admission, or change selected kappa.'}) diff --git a/research/native-retimed-helper-split/retained/REMOTE-PINS.json b/research/native-retimed-helper-split/retained/REMOTE-PINS.json new file mode 100644 index 0000000000..16e9958b54 --- /dev/null +++ b/research/native-retimed-helper-split/retained/REMOTE-PINS.json @@ -0,0 +1,152 @@ +[ + { + "name": "algebra.py", + "path": "research/p104-paid-idle-fragmentation/frozen/two-fragment/algebra.py", + "sha": "a06d6f641685e96b2f150ea6b741930a9ec037f8", + "local": "retained/caller/algebra.py" + }, + { + "name": "rows.py", + "path": "research/p104-paid-idle-fragmentation/frozen/two-fragment/rows.py", + "sha": "c4fba4d14c94e2dfd85e704ab64283c53fd5ad3a", + "local": "retained/caller/rows.py" + }, + { + "name": "scalars.py", + "path": "research/p104-paid-idle-fragmentation/frozen/two-fragment/scalars.py", + "sha": "7b3a96488cdf135452d926056e9e95224ea7e047", + "local": "retained/caller/scalars.py" + }, + { + "name": "root_check.py", + "path": "research/p104-paid-idle-fragmentation/frozen/two-fragment/root_check.py", + "sha": "ee4f089aa61e3a56d3cfef1c9293593d77592628", + "local": "retained/caller/root_check.py" + }, + { + "name": "caller.py", + "path": "research/p104-paid-idle-fragmentation/frozen/two-fragment/caller.py", + "sha": "002aaa9210960c3a94077e23c49d9983b4565512", + "local": "retained/caller/caller.py" + }, + { + "name": "retirement.py", + "path": "research/p104-paid-idle-fragmentation/frozen/two-fragment/retirement.py", + "sha": "511b7cefd26668885b5ebeebeae9cb9f677df6d4", + "local": "retained/caller/retirement.py" + }, + { + "name": "independent.py", + "path": "research/p104-paid-idle-fragmentation/frozen/two-fragment/independent.py", + "sha": "772d19a926642ddc79807da0b4be93c94aca18da", + "local": "retained/caller/independent.py" + }, + { + "name": "ROOT.json", + "path": "research/p104-paid-idle-fragmentation/frozen/two-fragment/ROOT.json", + "sha": "d153188cc7bdc96d80f3f3bdae8e88865ef1d437", + "local": "retained/caller/ROOT.json" + }, + { + "name": "CONTROLLER.json", + "path": "research/p104-paid-idle-fragmentation/frozen/two-fragment/CONTROLLER.json", + "sha": "1c16cfbedcc704de405c755a395fca831fc65568", + "local": "retained/caller/CONTROLLER.json" + }, + { + "name": "CALLER-UNRETIRED.json", + "path": "research/p104-paid-idle-fragmentation/frozen/two-fragment/CALLER-UNRETIRED.json", + "sha": "30d8f94afc279779ef5afb4a4fc6974073d6a30e", + "local": "retained/caller/CALLER-UNRETIRED.json" + }, + { + "name": "CALLER-ONE-RETIRED.json", + "path": "research/p104-paid-idle-fragmentation/frozen/two-fragment/CALLER-ONE-RETIRED.json", + "sha": "9a45cbfc72f619f5608d96a02a9372a715131f1e", + "local": "retained/caller/CALLER-ONE-RETIRED.json" + }, + { + "name": "RETIREMENT-WITNESSES.json", + "path": "research/p104-paid-idle-fragmentation/frozen/two-fragment/RETIREMENT-WITNESSES.json", + "sha": "6403f0e21648c0e7afbb2fc6972af5e6d9018397", + "local": "retained/caller/RETIREMENT-WITNESSES.json" + }, + { + "name": "INDEPENDENT.json", + "path": "research/p104-paid-idle-fragmentation/frozen/two-fragment/INDEPENDENT.json", + "sha": "8a70990cacd372edbf53ea0cc9b727c97fa19c0f", + "local": "retained/caller/INDEPENDENT.json" + }, + { + "name": "RESULT.json", + "path": "research/p104-paid-idle-fragmentation/frozen/two-fragment/RESULT.json", + "sha": "91a52a23c5b8bf7149c1c6bc64d46fd34a0e480d", + "local": "retained/caller/RESULT.json" + }, + { + "name": "PROOF.md", + "path": "research/p104-paid-idle-fragmentation/frozen/two-fragment/PROOF.md", + "sha": "1d23498f0dc2db6e76962d6b993063c0781d2999", + "local": "retained/caller/PROOF.md" + }, + { + "name": "NOTICE", + "path": "research/p104-paid-idle-fragmentation/frozen/two-fragment/NOTICE", + "sha": "fed7ebcefa7b00b0af07d87202aa4bfdb665377e", + "local": "retained/caller/NOTICE" + }, + { + "name": "LICENSE", + "path": "research/p104-paid-idle-fragmentation/frozen/two-fragment/LICENSE", + "sha": "261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64", + "local": "retained/caller/LICENSE" + }, + { + "name": "pricing.py", + "path": "research/p104-paid-idle-fragmentation/frozen/two-fragment/pricing.py", + "sha": "5f92b18de7b4c5894716003eff4c6dde2f016dd9", + "local": "retained/caller/pricing.py" + }, + { + "name": "physical.py", + "path": "research/p104-paid-idle-fragmentation/frozen/sources/pr6702/unpacked/research/gaussian-root-retirement/physical.py", + "sha": "ff344772157f43a225b0c1d18c65298a01bc67a3", + "local": "retained/runtime/physical.py" + }, + { + "name": "intervals.py", + "path": "research/p104-paid-idle-fragmentation/frozen/runtime/root/research/higher-moment-strictification/verify.py", + "sha": "4b24a5096154736ce060474eb8c72dc64c303699", + "local": "retained/runtime/intervals.py" + }, + { + "name": "second_intervals.py", + "path": "research/p104-paid-idle-fragmentation/frozen/runtime/root/research/kappa-rebuild/architecture/mixed_target_probe.py", + "sha": "4fc05ab08138218ba9f09e5c89b649afae7c914e", + "local": "retained/runtime/second_intervals.py" + }, + { + "name": "endpoint.py", + "path": "research/p104-paid-idle-fragmentation/frozen/runtime/root/research/pr4359-p7-padding/dependencies/compiler-refill/endpoint.py", + "sha": "340e1f0ffb8a1a9c38fbbd9119580b6d23e01b59", + "local": "retained/runtime/endpoint.py" + }, + { + "name": "native_inventory.py", + "path": "research/p104-paid-idle-fragmentation/frozen/runtime/root/research/pr4359-p7-padding/native_inventory.py", + "sha": "8d2d96e3998254c2333c43fe47cdfd074cbd811e", + "local": "retained/runtime/native_inventory.py" + }, + { + "name": "BIT-RESULT.json", + "path": "research/p104-paid-idle-fragmentation/frozen/runtime/root/research/query-thinned-controllers/RESULT.json", + "sha": "e0695152c98d727edfd0d2034b58a1c7e8682c0c", + "local": "retained/runtime/BIT-RESULT.json" + }, + { + "name": "DATA-PHASES.json", + "path": "research/p104-paid-idle-fragmentation/frozen/runtime/root/research/kappa-0023-productive-jobs/dependencies/kappa-next-regime/direct-decoder/sources/DATA-PHASES.json", + "sha": "d9a4f84211182ca200c081ea061d724c8a2cfb70", + "local": "retained/runtime/DATA-PHASES.json" + } +] diff --git a/research/native-retimed-helper-split/retained/SOURCE-PINS.json b/research/native-retimed-helper-split/retained/SOURCE-PINS.json new file mode 100644 index 0000000000..000f8177d8 --- /dev/null +++ b/research/native-retimed-helper-split/retained/SOURCE-PINS.json @@ -0,0 +1,267 @@ +[ + { + "local": "retained/caller/algebra.py", + "repository": "zxv/integer-mult-bounds", + "commit": "435bbe91fb28cb1d7a569ca70c6c4e9eb302d486", + "path": "research/p104-paid-idle-fragmentation/frozen/two-fragment/algebra.py", + "git_blob": "a06d6f641685e96b2f150ea6b741930a9ec037f8", + "sha256": "02eb3380715294334710edd3273f267dc048264555bd60fefb86022bc9eda835" + }, + { + "local": "retained/caller/rows.py", + "repository": "zxv/integer-mult-bounds", + "commit": "435bbe91fb28cb1d7a569ca70c6c4e9eb302d486", + "path": "research/p104-paid-idle-fragmentation/frozen/two-fragment/rows.py", + "git_blob": "c4fba4d14c94e2dfd85e704ab64283c53fd5ad3a", + "sha256": "78d65ec0b9f9eb8b5b310ba40acfe229e33bd69ffc47eb20d0eaa9037e43bd14" + }, + { + "local": "retained/caller/scalars.py", + "repository": "zxv/integer-mult-bounds", + "commit": "435bbe91fb28cb1d7a569ca70c6c4e9eb302d486", + "path": "research/p104-paid-idle-fragmentation/frozen/two-fragment/scalars.py", + "git_blob": "7b3a96488cdf135452d926056e9e95224ea7e047", + "sha256": "d42f49f61f0d95c47cb1d69fe895fbb4761e083d2503413500140b4fb061d7f3" + }, + { + "local": "retained/caller/root_check.py", + "repository": "zxv/integer-mult-bounds", + "commit": "435bbe91fb28cb1d7a569ca70c6c4e9eb302d486", + "path": "research/p104-paid-idle-fragmentation/frozen/two-fragment/root_check.py", + "git_blob": "ee4f089aa61e3a56d3cfef1c9293593d77592628", + "sha256": "2737397674e372f58ae15d367d6ccf767b383d7a51ad31da2420d8ee1253030e" + }, + { + "local": "retained/caller/caller.py", + "repository": "zxv/integer-mult-bounds", + "commit": "435bbe91fb28cb1d7a569ca70c6c4e9eb302d486", + "path": "research/p104-paid-idle-fragmentation/frozen/two-fragment/caller.py", + "git_blob": "002aaa9210960c3a94077e23c49d9983b4565512", + "sha256": "e99e4287091c6ce4ec9a563cb9ac6f45be35ff1ef421b4efa8c200cb9d639d6c" + }, + { + "local": "retained/caller/retirement.py", + "repository": "zxv/integer-mult-bounds", + "commit": "435bbe91fb28cb1d7a569ca70c6c4e9eb302d486", + "path": "research/p104-paid-idle-fragmentation/frozen/two-fragment/retirement.py", + "git_blob": "511b7cefd26668885b5ebeebeae9cb9f677df6d4", + "sha256": "a13c0517fa244bb013d267deface5acd1119eea1cd027a8aaf63c3d7c422eded" + }, + { + "local": "retained/caller/independent.py", + "repository": "zxv/integer-mult-bounds", + "commit": "435bbe91fb28cb1d7a569ca70c6c4e9eb302d486", + "path": "research/p104-paid-idle-fragmentation/frozen/two-fragment/independent.py", + "git_blob": "772d19a926642ddc79807da0b4be93c94aca18da", + "sha256": "5c488b9cc0759b618cd86c8b9b6337c13c33195537ff7421a90477890f17201f" + }, + { + "local": "retained/caller/ROOT.json", + "repository": "zxv/integer-mult-bounds", + "commit": "435bbe91fb28cb1d7a569ca70c6c4e9eb302d486", + "path": "research/p104-paid-idle-fragmentation/frozen/two-fragment/ROOT.json", + "git_blob": "d153188cc7bdc96d80f3f3bdae8e88865ef1d437", + "sha256": "b31151c36e39c9267bcc81ec3e13d9d29df9d0c0b404830a9cfb01e21a5b8fc2" + }, + { + "local": "retained/caller/CONTROLLER.json", + "repository": "zxv/integer-mult-bounds", + "commit": "435bbe91fb28cb1d7a569ca70c6c4e9eb302d486", + "path": "research/p104-paid-idle-fragmentation/frozen/two-fragment/CONTROLLER.json", + "git_blob": "1c16cfbedcc704de405c755a395fca831fc65568", + "sha256": "543b8728e659561b95e127dad7bd7534645996d7d2c61602bb5d89c89a73944c" + }, + { + "local": "retained/caller/CALLER-UNRETIRED.json", + "repository": "zxv/integer-mult-bounds", + "commit": "435bbe91fb28cb1d7a569ca70c6c4e9eb302d486", + "path": "research/p104-paid-idle-fragmentation/frozen/two-fragment/CALLER-UNRETIRED.json", + "git_blob": "30d8f94afc279779ef5afb4a4fc6974073d6a30e", + "sha256": "8693f74b4559c27dd670f788c6e8c7be8bc7cf9cd6a6abb80455fee86d20bc99" + }, + { + "local": "retained/caller/CALLER-ONE-RETIRED.json", + "repository": "zxv/integer-mult-bounds", + "commit": "435bbe91fb28cb1d7a569ca70c6c4e9eb302d486", + "path": "research/p104-paid-idle-fragmentation/frozen/two-fragment/CALLER-ONE-RETIRED.json", + "git_blob": "9a45cbfc72f619f5608d96a02a9372a715131f1e", + "sha256": "8d7889e817faf1bbf81bb4ed681db039df6e26ecdab5555dff60c3d0e4309030" + }, + { + "local": "retained/caller/RETIREMENT-WITNESSES.json", + "repository": "zxv/integer-mult-bounds", + "commit": "435bbe91fb28cb1d7a569ca70c6c4e9eb302d486", + "path": "research/p104-paid-idle-fragmentation/frozen/two-fragment/RETIREMENT-WITNESSES.json", + "git_blob": "6403f0e21648c0e7afbb2fc6972af5e6d9018397", + "sha256": "272534848a8fe8a9fd523f4daf2747b24a6b26eb9a848d27cafcb22a2e718136" + }, + { + "local": "retained/caller/INDEPENDENT.json", + "repository": "zxv/integer-mult-bounds", + "commit": "435bbe91fb28cb1d7a569ca70c6c4e9eb302d486", + "path": "research/p104-paid-idle-fragmentation/frozen/two-fragment/INDEPENDENT.json", + "git_blob": "8a70990cacd372edbf53ea0cc9b727c97fa19c0f", + "sha256": "df00dfe2682da4bc679d62e5a63419a5877bfb78369d35a1c2634c0964af0a9f" + }, + { + "local": "retained/caller/RESULT.json", + "repository": "zxv/integer-mult-bounds", + "commit": "435bbe91fb28cb1d7a569ca70c6c4e9eb302d486", + "path": "research/p104-paid-idle-fragmentation/frozen/two-fragment/RESULT.json", + "git_blob": "91a52a23c5b8bf7149c1c6bc64d46fd34a0e480d", + "sha256": "e1df91e78b3b1aeafcea9c88bc8badef8a294e88e166df458e41860ae9f9b25a" + }, + { + "local": "retained/caller/PROOF.md", + "repository": "zxv/integer-mult-bounds", + "commit": "435bbe91fb28cb1d7a569ca70c6c4e9eb302d486", + "path": "research/p104-paid-idle-fragmentation/frozen/two-fragment/PROOF.md", + "git_blob": "1d23498f0dc2db6e76962d6b993063c0781d2999", + "sha256": "0d79d6530c6d42cf20a27847ff7a9c57da5fb329507cd288192a28821db50226" + }, + { + "local": "retained/caller/NOTICE", + "repository": "zxv/integer-mult-bounds", + "commit": "435bbe91fb28cb1d7a569ca70c6c4e9eb302d486", + "path": "research/p104-paid-idle-fragmentation/frozen/two-fragment/NOTICE", + "git_blob": "fed7ebcefa7b00b0af07d87202aa4bfdb665377e", + "sha256": "fe9a9cc1c673c523676607dc6aea658a89f79d583dfdf2831fa9472cdbad2e69" + }, + { + "local": "retained/caller/LICENSE", + "repository": "zxv/integer-mult-bounds", + "commit": "435bbe91fb28cb1d7a569ca70c6c4e9eb302d486", + "path": "research/p104-paid-idle-fragmentation/frozen/two-fragment/LICENSE", + "git_blob": "261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64", + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4" + }, + { + "local": "retained/caller/pricing.py", + "repository": "zxv/integer-mult-bounds", + "commit": "435bbe91fb28cb1d7a569ca70c6c4e9eb302d486", + "path": "research/p104-paid-idle-fragmentation/frozen/two-fragment/pricing.py", + "git_blob": "5f92b18de7b4c5894716003eff4c6dde2f016dd9", + "sha256": "cbd2b98722461ec6d91879154e837ba9a7dfaeeb03ae249165cda688b24233c2" + }, + { + "local": "retained/runtime/physical.py", + "repository": "zxv/integer-mult-bounds", + "commit": "435bbe91fb28cb1d7a569ca70c6c4e9eb302d486", + "path": "research/p104-paid-idle-fragmentation/frozen/sources/pr6702/unpacked/research/gaussian-root-retirement/physical.py", + "git_blob": "ff344772157f43a225b0c1d18c65298a01bc67a3", + "sha256": "8bff8960ec863c86ed656b0c18e0387bca3d640a34b6c265639eab61a8a6018c" + }, + { + "local": "retained/runtime/intervals.py", + "repository": "zxv/integer-mult-bounds", + "commit": "435bbe91fb28cb1d7a569ca70c6c4e9eb302d486", + "path": "research/p104-paid-idle-fragmentation/frozen/runtime/root/research/higher-moment-strictification/verify.py", + "git_blob": "4b24a5096154736ce060474eb8c72dc64c303699", + "sha256": "0ce7e7137422d5ffeda22085c81fa88471bbe963100fdad62e659f1e3bf89326" + }, + { + "local": "retained/runtime/second_intervals.py", + "repository": "zxv/integer-mult-bounds", + "commit": "435bbe91fb28cb1d7a569ca70c6c4e9eb302d486", + "path": "research/p104-paid-idle-fragmentation/frozen/runtime/root/research/kappa-rebuild/architecture/mixed_target_probe.py", + "git_blob": "4fc05ab08138218ba9f09e5c89b649afae7c914e", + "sha256": "011c3c9d0cf81103dc84d709a0e36793eb7c5ae3f23c85eac27650ef13afa04a" + }, + { + "local": "retained/runtime/endpoint.py", + "repository": "zxv/integer-mult-bounds", + "commit": "435bbe91fb28cb1d7a569ca70c6c4e9eb302d486", + "path": "research/p104-paid-idle-fragmentation/frozen/runtime/root/research/pr4359-p7-padding/dependencies/compiler-refill/endpoint.py", + "git_blob": "340e1f0ffb8a1a9c38fbbd9119580b6d23e01b59", + "sha256": "d097e55f06c3f244f2074ffd7c1a0a5f3c4b4b6a6accf9619d1dde5c0ae85e15" + }, + { + "local": "retained/runtime/native_inventory.py", + "repository": "zxv/integer-mult-bounds", + "commit": "435bbe91fb28cb1d7a569ca70c6c4e9eb302d486", + "path": "research/p104-paid-idle-fragmentation/frozen/runtime/root/research/pr4359-p7-padding/native_inventory.py", + "git_blob": "8d2d96e3998254c2333c43fe47cdfd074cbd811e", + "sha256": "65539acaf45bdfe8c5aee6830f9c9b3d1107c442a60842ef803fdd7688de8f32" + }, + { + "local": "retained/runtime/BIT-RESULT.json", + "repository": "zxv/integer-mult-bounds", + "commit": "435bbe91fb28cb1d7a569ca70c6c4e9eb302d486", + "path": "research/p104-paid-idle-fragmentation/frozen/runtime/root/research/query-thinned-controllers/RESULT.json", + "git_blob": "e0695152c98d727edfd0d2034b58a1c7e8682c0c", + "sha256": "6ebfc8c0f09166f4834e9d7427410cb31aefff2cd4d4ce588c8e52c9c70e9a0f" + }, + { + "local": "retained/runtime/DATA-PHASES.json", + "repository": "zxv/integer-mult-bounds", + "commit": "435bbe91fb28cb1d7a569ca70c6c4e9eb302d486", + "path": "research/p104-paid-idle-fragmentation/frozen/runtime/root/research/kappa-0023-productive-jobs/dependencies/kappa-next-regime/direct-decoder/sources/DATA-PHASES.json", + "git_blob": "d9a4f84211182ca200c081ea061d724c8a2cfb70", + "sha256": "c5916ff312678f12aba403847643fbbc29f643acec60bdf836fa56cd3e8251fa" + }, + { + "local": "retained/native/clifford_exact.py", + "repository": "CrocSwap/integer-mult-bounds", + "commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a", + "path": "research/p104-native-channel/vendor/clifford_exact.py", + "git_blob": "166841a037f069249f6f7f6dedb89248812f59e2", + "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962" + }, + { + "local": "retained/native/native_verify.py", + "repository": "CrocSwap/integer-mult-bounds", + "commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a", + "path": "research/p104-native-channel/vendor/native_verify.py", + "git_blob": "2c209dfa9cfade3bc20ac5fc9d876b433a147f8c", + "sha256": "3049471905b47b385c88378a1a3be7a18b8858aadd035b8a6da2f4a03b470f38" + }, + { + "local": "retained/native/construct.py", + "repository": "CrocSwap/integer-mult-bounds", + "commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a", + "path": "research/p104-helper-subspace-splits/construct.py", + "git_blob": "698a4cbcc0d7afbba8dccfb7f453315ed7230795", + "sha256": "8e1a674ebed7bffb9fd6995555895a9925b665c2dec0e91f2876ff043901006f" + }, + { + "local": "retained/native/local.py", + "repository": "CrocSwap/integer-mult-bounds", + "commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a", + "path": "research/p104-helper-subspace-splits/local.py", + "git_blob": "e6e28bacdad7cb51400d827b9a6e02f2b605d357", + "sha256": "ef430511ce36fc658ab711bd84cd2d7b484b8af173238ff89cbfec6139fefbad" + }, + { + "local": "retained/native/PR6702-WORD.json.gz", + "repository": "zxv/integer-mult-bounds", + "commit": "435bbe91fb28cb1d7a569ca70c6c4e9eb302d486", + "path": "research/p104-paid-idle-fragmentation/frozen/sources/pr6702/unpacked/research/gaussian-root-retirement/native/research/p104-scaled-transport-fusion/WORD.json.gz", + "git_blob": "3aa0220fe3a469e96b825995cab760c85888abcb", + "sha256": "e8c7a9d54d98a4cfa27e15593016b3908afed303e0f480076ed3f596192e5a4d", + "lineage": "Exact native word retained from #6702, including its helper607 split." + }, + { + "local": "retained/physical-review/verify.py", + "repository": "CubeJerry/integer-mult-bounds", + "commit": "c3e0500c7645b1bc228ebe5e5190e304a2da46ca", + "path": "research/p104-fragment-physical-invoice-audit/verify.py", + "git_blob": "c3ab55232926839649b708c12e4c3d673e155954", + "sha256": "e038e3fb7b7c757ad46b8e250088e530bbe2aee7d334795abeb7285e9458e5d9" + }, + { + "local": "retained/physical-review/PROOF.md", + "repository": "CubeJerry/integer-mult-bounds", + "commit": "c3e0500c7645b1bc228ebe5e5190e304a2da46ca", + "path": "research/p104-fragment-physical-invoice-audit/PROOF.md", + "git_blob": "5a5844ee9a56f701fdbe797a5d0eded35ed0777d", + "sha256": "3eee96d547b9676fac93b867f4b6228608e5fb38a19bceb97c98c3c679f96093" + }, + { + "local": "retained/physical-review/NOTICE", + "repository": "CubeJerry/integer-mult-bounds", + "commit": "c3e0500c7645b1bc228ebe5e5190e304a2da46ca", + "path": "research/p104-fragment-physical-invoice-audit/NOTICE", + "git_blob": "0b9b488b10a070bdae8b68d59e4e3ace7e387342", + "sha256": "e9c62281ffa22f6bb474e3b0d3b4b4bf1d7ff8ae0471096533d9b646d4eb7e63" + } +] diff --git a/research/native-retimed-helper-split/retained/caller/CALLER-ONE-RETIRED.json b/research/native-retimed-helper-split/retained/caller/CALLER-ONE-RETIRED.json new file mode 100644 index 0000000000..9a45cbfc72 --- /dev/null +++ b/research/native-retimed-helper-split/retained/caller/CALLER-ONE-RETIRED.json @@ -0,0 +1,4210 @@ +{ + "schema": "two-paid-fragments-two-independent-retirements/1", + "roles": 33, + "stages": 18, + "ambient_rank": 153, + "events": [ + [ + "ADD", + 6, + 7, + "1" + ], + [ + "SCALE", + 6, + "-1" + ], + [ + "ADD", + 7, + 6, + "2" + ], + [ + "SWAP", + 6, + 7 + ], + [ + "ADD", + 7, + 6, + "-1" + ], + [ + "SCALE", + 1, + "-1" + ], + [ + "ADD", + 1, + 0, + "1" + ], + [ + "SWAP", + 0, + 9 + ], + [ + "SWAP", + 1, + 8 + ], + [ + "SWAP", + 8, + 9 + ], + [ + "ADD", + 0, + 8, + "1" + ], + [ + "ADD", + 9, + 1, + "-1" + ], + [ + "LAMBDA", + 8, + -1 + ], + [ + "QUERY", + 8, + 9, + -1 + ], + [ + "LAMBDA", + 8, + 1 + ], + [ + "ADD", + 9, + 1, + "1" + ], + [ + "ADD", + 0, + 8, + "-1" + ], + [ + "IDLE", + 8, + 9, + [ + 1, + 2, + 3, + 4 + ] + ], + [ + "SCALE", + 1, + "-1" + ], + [ + "SWAP", + 1, + 11 + ], + [ + "SWAP", + 0, + 10 + ], + [ + "SWAP", + 10, + 11 + ], + [ + "ADD", + 1, + 10, + "1" + ], + [ + "ADD", + 11, + 0, + "-1" + ], + [ + "LAMBDA", + 10, + -1 + ], + [ + "QUERY", + 10, + 11, + -1 + ], + [ + "LAMBDA", + 10, + 1 + ], + [ + "ADD", + 11, + 0, + "1" + ], + [ + "ADD", + 1, + 10, + "-1" + ], + [ + "IDLE", + 10, + 11, + [ + 1, + 2 + ] + ], + [ + "SCALE", + 0, + "-1" + ], + [ + "LAMBDA", + 0, + -1 + ], + [ + "LOCAL", + 1, + 1, + 0 + ], + [ + "LAMBDA", + 0, + 1 + ], + [ + "SCALE", + 0, + "-1" + ], + [ + "LAMBDA", + 1, + -1 + ], + [ + "LOCAL", + 2, + 0, + 1 + ], + [ + "LAMBDA", + 1, + 1 + ], + [ + "ADD", + 1, + 10, + "1" + ], + [ + "SCALE", + 10, + "-1" + ], + [ + "ADD", + 10, + 1, + "1" + ], + [ + "SWAP", + 0, + 11 + ], + [ + "SCALE", + 11, + "-1" + ], + [ + "ADD", + 11, + 0, + "1" + ], + [ + "SCALE", + 1, + "-1" + ], + [ + "SWAP", + 0, + 13 + ], + [ + "SWAP", + 1, + 12 + ], + [ + "SWAP", + 12, + 13 + ], + [ + "ADD", + 0, + 12, + "1" + ], + [ + "ADD", + 13, + 1, + "-1" + ], + [ + "LAMBDA", + 12, + -1 + ], + [ + "QUERY", + 12, + 13, + -1 + ], + [ + "LAMBDA", + 12, + 1 + ], + [ + "ADD", + 13, + 1, + "1" + ], + [ + "ADD", + 0, + 12, + "-1" + ], + [ + "IDLE", + 12, + 13, + [ + 3, + 4 + ] + ], + [ + "SCALE", + 1, + "-1" + ], + [ + "LAMBDA", + 1, + -1 + ], + [ + "LOCAL", + 3, + 0, + 1 + ], + [ + "LAMBDA", + 1, + 1 + ], + [ + "SCALE", + 1, + "-1" + ], + [ + "LAMBDA", + 0, + -1 + ], + [ + "LOCAL", + 4, + 1, + 0 + ], + [ + "LAMBDA", + 0, + 1 + ], + [ + "ADD", + 0, + 12, + "1" + ], + [ + "SCALE", + 12, + "-1" + ], + [ + "ADD", + 12, + 0, + "1" + ], + [ + "SWAP", + 1, + 13 + ], + [ + "SCALE", + 13, + "-1" + ], + [ + "ADD", + 13, + 1, + "1" + ], + [ + "ADD", + 0, + 8, + "1" + ], + [ + "SCALE", + 8, + "-1" + ], + [ + "ADD", + 8, + 0, + "1" + ], + [ + "SWAP", + 1, + 9 + ], + [ + "SCALE", + 9, + "-1" + ], + [ + "ADD", + 9, + 1, + "1" + ], + [ + "ADD", + 0, + 1, + "-1" + ], + [ + "SCALE", + 1, + "-1" + ], + [ + "ADD", + 1, + 0, + "1" + ], + [ + "ADD", + 1, + 7, + "-2" + ], + [ + "ADD", + 0, + 7, + "-1" + ], + [ + "SCALE", + 7, + "-1" + ], + [ + "SCALE", + 6, + "-1" + ], + [ + "ADD", + 7, + 6, + "1" + ], + [ + "SWAP", + 5, + 7 + ], + [ + "SWAP", + 4, + 6 + ], + [ + "SWAP", + 3, + 5 + ], + [ + "SWAP", + 2, + 4 + ], + [ + "SCALE", + 1, + "-1" + ], + [ + "SWAP", + 1, + 3 + ], + [ + "ADD", + 3, + 0, + "2" + ], + [ + "ADD", + 2, + 0, + "1" + ], + [ + "ADD", + 1, + 0, + "1" + ], + [ + "SWAP", + 0, + 15 + ], + [ + "SWAP", + 1, + 14 + ], + [ + "SWAP", + 14, + 15 + ], + [ + "ADD", + 0, + 14, + "1" + ], + [ + "ADD", + 15, + 1, + "-1" + ], + [ + "LAMBDA", + 14, + -1 + ], + [ + "QUERY", + 14, + 15, + -1 + ], + [ + "LAMBDA", + 14, + 1 + ], + [ + "ADD", + 15, + 1, + "1" + ], + [ + "ADD", + 0, + 14, + "-1" + ], + [ + "IDLE", + 14, + 15, + [ + 5, + 6, + 7, + 8 + ] + ], + [ + "SCALE", + 1, + "-1" + ], + [ + "SWAP", + 1, + 17 + ], + [ + "SWAP", + 0, + 16 + ], + [ + "SWAP", + 16, + 17 + ], + [ + "ADD", + 1, + 16, + "1" + ], + [ + "ADD", + 17, + 0, + "-1" + ], + [ + "LAMBDA", + 16, + -1 + ], + [ + "QUERY", + 16, + 17, + -1 + ], + [ + "LAMBDA", + 16, + 1 + ], + [ + "ADD", + 17, + 0, + "1" + ], + [ + "ADD", + 1, + 16, + "-1" + ], + [ + "IDLE", + 16, + 17, + [ + 5, + 6 + ] + ], + [ + "SCALE", + 0, + "-1" + ], + [ + "LAMBDA", + 0, + -1 + ], + [ + "LOCAL", + 5, + 1, + 0 + ], + [ + "LAMBDA", + 0, + 1 + ], + [ + "SCALE", + 0, + "-1" + ], + [ + "LAMBDA", + 1, + -1 + ], + [ + "LOCAL", + 6, + 0, + 1 + ], + [ + "LAMBDA", + 1, + 1 + ], + [ + "ADD", + 1, + 16, + "1" + ], + [ + "SCALE", + 16, + "-1" + ], + [ + "ADD", + 16, + 1, + "1" + ], + [ + "SWAP", + 0, + 17 + ], + [ + "SCALE", + 17, + "-1" + ], + [ + "ADD", + 17, + 0, + "1" + ], + [ + "SCALE", + 1, + "-1" + ], + [ + "SWAP", + 0, + 19 + ], + [ + "SWAP", + 1, + 18 + ], + [ + "SWAP", + 18, + 19 + ], + [ + "ADD", + 0, + 18, + "1" + ], + [ + "ADD", + 19, + 1, + "-1" + ], + [ + "LAMBDA", + 18, + -1 + ], + [ + "QUERY", + 18, + 19, + -1 + ], + [ + "LAMBDA", + 18, + 1 + ], + [ + "ADD", + 19, + 1, + "1" + ], + [ + "ADD", + 0, + 18, + "-1" + ], + [ + "IDLE", + 18, + 19, + [ + 7, + 8 + ] + ], + [ + "SCALE", + 1, + "-1" + ], + [ + "LAMBDA", + 1, + -1 + ], + [ + "LOCAL", + 7, + 0, + 1 + ], + [ + "LAMBDA", + 1, + 1 + ], + [ + "SCALE", + 1, + "-1" + ], + [ + "LAMBDA", + 0, + -1 + ], + [ + "LOCAL", + 8, + 1, + 0 + ], + [ + "LAMBDA", + 0, + 1 + ], + [ + "ADD", + 0, + 18, + "1" + ], + [ + "SCALE", + 18, + "-1" + ], + [ + "ADD", + 18, + 0, + "1" + ], + [ + "SWAP", + 1, + 19 + ], + [ + "SCALE", + 19, + "-1" + ], + [ + "ADD", + 19, + 1, + "1" + ], + [ + "ADD", + 0, + 14, + "1" + ], + [ + "SCALE", + 14, + "-1" + ], + [ + "ADD", + 14, + 0, + "1" + ], + [ + "SWAP", + 1, + 15 + ], + [ + "SCALE", + 15, + "-1" + ], + [ + "ADD", + 15, + 1, + "1" + ], + [ + "ADD", + 0, + 1, + "-1" + ], + [ + "IDLE_ONE", + 2, + [ + 5, + 6, + 7, + 8 + ] + ], + [ + "ADD", + 0, + 2, + "1" + ], + [ + "ADD", + 2, + 1, + "-1" + ], + [ + "SWAP", + 2, + 6 + ], + [ + "SWAP", + 2, + 32 + ], + [ + "ADD", + 2, + 1, + "1" + ], + [ + "ADD", + 0, + 2, + "-1" + ], + [ + "SCALE", + 1, + "-1" + ], + [ + "LAMBDA", + 1, + -1 + ], + [ + "LOCAL", + 9, + 0, + 1 + ], + [ + "LAMBDA", + 1, + 1 + ], + [ + "SCALE", + 1, + "-1" + ], + [ + "ADD", + 1, + 0, + "1" + ], + [ + "IDLE_ONE", + 2, + [ + 9 + ] + ], + [ + "IDLE_ONE", + 3, + [ + 5, + 6, + 7, + 8, + 9 + ] + ], + [ + "SWAP", + 32, + 7 + ], + [ + "SWAP", + 5, + 32 + ], + [ + "SWAP", + 4, + 7 + ], + [ + "SCALE", + 3, + "-1" + ], + [ + "SWAP", + 3, + 32 + ], + [ + "ADD", + 1, + 2, + "-2" + ], + [ + "ADD", + 0, + 2, + "-1" + ], + [ + "SCALE", + 2, + "-1" + ], + [ + "SWAP", + 2, + 7 + ], + [ + "ADD", + 0, + 1, + "-1" + ], + [ + "ADD", + 7, + 1, + "-1" + ], + [ + "SWAP", + 1, + 32 + ], + [ + "ADD", + 32, + 0, + "1" + ], + [ + "ADD", + 1, + 0, + "2" + ], + [ + "ADD", + 1, + 7, + "-1" + ], + [ + "ADD", + 1, + 32, + "-1" + ], + [ + "ADD", + 1, + 5, + "-2" + ], + [ + "ADD", + 0, + 5, + "-2" + ], + [ + "ADD", + 1, + 4, + "-2" + ], + [ + "ADD", + 0, + 4, + "-2" + ], + [ + "SCALE", + 3, + "-1" + ], + [ + "ADD", + 1, + 2, + "-1" + ], + [ + "SWAP", + 2, + 3 + ], + [ + "ADD", + 0, + 1, + "-1" + ], + [ + "ADD", + 5, + 1, + "2" + ], + [ + "ADD", + 4, + 1, + "-2" + ], + [ + "ADD", + 3, + 1, + "-2" + ], + [ + "SWAP", + 1, + 2 + ], + [ + "ADD", + 5, + 0, + "6" + ], + [ + "ADD", + 4, + 0, + "-6" + ], + [ + "ADD", + 3, + 0, + "-6" + ], + [ + "ADD", + 2, + 0, + "2" + ], + [ + "SWAP", + 0, + 2 + ], + [ + "ADD", + 2, + 0, + "1" + ], + [ + "SWAP", + 0, + 2 + ], + [ + "ADD", + 1, + 0, + "1" + ], + [ + "LAMBDA", + 0, + -1 + ], + [ + "QUERY", + 0, + 1, + -1 + ], + [ + "LAMBDA", + 0, + 1 + ], + [ + "ADD", + 0, + 1, + "-1" + ], + [ + "ADD", + 5, + 7, + "-4" + ], + [ + "ADD", + 4, + 7, + "4" + ], + [ + "ADD", + 3, + 7, + "4" + ], + [ + "ADD", + 2, + 7, + "-1" + ], + [ + "ADD", + 1, + 7, + "-2" + ], + [ + "ADD", + 0, + 7, + "-2" + ], + [ + "ADD", + 5, + 32, + "-4" + ], + [ + "ADD", + 4, + 32, + "4" + ], + [ + "ADD", + 3, + 32, + "4" + ], + [ + "ADD", + 2, + 32, + "-1" + ], + [ + "ADD", + 1, + 32, + "-2" + ], + [ + "ADD", + 0, + 32, + "-2" + ], + [ + "ADD", + 4, + 5, + "1" + ], + [ + "SCALE", + 5, + "-1" + ], + [ + "ADD", + 3, + 4, + "-4" + ], + [ + "ADD", + 2, + 4, + "2" + ], + [ + "ADD", + 1, + 4, + "2" + ], + [ + "ADD", + 0, + 4, + "2" + ], + [ + "SCALE", + 4, + "-1" + ], + [ + "ADD", + 5, + 4, + "2" + ], + [ + "SWAP", + 4, + 5 + ], + [ + "ADD", + 5, + 4, + "1" + ], + [ + "SWAP", + 4, + 5 + ], + [ + "ADD", + 5, + 4, + "-2" + ], + [ + "ADD", + 1, + 2, + "-2" + ], + [ + "ADD", + 0, + 2, + "-2" + ], + [ + "ADD", + 5, + 2, + "-4" + ], + [ + "ADD", + 4, + 2, + "4" + ], + [ + "ADD", + 3, + 2, + "3" + ], + [ + "SWAP", + 2, + 3 + ], + [ + "ADD", + 3, + 2, + "1" + ], + [ + "SWAP", + 2, + 3 + ], + [ + "SCALE", + 1, + "-1" + ], + [ + "SWAP", + 1, + 3 + ], + [ + "SCALE", + 0, + "-1" + ], + [ + "ADD", + 5, + 0, + "2" + ], + [ + "ADD", + 4, + 0, + "-2" + ], + [ + "ADD", + 3, + 0, + "-1" + ], + [ + "ADD", + 2, + 0, + "-2" + ], + [ + "ADD", + 1, + 7, + "-1" + ], + [ + "ADD", + 1, + 32, + "-1" + ], + [ + "ADD", + 1, + 5, + "1" + ], + [ + "ADD", + 1, + 4, + "1" + ], + [ + "SCALE", + 3, + "-1" + ], + [ + "ADD", + 1, + 2, + "-1" + ], + [ + "SCALE", + 1, + "-1" + ], + [ + "ADD", + 3, + 1, + "3" + ], + [ + "SWAP", + 1, + 3 + ], + [ + "SCALE", + 0, + "-1" + ], + [ + "ADD", + 5, + 0, + "2" + ], + [ + "ADD", + 4, + 0, + "-2" + ], + [ + "ADD", + 3, + 0, + "-2" + ], + [ + "ADD", + 2, + 0, + "-2" + ], + [ + "ADD", + 1, + 0, + "-4" + ], + [ + "LAMBDA", + 0, + -1 + ], + [ + "QUERY", + 0, + 1, + -1 + ], + [ + "LAMBDA", + 0, + 1 + ], + [ + "ADD", + 0, + 1, + "-1" + ], + [ + "ADD", + 3, + 7, + "-1" + ], + [ + "ADD", + 1, + 7, + "-3" + ], + [ + "ADD", + 3, + 32, + "-1" + ], + [ + "ADD", + 1, + 32, + "-3" + ], + [ + "ADD", + 3, + 5, + "1" + ], + [ + "ADD", + 1, + 5, + "3" + ], + [ + "ADD", + 3, + 4, + "1" + ], + [ + "ADD", + 1, + 4, + "3" + ], + [ + "ADD", + 1, + 3, + "-3" + ], + [ + "SCALE", + 3, + "-1" + ], + [ + "ADD", + 3, + 2, + "1" + ], + [ + "SCALE", + 1, + "-1" + ], + [ + "SWAP", + 1, + 3 + ], + [ + "SCALE", + 0, + "-1" + ], + [ + "ADD", + 5, + 0, + "2" + ], + [ + "ADD", + 4, + 0, + "-2" + ], + [ + "ADD", + 3, + 0, + "-2" + ], + [ + "ADD", + 2, + 0, + "-2" + ], + [ + "ADD", + 32, + 7, + "1" + ], + [ + "ADD", + 5, + 7, + "1" + ], + [ + "ADD", + 4, + 7, + "-1" + ], + [ + "ADD", + 3, + 7, + "-1" + ], + [ + "ADD", + 2, + 7, + "-1" + ], + [ + "ADD", + 1, + 7, + "-1" + ], + [ + "ADD", + 1, + 32, + "-1" + ], + [ + "SWAP", + 32, + 7 + ], + [ + "ADD", + 1, + 5, + "-2" + ], + [ + "ADD", + 0, + 5, + "-2" + ], + [ + "SWAP", + 5, + 32 + ], + [ + "ADD", + 1, + 4, + "-2" + ], + [ + "ADD", + 0, + 4, + "-2" + ], + [ + "SWAP", + 4, + 5 + ], + [ + "SWAP", + 3, + 4 + ], + [ + "ADD", + 1, + 2, + "-1" + ], + [ + "SWAP", + 2, + 3 + ], + [ + "ADD", + 0, + 1, + "-1" + ], + [ + "SWAP", + 1, + 2 + ], + [ + "ADD", + 2, + 0, + "2" + ], + [ + "SWAP", + 0, + 2 + ], + [ + "ADD", + 2, + 0, + "1" + ], + [ + "SWAP", + 0, + 2 + ], + [ + "ADD", + 2, + 0, + "-1" + ], + [ + "SWAP", + 0, + 1 + ], + [ + "LAMBDA", + 0, + -1 + ], + [ + "QUERY", + 0, + 1, + -1 + ], + [ + "LAMBDA", + 0, + 1 + ], + [ + "ADD", + 0, + 1, + "-1" + ], + [ + "ADD", + 32, + 7, + "-1" + ], + [ + "ADD", + 5, + 7, + "1" + ], + [ + "ADD", + 4, + 7, + "1" + ], + [ + "ADD", + 3, + 7, + "1" + ], + [ + "ADD", + 2, + 7, + "1" + ], + [ + "ADD", + 1, + 7, + "-2" + ], + [ + "ADD", + 0, + 7, + "-1" + ], + [ + "ADD", + 5, + 32, + "1" + ], + [ + "ADD", + 4, + 32, + "1" + ], + [ + "ADD", + 3, + 32, + "1" + ], + [ + "ADD", + 0, + 32, + "-1" + ], + [ + "SCALE", + 32, + "-1" + ], + [ + "ADD", + 7, + 32, + "-1" + ], + [ + "ADD", + 4, + 5, + "-1" + ], + [ + "ADD", + 3, + 5, + "-1" + ], + [ + "ADD", + 1, + 5, + "2" + ], + [ + "ADD", + 0, + 5, + "1" + ], + [ + "ADD", + 7, + 5, + "-1" + ], + [ + "ADD", + 32, + 5, + "1" + ], + [ + "ADD", + 3, + 4, + "-1" + ], + [ + "ADD", + 0, + 4, + "1" + ], + [ + "SCALE", + 4, + "-1" + ], + [ + "ADD", + 7, + 4, + "1" + ], + [ + "ADD", + 32, + 4, + "-1" + ], + [ + "ADD", + 5, + 4, + "-1" + ], + [ + "ADD", + 0, + 3, + "1" + ], + [ + "SCALE", + 3, + "-1" + ], + [ + "ADD", + 7, + 3, + "1" + ], + [ + "ADD", + 32, + 3, + "-1" + ], + [ + "ADD", + 5, + 3, + "-1" + ], + [ + "ADD", + 4, + 3, + "1" + ], + [ + "ADD", + 1, + 2, + "2" + ], + [ + "ADD", + 0, + 2, + "1" + ], + [ + "SCALE", + 2, + "-1" + ], + [ + "ADD", + 7, + 2, + "1" + ], + [ + "ADD", + 32, + 2, + "-1" + ], + [ + "ADD", + 5, + 2, + "-1" + ], + [ + "ADD", + 4, + 2, + "1" + ], + [ + "ADD", + 3, + 2, + "1" + ], + [ + "ADD", + 0, + 1, + "1" + ], + [ + "ADD", + 7, + 1, + "-1" + ], + [ + "ADD", + 32, + 1, + "1" + ], + [ + "ADD", + 5, + 1, + "1" + ], + [ + "ADD", + 4, + 1, + "-1" + ], + [ + "ADD", + 3, + 1, + "-1" + ], + [ + "ADD", + 2, + 1, + "-1" + ], + [ + "ADD", + 7, + 0, + "1" + ], + [ + "ADD", + 32, + 0, + "-1" + ], + [ + "ADD", + 5, + 0, + "-1" + ], + [ + "ADD", + 4, + 0, + "1" + ], + [ + "ADD", + 3, + 0, + "1" + ], + [ + "ADD", + 2, + 0, + "1" + ], + [ + "SWAP", + 0, + 1 + ], + [ + "ADD", + 4, + 5, + "1" + ], + [ + "ADD", + 2, + 5, + "2" + ], + [ + "ADD", + 0, + 5, + "-1" + ], + [ + "ADD", + 2, + 4, + "-4" + ], + [ + "ADD", + 0, + 4, + "2" + ], + [ + "SCALE", + 4, + "-1" + ], + [ + "ADD", + 5, + 4, + "1" + ], + [ + "SWAP", + 3, + 5 + ], + [ + "SCALE", + 2, + "-1" + ], + [ + "SWAP", + 2, + 3 + ], + [ + "SWAP", + 1, + 4 + ], + [ + "ADD", + 3, + 0, + "-2" + ], + [ + "ADD", + 2, + 0, + "1" + ], + [ + "ADD", + 1, + 0, + "1" + ], + [ + "LAMBDA", + 0, + -1 + ], + [ + "LOCAL", + 10, + 1, + 0 + ], + [ + "LAMBDA", + 0, + 1 + ], + [ + "ADD", + 0, + 1, + "-1" + ], + [ + "IDLE_ONE", + 2, + [ + 10 + ] + ], + [ + "SCALE", + 1, + "-1" + ], + [ + "SWAP", + 1, + 21 + ], + [ + "SWAP", + 0, + 20 + ], + [ + "SWAP", + 20, + 21 + ], + [ + "ADD", + 1, + 20, + "1" + ], + [ + "ADD", + 21, + 0, + "-1" + ], + [ + "LAMBDA", + 20, + -1 + ], + [ + "QUERY", + 20, + 21, + -1 + ], + [ + "LAMBDA", + 20, + 1 + ], + [ + "ADD", + 21, + 0, + "1" + ], + [ + "ADD", + 1, + 20, + "-1" + ], + [ + "IDLE", + 20, + 21, + [ + 11, + 12, + 13, + 14 + ] + ], + [ + "SCALE", + 0, + "-1" + ], + [ + "SWAP", + 0, + 23 + ], + [ + "SWAP", + 1, + 22 + ], + [ + "SWAP", + 22, + 23 + ], + [ + "ADD", + 0, + 22, + "1" + ], + [ + "ADD", + 23, + 1, + "-1" + ], + [ + "LAMBDA", + 22, + -1 + ], + [ + "QUERY", + 22, + 23, + -1 + ], + [ + "LAMBDA", + 22, + 1 + ], + [ + "ADD", + 23, + 1, + "1" + ], + [ + "ADD", + 0, + 22, + "-1" + ], + [ + "IDLE", + 22, + 23, + [ + 11, + 12 + ] + ], + [ + "SCALE", + 1, + "-1" + ], + [ + "LAMBDA", + 1, + -1 + ], + [ + "LOCAL", + 11, + 0, + 1 + ], + [ + "LAMBDA", + 1, + 1 + ], + [ + "SCALE", + 1, + "-1" + ], + [ + "LAMBDA", + 0, + -1 + ], + [ + "LOCAL", + 12, + 1, + 0 + ], + [ + "LAMBDA", + 0, + 1 + ], + [ + "ADD", + 0, + 22, + "1" + ], + [ + "SCALE", + 22, + "-1" + ], + [ + "ADD", + 22, + 0, + "1" + ], + [ + "SWAP", + 1, + 23 + ], + [ + "SCALE", + 23, + "-1" + ], + [ + "ADD", + 23, + 1, + "1" + ], + [ + "SCALE", + 0, + "-1" + ], + [ + "SWAP", + 1, + 25 + ], + [ + "SWAP", + 0, + 24 + ], + [ + "SWAP", + 24, + 25 + ], + [ + "ADD", + 1, + 24, + "1" + ], + [ + "ADD", + 25, + 0, + "-1" + ], + [ + "LAMBDA", + 24, + -1 + ], + [ + "QUERY", + 24, + 25, + -1 + ], + [ + "LAMBDA", + 24, + 1 + ], + [ + "ADD", + 25, + 0, + "1" + ], + [ + "ADD", + 1, + 24, + "-1" + ], + [ + "IDLE", + 24, + 25, + [ + 13, + 14 + ] + ], + [ + "SCALE", + 0, + "-1" + ], + [ + "LAMBDA", + 0, + -1 + ], + [ + "LOCAL", + 13, + 1, + 0 + ], + [ + "LAMBDA", + 0, + 1 + ], + [ + "SCALE", + 0, + "-1" + ], + [ + "LAMBDA", + 1, + -1 + ], + [ + "LOCAL", + 14, + 0, + 1 + ], + [ + "LAMBDA", + 1, + 1 + ], + [ + "ADD", + 1, + 24, + "1" + ], + [ + "SCALE", + 24, + "-1" + ], + [ + "ADD", + 24, + 1, + "1" + ], + [ + "SWAP", + 0, + 25 + ], + [ + "SCALE", + 25, + "-1" + ], + [ + "ADD", + 25, + 0, + "1" + ], + [ + "ADD", + 1, + 20, + "1" + ], + [ + "SCALE", + 20, + "-1" + ], + [ + "ADD", + 20, + 1, + "1" + ], + [ + "SWAP", + 0, + 21 + ], + [ + "SCALE", + 21, + "-1" + ], + [ + "ADD", + 21, + 0, + "1" + ], + [ + "SCALE", + 1, + "-1" + ], + [ + "ADD", + 1, + 0, + "1" + ], + [ + "IDLE_ONE", + 2, + [ + 11, + 12, + 13, + 14 + ] + ], + [ + "IDLE_ONE", + 3, + [ + 10, + 11, + 12, + 13, + 14 + ] + ], + [ + "SCALE", + 3, + "-1" + ], + [ + "SWAP", + 3, + 5 + ], + [ + "ADD", + 0, + 2, + "-1" + ], + [ + "SWAP", + 2, + 5 + ], + [ + "ADD", + 0, + 1, + "-1" + ], + [ + "ADD", + 5, + 1, + "-1" + ], + [ + "SWAP", + 1, + 4 + ], + [ + "SCALE", + 0, + "-1" + ], + [ + "ADD", + 4, + 0, + "-1" + ], + [ + "ADD", + 2, + 0, + "-2" + ], + [ + "SWAP", + 1, + 2 + ], + [ + "SCALE", + 0, + "-1" + ], + [ + "ADD", + 1, + 0, + "-1" + ], + [ + "SWAP", + 0, + 27 + ], + [ + "SWAP", + 1, + 26 + ], + [ + "SWAP", + 26, + 27 + ], + [ + "ADD", + 0, + 26, + "1" + ], + [ + "ADD", + 27, + 1, + "-1" + ], + [ + "LAMBDA", + 26, + -1 + ], + [ + "QUERY", + 26, + 27, + -1 + ], + [ + "LAMBDA", + 26, + 1 + ], + [ + "ADD", + 27, + 1, + "1" + ], + [ + "ADD", + 0, + 26, + "-1" + ], + [ + "IDLE", + 26, + 27, + [ + 15, + 16, + 17, + 18 + ] + ], + [ + "SCALE", + 1, + "-1" + ], + [ + "SWAP", + 1, + 29 + ], + [ + "SWAP", + 0, + 28 + ], + [ + "SWAP", + 28, + 29 + ], + [ + "ADD", + 1, + 28, + "1" + ], + [ + "ADD", + 29, + 0, + "-1" + ], + [ + "LAMBDA", + 28, + -1 + ], + [ + "QUERY", + 28, + 29, + -1 + ], + [ + "LAMBDA", + 28, + 1 + ], + [ + "ADD", + 29, + 0, + "1" + ], + [ + "ADD", + 1, + 28, + "-1" + ], + [ + "IDLE", + 28, + 29, + [ + 15, + 16 + ] + ], + [ + "SCALE", + 0, + "-1" + ], + [ + "LAMBDA", + 0, + -1 + ], + [ + "LOCAL", + 15, + 1, + 0 + ], + [ + "LAMBDA", + 0, + 1 + ], + [ + "SCALE", + 0, + "-1" + ], + [ + "LAMBDA", + 1, + -1 + ], + [ + "LOCAL", + 16, + 0, + 1 + ], + [ + "LAMBDA", + 1, + 1 + ], + [ + "ADD", + 1, + 28, + "1" + ], + [ + "SCALE", + 28, + "-1" + ], + [ + "ADD", + 28, + 1, + "1" + ], + [ + "SWAP", + 0, + 29 + ], + [ + "SCALE", + 29, + "-1" + ], + [ + "ADD", + 29, + 0, + "1" + ], + [ + "SCALE", + 1, + "-1" + ], + [ + "SWAP", + 0, + 31 + ], + [ + "SWAP", + 1, + 30 + ], + [ + "SWAP", + 30, + 31 + ], + [ + "ADD", + 0, + 30, + "1" + ], + [ + "ADD", + 31, + 1, + "-1" + ], + [ + "LAMBDA", + 30, + -1 + ], + [ + "QUERY", + 30, + 31, + -1 + ], + [ + "LAMBDA", + 30, + 1 + ], + [ + "ADD", + 31, + 1, + "1" + ], + [ + "ADD", + 0, + 30, + "-1" + ], + [ + "IDLE", + 30, + 31, + [ + 17, + 18 + ] + ], + [ + "SCALE", + 1, + "-1" + ], + [ + "LAMBDA", + 1, + -1 + ], + [ + "LOCAL", + 17, + 0, + 1 + ], + [ + "LAMBDA", + 1, + 1 + ], + [ + "SCALE", + 1, + "-1" + ], + [ + "LAMBDA", + 0, + -1 + ], + [ + "LOCAL", + 18, + 1, + 0 + ], + [ + "LAMBDA", + 0, + 1 + ], + [ + "ADD", + 0, + 30, + "1" + ], + [ + "SCALE", + 30, + "-1" + ], + [ + "ADD", + 30, + 0, + "1" + ], + [ + "SWAP", + 1, + 31 + ], + [ + "SCALE", + 31, + "-1" + ], + [ + "ADD", + 31, + 1, + "1" + ], + [ + "ADD", + 0, + 26, + "1" + ], + [ + "SCALE", + 26, + "-1" + ], + [ + "ADD", + 26, + 0, + "1" + ], + [ + "SWAP", + 1, + 27 + ], + [ + "SCALE", + 27, + "-1" + ], + [ + "ADD", + 27, + 1, + "1" + ], + [ + "ADD", + 0, + 1, + "-1" + ], + [ + "SWAP", + 1, + 2 + ], + [ + "SCALE", + 0, + "-1" + ], + [ + "ADD", + 2, + 0, + "-1" + ], + [ + "LAMBDA", + 0, + -1 + ], + [ + "LAMBDA", + 1, + -1 + ], + [ + "LAMBDA", + 2, + -1 + ], + [ + "LAMBDA", + 3, + -1 + ], + [ + "LAMBDA", + 4, + -1 + ], + [ + "LAMBDA", + 5, + -1 + ], + [ + "LAMBDA", + 32, + -1 + ], + [ + "LAMBDA", + 7, + -1 + ], + [ + "LAMBDA", + 8, + -1 + ], + [ + "LAMBDA", + 9, + -1 + ], + [ + "LAMBDA", + 10, + -1 + ], + [ + "LAMBDA", + 11, + -1 + ], + [ + "LAMBDA", + 12, + -1 + ], + [ + "LAMBDA", + 13, + -1 + ], + [ + "LAMBDA", + 14, + -1 + ], + [ + "LAMBDA", + 15, + -1 + ], + [ + "LAMBDA", + 16, + -1 + ], + [ + "LAMBDA", + 17, + -1 + ], + [ + "LAMBDA", + 18, + -1 + ], + [ + "LAMBDA", + 19, + -1 + ], + [ + "LAMBDA", + 20, + -1 + ], + [ + "LAMBDA", + 21, + -1 + ], + [ + "LAMBDA", + 22, + -1 + ], + [ + "LAMBDA", + 23, + -1 + ], + [ + "LAMBDA", + 24, + -1 + ], + [ + "LAMBDA", + 25, + -1 + ], + [ + "LAMBDA", + 26, + -1 + ], + [ + "LAMBDA", + 27, + -1 + ], + [ + "LAMBDA", + 28, + -1 + ], + [ + "LAMBDA", + 29, + -1 + ], + [ + "LAMBDA", + 30, + -1 + ], + [ + "LAMBDA", + 31, + -1 + ], + [ + "ADD", + 7, + 32, + "1" + ], + [ + "SWAP", + 32, + 7 + ], + [ + "ADD", + 7, + 32, + "-2" + ], + [ + "SCALE", + 32, + "-1" + ], + [ + "ADD", + 32, + 7, + "-1" + ] + ], + "diagonal": [ + [ + -1, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + [ + -1, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + "nodes": [ + { + "roles": [ + 8, + 9 + ], + "stages": [ + 1, + 2, + 3, + 4 + ] + }, + { + "roles": [ + 10, + 11 + ], + "stages": [ + 1, + 2 + ] + }, + { + "roles": [ + 12, + 13 + ], + "stages": [ + 3, + 4 + ] + }, + { + "roles": [ + 14, + 15 + ], + "stages": [ + 5, + 6, + 7, + 8 + ] + }, + { + "roles": [ + 16, + 17 + ], + "stages": [ + 5, + 6 + ] + }, + { + "roles": [ + 18, + 19 + ], + "stages": [ + 7, + 8 + ] + }, + { + "roles": [ + 20, + 21 + ], + "stages": [ + 11, + 12, + 13, + 14 + ] + }, + { + "roles": [ + 22, + 23 + ], + "stages": [ + 11, + 12 + ] + }, + { + "roles": [ + 24, + 25 + ], + "stages": [ + 13, + 14 + ] + }, + { + "roles": [ + 26, + 27 + ], + "stages": [ + 15, + 16, + 17, + 18 + ] + }, + { + "roles": [ + 28, + 29 + ], + "stages": [ + 15, + 16 + ] + }, + { + "roles": [ + 30, + 31 + ], + "stages": [ + 17, + 18 + ] + } + ] +} diff --git a/research/native-retimed-helper-split/retained/caller/CALLER-UNRETIRED.json b/research/native-retimed-helper-split/retained/caller/CALLER-UNRETIRED.json new file mode 100644 index 0000000000..30d8f94afc --- /dev/null +++ b/research/native-retimed-helper-split/retained/caller/CALLER-UNRETIRED.json @@ -0,0 +1,4098 @@ +{ + "schema": "root8-common-idle-fusion/1", + "roles": 32, + "stages": 18, + "ambient_rank": 153, + "events": [ + [ + "SCALE", + 1, + "-1" + ], + [ + "ADD", + 1, + 0, + "1" + ], + [ + "SWAP", + 0, + 9 + ], + [ + "SWAP", + 1, + 8 + ], + [ + "SWAP", + 8, + 9 + ], + [ + "ADD", + 0, + 8, + "1" + ], + [ + "ADD", + 9, + 1, + "-1" + ], + [ + "LAMBDA", + 8, + -1 + ], + [ + "QUERY", + 8, + 9, + -1 + ], + [ + "LAMBDA", + 8, + 1 + ], + [ + "ADD", + 9, + 1, + "1" + ], + [ + "ADD", + 0, + 8, + "-1" + ], + [ + "IDLE", + 8, + 9, + [ + 1, + 2, + 3, + 4 + ] + ], + [ + "SCALE", + 1, + "-1" + ], + [ + "SWAP", + 1, + 11 + ], + [ + "SWAP", + 0, + 10 + ], + [ + "SWAP", + 10, + 11 + ], + [ + "ADD", + 1, + 10, + "1" + ], + [ + "ADD", + 11, + 0, + "-1" + ], + [ + "LAMBDA", + 10, + -1 + ], + [ + "QUERY", + 10, + 11, + -1 + ], + [ + "LAMBDA", + 10, + 1 + ], + [ + "ADD", + 11, + 0, + "1" + ], + [ + "ADD", + 1, + 10, + "-1" + ], + [ + "IDLE", + 10, + 11, + [ + 1, + 2 + ] + ], + [ + "SCALE", + 0, + "-1" + ], + [ + "LAMBDA", + 0, + -1 + ], + [ + "LOCAL", + 1, + 1, + 0 + ], + [ + "LAMBDA", + 0, + 1 + ], + [ + "SCALE", + 0, + "-1" + ], + [ + "LAMBDA", + 1, + -1 + ], + [ + "LOCAL", + 2, + 0, + 1 + ], + [ + "LAMBDA", + 1, + 1 + ], + [ + "ADD", + 1, + 10, + "1" + ], + [ + "SCALE", + 10, + "-1" + ], + [ + "ADD", + 10, + 1, + "1" + ], + [ + "SWAP", + 0, + 11 + ], + [ + "SCALE", + 11, + "-1" + ], + [ + "ADD", + 11, + 0, + "1" + ], + [ + "SCALE", + 1, + "-1" + ], + [ + "SWAP", + 0, + 13 + ], + [ + "SWAP", + 1, + 12 + ], + [ + "SWAP", + 12, + 13 + ], + [ + "ADD", + 0, + 12, + "1" + ], + [ + "ADD", + 13, + 1, + "-1" + ], + [ + "LAMBDA", + 12, + -1 + ], + [ + "QUERY", + 12, + 13, + -1 + ], + [ + "LAMBDA", + 12, + 1 + ], + [ + "ADD", + 13, + 1, + "1" + ], + [ + "ADD", + 0, + 12, + "-1" + ], + [ + "IDLE", + 12, + 13, + [ + 3, + 4 + ] + ], + [ + "SCALE", + 1, + "-1" + ], + [ + "LAMBDA", + 1, + -1 + ], + [ + "LOCAL", + 3, + 0, + 1 + ], + [ + "LAMBDA", + 1, + 1 + ], + [ + "SCALE", + 1, + "-1" + ], + [ + "LAMBDA", + 0, + -1 + ], + [ + "LOCAL", + 4, + 1, + 0 + ], + [ + "LAMBDA", + 0, + 1 + ], + [ + "ADD", + 0, + 12, + "1" + ], + [ + "SCALE", + 12, + "-1" + ], + [ + "ADD", + 12, + 0, + "1" + ], + [ + "SWAP", + 1, + 13 + ], + [ + "SCALE", + 13, + "-1" + ], + [ + "ADD", + 13, + 1, + "1" + ], + [ + "ADD", + 0, + 8, + "1" + ], + [ + "SCALE", + 8, + "-1" + ], + [ + "ADD", + 8, + 0, + "1" + ], + [ + "SWAP", + 1, + 9 + ], + [ + "SCALE", + 9, + "-1" + ], + [ + "ADD", + 9, + 1, + "1" + ], + [ + "ADD", + 0, + 1, + "-1" + ], + [ + "SCALE", + 1, + "-1" + ], + [ + "ADD", + 1, + 0, + "1" + ], + [ + "ADD", + 1, + 7, + "-2" + ], + [ + "ADD", + 0, + 7, + "-1" + ], + [ + "SCALE", + 7, + "-1" + ], + [ + "SCALE", + 6, + "-1" + ], + [ + "ADD", + 7, + 6, + "1" + ], + [ + "SWAP", + 5, + 7 + ], + [ + "SWAP", + 4, + 6 + ], + [ + "SWAP", + 3, + 5 + ], + [ + "SWAP", + 2, + 4 + ], + [ + "SCALE", + 1, + "-1" + ], + [ + "SWAP", + 1, + 3 + ], + [ + "ADD", + 3, + 0, + "2" + ], + [ + "ADD", + 2, + 0, + "1" + ], + [ + "ADD", + 1, + 0, + "1" + ], + [ + "SWAP", + 0, + 15 + ], + [ + "SWAP", + 1, + 14 + ], + [ + "SWAP", + 14, + 15 + ], + [ + "ADD", + 0, + 14, + "1" + ], + [ + "ADD", + 15, + 1, + "-1" + ], + [ + "LAMBDA", + 14, + -1 + ], + [ + "QUERY", + 14, + 15, + -1 + ], + [ + "LAMBDA", + 14, + 1 + ], + [ + "ADD", + 15, + 1, + "1" + ], + [ + "ADD", + 0, + 14, + "-1" + ], + [ + "IDLE", + 14, + 15, + [ + 5, + 6, + 7, + 8 + ] + ], + [ + "SCALE", + 1, + "-1" + ], + [ + "SWAP", + 1, + 17 + ], + [ + "SWAP", + 0, + 16 + ], + [ + "SWAP", + 16, + 17 + ], + [ + "ADD", + 1, + 16, + "1" + ], + [ + "ADD", + 17, + 0, + "-1" + ], + [ + "LAMBDA", + 16, + -1 + ], + [ + "QUERY", + 16, + 17, + -1 + ], + [ + "LAMBDA", + 16, + 1 + ], + [ + "ADD", + 17, + 0, + "1" + ], + [ + "ADD", + 1, + 16, + "-1" + ], + [ + "IDLE", + 16, + 17, + [ + 5, + 6 + ] + ], + [ + "SCALE", + 0, + "-1" + ], + [ + "LAMBDA", + 0, + -1 + ], + [ + "LOCAL", + 5, + 1, + 0 + ], + [ + "LAMBDA", + 0, + 1 + ], + [ + "SCALE", + 0, + "-1" + ], + [ + "LAMBDA", + 1, + -1 + ], + [ + "LOCAL", + 6, + 0, + 1 + ], + [ + "LAMBDA", + 1, + 1 + ], + [ + "ADD", + 1, + 16, + "1" + ], + [ + "SCALE", + 16, + "-1" + ], + [ + "ADD", + 16, + 1, + "1" + ], + [ + "SWAP", + 0, + 17 + ], + [ + "SCALE", + 17, + "-1" + ], + [ + "ADD", + 17, + 0, + "1" + ], + [ + "SCALE", + 1, + "-1" + ], + [ + "SWAP", + 0, + 19 + ], + [ + "SWAP", + 1, + 18 + ], + [ + "SWAP", + 18, + 19 + ], + [ + "ADD", + 0, + 18, + "1" + ], + [ + "ADD", + 19, + 1, + "-1" + ], + [ + "LAMBDA", + 18, + -1 + ], + [ + "QUERY", + 18, + 19, + -1 + ], + [ + "LAMBDA", + 18, + 1 + ], + [ + "ADD", + 19, + 1, + "1" + ], + [ + "ADD", + 0, + 18, + "-1" + ], + [ + "IDLE", + 18, + 19, + [ + 7, + 8 + ] + ], + [ + "SCALE", + 1, + "-1" + ], + [ + "LAMBDA", + 1, + -1 + ], + [ + "LOCAL", + 7, + 0, + 1 + ], + [ + "LAMBDA", + 1, + 1 + ], + [ + "SCALE", + 1, + "-1" + ], + [ + "LAMBDA", + 0, + -1 + ], + [ + "LOCAL", + 8, + 1, + 0 + ], + [ + "LAMBDA", + 0, + 1 + ], + [ + "ADD", + 0, + 18, + "1" + ], + [ + "SCALE", + 18, + "-1" + ], + [ + "ADD", + 18, + 0, + "1" + ], + [ + "SWAP", + 1, + 19 + ], + [ + "SCALE", + 19, + "-1" + ], + [ + "ADD", + 19, + 1, + "1" + ], + [ + "ADD", + 0, + 14, + "1" + ], + [ + "SCALE", + 14, + "-1" + ], + [ + "ADD", + 14, + 0, + "1" + ], + [ + "SWAP", + 1, + 15 + ], + [ + "SCALE", + 15, + "-1" + ], + [ + "ADD", + 15, + 1, + "1" + ], + [ + "ADD", + 0, + 1, + "-1" + ], + [ + "IDLE_ONE", + 2, + [ + 5, + 6, + 7, + 8 + ] + ], + [ + "SCALE", + 1, + "-1" + ], + [ + "LAMBDA", + 1, + -1 + ], + [ + "LOCAL", + 9, + 0, + 1 + ], + [ + "LAMBDA", + 1, + 1 + ], + [ + "SCALE", + 1, + "-1" + ], + [ + "ADD", + 1, + 0, + "1" + ], + [ + "IDLE_ONE", + 2, + [ + 9 + ] + ], + [ + "IDLE_ONE", + 3, + [ + 5, + 6, + 7, + 8, + 9 + ] + ], + [ + "SWAP", + 6, + 7 + ], + [ + "SWAP", + 5, + 6 + ], + [ + "SWAP", + 4, + 7 + ], + [ + "SCALE", + 3, + "-1" + ], + [ + "SWAP", + 3, + 6 + ], + [ + "ADD", + 1, + 2, + "-2" + ], + [ + "ADD", + 0, + 2, + "-1" + ], + [ + "SCALE", + 2, + "-1" + ], + [ + "SWAP", + 2, + 7 + ], + [ + "ADD", + 0, + 1, + "-1" + ], + [ + "ADD", + 7, + 1, + "-1" + ], + [ + "SWAP", + 1, + 6 + ], + [ + "ADD", + 6, + 0, + "1" + ], + [ + "ADD", + 1, + 0, + "2" + ], + [ + "ADD", + 1, + 7, + "-1" + ], + [ + "ADD", + 1, + 6, + "-1" + ], + [ + "ADD", + 1, + 5, + "-2" + ], + [ + "ADD", + 0, + 5, + "-2" + ], + [ + "ADD", + 1, + 4, + "-2" + ], + [ + "ADD", + 0, + 4, + "-2" + ], + [ + "SCALE", + 3, + "-1" + ], + [ + "ADD", + 1, + 2, + "-1" + ], + [ + "SWAP", + 2, + 3 + ], + [ + "ADD", + 0, + 1, + "-1" + ], + [ + "ADD", + 5, + 1, + "2" + ], + [ + "ADD", + 4, + 1, + "-2" + ], + [ + "ADD", + 3, + 1, + "-2" + ], + [ + "SWAP", + 1, + 2 + ], + [ + "ADD", + 5, + 0, + "6" + ], + [ + "ADD", + 4, + 0, + "-6" + ], + [ + "ADD", + 3, + 0, + "-6" + ], + [ + "ADD", + 2, + 0, + "2" + ], + [ + "SWAP", + 0, + 2 + ], + [ + "ADD", + 2, + 0, + "1" + ], + [ + "SWAP", + 0, + 2 + ], + [ + "ADD", + 1, + 0, + "1" + ], + [ + "LAMBDA", + 0, + -1 + ], + [ + "QUERY", + 0, + 1, + -1 + ], + [ + "LAMBDA", + 0, + 1 + ], + [ + "ADD", + 0, + 1, + "-1" + ], + [ + "ADD", + 5, + 7, + "-4" + ], + [ + "ADD", + 4, + 7, + "4" + ], + [ + "ADD", + 3, + 7, + "4" + ], + [ + "ADD", + 2, + 7, + "-1" + ], + [ + "ADD", + 1, + 7, + "-2" + ], + [ + "ADD", + 0, + 7, + "-2" + ], + [ + "ADD", + 5, + 6, + "-4" + ], + [ + "ADD", + 4, + 6, + "4" + ], + [ + "ADD", + 3, + 6, + "4" + ], + [ + "ADD", + 2, + 6, + "-1" + ], + [ + "ADD", + 1, + 6, + "-2" + ], + [ + "ADD", + 0, + 6, + "-2" + ], + [ + "ADD", + 4, + 5, + "1" + ], + [ + "SCALE", + 5, + "-1" + ], + [ + "ADD", + 3, + 4, + "-4" + ], + [ + "ADD", + 2, + 4, + "2" + ], + [ + "ADD", + 1, + 4, + "2" + ], + [ + "ADD", + 0, + 4, + "2" + ], + [ + "SCALE", + 4, + "-1" + ], + [ + "ADD", + 5, + 4, + "2" + ], + [ + "SWAP", + 4, + 5 + ], + [ + "ADD", + 5, + 4, + "1" + ], + [ + "SWAP", + 4, + 5 + ], + [ + "ADD", + 5, + 4, + "-2" + ], + [ + "ADD", + 1, + 2, + "-2" + ], + [ + "ADD", + 0, + 2, + "-2" + ], + [ + "ADD", + 5, + 2, + "-4" + ], + [ + "ADD", + 4, + 2, + "4" + ], + [ + "ADD", + 3, + 2, + "3" + ], + [ + "SWAP", + 2, + 3 + ], + [ + "ADD", + 3, + 2, + "1" + ], + [ + "SWAP", + 2, + 3 + ], + [ + "SCALE", + 1, + "-1" + ], + [ + "SWAP", + 1, + 3 + ], + [ + "SCALE", + 0, + "-1" + ], + [ + "ADD", + 5, + 0, + "2" + ], + [ + "ADD", + 4, + 0, + "-2" + ], + [ + "ADD", + 3, + 0, + "-1" + ], + [ + "ADD", + 2, + 0, + "-2" + ], + [ + "ADD", + 1, + 7, + "-1" + ], + [ + "ADD", + 1, + 6, + "-1" + ], + [ + "ADD", + 1, + 5, + "1" + ], + [ + "ADD", + 1, + 4, + "1" + ], + [ + "SCALE", + 3, + "-1" + ], + [ + "ADD", + 1, + 2, + "-1" + ], + [ + "SCALE", + 1, + "-1" + ], + [ + "ADD", + 3, + 1, + "3" + ], + [ + "SWAP", + 1, + 3 + ], + [ + "SCALE", + 0, + "-1" + ], + [ + "ADD", + 5, + 0, + "2" + ], + [ + "ADD", + 4, + 0, + "-2" + ], + [ + "ADD", + 3, + 0, + "-2" + ], + [ + "ADD", + 2, + 0, + "-2" + ], + [ + "ADD", + 1, + 0, + "-4" + ], + [ + "LAMBDA", + 0, + -1 + ], + [ + "QUERY", + 0, + 1, + -1 + ], + [ + "LAMBDA", + 0, + 1 + ], + [ + "ADD", + 0, + 1, + "-1" + ], + [ + "ADD", + 3, + 7, + "-1" + ], + [ + "ADD", + 1, + 7, + "-3" + ], + [ + "ADD", + 3, + 6, + "-1" + ], + [ + "ADD", + 1, + 6, + "-3" + ], + [ + "ADD", + 3, + 5, + "1" + ], + [ + "ADD", + 1, + 5, + "3" + ], + [ + "ADD", + 3, + 4, + "1" + ], + [ + "ADD", + 1, + 4, + "3" + ], + [ + "ADD", + 1, + 3, + "-3" + ], + [ + "SCALE", + 3, + "-1" + ], + [ + "ADD", + 3, + 2, + "1" + ], + [ + "SCALE", + 1, + "-1" + ], + [ + "SWAP", + 1, + 3 + ], + [ + "SCALE", + 0, + "-1" + ], + [ + "ADD", + 5, + 0, + "2" + ], + [ + "ADD", + 4, + 0, + "-2" + ], + [ + "ADD", + 3, + 0, + "-2" + ], + [ + "ADD", + 2, + 0, + "-2" + ], + [ + "ADD", + 6, + 7, + "1" + ], + [ + "ADD", + 5, + 7, + "1" + ], + [ + "ADD", + 4, + 7, + "-1" + ], + [ + "ADD", + 3, + 7, + "-1" + ], + [ + "ADD", + 2, + 7, + "-1" + ], + [ + "ADD", + 1, + 7, + "-1" + ], + [ + "ADD", + 1, + 6, + "-1" + ], + [ + "SWAP", + 6, + 7 + ], + [ + "ADD", + 1, + 5, + "-2" + ], + [ + "ADD", + 0, + 5, + "-2" + ], + [ + "SWAP", + 5, + 6 + ], + [ + "ADD", + 1, + 4, + "-2" + ], + [ + "ADD", + 0, + 4, + "-2" + ], + [ + "SWAP", + 4, + 5 + ], + [ + "SWAP", + 3, + 4 + ], + [ + "ADD", + 1, + 2, + "-1" + ], + [ + "SWAP", + 2, + 3 + ], + [ + "ADD", + 0, + 1, + "-1" + ], + [ + "SWAP", + 1, + 2 + ], + [ + "ADD", + 2, + 0, + "2" + ], + [ + "SWAP", + 0, + 2 + ], + [ + "ADD", + 2, + 0, + "1" + ], + [ + "SWAP", + 0, + 2 + ], + [ + "ADD", + 2, + 0, + "-1" + ], + [ + "SWAP", + 0, + 1 + ], + [ + "LAMBDA", + 0, + -1 + ], + [ + "QUERY", + 0, + 1, + -1 + ], + [ + "LAMBDA", + 0, + 1 + ], + [ + "ADD", + 0, + 1, + "-1" + ], + [ + "ADD", + 6, + 7, + "-1" + ], + [ + "ADD", + 5, + 7, + "1" + ], + [ + "ADD", + 4, + 7, + "1" + ], + [ + "ADD", + 3, + 7, + "1" + ], + [ + "ADD", + 2, + 7, + "1" + ], + [ + "ADD", + 1, + 7, + "-2" + ], + [ + "ADD", + 0, + 7, + "-1" + ], + [ + "ADD", + 5, + 6, + "1" + ], + [ + "ADD", + 4, + 6, + "1" + ], + [ + "ADD", + 3, + 6, + "1" + ], + [ + "ADD", + 0, + 6, + "-1" + ], + [ + "SCALE", + 6, + "-1" + ], + [ + "ADD", + 7, + 6, + "-1" + ], + [ + "ADD", + 4, + 5, + "-1" + ], + [ + "ADD", + 3, + 5, + "-1" + ], + [ + "ADD", + 1, + 5, + "2" + ], + [ + "ADD", + 0, + 5, + "1" + ], + [ + "ADD", + 7, + 5, + "-1" + ], + [ + "ADD", + 6, + 5, + "1" + ], + [ + "ADD", + 3, + 4, + "-1" + ], + [ + "ADD", + 0, + 4, + "1" + ], + [ + "SCALE", + 4, + "-1" + ], + [ + "ADD", + 7, + 4, + "1" + ], + [ + "ADD", + 6, + 4, + "-1" + ], + [ + "ADD", + 5, + 4, + "-1" + ], + [ + "ADD", + 0, + 3, + "1" + ], + [ + "SCALE", + 3, + "-1" + ], + [ + "ADD", + 7, + 3, + "1" + ], + [ + "ADD", + 6, + 3, + "-1" + ], + [ + "ADD", + 5, + 3, + "-1" + ], + [ + "ADD", + 4, + 3, + "1" + ], + [ + "ADD", + 1, + 2, + "2" + ], + [ + "ADD", + 0, + 2, + "1" + ], + [ + "SCALE", + 2, + "-1" + ], + [ + "ADD", + 7, + 2, + "1" + ], + [ + "ADD", + 6, + 2, + "-1" + ], + [ + "ADD", + 5, + 2, + "-1" + ], + [ + "ADD", + 4, + 2, + "1" + ], + [ + "ADD", + 3, + 2, + "1" + ], + [ + "ADD", + 0, + 1, + "1" + ], + [ + "ADD", + 7, + 1, + "-1" + ], + [ + "ADD", + 6, + 1, + "1" + ], + [ + "ADD", + 5, + 1, + "1" + ], + [ + "ADD", + 4, + 1, + "-1" + ], + [ + "ADD", + 3, + 1, + "-1" + ], + [ + "ADD", + 2, + 1, + "-1" + ], + [ + "ADD", + 7, + 0, + "1" + ], + [ + "ADD", + 6, + 0, + "-1" + ], + [ + "ADD", + 5, + 0, + "-1" + ], + [ + "ADD", + 4, + 0, + "1" + ], + [ + "ADD", + 3, + 0, + "1" + ], + [ + "ADD", + 2, + 0, + "1" + ], + [ + "SWAP", + 0, + 1 + ], + [ + "ADD", + 4, + 5, + "1" + ], + [ + "ADD", + 2, + 5, + "2" + ], + [ + "ADD", + 0, + 5, + "-1" + ], + [ + "ADD", + 2, + 4, + "-4" + ], + [ + "ADD", + 0, + 4, + "2" + ], + [ + "SCALE", + 4, + "-1" + ], + [ + "ADD", + 5, + 4, + "1" + ], + [ + "SWAP", + 3, + 5 + ], + [ + "SCALE", + 2, + "-1" + ], + [ + "SWAP", + 2, + 3 + ], + [ + "SWAP", + 1, + 4 + ], + [ + "ADD", + 3, + 0, + "-2" + ], + [ + "ADD", + 2, + 0, + "1" + ], + [ + "ADD", + 1, + 0, + "1" + ], + [ + "LAMBDA", + 0, + -1 + ], + [ + "LOCAL", + 10, + 1, + 0 + ], + [ + "LAMBDA", + 0, + 1 + ], + [ + "ADD", + 0, + 1, + "-1" + ], + [ + "IDLE_ONE", + 2, + [ + 10 + ] + ], + [ + "SCALE", + 1, + "-1" + ], + [ + "SWAP", + 1, + 21 + ], + [ + "SWAP", + 0, + 20 + ], + [ + "SWAP", + 20, + 21 + ], + [ + "ADD", + 1, + 20, + "1" + ], + [ + "ADD", + 21, + 0, + "-1" + ], + [ + "LAMBDA", + 20, + -1 + ], + [ + "QUERY", + 20, + 21, + -1 + ], + [ + "LAMBDA", + 20, + 1 + ], + [ + "ADD", + 21, + 0, + "1" + ], + [ + "ADD", + 1, + 20, + "-1" + ], + [ + "IDLE", + 20, + 21, + [ + 11, + 12, + 13, + 14 + ] + ], + [ + "SCALE", + 0, + "-1" + ], + [ + "SWAP", + 0, + 23 + ], + [ + "SWAP", + 1, + 22 + ], + [ + "SWAP", + 22, + 23 + ], + [ + "ADD", + 0, + 22, + "1" + ], + [ + "ADD", + 23, + 1, + "-1" + ], + [ + "LAMBDA", + 22, + -1 + ], + [ + "QUERY", + 22, + 23, + -1 + ], + [ + "LAMBDA", + 22, + 1 + ], + [ + "ADD", + 23, + 1, + "1" + ], + [ + "ADD", + 0, + 22, + "-1" + ], + [ + "IDLE", + 22, + 23, + [ + 11, + 12 + ] + ], + [ + "SCALE", + 1, + "-1" + ], + [ + "LAMBDA", + 1, + -1 + ], + [ + "LOCAL", + 11, + 0, + 1 + ], + [ + "LAMBDA", + 1, + 1 + ], + [ + "SCALE", + 1, + "-1" + ], + [ + "LAMBDA", + 0, + -1 + ], + [ + "LOCAL", + 12, + 1, + 0 + ], + [ + "LAMBDA", + 0, + 1 + ], + [ + "ADD", + 0, + 22, + "1" + ], + [ + "SCALE", + 22, + "-1" + ], + [ + "ADD", + 22, + 0, + "1" + ], + [ + "SWAP", + 1, + 23 + ], + [ + "SCALE", + 23, + "-1" + ], + [ + "ADD", + 23, + 1, + "1" + ], + [ + "SCALE", + 0, + "-1" + ], + [ + "SWAP", + 1, + 25 + ], + [ + "SWAP", + 0, + 24 + ], + [ + "SWAP", + 24, + 25 + ], + [ + "ADD", + 1, + 24, + "1" + ], + [ + "ADD", + 25, + 0, + "-1" + ], + [ + "LAMBDA", + 24, + -1 + ], + [ + "QUERY", + 24, + 25, + -1 + ], + [ + "LAMBDA", + 24, + 1 + ], + [ + "ADD", + 25, + 0, + "1" + ], + [ + "ADD", + 1, + 24, + "-1" + ], + [ + "IDLE", + 24, + 25, + [ + 13, + 14 + ] + ], + [ + "SCALE", + 0, + "-1" + ], + [ + "LAMBDA", + 0, + -1 + ], + [ + "LOCAL", + 13, + 1, + 0 + ], + [ + "LAMBDA", + 0, + 1 + ], + [ + "SCALE", + 0, + "-1" + ], + [ + "LAMBDA", + 1, + -1 + ], + [ + "LOCAL", + 14, + 0, + 1 + ], + [ + "LAMBDA", + 1, + 1 + ], + [ + "ADD", + 1, + 24, + "1" + ], + [ + "SCALE", + 24, + "-1" + ], + [ + "ADD", + 24, + 1, + "1" + ], + [ + "SWAP", + 0, + 25 + ], + [ + "SCALE", + 25, + "-1" + ], + [ + "ADD", + 25, + 0, + "1" + ], + [ + "ADD", + 1, + 20, + "1" + ], + [ + "SCALE", + 20, + "-1" + ], + [ + "ADD", + 20, + 1, + "1" + ], + [ + "SWAP", + 0, + 21 + ], + [ + "SCALE", + 21, + "-1" + ], + [ + "ADD", + 21, + 0, + "1" + ], + [ + "SCALE", + 1, + "-1" + ], + [ + "ADD", + 1, + 0, + "1" + ], + [ + "IDLE_ONE", + 2, + [ + 11, + 12, + 13, + 14 + ] + ], + [ + "IDLE_ONE", + 3, + [ + 10, + 11, + 12, + 13, + 14 + ] + ], + [ + "SCALE", + 3, + "-1" + ], + [ + "SWAP", + 3, + 5 + ], + [ + "ADD", + 0, + 2, + "-1" + ], + [ + "SWAP", + 2, + 5 + ], + [ + "ADD", + 0, + 1, + "-1" + ], + [ + "ADD", + 5, + 1, + "-1" + ], + [ + "SWAP", + 1, + 4 + ], + [ + "SCALE", + 0, + "-1" + ], + [ + "ADD", + 4, + 0, + "-1" + ], + [ + "ADD", + 2, + 0, + "-2" + ], + [ + "SWAP", + 1, + 2 + ], + [ + "SCALE", + 0, + "-1" + ], + [ + "ADD", + 1, + 0, + "-1" + ], + [ + "SWAP", + 0, + 27 + ], + [ + "SWAP", + 1, + 26 + ], + [ + "SWAP", + 26, + 27 + ], + [ + "ADD", + 0, + 26, + "1" + ], + [ + "ADD", + 27, + 1, + "-1" + ], + [ + "LAMBDA", + 26, + -1 + ], + [ + "QUERY", + 26, + 27, + -1 + ], + [ + "LAMBDA", + 26, + 1 + ], + [ + "ADD", + 27, + 1, + "1" + ], + [ + "ADD", + 0, + 26, + "-1" + ], + [ + "IDLE", + 26, + 27, + [ + 15, + 16, + 17, + 18 + ] + ], + [ + "SCALE", + 1, + "-1" + ], + [ + "SWAP", + 1, + 29 + ], + [ + "SWAP", + 0, + 28 + ], + [ + "SWAP", + 28, + 29 + ], + [ + "ADD", + 1, + 28, + "1" + ], + [ + "ADD", + 29, + 0, + "-1" + ], + [ + "LAMBDA", + 28, + -1 + ], + [ + "QUERY", + 28, + 29, + -1 + ], + [ + "LAMBDA", + 28, + 1 + ], + [ + "ADD", + 29, + 0, + "1" + ], + [ + "ADD", + 1, + 28, + "-1" + ], + [ + "IDLE", + 28, + 29, + [ + 15, + 16 + ] + ], + [ + "SCALE", + 0, + "-1" + ], + [ + "LAMBDA", + 0, + -1 + ], + [ + "LOCAL", + 15, + 1, + 0 + ], + [ + "LAMBDA", + 0, + 1 + ], + [ + "SCALE", + 0, + "-1" + ], + [ + "LAMBDA", + 1, + -1 + ], + [ + "LOCAL", + 16, + 0, + 1 + ], + [ + "LAMBDA", + 1, + 1 + ], + [ + "ADD", + 1, + 28, + "1" + ], + [ + "SCALE", + 28, + "-1" + ], + [ + "ADD", + 28, + 1, + "1" + ], + [ + "SWAP", + 0, + 29 + ], + [ + "SCALE", + 29, + "-1" + ], + [ + "ADD", + 29, + 0, + "1" + ], + [ + "SCALE", + 1, + "-1" + ], + [ + "SWAP", + 0, + 31 + ], + [ + "SWAP", + 1, + 30 + ], + [ + "SWAP", + 30, + 31 + ], + [ + "ADD", + 0, + 30, + "1" + ], + [ + "ADD", + 31, + 1, + "-1" + ], + [ + "LAMBDA", + 30, + -1 + ], + [ + "QUERY", + 30, + 31, + -1 + ], + [ + "LAMBDA", + 30, + 1 + ], + [ + "ADD", + 31, + 1, + "1" + ], + [ + "ADD", + 0, + 30, + "-1" + ], + [ + "IDLE", + 30, + 31, + [ + 17, + 18 + ] + ], + [ + "SCALE", + 1, + "-1" + ], + [ + "LAMBDA", + 1, + -1 + ], + [ + "LOCAL", + 17, + 0, + 1 + ], + [ + "LAMBDA", + 1, + 1 + ], + [ + "SCALE", + 1, + "-1" + ], + [ + "LAMBDA", + 0, + -1 + ], + [ + "LOCAL", + 18, + 1, + 0 + ], + [ + "LAMBDA", + 0, + 1 + ], + [ + "ADD", + 0, + 30, + "1" + ], + [ + "SCALE", + 30, + "-1" + ], + [ + "ADD", + 30, + 0, + "1" + ], + [ + "SWAP", + 1, + 31 + ], + [ + "SCALE", + 31, + "-1" + ], + [ + "ADD", + 31, + 1, + "1" + ], + [ + "ADD", + 0, + 26, + "1" + ], + [ + "SCALE", + 26, + "-1" + ], + [ + "ADD", + 26, + 0, + "1" + ], + [ + "SWAP", + 1, + 27 + ], + [ + "SCALE", + 27, + "-1" + ], + [ + "ADD", + 27, + 1, + "1" + ], + [ + "ADD", + 0, + 1, + "-1" + ], + [ + "SWAP", + 1, + 2 + ], + [ + "SCALE", + 0, + "-1" + ], + [ + "ADD", + 2, + 0, + "-1" + ], + [ + "LAMBDA", + 0, + -1 + ], + [ + "LAMBDA", + 1, + -1 + ], + [ + "LAMBDA", + 2, + -1 + ], + [ + "LAMBDA", + 3, + -1 + ], + [ + "LAMBDA", + 4, + -1 + ], + [ + "LAMBDA", + 5, + -1 + ], + [ + "LAMBDA", + 6, + -1 + ], + [ + "LAMBDA", + 7, + -1 + ], + [ + "LAMBDA", + 8, + -1 + ], + [ + "LAMBDA", + 9, + -1 + ], + [ + "LAMBDA", + 10, + -1 + ], + [ + "LAMBDA", + 11, + -1 + ], + [ + "LAMBDA", + 12, + -1 + ], + [ + "LAMBDA", + 13, + -1 + ], + [ + "LAMBDA", + 14, + -1 + ], + [ + "LAMBDA", + 15, + -1 + ], + [ + "LAMBDA", + 16, + -1 + ], + [ + "LAMBDA", + 17, + -1 + ], + [ + "LAMBDA", + 18, + -1 + ], + [ + "LAMBDA", + 19, + -1 + ], + [ + "LAMBDA", + 20, + -1 + ], + [ + "LAMBDA", + 21, + -1 + ], + [ + "LAMBDA", + 22, + -1 + ], + [ + "LAMBDA", + 23, + -1 + ], + [ + "LAMBDA", + 24, + -1 + ], + [ + "LAMBDA", + 25, + -1 + ], + [ + "LAMBDA", + 26, + -1 + ], + [ + "LAMBDA", + 27, + -1 + ], + [ + "LAMBDA", + 28, + -1 + ], + [ + "LAMBDA", + 29, + -1 + ], + [ + "LAMBDA", + 30, + -1 + ], + [ + "LAMBDA", + 31, + -1 + ] + ], + "diagonal": [ + [ + -1, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + [ + -1, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1 + ] + ], + "nodes": [ + { + "roles": [ + 8, + 9 + ], + "stages": [ + 1, + 2, + 3, + 4 + ] + }, + { + "roles": [ + 10, + 11 + ], + "stages": [ + 1, + 2 + ] + }, + { + "roles": [ + 12, + 13 + ], + "stages": [ + 3, + 4 + ] + }, + { + "roles": [ + 14, + 15 + ], + "stages": [ + 5, + 6, + 7, + 8 + ] + }, + { + "roles": [ + 16, + 17 + ], + "stages": [ + 5, + 6 + ] + }, + { + "roles": [ + 18, + 19 + ], + "stages": [ + 7, + 8 + ] + }, + { + "roles": [ + 20, + 21 + ], + "stages": [ + 11, + 12, + 13, + 14 + ] + }, + { + "roles": [ + 22, + 23 + ], + "stages": [ + 11, + 12 + ] + }, + { + "roles": [ + 24, + 25 + ], + "stages": [ + 13, + 14 + ] + }, + { + "roles": [ + 26, + 27 + ], + "stages": [ + 15, + 16, + 17, + 18 + ] + }, + { + "roles": [ + 28, + 29 + ], + "stages": [ + 15, + 16 + ] + }, + { + "roles": [ + 30, + 31 + ], + "stages": [ + 17, + 18 + ] + } + ] +} diff --git a/research/native-retimed-helper-split/retained/caller/CONTROLLER.json b/research/native-retimed-helper-split/retained/caller/CONTROLLER.json new file mode 100644 index 0000000000..1c16cfbedc --- /dev/null +++ b/research/native-retimed-helper-split/retained/caller/CONTROLLER.json @@ -0,0 +1,4308 @@ +{ + "schema": "two-paid-fragments-two-independent-retirements/1", + "roles": 34, + "stages": 18, + "ambient_rank": 153, + "events": [ + [ + "SCALE", + 5, + "-1" + ], + [ + "SCALE", + 4, + "-1" + ], + [ + "ADD", + 5, + 4, + "-2" + ], + [ + "ADD", + 6, + 7, + "1" + ], + [ + "SCALE", + 6, + "-1" + ], + [ + "ADD", + 7, + 6, + "2" + ], + [ + "SWAP", + 6, + 7 + ], + [ + "ADD", + 7, + 6, + "-1" + ], + [ + "SCALE", + 1, + "-1" + ], + [ + "ADD", + 1, + 0, + "1" + ], + [ + "SWAP", + 0, + 9 + ], + [ + "SWAP", + 1, + 8 + ], + [ + "SWAP", + 8, + 9 + ], + [ + "ADD", + 0, + 8, + "1" + ], + [ + "ADD", + 9, + 1, + "-1" + ], + [ + "LAMBDA", + 8, + -1 + ], + [ + "QUERY", + 8, + 9, + -1 + ], + [ + "LAMBDA", + 8, + 1 + ], + [ + "ADD", + 9, + 1, + "1" + ], + [ + "ADD", + 0, + 8, + "-1" + ], + [ + "IDLE", + 8, + 9, + [ + 1, + 2, + 3, + 4 + ] + ], + [ + "SCALE", + 1, + "-1" + ], + [ + "SWAP", + 1, + 11 + ], + [ + "SWAP", + 0, + 10 + ], + [ + "SWAP", + 10, + 11 + ], + [ + "ADD", + 1, + 10, + "1" + ], + [ + "ADD", + 11, + 0, + "-1" + ], + [ + "LAMBDA", + 10, + -1 + ], + [ + "QUERY", + 10, + 11, + -1 + ], + [ + "LAMBDA", + 10, + 1 + ], + [ + "ADD", + 11, + 0, + "1" + ], + [ + "ADD", + 1, + 10, + "-1" + ], + [ + "IDLE", + 10, + 11, + [ + 1, + 2 + ] + ], + [ + "SCALE", + 0, + "-1" + ], + [ + "LAMBDA", + 0, + -1 + ], + [ + "LOCAL", + 1, + 1, + 0 + ], + [ + "LAMBDA", + 0, + 1 + ], + [ + "SCALE", + 0, + "-1" + ], + [ + "LAMBDA", + 1, + -1 + ], + [ + "LOCAL", + 2, + 0, + 1 + ], + [ + "LAMBDA", + 1, + 1 + ], + [ + "ADD", + 1, + 10, + "1" + ], + [ + "SCALE", + 10, + "-1" + ], + [ + "ADD", + 10, + 1, + "1" + ], + [ + "SWAP", + 0, + 11 + ], + [ + "SCALE", + 11, + "-1" + ], + [ + "ADD", + 11, + 0, + "1" + ], + [ + "SCALE", + 1, + "-1" + ], + [ + "SWAP", + 0, + 13 + ], + [ + "SWAP", + 1, + 12 + ], + [ + "SWAP", + 12, + 13 + ], + [ + "ADD", + 0, + 12, + "1" + ], + [ + "ADD", + 13, + 1, + "-1" + ], + [ + "LAMBDA", + 12, + -1 + ], + [ + "QUERY", + 12, + 13, + -1 + ], + [ + "LAMBDA", + 12, + 1 + ], + [ + "ADD", + 13, + 1, + "1" + ], + [ + "ADD", + 0, + 12, + "-1" + ], + [ + "IDLE", + 12, + 13, + [ + 3, + 4 + ] + ], + [ + "SCALE", + 1, + "-1" + ], + [ + "LAMBDA", + 1, + -1 + ], + [ + "LOCAL", + 3, + 0, + 1 + ], + [ + "LAMBDA", + 1, + 1 + ], + [ + "SCALE", + 1, + "-1" + ], + [ + "LAMBDA", + 0, + -1 + ], + [ + "LOCAL", + 4, + 1, + 0 + ], + [ + "LAMBDA", + 0, + 1 + ], + [ + "ADD", + 0, + 12, + "1" + ], + [ + "SCALE", + 12, + "-1" + ], + [ + "ADD", + 12, + 0, + "1" + ], + [ + "SWAP", + 1, + 13 + ], + [ + "SCALE", + 13, + "-1" + ], + [ + "ADD", + 13, + 1, + "1" + ], + [ + "ADD", + 0, + 8, + "1" + ], + [ + "SCALE", + 8, + "-1" + ], + [ + "ADD", + 8, + 0, + "1" + ], + [ + "SWAP", + 1, + 9 + ], + [ + "SCALE", + 9, + "-1" + ], + [ + "ADD", + 9, + 1, + "1" + ], + [ + "ADD", + 0, + 1, + "-1" + ], + [ + "SCALE", + 1, + "-1" + ], + [ + "ADD", + 1, + 0, + "1" + ], + [ + "ADD", + 1, + 7, + "-2" + ], + [ + "ADD", + 0, + 7, + "-1" + ], + [ + "SCALE", + 7, + "-1" + ], + [ + "SCALE", + 6, + "-1" + ], + [ + "ADD", + 7, + 6, + "1" + ], + [ + "SWAP", + 5, + 7 + ], + [ + "SWAP", + 4, + 6 + ], + [ + "SWAP", + 3, + 5 + ], + [ + "SWAP", + 2, + 4 + ], + [ + "SCALE", + 1, + "-1" + ], + [ + "SWAP", + 1, + 3 + ], + [ + "ADD", + 3, + 0, + "2" + ], + [ + "ADD", + 2, + 0, + "1" + ], + [ + "ADD", + 1, + 0, + "1" + ], + [ + "SWAP", + 0, + 15 + ], + [ + "SWAP", + 1, + 14 + ], + [ + "SWAP", + 14, + 15 + ], + [ + "ADD", + 0, + 14, + "1" + ], + [ + "ADD", + 15, + 1, + "-1" + ], + [ + "LAMBDA", + 14, + -1 + ], + [ + "QUERY", + 14, + 15, + -1 + ], + [ + "LAMBDA", + 14, + 1 + ], + [ + "ADD", + 15, + 1, + "1" + ], + [ + "ADD", + 0, + 14, + "-1" + ], + [ + "IDLE", + 14, + 15, + [ + 5, + 6, + 7, + 8 + ] + ], + [ + "SCALE", + 1, + "-1" + ], + [ + "SWAP", + 1, + 17 + ], + [ + "SWAP", + 0, + 16 + ], + [ + "SWAP", + 16, + 17 + ], + [ + "ADD", + 1, + 16, + "1" + ], + [ + "ADD", + 17, + 0, + "-1" + ], + [ + "LAMBDA", + 16, + -1 + ], + [ + "QUERY", + 16, + 17, + -1 + ], + [ + "LAMBDA", + 16, + 1 + ], + [ + "ADD", + 17, + 0, + "1" + ], + [ + "ADD", + 1, + 16, + "-1" + ], + [ + "IDLE", + 16, + 17, + [ + 5, + 6 + ] + ], + [ + "SCALE", + 0, + "-1" + ], + [ + "LAMBDA", + 0, + -1 + ], + [ + "LOCAL", + 5, + 1, + 0 + ], + [ + "LAMBDA", + 0, + 1 + ], + [ + "SCALE", + 0, + "-1" + ], + [ + "LAMBDA", + 1, + -1 + ], + [ + "LOCAL", + 6, + 0, + 1 + ], + [ + "LAMBDA", + 1, + 1 + ], + [ + "ADD", + 1, + 16, + "1" + ], + [ + "SCALE", + 16, + "-1" + ], + [ + "ADD", + 16, + 1, + "1" + ], + [ + "SWAP", + 0, + 17 + ], + [ + "SCALE", + 17, + "-1" + ], + [ + "ADD", + 17, + 0, + "1" + ], + [ + "SCALE", + 1, + "-1" + ], + [ + "SWAP", + 0, + 19 + ], + [ + "SWAP", + 1, + 18 + ], + [ + "SWAP", + 18, + 19 + ], + [ + "ADD", + 0, + 18, + "1" + ], + [ + "ADD", + 19, + 1, + "-1" + ], + [ + "LAMBDA", + 18, + -1 + ], + [ + "QUERY", + 18, + 19, + -1 + ], + [ + "LAMBDA", + 18, + 1 + ], + [ + "ADD", + 19, + 1, + "1" + ], + [ + "ADD", + 0, + 18, + "-1" + ], + [ + "IDLE", + 18, + 19, + [ + 7, + 8 + ] + ], + [ + "SCALE", + 1, + "-1" + ], + [ + "LAMBDA", + 1, + -1 + ], + [ + "LOCAL", + 7, + 0, + 1 + ], + [ + "LAMBDA", + 1, + 1 + ], + [ + "SCALE", + 1, + "-1" + ], + [ + "LAMBDA", + 0, + -1 + ], + [ + "LOCAL", + 8, + 1, + 0 + ], + [ + "LAMBDA", + 0, + 1 + ], + [ + "ADD", + 0, + 18, + "1" + ], + [ + "SCALE", + 18, + "-1" + ], + [ + "ADD", + 18, + 0, + "1" + ], + [ + "SWAP", + 1, + 19 + ], + [ + "SCALE", + 19, + "-1" + ], + [ + "ADD", + 19, + 1, + "1" + ], + [ + "ADD", + 0, + 14, + "1" + ], + [ + "SCALE", + 14, + "-1" + ], + [ + "ADD", + 14, + 0, + "1" + ], + [ + "SWAP", + 1, + 15 + ], + [ + "SCALE", + 15, + "-1" + ], + [ + "ADD", + 15, + 1, + "1" + ], + [ + "ADD", + 0, + 1, + "-1" + ], + [ + "IDLE_ONE", + 2, + [ + 5, + 6, + 7, + 8 + ] + ], + [ + "ADD", + 0, + 2, + "1" + ], + [ + "ADD", + 2, + 1, + "-1" + ], + [ + "SWAP", + 2, + 6 + ], + [ + "SWAP", + 2, + 32 + ], + [ + "ADD", + 2, + 1, + "1" + ], + [ + "ADD", + 0, + 2, + "-1" + ], + [ + "SCALE", + 1, + "-1" + ], + [ + "LAMBDA", + 1, + -1 + ], + [ + "LOCAL", + 9, + 0, + 1 + ], + [ + "LAMBDA", + 1, + 1 + ], + [ + "SCALE", + 1, + "-1" + ], + [ + "ADD", + 1, + 0, + "1" + ], + [ + "IDLE_ONE", + 2, + [ + 9 + ] + ], + [ + "IDLE_ONE", + 3, + [ + 5, + 6, + 7, + 8, + 9 + ] + ], + [ + "SWAP", + 32, + 7 + ], + [ + "SWAP", + 5, + 32 + ], + [ + "SWAP", + 4, + 7 + ], + [ + "SCALE", + 3, + "-1" + ], + [ + "SWAP", + 3, + 32 + ], + [ + "ADD", + 1, + 2, + "-2" + ], + [ + "ADD", + 0, + 2, + "-1" + ], + [ + "SCALE", + 2, + "-1" + ], + [ + "SWAP", + 2, + 7 + ], + [ + "ADD", + 0, + 1, + "-1" + ], + [ + "ADD", + 7, + 1, + "-1" + ], + [ + "SWAP", + 1, + 32 + ], + [ + "ADD", + 32, + 0, + "1" + ], + [ + "ADD", + 1, + 0, + "2" + ], + [ + "ADD", + 1, + 7, + "-1" + ], + [ + "ADD", + 1, + 32, + "-1" + ], + [ + "ADD", + 1, + 5, + "-2" + ], + [ + "ADD", + 0, + 5, + "-2" + ], + [ + "ADD", + 1, + 4, + "-2" + ], + [ + "ADD", + 0, + 4, + "-2" + ], + [ + "SCALE", + 3, + "-1" + ], + [ + "ADD", + 1, + 2, + "-1" + ], + [ + "SWAP", + 2, + 3 + ], + [ + "ADD", + 0, + 1, + "-1" + ], + [ + "ADD", + 5, + 1, + "2" + ], + [ + "ADD", + 4, + 1, + "-2" + ], + [ + "ADD", + 3, + 1, + "-2" + ], + [ + "SWAP", + 1, + 2 + ], + [ + "ADD", + 5, + 0, + "6" + ], + [ + "ADD", + 4, + 0, + "-6" + ], + [ + "ADD", + 3, + 0, + "-6" + ], + [ + "ADD", + 2, + 0, + "2" + ], + [ + "SWAP", + 0, + 2 + ], + [ + "ADD", + 2, + 0, + "1" + ], + [ + "SWAP", + 0, + 2 + ], + [ + "ADD", + 1, + 0, + "1" + ], + [ + "LAMBDA", + 0, + -1 + ], + [ + "QUERY", + 0, + 1, + -1 + ], + [ + "LAMBDA", + 0, + 1 + ], + [ + "ADD", + 0, + 1, + "-1" + ], + [ + "ADD", + 5, + 7, + "-4" + ], + [ + "ADD", + 4, + 7, + "4" + ], + [ + "ADD", + 3, + 7, + "4" + ], + [ + "ADD", + 2, + 7, + "-1" + ], + [ + "ADD", + 1, + 7, + "-2" + ], + [ + "ADD", + 0, + 7, + "-2" + ], + [ + "ADD", + 5, + 32, + "-4" + ], + [ + "ADD", + 4, + 32, + "4" + ], + [ + "ADD", + 3, + 32, + "4" + ], + [ + "ADD", + 2, + 32, + "-1" + ], + [ + "ADD", + 1, + 32, + "-2" + ], + [ + "ADD", + 0, + 32, + "-2" + ], + [ + "ADD", + 4, + 5, + "1" + ], + [ + "SCALE", + 5, + "-1" + ], + [ + "ADD", + 3, + 4, + "-4" + ], + [ + "ADD", + 2, + 4, + "2" + ], + [ + "ADD", + 1, + 4, + "2" + ], + [ + "ADD", + 0, + 4, + "2" + ], + [ + "SCALE", + 4, + "-1" + ], + [ + "ADD", + 5, + 4, + "2" + ], + [ + "SWAP", + 4, + 5 + ], + [ + "ADD", + 5, + 4, + "1" + ], + [ + "SWAP", + 4, + 5 + ], + [ + "ADD", + 5, + 4, + "-2" + ], + [ + "ADD", + 1, + 2, + "-2" + ], + [ + "ADD", + 0, + 2, + "-2" + ], + [ + "ADD", + 5, + 2, + "-4" + ], + [ + "ADD", + 4, + 2, + "4" + ], + [ + "ADD", + 3, + 2, + "3" + ], + [ + "SWAP", + 2, + 3 + ], + [ + "ADD", + 3, + 2, + "1" + ], + [ + "SWAP", + 2, + 3 + ], + [ + "SCALE", + 1, + "-1" + ], + [ + "SWAP", + 1, + 3 + ], + [ + "SCALE", + 0, + "-1" + ], + [ + "ADD", + 5, + 0, + "2" + ], + [ + "ADD", + 4, + 0, + "-2" + ], + [ + "ADD", + 3, + 0, + "-1" + ], + [ + "ADD", + 2, + 0, + "-2" + ], + [ + "ADD", + 1, + 7, + "-1" + ], + [ + "ADD", + 1, + 32, + "-1" + ], + [ + "ADD", + 1, + 5, + "1" + ], + [ + "ADD", + 1, + 4, + "1" + ], + [ + "SCALE", + 3, + "-1" + ], + [ + "ADD", + 1, + 2, + "-1" + ], + [ + "SCALE", + 1, + "-1" + ], + [ + "ADD", + 3, + 1, + "3" + ], + [ + "SWAP", + 1, + 3 + ], + [ + "SCALE", + 0, + "-1" + ], + [ + "ADD", + 5, + 0, + "2" + ], + [ + "ADD", + 4, + 0, + "-2" + ], + [ + "ADD", + 3, + 0, + "-2" + ], + [ + "ADD", + 2, + 0, + "-2" + ], + [ + "ADD", + 1, + 0, + "-4" + ], + [ + "LAMBDA", + 0, + -1 + ], + [ + "QUERY", + 0, + 1, + -1 + ], + [ + "LAMBDA", + 0, + 1 + ], + [ + "ADD", + 0, + 1, + "-1" + ], + [ + "ADD", + 3, + 7, + "-1" + ], + [ + "ADD", + 1, + 7, + "-3" + ], + [ + "ADD", + 3, + 32, + "-1" + ], + [ + "ADD", + 1, + 32, + "-3" + ], + [ + "ADD", + 3, + 5, + "1" + ], + [ + "ADD", + 1, + 5, + "3" + ], + [ + "ADD", + 3, + 4, + "1" + ], + [ + "ADD", + 1, + 4, + "3" + ], + [ + "ADD", + 1, + 3, + "-3" + ], + [ + "SCALE", + 3, + "-1" + ], + [ + "ADD", + 3, + 2, + "1" + ], + [ + "SCALE", + 1, + "-1" + ], + [ + "SWAP", + 1, + 3 + ], + [ + "SCALE", + 0, + "-1" + ], + [ + "ADD", + 5, + 0, + "2" + ], + [ + "ADD", + 4, + 0, + "-2" + ], + [ + "ADD", + 3, + 0, + "-2" + ], + [ + "ADD", + 2, + 0, + "-2" + ], + [ + "ADD", + 32, + 7, + "1" + ], + [ + "ADD", + 5, + 7, + "1" + ], + [ + "ADD", + 4, + 7, + "-1" + ], + [ + "ADD", + 3, + 7, + "-1" + ], + [ + "ADD", + 2, + 7, + "-1" + ], + [ + "ADD", + 1, + 7, + "-1" + ], + [ + "ADD", + 1, + 32, + "-1" + ], + [ + "SWAP", + 32, + 7 + ], + [ + "ADD", + 1, + 5, + "-2" + ], + [ + "ADD", + 0, + 5, + "-2" + ], + [ + "SWAP", + 5, + 32 + ], + [ + "ADD", + 1, + 4, + "-2" + ], + [ + "ADD", + 0, + 4, + "-2" + ], + [ + "SWAP", + 4, + 5 + ], + [ + "SWAP", + 3, + 4 + ], + [ + "ADD", + 1, + 2, + "-1" + ], + [ + "SWAP", + 2, + 3 + ], + [ + "ADD", + 0, + 1, + "-1" + ], + [ + "SWAP", + 1, + 2 + ], + [ + "ADD", + 2, + 0, + "2" + ], + [ + "SWAP", + 0, + 2 + ], + [ + "ADD", + 2, + 0, + "1" + ], + [ + "SWAP", + 0, + 2 + ], + [ + "ADD", + 2, + 0, + "-1" + ], + [ + "SWAP", + 0, + 1 + ], + [ + "LAMBDA", + 0, + -1 + ], + [ + "QUERY", + 0, + 1, + -1 + ], + [ + "LAMBDA", + 0, + 1 + ], + [ + "ADD", + 0, + 1, + "-1" + ], + [ + "ADD", + 32, + 7, + "-1" + ], + [ + "ADD", + 5, + 7, + "1" + ], + [ + "ADD", + 4, + 7, + "1" + ], + [ + "ADD", + 3, + 7, + "1" + ], + [ + "ADD", + 2, + 7, + "1" + ], + [ + "ADD", + 1, + 7, + "-2" + ], + [ + "ADD", + 0, + 7, + "-1" + ], + [ + "ADD", + 5, + 32, + "1" + ], + [ + "ADD", + 4, + 32, + "1" + ], + [ + "ADD", + 3, + 32, + "1" + ], + [ + "ADD", + 0, + 32, + "-1" + ], + [ + "SCALE", + 32, + "-1" + ], + [ + "ADD", + 7, + 32, + "-1" + ], + [ + "ADD", + 4, + 5, + "-1" + ], + [ + "ADD", + 3, + 5, + "-1" + ], + [ + "ADD", + 1, + 5, + "2" + ], + [ + "ADD", + 0, + 5, + "1" + ], + [ + "ADD", + 7, + 5, + "-1" + ], + [ + "ADD", + 32, + 5, + "1" + ], + [ + "ADD", + 3, + 4, + "-1" + ], + [ + "ADD", + 0, + 4, + "1" + ], + [ + "SCALE", + 4, + "-1" + ], + [ + "ADD", + 7, + 4, + "1" + ], + [ + "ADD", + 32, + 4, + "-1" + ], + [ + "ADD", + 5, + 4, + "-1" + ], + [ + "ADD", + 0, + 3, + "1" + ], + [ + "SCALE", + 3, + "-1" + ], + [ + "ADD", + 7, + 3, + "1" + ], + [ + "ADD", + 32, + 3, + "-1" + ], + [ + "ADD", + 5, + 3, + "-1" + ], + [ + "ADD", + 4, + 3, + "1" + ], + [ + "ADD", + 1, + 2, + "2" + ], + [ + "ADD", + 0, + 2, + "1" + ], + [ + "SCALE", + 2, + "-1" + ], + [ + "ADD", + 7, + 2, + "1" + ], + [ + "ADD", + 32, + 2, + "-1" + ], + [ + "ADD", + 5, + 2, + "-1" + ], + [ + "ADD", + 4, + 2, + "1" + ], + [ + "ADD", + 3, + 2, + "1" + ], + [ + "ADD", + 0, + 1, + "1" + ], + [ + "ADD", + 7, + 1, + "-1" + ], + [ + "ADD", + 32, + 1, + "1" + ], + [ + "ADD", + 5, + 1, + "1" + ], + [ + "ADD", + 4, + 1, + "-1" + ], + [ + "ADD", + 3, + 1, + "-1" + ], + [ + "ADD", + 2, + 1, + "-1" + ], + [ + "ADD", + 7, + 0, + "1" + ], + [ + "ADD", + 32, + 0, + "-1" + ], + [ + "ADD", + 5, + 0, + "-1" + ], + [ + "ADD", + 4, + 0, + "1" + ], + [ + "ADD", + 3, + 0, + "1" + ], + [ + "ADD", + 2, + 0, + "1" + ], + [ + "SWAP", + 0, + 1 + ], + [ + "ADD", + 4, + 5, + "1" + ], + [ + "ADD", + 2, + 5, + "2" + ], + [ + "ADD", + 0, + 5, + "-1" + ], + [ + "ADD", + 2, + 4, + "-4" + ], + [ + "ADD", + 0, + 4, + "2" + ], + [ + "SCALE", + 4, + "-1" + ], + [ + "ADD", + 5, + 4, + "1" + ], + [ + "SWAP", + 3, + 5 + ], + [ + "SCALE", + 2, + "-1" + ], + [ + "SWAP", + 2, + 3 + ], + [ + "SWAP", + 1, + 4 + ], + [ + "ADD", + 3, + 0, + "-2" + ], + [ + "ADD", + 2, + 0, + "1" + ], + [ + "ADD", + 1, + 0, + "1" + ], + [ + "LAMBDA", + 0, + -1 + ], + [ + "LOCAL", + 10, + 1, + 0 + ], + [ + "LAMBDA", + 0, + 1 + ], + [ + "ADD", + 0, + 1, + "-1" + ], + [ + "IDLE_ONE", + 2, + [ + 10 + ] + ], + [ + "ADD", + 1, + 2, + "1" + ], + [ + "ADD", + 2, + 0, + "-1" + ], + [ + "SWAP", + 2, + 4 + ], + [ + "LAMBDA", + 4, + -1 + ], + [ + "LAMBDA", + 33, + 1 + ], + [ + "SWAP", + 2, + 33 + ], + [ + "ADD", + 2, + 0, + "1" + ], + [ + "ADD", + 1, + 2, + "-1" + ], + [ + "SCALE", + 1, + "-1" + ], + [ + "SWAP", + 1, + 21 + ], + [ + "SWAP", + 0, + 20 + ], + [ + "SWAP", + 20, + 21 + ], + [ + "ADD", + 1, + 20, + "1" + ], + [ + "ADD", + 21, + 0, + "-1" + ], + [ + "LAMBDA", + 20, + -1 + ], + [ + "QUERY", + 20, + 21, + -1 + ], + [ + "LAMBDA", + 20, + 1 + ], + [ + "ADD", + 21, + 0, + "1" + ], + [ + "ADD", + 1, + 20, + "-1" + ], + [ + "IDLE", + 20, + 21, + [ + 11, + 12, + 13, + 14 + ] + ], + [ + "SCALE", + 0, + "-1" + ], + [ + "SWAP", + 0, + 23 + ], + [ + "SWAP", + 1, + 22 + ], + [ + "SWAP", + 22, + 23 + ], + [ + "ADD", + 0, + 22, + "1" + ], + [ + "ADD", + 23, + 1, + "-1" + ], + [ + "LAMBDA", + 22, + -1 + ], + [ + "QUERY", + 22, + 23, + -1 + ], + [ + "LAMBDA", + 22, + 1 + ], + [ + "ADD", + 23, + 1, + "1" + ], + [ + "ADD", + 0, + 22, + "-1" + ], + [ + "IDLE", + 22, + 23, + [ + 11, + 12 + ] + ], + [ + "SCALE", + 1, + "-1" + ], + [ + "LAMBDA", + 1, + -1 + ], + [ + "LOCAL", + 11, + 0, + 1 + ], + [ + "LAMBDA", + 1, + 1 + ], + [ + "SCALE", + 1, + "-1" + ], + [ + "LAMBDA", + 0, + -1 + ], + [ + "LOCAL", + 12, + 1, + 0 + ], + [ + "LAMBDA", + 0, + 1 + ], + [ + "ADD", + 0, + 22, + "1" + ], + [ + "SCALE", + 22, + "-1" + ], + [ + "ADD", + 22, + 0, + "1" + ], + [ + "SWAP", + 1, + 23 + ], + [ + "SCALE", + 23, + "-1" + ], + [ + "ADD", + 23, + 1, + "1" + ], + [ + "SCALE", + 0, + "-1" + ], + [ + "SWAP", + 1, + 25 + ], + [ + "SWAP", + 0, + 24 + ], + [ + "SWAP", + 24, + 25 + ], + [ + "ADD", + 1, + 24, + "1" + ], + [ + "ADD", + 25, + 0, + "-1" + ], + [ + "LAMBDA", + 24, + -1 + ], + [ + "QUERY", + 24, + 25, + -1 + ], + [ + "LAMBDA", + 24, + 1 + ], + [ + "ADD", + 25, + 0, + "1" + ], + [ + "ADD", + 1, + 24, + "-1" + ], + [ + "IDLE", + 24, + 25, + [ + 13, + 14 + ] + ], + [ + "SCALE", + 0, + "-1" + ], + [ + "LAMBDA", + 0, + -1 + ], + [ + "LOCAL", + 13, + 1, + 0 + ], + [ + "LAMBDA", + 0, + 1 + ], + [ + "SCALE", + 0, + "-1" + ], + [ + "LAMBDA", + 1, + -1 + ], + [ + "LOCAL", + 14, + 0, + 1 + ], + [ + "LAMBDA", + 1, + 1 + ], + [ + "ADD", + 1, + 24, + "1" + ], + [ + "SCALE", + 24, + "-1" + ], + [ + "ADD", + 24, + 1, + "1" + ], + [ + "SWAP", + 0, + 25 + ], + [ + "SCALE", + 25, + "-1" + ], + [ + "ADD", + 25, + 0, + "1" + ], + [ + "ADD", + 1, + 20, + "1" + ], + [ + "SCALE", + 20, + "-1" + ], + [ + "ADD", + 20, + 1, + "1" + ], + [ + "SWAP", + 0, + 21 + ], + [ + "SCALE", + 21, + "-1" + ], + [ + "ADD", + 21, + 0, + "1" + ], + [ + "SCALE", + 1, + "-1" + ], + [ + "ADD", + 1, + 0, + "1" + ], + [ + "IDLE_ONE", + 2, + [ + 11, + 12, + 13, + 14 + ] + ], + [ + "IDLE_ONE", + 3, + [ + 10, + 11, + 12, + 13, + 14 + ] + ], + [ + "SCALE", + 3, + "-1" + ], + [ + "SWAP", + 3, + 5 + ], + [ + "ADD", + 0, + 2, + "-1" + ], + [ + "SWAP", + 2, + 5 + ], + [ + "ADD", + 0, + 1, + "-1" + ], + [ + "ADD", + 5, + 1, + "-1" + ], + [ + "SWAP", + 1, + 33 + ], + [ + "SCALE", + 0, + "-1" + ], + [ + "ADD", + 33, + 0, + "-1" + ], + [ + "ADD", + 2, + 0, + "-2" + ], + [ + "SWAP", + 1, + 2 + ], + [ + "SCALE", + 0, + "-1" + ], + [ + "ADD", + 1, + 0, + "-1" + ], + [ + "SWAP", + 0, + 27 + ], + [ + "SWAP", + 1, + 26 + ], + [ + "SWAP", + 26, + 27 + ], + [ + "ADD", + 0, + 26, + "1" + ], + [ + "ADD", + 27, + 1, + "-1" + ], + [ + "LAMBDA", + 26, + -1 + ], + [ + "QUERY", + 26, + 27, + -1 + ], + [ + "LAMBDA", + 26, + 1 + ], + [ + "ADD", + 27, + 1, + "1" + ], + [ + "ADD", + 0, + 26, + "-1" + ], + [ + "IDLE", + 26, + 27, + [ + 15, + 16, + 17, + 18 + ] + ], + [ + "SCALE", + 1, + "-1" + ], + [ + "SWAP", + 1, + 29 + ], + [ + "SWAP", + 0, + 28 + ], + [ + "SWAP", + 28, + 29 + ], + [ + "ADD", + 1, + 28, + "1" + ], + [ + "ADD", + 29, + 0, + "-1" + ], + [ + "LAMBDA", + 28, + -1 + ], + [ + "QUERY", + 28, + 29, + -1 + ], + [ + "LAMBDA", + 28, + 1 + ], + [ + "ADD", + 29, + 0, + "1" + ], + [ + "ADD", + 1, + 28, + "-1" + ], + [ + "IDLE", + 28, + 29, + [ + 15, + 16 + ] + ], + [ + "SCALE", + 0, + "-1" + ], + [ + "LAMBDA", + 0, + -1 + ], + [ + "LOCAL", + 15, + 1, + 0 + ], + [ + "LAMBDA", + 0, + 1 + ], + [ + "SCALE", + 0, + "-1" + ], + [ + "LAMBDA", + 1, + -1 + ], + [ + "LOCAL", + 16, + 0, + 1 + ], + [ + "LAMBDA", + 1, + 1 + ], + [ + "ADD", + 1, + 28, + "1" + ], + [ + "SCALE", + 28, + "-1" + ], + [ + "ADD", + 28, + 1, + "1" + ], + [ + "SWAP", + 0, + 29 + ], + [ + "SCALE", + 29, + "-1" + ], + [ + "ADD", + 29, + 0, + "1" + ], + [ + "SCALE", + 1, + "-1" + ], + [ + "SWAP", + 0, + 31 + ], + [ + "SWAP", + 1, + 30 + ], + [ + "SWAP", + 30, + 31 + ], + [ + "ADD", + 0, + 30, + "1" + ], + [ + "ADD", + 31, + 1, + "-1" + ], + [ + "LAMBDA", + 30, + -1 + ], + [ + "QUERY", + 30, + 31, + -1 + ], + [ + "LAMBDA", + 30, + 1 + ], + [ + "ADD", + 31, + 1, + "1" + ], + [ + "ADD", + 0, + 30, + "-1" + ], + [ + "IDLE", + 30, + 31, + [ + 17, + 18 + ] + ], + [ + "SCALE", + 1, + "-1" + ], + [ + "LAMBDA", + 1, + -1 + ], + [ + "LOCAL", + 17, + 0, + 1 + ], + [ + "LAMBDA", + 1, + 1 + ], + [ + "SCALE", + 1, + "-1" + ], + [ + "LAMBDA", + 0, + -1 + ], + [ + "LOCAL", + 18, + 1, + 0 + ], + [ + "LAMBDA", + 0, + 1 + ], + [ + "ADD", + 0, + 30, + "1" + ], + [ + "SCALE", + 30, + "-1" + ], + [ + "ADD", + 30, + 0, + "1" + ], + [ + "SWAP", + 1, + 31 + ], + [ + "SCALE", + 31, + "-1" + ], + [ + "ADD", + 31, + 1, + "1" + ], + [ + "ADD", + 0, + 26, + "1" + ], + [ + "SCALE", + 26, + "-1" + ], + [ + "ADD", + 26, + 0, + "1" + ], + [ + "SWAP", + 1, + 27 + ], + [ + "SCALE", + 27, + "-1" + ], + [ + "ADD", + 27, + 1, + "1" + ], + [ + "ADD", + 0, + 1, + "-1" + ], + [ + "SWAP", + 1, + 2 + ], + [ + "SCALE", + 0, + "-1" + ], + [ + "ADD", + 2, + 0, + "-1" + ], + [ + "LAMBDA", + 0, + -1 + ], + [ + "LAMBDA", + 1, + -1 + ], + [ + "LAMBDA", + 2, + -1 + ], + [ + "LAMBDA", + 3, + -1 + ], + [ + "LAMBDA", + 33, + -1 + ], + [ + "LAMBDA", + 5, + -1 + ], + [ + "LAMBDA", + 32, + -1 + ], + [ + "LAMBDA", + 7, + -1 + ], + [ + "LAMBDA", + 8, + -1 + ], + [ + "LAMBDA", + 9, + -1 + ], + [ + "LAMBDA", + 10, + -1 + ], + [ + "LAMBDA", + 11, + -1 + ], + [ + "LAMBDA", + 12, + -1 + ], + [ + "LAMBDA", + 13, + -1 + ], + [ + "LAMBDA", + 14, + -1 + ], + [ + "LAMBDA", + 15, + -1 + ], + [ + "LAMBDA", + 16, + -1 + ], + [ + "LAMBDA", + 17, + -1 + ], + [ + "LAMBDA", + 18, + -1 + ], + [ + "LAMBDA", + 19, + -1 + ], + [ + "LAMBDA", + 20, + -1 + ], + [ + "LAMBDA", + 21, + -1 + ], + [ + "LAMBDA", + 22, + -1 + ], + [ + "LAMBDA", + 23, + -1 + ], + [ + "LAMBDA", + 24, + -1 + ], + [ + "LAMBDA", + 25, + -1 + ], + [ + "LAMBDA", + 26, + -1 + ], + [ + "LAMBDA", + 27, + -1 + ], + [ + "LAMBDA", + 28, + -1 + ], + [ + "LAMBDA", + 29, + -1 + ], + [ + "LAMBDA", + 30, + -1 + ], + [ + "LAMBDA", + 31, + -1 + ], + [ + "ADD", + 7, + 32, + "1" + ], + [ + "SWAP", + 32, + 7 + ], + [ + "ADD", + 7, + 32, + "-2" + ], + [ + "SCALE", + 32, + "-1" + ], + [ + "ADD", + 32, + 7, + "-1" + ], + [ + "ADD", + 5, + 33, + "2" + ], + [ + "SCALE", + 33, + "-1" + ], + [ + "SCALE", + 5, + "-1" + ] + ], + "diagonal": [ + [ + -1, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + [ + -1, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1 + ], + [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0 + ] + ], + "nodes": [ + { + "roles": [ + 8, + 9 + ], + "stages": [ + 1, + 2, + 3, + 4 + ] + }, + { + "roles": [ + 10, + 11 + ], + "stages": [ + 1, + 2 + ] + }, + { + "roles": [ + 12, + 13 + ], + "stages": [ + 3, + 4 + ] + }, + { + "roles": [ + 14, + 15 + ], + "stages": [ + 5, + 6, + 7, + 8 + ] + }, + { + "roles": [ + 16, + 17 + ], + "stages": [ + 5, + 6 + ] + }, + { + "roles": [ + 18, + 19 + ], + "stages": [ + 7, + 8 + ] + }, + { + "roles": [ + 20, + 21 + ], + "stages": [ + 11, + 12, + 13, + 14 + ] + }, + { + "roles": [ + 22, + 23 + ], + "stages": [ + 11, + 12 + ] + }, + { + "roles": [ + 24, + 25 + ], + "stages": [ + 13, + 14 + ] + }, + { + "roles": [ + 26, + 27 + ], + "stages": [ + 15, + 16, + 17, + 18 + ] + }, + { + "roles": [ + 28, + 29 + ], + "stages": [ + 15, + 16 + ] + }, + { + "roles": [ + 30, + 31 + ], + "stages": [ + 17, + 18 + ] + } + ] +} diff --git a/research/native-retimed-helper-split/retained/caller/INDEPENDENT.json b/research/native-retimed-helper-split/retained/caller/INDEPENDENT.json new file mode 100644 index 0000000000..8a70990cac --- /dev/null +++ b/research/native-retimed-helper-split/retained/caller/INDEPENDENT.json @@ -0,0 +1,60 @@ +{ + "inputs_sha256": { + "CALLER-ONE-RETIRED.json": "8d7889e817faf1bbf81bb4ed681db039df6e26ecdab5555dff60c3d0e4309030", + "CALLER-UNRETIRED.json": "8693f74b4559c27dd670f788c6e8c7be8bc7cf9cd6a6abb80455fee86d20bc99", + "CONTROLLER.json": "543b8728e659561b95e127dad7bd7534645996d7d2c61602bb5d89c89a73944c", + "RETIREMENT-WITNESSES.json": "272534848a8fe8a9fd523f4daf2747b24a6b26eb9a848d27cafcb22a2e718136" + }, + "negative_controls": { + "final_return": "Independent forward column 5", + "first_handoff": "Independent forward column 4", + "first_input": "Independent reverse row 6", + "omitted_ADD": "Independent forward column 4", + "omitted_IDLE": "Independent forward column 0", + "omitted_IDLE_ONE": "Independent forward column 0", + "omitted_LAMBDA": "Independent forward column 0", + "omitted_LOCAL": "All distinct stages exactly once", + "omitted_QUERY": "Independent forward column 0", + "second_handoff": "Independent forward column 4", + "unearned_head_32": "Independent forward column 32", + "unearned_head_33": "Independent forward column 33", + "unearned_head_6": "Independent forward column 6", + "wrong_cut_normalizer": "Independent forward column 4" + }, + "pairs": [ + { + "all_coefficients": "exact Laurent/Gaussian", + "cut_after": 158, + "dual_pairings": "1", + "head": 0, + "odd_denominators": false, + "pivot": 6, + "prefix_stages": [ + 5, + 6, + 7, + 8 + ] + }, + { + "all_coefficients": "exact Laurent/Gaussian", + "cut_after": 394, + "dual_pairings": "1", + "head": 1, + "odd_denominators": false, + "pivot": 4, + "prefix_stages": [ + 10 + ] + } + ], + "scope": "Exact all-input caller algebra and dyadic witnesses. Physical/native/finite/outer assumptions are separate.", + "status": "PASS_INDEPENDENT_TWO_PAID_FRAGMENTS", + "word": { + "events": 606, + "forward_coefficients": 1156, + "independent_body_variables": 18, + "inputs": 34, + "reverse_coefficients": 1156 + } +} diff --git a/research/native-retimed-helper-split/retained/caller/LICENSE b/research/native-retimed-helper-split/retained/caller/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/native-retimed-helper-split/retained/caller/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/native-retimed-helper-split/retained/caller/NOTICE b/research/native-retimed-helper-split/retained/caller/NOTICE new file mode 100644 index 0000000000..fed7ebcefa --- /dev/null +++ b/research/native-retimed-helper-split/retained/caller/NOTICE @@ -0,0 +1,40 @@ +New common-idle eight-field caller, source-specific fresh-input cut, full signed invoice and verification integration: +thu-nmrc with substantial OpenAI Codex assistance, including parallel mathematical and verification agents. Apache-2.0. +Author-side validation only; no independent scientific acceptance is claimed. + +Binary query suppliers, common-projector root and normalization, and dual-pair retirement methods retain Cinna Davis, Ali Romman and the complete retained predecessor credit. +All original source files and nested notices remain unchanged. + +Preserved predecessor notice: + +Paid-job merges in the PR6529 native word, price and integration: +DreamingOfClouds with Claude Opus 5.5 (Anthropic), via Claude Code. Apache-2.0. +No independent scientific acceptance is claimed. + +Caller, retirement-aware tree allocation, proof and checks (PR6551): +Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. + +The executable source is retained in source.tar from original head +775722aa94a5e85b05d1d704d7dca10cbf016f0c (PR6545), with the PR6529 layer +edited as described in README.md. +RETAINED.json binds original paths, Git blobs and SHA256 values. Original +source headers and notices remain; the PR6529 verifier, pricing and word are +edited as described in README.md. ADAPTERS.json records +all changes to the source drivers, constructor and price. Runtime driver +and constructor copies are created in a private temporary directory. + +PR6545: independent Gaussian retirement, exact dual pairs and complete caller. +PR5599/5602/5611/5615: causal handoff, productive helper and basis methods. +PR6348/6398: binary query suppliers and the six-field mixed root. +PR6529: scaled transport fusion and the complete native word. +PR6524: explicit complete replay interfaces. + +Credit Rohan Arun's PR6399/6417, Erwan L.'s PR6453, DreamingOfClouds' PR6375, +PR6353/6372 and all retained native predecessors. Native work retains +Cinna Davis, David Arias, Gareth Davidson and their predecessors. Productive +recursion retains Jacob Alan Sussman's credit. Price and interval work +retains zxv, Cao Yifan, ywz65 and Nick Petalas's credit. + +Other retained contributors include Mason Hale, Pierre-Loic Doulcet and +Chris R / Clear1nsight. The source archive and its nested notices retain +the complete native, helper, compiler and analytic source attribution. diff --git a/research/native-retimed-helper-split/retained/caller/PROOF.md b/research/native-retimed-helper-split/retained/caller/PROOF.md new file mode 100644 index 0000000000..1d23498f0d --- /dev/null +++ b/research/native-retimed-helper-split/retained/caller/PROOF.md @@ -0,0 +1,35 @@ +# Conditional κ = 0.00330720 from two paid idle fragments + +This complete construction raises conditional κ from **0.00330420** in [PR6716](https://github.com/CrocSwap/integer-mult-bounds/pull/6716) to **0.00330720**, an absolute increase of **0.00000300** (about **0.09079%**). It retains the five assumptions `native_all_columns`, `owned_erasure`, `compiler`, `precision_tape`, and `analytic_recovery`. It does not claim an unconditional theorem or change the repository's selected frontier. + +The native supplier is unchanged. Its pinned source and full replay are retained in the sibling `sources/pr6716/` and `fragment/RESULT.json`. Native and earlier caller authors retain their recorded credits. The two-pair root, paid fragmentation and new witnesses were developed with OpenAI Codex for [zxv](https://github.com/zxv). + +## Actual caller + +An eight-field shortest root uses nine nilpotent queries and six full sites, at indices **0,1,2,6,7,8**, with ranks **(2,4,4,4,4,2)**. Its two rank-four shared stage supports are `{0,1,6,7}` and `{0,2,4,5}`. Their active native queries are exactly `E01,-E10` in their respective common bases. Both remaining coordinates in each bank are genuine common idle directions. The exact integer root and every basis are in `ROOT.json`; `root_check.py` checks every independent stage and central character. + +The child sizes are **(4,4,1,1,4,4)**. All 18 native invocations, 12 internal binary suppliers, 15 thin queries, all idles, arbitrary public inputs, owned lifetimes and phases are counted. Rotate the two idle banks by determinant-one matrices `[[2,-1],[1,0]]` and `[[-2,-1],[1,0]]`. In each bank, pay one idle direction separately on its two child bodies. The other direction retains its combined job. + +The first equal-target group is fields 6,7. Its exact input column and row are `c=-2e6+e7`, `d=e7^T`. After the first paid fragment, the prefix has the dual identities `Pc=D_B a`, `bP=D_B d`, where `a=-e0+e2`, `b=-e1^T+e2^T`. Both pairings are one. The literal input matrix is `[[-2,-1],[1,0]]`; the cut basis is `ADD(0,2,1); ADD(2,1,-1); SWAP(2,6)`. Retire original field 6 and introduce fresh arbitrary field 32 only into the suffix. This replaces qBC by independent B and qC. + +The second group is fields 4,5. Take `c=-e4+2e5`, `d=-e4^T`. Its prefix has `Pc=S D_D a`, `bP=S D_D d`, with `a=-e1+e2`, `b=-e0^T+e2^T`, and normalized central involution `S=λq^-1`. The input matrix is `[[-1,0],[2,-1]]`. The cut basis is `ADD(1,2,1); ADD(2,0,-1); SWAP(2,4); LAMBDA(4,-1)`. The final ordinary normalization turns the prefix into q^-1 D_D. Retire field 4 and introduce fresh field 33 to the inverse cut basis and suffix. The inverse ordinary normalization is paid and leaves a plain E output. This replaces qDE by independent qD and E. + +All basis coefficients are legal dyadics; the listed scalar input matrices have determinant one. Every added field is arbitrary and untouched before its handoff. No stage factor occurs in an ordinary basis. The dual-pair retirement argument and general lemma are also explained in `../fragment/PROOF.md`. + +## Complete economics and qualification + +At this allocation, each changed target has rank 41 and is replaced by independent ranks 32 and 9. Each changed paid rank-40 idle is replaced by paid ranks 32 and 8. Therefore, relative to this same unfragmented root and allocation, + +``` +ΔT = 208(H32 + H9 - H41), +ΔP = 208(H32 + H8 - H40), +Δ(T-P) = 208((H9-H8)-(H41-H40)) > 0. +``` + +The last inequality follows from strictly decreasing increments of `H(r)=r^t`, for `0 2^26*N^5 avoiding all fixed denominators and rank witnesses" + }, + "outer": { + "functional_checks": { + "actual_new_BIT_stock_sublinear": "348599999253/350000000000", + "fixed_halo_explicit_metadata_branch": "26950000001/350000000", + "new_BIT_row_stock_sublinear_in_active_group": "1395799997009/1400000000000", + "new_semantic_group_guard": "3/1400000000" + }, + "margins": { + "boundary_algebraic_matrix": "6482117595369917/1960000000000000000", + "fused_gaussian": "6482117586109751/1960000000000000000", + "global_coordinate_router": "1157521/350000000", + "group_bit_router": "1620529746527437/490000000000000000", + "group_scans": "699999999/700000000", + "main_transform": "6482116195369917/1960000000000000000", + "microbox_face_corrections": "26950000001/350000000", + "polynomial_products": "1399999999/1400000000", + "sparse_union_movement": "802732117595369917/1960000000000000000" + }, + "parameters": { + "a": "1157521/350000000", + "b": "926017/280000000", + "beta": "1399999997/1400000000", + "bit_saving": "17/5000", + "cap_xi": "1782732116195369917/1960000000000000000", + "complex_uniform_saving": "2315043/700000000", + "d": "1/1400000000", + "epsilon": "1399999999/1400000000", + "kappa": "2067/625000", + "lambda_": "398677119/400000000", + "lambda_prime": "1395369917/1400000000", + "layout": "1/1400000000", + "q": "4630083/1400000000", + "r0": "1/14000000000", + "stop": "1/1400000000", + "tested_saving": "661441/200000000" + }, + "strict_checks": { + "actual_bit_above_effective": "32479/350000000", + "actual_logarithmic_gamma_guard": "1/1400000000", + "actual_logarithmic_group_guard": "177267885904630083/980000000000000000", + "alpha_logarithm_absorption": "1/14000000000", + "boundary_algebraic_matrix_above_kappa": "5595369917/1960000000000000000", + "cap_above_band": "802732116195369917/1960000000000000000", + "cap_below_cell": "177267882404630083/1960000000000000000", + "cap_below_phase_cell_power": "2137267883804630083/1960000000000000000", + "complex_above_effective": "1/1400000000", + "complex_below_one_over_32": "7823983/280000000", + "complex_endpoint": "1/700000000", + "epsilon_below_one": "1/1400000000", + "epsilon_positive": "1399999999/1400000000", + "fine_prime_halo_umbrella": "7/2", + "fused_gaussian_above_kappa": "5586109751/1960000000000000000", + "gaussian_above_main": "695369917/980000000000000000", + "global_coordinate_router_above_kappa": "1/350000000", + "global_gamma_power_slack": "9/14000000000", + "group_below_dimension": "1/700000000", + "group_bit_router_above_kappa": "1746527437/490000000000000000", + "group_gauge_power_slack": "177267885834630083/980000000000000000", + "group_key_fits_record": "1/700000000", + "group_positive": "1399999997/1400000000", + "group_scans_above_kappa": "697684959/700000000", + "halo_covers_generic_inverse_radius": "5", + "improvement_over_user_baseline": "788114790400418148631/500000000000000000000000", + "lambda_above_internal": "1/2800000000", + "lambda_above_sigma": "3/2800000000", + "lambda_above_tau": "1/2800000000", + "lambda_prime_above_lambda": "1/2800000000", + "lambda_prime_above_leaf": "559073983/392000000000000000", + "leaf_saving_above_effective": "279073983/392000000000000000", + "main_transform_above_kappa": "4195369917/1960000000000000000", + "membership_arithmetic_fits_record": "1/1400000000", + "microbox_face_corrections_above_kappa": "26948842481/350000000", + "microbox_halo_volume": "110600000003/1400000000", + "new_complex_uniform_saving_above_b": "1/1400000000", + "new_semantic_guard_with_C1_one": "1/1400000000", + "polynomial_products_above_kappa": "1395369919/1400000000", + "positive_layout_slack": "1/1400000000", + "q_below_effective": "1/1400000000", + "q_below_internal": "1/1400000000", + "q_below_leaf": "559073983/392000000000000000", + "q_positive": "4630083/1400000000", + "short_record_fallback": "279073983/280000000", + "source_axis_superpolynomial": "1/1400000000", + "sparse_union_movement_above_kappa": "796250005595369917/1960000000000000000", + "stop_below_one": "1399999999/1400000000", + "stop_positive": "1/1400000000", + "strassen_integer_power_gap": "1951441519231", + "support_router_span": "3/1400000000", + "theta_positive_polynomial_power": "2", + "union_header_fits_record": "3/1400000000", + "union_tag_work_per_visit_fits_record": "3/1400000000" + } + }, + "paid": { + "1": 41718, + "16": 1664, + "2": 8172, + "3": 8820, + "32": 1040, + "4": 1962, + "40": 208, + "5": 2736, + "6": 144, + "7": 162, + "8": 226 + }, + "paid_calls": 66852, + "productive_fields": 13670, + "rank_mass_surplus": 760, + "raw_endpoint_margins": { + "lower": { + "first": { + "lower": "0.000000012241021201049020389571", + "upper": "0.000000012241021201049020389572" + }, + "second": { + "lower": "0.000000012241021201049020389571", + "upper": "0.000000012241021201049020389572" + } + }, + "tested": { + "first": { + "lower": "0.009058961691252906915782316974", + "upper": "0.009058961691252906915782316975" + }, + "second": { + "lower": "0.009058961691252906915782316974", + "upper": "0.009058961691252906915782316975" + } + }, + "upper": { + "first": { + "lower": "-0.000000010586229350315545104600", + "upper": "-0.000000010586229350315545104599" + }, + "second": { + "lower": "-0.000000010586229350315545104600", + "upper": "-0.000000010586229350315545104599" + } + } + }, + "raw_root_interval": [ + "258378491/78125000000", + "33072446849/10000000000000" + ], + "scope": "Complete conditional price, requiring the supplied caller/native/physical inputs to be independently verified by the package. Does not itself verify those scientific inputs, discharge inherited assumptions, establish scientific admission, or change selected kappa.", + "source_assumptions": [ + "native_all_columns", + "owned_erasure", + "compiler", + "precision_tape", + "analytic_recovery" + ], + "status": "PASS_TWO_PAID_FRAGMENTS_COMPLETE_PRICE", + "strictification": { + "alpha": { + "lower": "0.999999948845481569256944273324", + "upper": "0.999999948845481569256944273325" + }, + "alternative_12_13_delta": { + "lower": "0.995287089787487100699714826591", + "upper": "0.995287089787487100699714826592" + }, + "cutoff": 11, + "decay": "31/32", + "delta": { + "lower": "0.918990959310893782567844250334", + "upper": "0.918990959310893782567844250335" + }, + "floor": 12, + "gamma": { + "lower": "0.919385386607784179769442173435", + "upper": "0.919385386607784179769442173436" + }, + "normalized_upper": "3017994256268166165656485281090535833916725756249835826793168925266538363332959118393649803728007713071868113265307008106165392759140166602231276176491193525838475223532850199880731698633371358238213826956369837083963326200431097200800059212002041494173164580120900614899652164774721219753022318014007470888704725853928034427162119973960367601209478471989008174546718847765864454317363747477784577139342980703179986004309023923501151623437162530359093275767500999488838821346878653618781517869929465644907239975200419119984961970595462459526672982124367238370081601117105862824672041626753878830761254937716087757500154780588952387888909545290321227690737337524636932986557487436400373746205087976939900823213412721260929246663645454333225533573417873878270966410674662217721400378580963662781229070699131856088606565064212802338219990676288305134052916065084223147113356681924295487922738831215975490003477881714792514602632531440142922321624246055420491548898870125266739034093403593861141750778390494324332020450631341177712407686809708639299932057929638453229385512844824477732475692497750505444293920505764644542985604027374525776713590758593290162240025857956398750701666193022661852817667334597363657250589474692558349187489784467784534308731452271464397192747555883724086986777180899255693019165197216450482165724399715348781376527863867611187937883511375183145576545939665590528177825191075315987382691696850289161949978761392853761291967438188096278517378245173041891296537114442099549460376841596189745440833356287809630492771955137857634049834843653214091059292899519993358715592551812122459678957257644252935128182771018674930860159078110203035231337278094843484497916736350269707423093669550405734836572742921142951535393569858677867578133947031681172583200575479732465576021412092436521998625141581486036597822439583555666166745205320062026011722745440952026157246983262052059609825801393194410107883674103170530206478790180680714175502948412787907330283634638118487371874649400893019006973397690500854473558401410620066158504863840613720936860712364614948768923065861574183333307699013929391851014406823186488763212430120437839480440610837443358734496436725017143197692415864041146359723246618363560963819742888006979937806707306886174644458636649893987953661905408261128055990516804739016024589981864256774788678522533600952517642689837813239015716470408358110154664695932620834322254734702246799101912684700303071151259570508727219713769405640694001219420631583405431371328147136055604276355342139039717035227877070657992677340778068793172328267591969261818125572871429869776365422773264912163077459311734702664754097848257207856647246563827576845151038301927915239078395646743310244244155118166302363634508949033003228555802638863720922802000624281277831431518083189590917186076428068361094207669086175823390707236441303930595597471590743181212100815143003489643346003177743777109770019130060803/3017994256268166165656491035063231693978398198787662079292383856990261666407268875266242316574304537824977438191233479479458365031897378910971682146847445831720529072444214239168813318361621021406537946333680719615698024395371618102654358301049375281526841923857353573281673124064137091623117665711938327458485803660406333782965399496384383273095619410140572062880895086412530676628570584973212341168338281143028843950725406810633018143519244412367157868500306391027430062953886066530011236452104054839696367657745585918153885105780436048055657351661582204778498269871018672509355754914642085687953169998781802659556167514409844216442138601869761940829666175939688866382484459348199377852059421048193136784272717556196313275587819271746647782752170997852125936391824736948646408133578263515625097682264701444334863759885223671808566007730417996869975879739069454556143502120678264337509191926420012606685608884721586159182735130329668235415015963539054143635378351553686650970085356070224050653205542765090703090192316158855819021850534846977519598595533227830830246675689299329067321128120764882495087257572668033863484660711961342702904922213132750672072529152647888921228554709611752116990888073427706144475582044612115354682916594199797791656758577997812612859332705485501315354164119374880954187452894641323180493161306005328627998639574009593540018002942935225879243521624482714761491136882238301907421656901587458169137534644297058714160255428538828222202270811680920184952032574111855818083323277337278951405159580396757098165528221317354723301942624608396313954059588718689633657419267824337962870655097477792938701413070284409091728049161298086123657787538745786057964843136234985017216030339846107466138423974925847895769642910846794142281362603017916752544796963565984849849769996708882692849515677511148222363661619367929957200111877107796960360666023556235009225611283531158403466647070581796672289974955924592777874597248446634937752574338785626877802036415577528724311421788748071123754637157691654232143301862938534179856363952063049872889542807412729837987869412746960678402767893645902016662880136171621266241700457558973760850667075103664334887633217911261504764438100508653101640059777972182615479323091990380294461729182853447358074876266516119635874601565061925989878395715844229089983460650371889224631036383672785343069536106257115040353041502759057432703560960094331869105852264578209033293234613213545309635230759049012769406664208577367799088589327982198040102650366683636258605290168036200739803674673414801290054883467223756247682810755116873536560345525083453513230497496834726668274182638946137769521096245230638941858893368170523070080321656837850831035321029960872976160298639386627768204700263664703090321168443994619637219281963172814020726543678137155435815999103603309013053863875221052240416961763005709684412496621711854336662627914279975977381641466926443784930454019244032", + "offset": "1/7", + "power": 1920, + "reserve": "1/1000000000000000000000000000" + }, + "targets": { + "1": 356, + "145": 104, + "17": 1664, + "2": 144, + "3": 72, + "32": 208, + "33": 832, + "4": 1944, + "41": 208, + "5": 288, + "6": 54, + "7": 162, + "73": 208, + "8": 720, + "9": 6706 + }, + "tested": "661441/200000000", + "thin_queries": 15, + "whole_idle_jobs": 3120 + }, + "controls": { + "D_handoff": "Every arbitrary-input forward coefficient", + "D_suffix_unearned_head": "Every independent reverse caller coefficient", + "body_handoff": "Every arbitrary-input forward coefficient", + "body_input_basis": "Every arbitrary-input forward coefficient", + "body_prefix_unearned_head": "Every independent reverse caller coefficient", + "body_suffix_wrong_body": "Every independent reverse caller coefficient", + "extra_productive_credit": "Every main target has its checked absolute physical phase", + "final_return": "Every arbitrary-input forward coefficient", + "fragmented_B_idle": "Every arbitrary-input forward coefficient", + "missing_add": "Every arbitrary-input forward coefficient", + "missing_idle": "Every arbitrary-input forward coefficient", + "missing_idle_one": "Every arbitrary-input forward coefficient", + "missing_lambda": "Every arbitrary-input forward coefficient", + "missing_local": "Every distinct native stage once", + "missing_query": "Every arbitrary-input forward coefficient", + "unpaid_native_job": "Exact PR6702 paid and independent-helper boundary" + }, + "native_unchanged": { + "all_columns_previously_replayed": 800, + "events": 18577, + "owned_fields": 29, + "owned_lifetimes": 47, + "peak_owned_fields": 14, + "public_inputs": 771 + }, + "paid_delta": { + "1": 2127, + "2": 454, + "3": 490, + "4": 109, + "40": 104, + "5": 152, + "6": 8, + "7": 9, + "8": 105 + }, + "physical": { + "central_square_columns": 53248, + "central_translations": 0, + "full_calls": 18, + "main_targets": { + "1": 104, + "145": 104, + "17": 1664, + "32": 208, + "33": 832, + "41": 208, + "73": 208, + "9": 208 + }, + "new_paid_jobs": 0, + "ordinary_normalizations": 100, + "physical_contacts": 7488, + "ports": 104, + "route_payload_sha256": "79930ec6c09a8e4930556c925c354bb5431203eaf069d9373f056049c061289b", + "tensor_rule": "Factorwise native maps; scalar signs stay outside the tensor power.", + "whole_idle_jobs": { + "16": 1664, + "32": 1040, + "40": 208, + "8": 208 + } + }, + "retirement_witnesses": [ + { + "cut_after": 158, + "cut_basis": [ + [ + "ADD", + 0, + 2, + "1" + ], + [ + "ADD", + 2, + 1, + "-1" + ], + [ + "SWAP", + 2, + 6 + ] + ], + "fresh": 32, + "handoff_after": 166, + "head": 0, + "input_basis": [ + [ + "ADD", + 6, + 7, + "1" + ], + [ + "SCALE", + 6, + "-1" + ], + [ + "ADD", + 7, + 6, + "2" + ], + [ + "SWAP", + 6, + 7 + ], + [ + "ADD", + 7, + 6, + "-1" + ] + ], + "pivot": 6, + "prefix_stages": [ + 5, + 6, + 7, + 8 + ], + "prefix_target": [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "suffix_target": [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + { + "cut_after": 394, + "cut_basis": [ + [ + "ADD", + 1, + 2, + "1" + ], + [ + "ADD", + 2, + 0, + "-1" + ], + [ + "SWAP", + 2, + 4 + ], + [ + "LAMBDA", + 4, + -1 + ] + ], + "fresh": 33, + "handoff_after": 401, + "head": 1, + "input_basis": [ + [ + "SCALE", + 5, + "-1" + ], + [ + "SCALE", + 4, + "-1" + ], + [ + "ADD", + 5, + 4, + "-2" + ] + ], + "pivot": 4, + "prefix_stages": [ + 10 + ], + "prefix_target": [ + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "suffix_target": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0 + ] + } + ], + "reverse": { + "coefficients": 1156, + "rows": 34 + }, + "root": { + "common_idle_pairs": 2, + "fields": 8, + "full_sites": [ + 0, + 1, + 2, + 6, + 7, + 8 + ], + "multilinear_stage_and_character_checks": 128, + "stage_ranks": [ + 2, + 4, + 4, + 4, + 4, + 2 + ] + }, + "scalar_envelope": { + "coefficient_height_units": 2280, + "event_census": { + "ADD": 275, + "IDLE": 12, + "IDLE_ONE": 6, + "LAMBDA": 100, + "LOCAL": 18, + "QUERY": 15, + "SCALE": 86, + "SWAP": 94 + }, + "max_scalar": "6", + "ordinary_lambdas": 100, + "per_instruction_envelope": 32, + "real_scalar_units_per_port": 3526, + "uncharged_gaussian_jobs": 0 + }, + "signed_gain": "208*((H9-H8)-(H41-H40)) at the new six-child allocation > 0 for H(r)=r^t, 0>r&1 for j in t['stages']]] + for r in range(next_role):emit('LAMBDA',r,-1) + diagonal=[[targets[r][0],0]+[int(j in targets[r][1])for j in range(1,stage+1)]for r in range(next_role)] + need((stage,next_role)==(18,32),'Complete caller dimensions') + return {'schema':'root8-common-idle-fusion/1','roles':next_role,'stages':stage,'ambient_rank':9+8*stage, + 'events':events,'diagonal':diagonal,'nodes':nodes} + +def replay(word): + n,width=word['roles'],word['stages']+2;zero=(0,)*width + rows=[[{zero:coefficient(1)}if i==j else {}for j in range(n)]for i in range(n)];seen=[] + for event in word['events']: + op=event[0] + if op=='ADD': + _,dst,src,c=event + for a,b in zip(rows[dst],rows[src]):accumulate(a,b,coefficient(c)) + elif op=='SCALE': + _,dst,c=event;rows[dst]=[{key:zmul(coefficient(c),value)for key,value in cell.items()}for cell in rows[dst]] + elif op=='SWAP': + _,a,b=event;rows[a],rows[b]=rows[b],rows[a] + elif op in ('LOCAL','QUERY'): + if op=='LOCAL':_,stage,src,dst=event;exponent=-1;seen.append(stage) + else:_,dst,src,exponent=event + term=(exponent,)+(0,)*(width-1) + for a,b in zip(rows[dst],shifted(rows[src],term)):accumulate(a,b) + if op=='LOCAL': + term=(0,)+tuple(int(s==stage)for s in range(width-1)) + for r in (src,dst):rows[r]=shifted(rows[r],term) + elif op=='Q_POWER':rows[event[1]]=shifted(rows[event[1]],(event[2],)+(0,)*(width-1)) + elif op=='LAMBDA': + _,r,sign=event;need(sign in(-1,1),'Ordinary normalization sign') + old=rows[r];other=shifted(old,(2,)+(0,)*(width-1));rows[r]=[{}for _ in range(n)] + for dst,a,b in zip(rows[r],old,other): + accumulate(dst,a,(Q(1,2),Q(sign,2)));accumulate(dst,b,(Q(1,2),Q(-sign,2))) + elif op in('IDLE','IDLE_ONE'): + roles,stages=(event[1:3],event[3])if op=='IDLE'else([event[1]],event[2]) + need(len(stages)==len(set(stages)),'Distinct whole-idle axes') + term=(0,)+tuple(int(s in stages)for s in range(width-1)) + for r in roles:rows[r]=shifted(rows[r],term) + else:raise ValueError('Unknown caller opcode') + expected=[[{(word['diagonal'][i][0]%4,)+tuple(word['diagonal'][i][1:]):coefficient(1)}if i==j else {}for j in range(n)]for i in range(n)] + need(sorted(seen)==list(range(1,word['stages']+1)),'Every distinct native stage once') + need(rows==expected,'Every arbitrary-input forward coefficient') + return {'inputs':n,'coefficients':n*n,'native_stages':len(seen),'events':len(word['events']), + 'event_sha256':sha256(json.dumps(word['events'],separators=(',',':')).encode()).hexdigest()} + +def controls(word): + controls={} + for op in('LOCAL','QUERY','IDLE','IDLE_ONE','LAMBDA','ADD'): + bad=deepcopy(word);del bad['events'][next(i for i,e in enumerate(bad['events'])if e[0]==op)] + try:replay(bad) + except ValueError as error:controls['missing_'+op.lower()]=str(error) + else:raise ValueError('Missing gate accepted: '+op) + return controls diff --git a/research/native-retimed-helper-split/retained/caller/independent.py b/research/native-retimed-helper-split/retained/caller/independent.py new file mode 100644 index 0000000000..772d19a926 --- /dev/null +++ b/research/native-retimed-helper-split/retained/caller/independent.py @@ -0,0 +1,231 @@ +"""Independent exact caller audit, requiring only the standard library. + +Binary suppliers and the dual-pair retirement method retain the authors +and credits recorded in source6702 and PR6545. The paid fragmentation, changed root and their +literal word are independently checked here using a separately written +Fraction Laurent-ring engine. No author constructor, replay, algebra, +native implementation, or saved mathematical result is imported. +OpenAI Codex assistance. Apache-2.0. + +Every fresh stage remains a distinct formal variable; only q^4=1 is +imposed. This does not replace native absolute-phase or physical checks, +discharge framework assumptions, or establish scientific admission. +""" +from argparse import ArgumentParser +from copy import deepcopy +from fractions import Fraction as F +from hashlib import sha256 +from pathlib import Path +import json +import sys + +sys.dont_write_bytecode = True +HERE = Path(__file__).resolve().parent +ZERO = F(0), F(0) +ONE = F(1), F(0) + + +def need(ok, message): + if not ok: + raise ValueError(message) + + +def complex_product(a, b): + return a[0] * b[0] - a[1] * b[1], a[0] * b[1] + a[1] * b[0] + + +def plus(a, b, factor=ONE): + out = dict(a) + for monomial, coefficient in b.items(): + z = complex_product(coefficient, factor) + old = out.get(monomial, ZERO) + z = old[0] + z[0], old[1] + z[1] + if z == ZERO: + out.pop(monomial, None) + else: + out[monomial] = z + return out + + +def scale(a, scalar): + scalar = F(scalar) + return {k: complex_product(v, (scalar, F(0))) for k, v in a.items()} if scalar else {} + + +def shift(a, q=0, stages=(), degree=1): + out = {} + for monomial, coefficient in a.items(): + key = list(monomial) + key[0] = (key[0] + q) % 4 + for stage in stages: + key[stage] += degree + out = plus(out, {tuple(key): coefficient}) + return out + + +def lam(a, sign): + need(sign in (-1, 1), 'Literal normalization sign') + return plus(plus({}, a, (F(1, 2), F(sign, 2))), + shift(a, q=2), (F(1, 2), F(-sign, 2))) + + +def normalized_central(a): + return lam(shift(a, q=-1), 1) + + +def forward(vector, event): + op = event[0] + if op == 'ADD': + vector[event[1]] = plus(vector[event[1]], vector[event[2]], (F(event[3]), F(0))) + elif op == 'SWAP': + vector[event[1]], vector[event[2]] = vector[event[2]], vector[event[1]] + elif op == 'SCALE': + vector[event[1]] = scale(vector[event[1]], event[2]) + elif op == 'LAMBDA': + vector[event[1]] = lam(vector[event[1]], event[2]) + elif op == 'Q_POWER': + vector[event[1]] = shift(vector[event[1]], q=event[2]) + elif op == 'QUERY': + vector[event[1]] = plus(vector[event[1]], shift(vector[event[2]], q=event[3])) + elif op == 'LOCAL': + _, stage, src, dst = event + vector[dst] = plus(vector[dst], shift(vector[src], q=-1)) + for owner in (src, dst): + vector[owner] = shift(vector[owner], stages=[stage]) + elif op in ('IDLE', 'IDLE_ONE'): + owners, stages = (event[1:3], event[3]) if op == 'IDLE' else ([event[1]], event[2]) + need(len(stages) == len(set(stages)), 'Distinct actual idle axes') + for owner in owners: + vector[owner] = shift(vector[owner], stages=stages) + else: + raise ValueError('Unknown event ' + op) + + +def right_action(row, event): + """Right multiplication by a forward event; never an inverse oracle.""" + op = event[0] + if op == 'ADD': + row[event[2]] = plus(row[event[2]], row[event[1]], (F(event[3]), F(0))) + elif op == 'SWAP': + row[event[1]], row[event[2]] = row[event[2]], row[event[1]] + elif op == 'SCALE': + row[event[1]] = scale(row[event[1]], event[2]) + elif op == 'LAMBDA': + row[event[1]] = lam(row[event[1]], event[2]) + elif op == 'Q_POWER': + row[event[1]] = shift(row[event[1]], q=event[2]) + elif op == 'QUERY': + row[event[2]] = plus(row[event[2]], shift(row[event[1]], q=event[3])) + elif op == 'LOCAL': + _, stage, src, dst = event + for owner in (src, dst): + row[owner] = shift(row[owner], stages=[stage]) + row[src] = plus(row[src], shift(row[dst], q=-1)) + elif op in ('IDLE', 'IDLE_ONE'): + owners, stages = (event[1:3], event[3]) if op == 'IDLE' else ([event[1]], event[2]) + need(len(stages) == len(set(stages)), 'Distinct actual idle axes') + for owner in owners: + row[owner] = shift(row[owner], stages=stages) + else: + raise ValueError('Unknown event ' + op) + + +def vector(n, one, entries): + out = [{} for _ in range(n)] + for role, coefficient in entries.items(): + out[role] = scale(one, coefficient) + return out + + +def dot(left, right): + out = {} + for a, b in zip(left, right): + for monomial, coefficient in a.items(): + term = shift(b, q=monomial[0]) + for stage, degree in enumerate(monomial[1:], 1): + if degree: + term = shift(term, stages=[stage], degree=degree) + out = plus(out, term, coefficient) + return out + + +def check_pair(base,witness,second=False): + n=base['roles'];one={(0,)*(base['stages']+1):ONE};pivot=4 if second else 6 + entries=({'c':{4:-1,5:2},'d':{4:-1},'a':{1:-1,2:1},'b':{0:-1,2:1}}if second else{'c':{6:-2,7:1},'d':{7:1},'a':{0:-1,2:1},'b':{1:-1,2:1}}) + c,d,a,b=[vector(n,one,entries[k])for k in('c','d','a','b')] + need(dot(d,c)==dot(b,a)==one,'Both dyadic dual pairings') + cut=witness['cut_after'];stages=[10]if second else[5,6,7,8] + need(cut==(394 if second else 158)and base['events'][cut]==['IDLE_ONE',2,stages],'Actual paid-fragment cut') + def factor(p): + p=shift(p,stages=stages) + return normalized_central(p)if second else p + col=deepcopy(c) + for e in base['events'][:cut+1]:forward(col,e) + need(col==[factor(p)for p in a],'Actual prefix column, including its normalized central phase') + row=deepcopy(b) + for e in reversed(base['events'][:cut+1]):right_action(row,e) + need(row==[factor(p)for p in d],'Actual prefix row, with no inverse inference') + unit=vector(n,one,{pivot:1});col=deepcopy(unit) + for e in witness['input_basis']:forward(col,e) + need(col==c,'Input basis literal column') + inv=[] + for e in reversed(witness['input_basis']): + e=deepcopy(e) + if e[0]=='ADD':e[-1]=str(-F(e[-1])) + elif e[0]=='SCALE':e[-1]=str(1/F(e[-1])) + inv.append(e) + row=deepcopy(unit) + for e in reversed(inv):right_action(row,e) + need(row==d,'Input basis inverse literal row') + cut_basis=witness['cut_basis'][:-1]if second else witness['cut_basis'] + col=deepcopy(a) + for e in cut_basis:forward(col,e) + need(col==unit,'Cut basis literal column') + row=deepcopy(unit) + for e in reversed(cut_basis):right_action(row,e) + need(row==b,'Cut basis literal row') + if second:need(witness['cut_basis'][-1]==['LAMBDA',4,-1],'Ordinary normalization of S D into q^-1 D') + return{'cut_after':cut,'pivot':pivot,'head':int(second),'prefix_stages':stages,'dual_pairings':'1','all_coefficients':'exact Laurent/Gaussian','odd_denominators':False} + +def check_word(word): + n=word['roles'];one={(0,)*(word['stages']+1):ONE} + need((n,word['stages'],len(word['events']))==(34,18,606),'Complete independent-input census') + need(all(t[1]==0 for t in word['diagonal']),'No untested old stage') + need(sorted(e[1]for e in word['events']if e[0]=='LOCAL')==list(range(1,19)),'All distinct stages exactly once') + for j in range(n): + v=vector(n,one,{j:1}) + for e in word['events']:forward(v,e) + d=word['diagonal'][j];expected=[{}for _ in range(n)];expected[j]={(d[0]%4,*d[2:]):ONE} + need(v==expected,'Independent forward column '+str(j)) + v=vector(n,one,{j:1}) + for e in reversed(word['events']):right_action(v,e) + need(v==expected,'Independent reverse row '+str(j)) + return{'inputs':n,'forward_coefficients':n*n,'reverse_coefficients':n*n,'events':606,'independent_body_variables':18} + +def rejected(f): + try:f() + except ValueError as e:return str(e) + raise ValueError('Invalid control accepted') + +def run(): + paths=[HERE/n for n in('CALLER-UNRETIRED.json','CALLER-ONE-RETIRED.json','CONTROLLER.json','RETIREMENT-WITNESSES.json')] + base,one,word,witness=[json.loads(p.read_bytes())for p in paths] + pairs=[check_pair(base,witness[0]),check_pair(one,witness[1],True)];whole=check_word(word);controls={} + for op in('LOCAL','QUERY','IDLE','IDLE_ONE','LAMBDA','ADD'): + bad=deepcopy(word);j=next(i for i,e in enumerate(bad['events'])if e[0]==op);bad['events'][j]=['SCALE',0,'1'] + controls['omitted_'+op]=rejected(lambda bad=bad:check_word(bad)) + for label,index in [('first_input',3),('first_handoff',witness[0]['handoff_after']+3),('second_handoff',witness[1]['handoff_after']),('final_return',605)]: + bad=deepcopy(word);bad['events'][index]=['SCALE',0,'1'] + controls[label]=rejected(lambda bad=bad:check_word(bad)) + for role in(6,32,33): + bad=deepcopy(word);bad['diagonal'][role][0]=0 if role==32 else -1 + controls['unearned_head_'+str(role)]=rejected(lambda bad=bad:check_word(bad)) + bad=deepcopy(word);bad['events'][witness[1]['handoff_after']][-1]=1 + controls['wrong_cut_normalizer']=rejected(lambda:check_word(bad)) + return{'status':'PASS_INDEPENDENT_TWO_PAID_FRAGMENTS','pairs':pairs,'word':whole,'negative_controls':controls,'inputs_sha256':{p.name:sha256(p.read_bytes()).hexdigest()for p in paths},'scope':'Exact all-input caller algebra and dyadic witnesses. Physical/native/finite/outer assumptions are separate.'} + +if __name__=='__main__': + r=run();raw=json.dumps(r,sort_keys=True,indent=2)+'\n' + if sys.argv[1:]==['--write']:(HERE/'INDEPENDENT.json').write_text(raw) + else:need((HERE/'INDEPENDENT.json').read_text()==raw,'Frozen independent audit') + print(r['status']) diff --git a/research/native-retimed-helper-split/retained/caller/pricing.py b/research/native-retimed-helper-split/retained/caller/pricing.py new file mode 100644 index 0000000000..5f92b18de7 --- /dev/null +++ b/research/native-retimed-helper-split/retained/caller/pricing.py @@ -0,0 +1,188 @@ +"""Complete price of the common-idle / second-retirement caller. + +The actual word and common-block construction are checked by the caller +package. This module independently counts every request and endpoint, then +uses the retained zxv/Cao Yifan interval engines, Jacob Alan Sussman compiler +and PR4359 outer ledger. Binary/caller/native authors retain their credit. +OpenAI Codex assistance, Apache-2.0. No selected-frontier change is inferred. +""" +from collections import Counter +from fractions import Fraction as Q + +KAPPA=Q('.00330720') +TESTED=Q('.003307205') +PREVIOUS=Q('.00330580') +HELPERS={1:14,2:8,3:4,4:108,5:16,6:3,7:9,8:40,9:361} +LOCAL_PAID={1:2231,2:454,3:490,4:109,5:152,6:8,7:9,8:1} + +def need(ok,message): + if not ok:raise ValueError(message) + +def encode(value): + if isinstance(value,Q):return str(value) + if isinstance(value,dict):return {str(k):encode(v)for k,v in value.items()} + if isinstance(value,(list,tuple)):return [encode(v)for v in value] + return value + +def formula_invoice(local): + T=Counter({r:18*n for r,n in local['helpers'].items()}) + P=Counter({r:18*n for r,n in local['paid'].items()}) + # Six child sizes(4,4,1,1,4,4), twelve genuine internal binary nodes. + for size,count in {2:8,4:4}.items(): + T[8*size+1]+=208*count + P[8*size]+=208*count + # Eight root outputs, one D target split into S,D and one BC into B,S*C. + T.update({145:104,73:208,41:208,9:208,1:104,32:208}) + P[1]+=15*104 + P[40]+=208 + P[32]+=208;P[8]+=208 # One whole common idle B+C and one paid fragmented direction. + return T,P + +def assemble(local,native,word,physical): + need(dict(local['paid'])==LOCAL_PAID and dict(local['helpers'])==HELPERS, + 'Exact PR6702 paid and independent-helper boundary') + need(local['helpers']==native['helpers'],'Every productive helper has a checked native map') + need(word['roles']==34 and word['stages']==18,'All independent main inputs and native stages') + T,P=Counter(),Counter();idle=Counter();counts=Counter(e[0]for e in word['events']) + for event in word['events']: + op=event[0] + if op=='LOCAL':T.update(local['helpers']);P.update(local['paid']) + elif op=='QUERY':P[1]+=104 + elif op in('IDLE','IDLE_ONE'): + stages=event[3]if op=='IDLE'else event[2] + need(len(stages)==len(set(stages)),'No repeated fresh axis in a whole idle') + r=8*len(stages);n=208 if op=='IDLE'else 104 + P[r]+=n;idle[r]+=n + main=Counter() + for term in word['diagonal']: + need(not term[1],'No old nonfresh stage-zero factor is silently present') + main[int(term[0]%2)+8*sum(term[2:])]+=104 + T.update(main) + need((T,P)==formula_invoice(local),'Formula and every emitted Gaussian request agree') + need(main==physical['main_targets'],'Every main target has its checked absolute physical phase') + need(idle==physical['whole_idle_jobs'],'Every fused and unfused whole idle is physically checked') + need((counts['LOCAL'],counts['QUERY'],counts['IDLE'],counts['IDLE_ONE'],counts['LAMBDA'])==(18,15,12,6,100), + 'Complete literal paid/normalization census') + need(len(word['events'])==606,'Every ordinary basis and retirement gate is present') + need((sum(T.values()),sum(P.values()))==(13670,66852),'All independent targets and paid requests') + need(sum(r*n for r,n in T.items())-sum(r*n for r,n in P.items())==760,'Exact unchanged rank-mass surplus') + need((max(T),max(P))==(145,40),'Actual maximum target and paid ranks') + return T,P,counts + +def ordinary(local,native,word): + from scalars import verify as scalar_envelope + actual_scalars=scalar_envelope(word) + need(native['helper_normalizers']==2*sum(HELPERS.values()) and native['main_adapters']==208, + 'Native normalization counts derive from every independent helper and main port') + need(local['owned_lifetimes']==47 and local['peak_owned_fields']==14, + 'Unchanged actual native owned lifetimes and peak') + need(local['public_inputs']==771 and local['owned_fields']==29, + 'Exact native public and owned label inventory') + # Source routes are literal whole-job / fixed17-axis route rates. The + # rates remain framework contracts; their counts are recomputed here. + routes=(sum(local['paid'].values())+native['helper_normalizers']+native['main_adapters'] + +4*104+4*local['owned_lifetimes'])*1000 + per_call=local['real_scalar_allowance']+routes + need(per_call<10**7,'All actual local scalar and route work fits the displayed per-call bound') + scalars=[abs(Q(e[-1]))for e in word['events']if e[0]in('ADD','SCALE')] + need(all(x and x.denominator&(x.denominator-1)==0 for x in scalars),'Every new basis coefficient is nonzero dyadic') + need(max(x.numerator.bit_length()for x in scalars)<=8 and max(x.denominator.bit_length()for x in scalars)<=7, + 'Literal dyadic coefficient-height gate, including the coefficient144') + # The complete Horner work is checked gate by gate, including coefficient144. + # scalar_envelope checks every actual gate's complete joint Horner, + # halving/sign and destination-add cost and coefficient height. + # Scanning all34 fields for each gate is an explicit overcount. + caller=32*word['roles']*104*len(word['events']) + need(104*actual_scalars['real_scalar_units_per_port']<=caller and + 104*actual_scalars['coefficient_height_units']<=caller, + 'Actual complete scalar work and height fit the new envelope') + thin=15*16*104 + output=word['roles']*104*(26+1000) + total=18*10**7+thin+caller+output + need(total<10**9,'Fresh complete ordinary count, not an opaque predecessor allowance') + return {'local_scalar':local['real_scalar_allowance'],'local_routes':routes,'local_per_call_counted':per_call, + 'local_per_call_upper':10**7,'native_invocations':18,'caller_gate_passes':caller,'thin_query_work':thin, + 'all_main_output_normalizers':output,'raw_scalar_upper':total,'raw_budget':10**9, + 'maximum_literal_scalar':max(scalars),'scalar_numerator_bits':8,'scalar_denominator_bits':7, + 'actual_scalar_work_per_port':actual_scalars['real_scalar_units_per_port'], + 'actual_scalar_height_per_port':actual_scalars['coefficient_height_units'], + 'peak_owned_fields':14,'native_owned_lifetimes':47,'new_productive_fresh_fields_per_port':2, + 'native_public_inputs':771,'native_owned_labels':29, + 'thin_owned_contract':'One uncredited copied-query stream reused sequentially, cleared on return; no new helper credit.', + 'scalar_growth_bound':'At most 2^(10^9+R*f), R the recounted complete paid rank mass; inherited physical precision/tape rates remain assumptions.'} + +def run(local,native,word,physical,L): + T,P,counts=assemble(local,native,word,physical) + work=ordinary(local,native,word) + E=L.load(L.ROOT/'research/higher-moment-strictification/verify.py','root8_first_intervals') + other=L.load(L.ROOT/'research/kappa-rebuild/architecture/mixed_target_probe.py','root8_second_intervals') + def margin(k): + t,p=E.moment(T,1-k),E.moment(P,1-k) + return t[0]-p[1],t[1]-p[0] + lower,upper=Q('.0033072446848'),Q('.0033072446849') + need(PREVIOUS0 and second[0]>0, + 'Both engines prove the raw endpoint/tested signs') + endpoints[name]={'first':E.display(first),'second':E.display(second)} + signed=Counter(T);signed.subtract(P);derivative=Q(0) + for r,n in signed.items(): + log=E.log_bounds(r) + derivative-=n*(E.mul(E.power(r,1-Q('.0034')),log)[0]if n>=0 else r*log[1]) + need(derivative<0,'Unique raw crossing through the retained BIT cap') + t,offset,power,cutoff,floor=1-TESTED,Q(1,7),1920,11,12 + target,paid=E.moment(T,t),E.moment(P,t) + alpha=E.divide(paid,target) + gamma=E.divide(E.moment(P,t+offset),E.mul(E.power(cutoff,offset),target)) + delta=E.divide((Q(sum(T.values())*floor),)*2,E.mul(E.power(cutoff,TESTED),target)) + reserve,decay=Q(1,10**27),Q(31,32) + need(alpha[1]<1-reserve and gamma[1]theta**logarithm_power,'Compiler shifted exits and complement capacity') + need(factor[1]<2**logarithm_power,'Compiler initial range') + gap=(TESTED-KAPPA)/7;need(gap.numerator==1,'Exact positive compiler grid') + step=gap.denominator + def wins(j):return(step*j+1)**logarithm_power<2**j + left,right=1,2 + while not wins(right):left,right=right,2*right + while right-left>1: + middle=(left+right)//2 + if wins(middle):right=middle + else:left=middle + H=step*right + need(H>8*power and wins(right)and not wins(right-1),'Explicit uniform threshold and adjacent-grid control') + bit=L.read(L.ROOT/'research/query-thinned-controllers/RESULT.json')['ordinary_BIT'] + atom=Q(bit['atom']);ordinary_bit=(1-atom)*Q(bit['after_cover'])+atom*Q('.0000384599');admitted=Q(bit['admitted']) + need(atom>ordinary_bit>admitted>TESTED and atom<1-ordinary_bit,'Retained ordinary/admitted BIT stock and savings') + outer_module=L.load(L.ROOT/'research/pr4359-p7-padding/dependencies/compiler-refill/endpoint.py','root8_outer') + params={'kappa':KAPPA,'tested_saving':TESTED,'complex_uniform_saving':KAPPA+6*gap, + 'b':KAPPA+5*gap,'a':KAPPA+4*gap,'q':KAPPA+3*gap,'bit_saving':admitted, + 'epsilon':1-gap,'beta':1-3*gap,'r0':gap/10,'stop':gap,'layout':gap,'d':gap} + outer=outer_module.ledger(params) + outer['functional_checks']['actual_new_BIT_stock_sublinear']=params['beta']*(1-atom) + need(len(outer['strict_checks'])==54 and len(outer['functional_checks'])==4,'Complete54+4 outer inventory') + need(all(v>0 for k in('strict_checks','functional_checks')for v in outer[k].values()),'Every outer inequality is strict') + bad=outer_module.ledger(dict(params,bit_saving=Q('.0027'))) + need(any(v<=0 for v in bad['strict_checks'].values()),'Insufficient BIT budget rejected') + work['paid_rank_mass']=sum(r*n for r,n in P.items()) + return encode({'status':'PASS_TWO_PAID_FRAGMENTS_COMPLETE_PRICE','kappa':KAPPA,'tested':TESTED, + 'targets':T,'paid':P,'productive_fields':sum(T.values()),'paid_calls':sum(P.values()),'rank_mass_surplus':760, + 'full_calls':18,'thin_queries':15,'whole_idle_jobs':3120,'counts':counts,'raw_root_interval':[lower,upper], + 'raw_endpoint_margins':endpoints,'derivative_upper':derivative,'nonrecursive':work, + 'strictification':{'power':power,'cutoff':cutoff,'floor':floor,'offset':offset,'reserve':reserve,'decay':decay, + 'alpha':E.display(alpha),'gamma':E.display(gamma),'delta':E.display(delta), + 'alternative_12_13_delta':E.display(alternative_delta),'normalized_upper':normalized}, + 'compiler':{'H':H,'N':'2^'+str(H),'integer_test_exponent':right,'theta':theta,'logarithm_power':logarithm_power, + 'eta':E.display(eta),'gap':gap,'uniform_saving':params['complex_uniform_saving'],'word_materialized':False}, + 'ordinary_BIT':bit,'outer':outer,'source_assumptions':['native_all_columns','owned_erasure','compiler','precision_tape','analytic_recovery'], + 'scope':'Complete conditional price, requiring the supplied caller/native/physical inputs to be independently verified by the package. Does not itself verify those scientific inputs, discharge inherited assumptions, establish scientific admission, or change selected kappa.'}) diff --git a/research/native-retimed-helper-split/retained/caller/retirement.py b/research/native-retimed-helper-split/retained/caller/retirement.py new file mode 100644 index 0000000000..511b7cefd2 --- /dev/null +++ b/research/native-retimed-helper-split/retained/caller/retirement.py @@ -0,0 +1,37 @@ +"""Literal independent body-bearing retirement, followed by retained D retirement.""" +from copy import deepcopy +from fractions import Fraction as Q +from pathlib import Path +HERE=Path(__file__).resolve().parent +def ordinary_inverse(events): + out=deepcopy(list(reversed(events))) + for e in out: + if e[0]=='ADD': e[-1]=str(-Q(e[-1])) + elif e[0]=='SCALE': e[-1]=str(1/Q(e[-1])) + elif e[0]=='LAMBDA': e[-1]=-e[-1] + elif e[0]!='SWAP': raise ValueError('ordinary inverse opcode') + return out + +SLOTS={'ADD':(1,2),'SWAP':(1,2),'SCALE':(1,),'LAMBDA':(1,),'Q_POWER':(1,),'QUERY':(1,2),'LOCAL':(2,3),'IDLE':(1,2),'IDLE_ONE':(1,)} + +def retire(w,pivot,E,A,stages,head,expected_cut): + w=deepcopy(w);fresh=w['roles'];cut=w['events'].index(['IDLE_ONE',2,stages]) + assert cut==expected_cut + def rename(e): + e=deepcopy(e) + for j in SLOTS[e[0]]: + if e[j]==pivot:e[j]=fresh + return e + ev=E+w['events'][:cut+1]+A;handoff=len(ev)-1 + ev +=[rename(e)for e in ordinary_inverse(A)+w['events'][cut+1:]+ordinary_inverse(E)] + old=w['diagonal'][pivot];prefix=[0]*(w['stages']+2);prefix[0]=-head + for s in stages:prefix[s+1]=1 + suffix=[x-y for x,y in zip(old,prefix)] + w['events']=ev;w['roles']+=1;w['diagonal'][pivot]=prefix;w['diagonal'].append(suffix) + w['schema']='two-paid-fragments-two-independent-retirements/1' + return w,dict(cut_after=cut,handoff_after=handoff,pivot=pivot,fresh=fresh,input_basis=E,cut_basis=A,prefix_stages=stages,head=head,prefix_target=prefix,suffix_target=suffix) + +def construct(base): + one,a=retire(base,6,[['ADD', 6, 7, '1'], ['SCALE', 6, '-1'], ['ADD', 7, 6, '2'], ['SWAP', 6, 7], ['ADD', 7, 6, '-1']],[['ADD', 0, 2, '1'], ['ADD', 2, 1, '-1'], ['SWAP', 2, 6]],[5, 6, 7, 8],0,158) + two,b=retire(one,4,[['SCALE', 5, '-1'], ['SCALE', 4, '-1'], ['ADD', 5, 4, '-2']],[['ADD', 1, 2, '1'], ['ADD', 2, 0, '-1'], ['SWAP', 2, 4], ['LAMBDA', 4, -1]],[10],1,394) + return one,two,[a,b] diff --git a/research/native-retimed-helper-split/retained/caller/root_check.py b/research/native-retimed-helper-split/retained/caller/root_check.py new file mode 100644 index 0000000000..ee4f089aa6 --- /dev/null +++ b/research/native-retimed-helper-split/retained/caller/root_check.py @@ -0,0 +1,38 @@ +"""Exact two-pair root, all independent stage coefficients and native bases.""" +from itertools import product +from algebra import Q,need,eye,matrix,multiply,inverse,add + +def verify(data): + I=eye(8);Z=[[Q(0)]*8 for _ in range(8)] + def diag(mask):return[[Q(int(i==j and mask>>i&1))for j in range(8)]for i in range(8)] + full=data['full_sites'];masks=data['masks'];need(full==[0,1,2,6,7,8]and masks==[3,195,195,53,53,5],'Actual two-pair root support') + Rs=[matrix(r)for r in data['queries']];ps={i:diag(masks[full.index(i)])for i in full};K=I + E=[[Q(int(i==0 and j==1))for j in range(8)]for i in range(8)] + for i,R in enumerate(Rs): + need(R!=Z and multiply(R,R)==Z,'Actual nonzero nilpotent query') + K=multiply(add(I,R,-2),K) + if i in ps: + P=ps[i];need(multiply(P,R)==R and multiply(R,P)==R,'Native stage support') + need(multiply(P,K)==multiply(K,P),'Every full-stage prefix commutant') + if i in(2,7):continue + C=matrix(data['bases'][str(i)]);Ci=inverse(C) + need(multiply(multiply(Ci,R),C)==E,'Rank-one actual native query basis') + if i in ps: + rho=data['stage_ranks'][full.index(i)];need(multiply(multiply(Ci,ps[i]),C)==diag((1<32 or increment>32:raise ValueError('Fresh 32-unit ordinary envelope fails') + total+=work;height+=increment + return {'real_scalar_units_per_port':total,'coefficient_height_units':height, + 'max_scalar':str(maximum),'per_instruction_envelope':32,'event_census':dict(counts), + 'ordinary_lambdas':counts['LAMBDA'],'uncharged_gaussian_jobs':0} diff --git a/research/native-retimed-helper-split/retained/native/PR6702-WORD.json.gz b/research/native-retimed-helper-split/retained/native/PR6702-WORD.json.gz new file mode 100644 index 0000000000..3aa0220fe3 Binary files /dev/null and b/research/native-retimed-helper-split/retained/native/PR6702-WORD.json.gz differ diff --git a/research/native-retimed-helper-split/retained/native/clifford_exact.py b/research/native-retimed-helper-split/retained/native/clifford_exact.py new file mode 100644 index 0000000000..166841a037 --- /dev/null +++ b/research/native-retimed-helper-split/retained/native/clifford_exact.py @@ -0,0 +1,149 @@ +"""Small exact Gaussian-dyadic Clifford compiler, independent of gx internals. +Paulis use i^p X^x Z^z. State vectors use integer Gaussian numerators / 2^d. +The tableau is supplemented by a literal circuit, so global phases are kept. +""" +from dataclasses import dataclass + +def parity(x):return x.bit_count()&1 +def rank(rows): + p={} + for x in rows: + while x: + b=x.bit_length()-1 + if b not in p:p[b]=x;break + x^=p[b] + return len(p) +def transpose(rows,n):return tuple(sum(((rows[j]>>i)&1)<>j&1);a[j],a[k]=a[k],a[j] + for i in range(n): + if i!=j and a[i]>>j&1:a[i]^=a[j] + assert [r&((1<>n for r in a) +def basis_extend(cols,n): + out=[] + for x in list(cols)+[1<len(out):out.append(x) + assert len(out)==n + return tuple(out) +def nullspace(rows,n): + a=list(rows);p=[];k=0 + for j in range(n): + t=next((i for i in range(k,len(a)) if a[i]>>j&1),None) + if t is None:continue + a[t],a[k]=a[k],a[t] + for i in range(len(a)): + if i!=k and a[i]>>j&1:a[i]^=a[k] + p.append(j);k+=1 + return tuple((1<>j)&1)<>i&1:out=pmul(out,T[i]) + for i in range(n): + if z>>i&1:out=pmul(out,T[n+i]) + return out +def compose(A,B):return tuple(apply(A,p) for p in B) +def inverse(T): + n=len(T)//2;cols=[x|(z<>n;u,v,p=apply(T,(x,z,0));assert (u,v)==identity(n)[j][:2];out.append((x,z,(-p)%4)) + return tuple(out) +def qvalue(Q,alpha,x,n): + return (sum(alpha[i] for i in range(n) if x>>i&1)+2*sum(parity((Q[i]>>(i+1))&(x>>(i+1))) for i in range(n) if x>>i&1))%4 +def mul_i(a,p): + x,y=a;p%=4 + return [(x,y),(-y,x),(-x,-y),(y,-x)][p] +@dataclass +class Op: + n:int + tab:tuple + circuit:list + def then(self,b): + assert self.n==b.n + return Op(self.n,compose(b.tab,self.tab),self.circuit+b.circuit) + def adjoint(self): + circ=[] + for e in reversed(self.circuit): + if e[0]=='P':circ.append(('P',inv(e[1],self.n))) + elif e[0]=='D':circ.append(('D',e[1],tuple((-x)%4 for x in e[2]))) + elif e[0]=='C':circ.append(('C',e[1],-e[2])) + elif e[0]=='phase':circ.append(('phase',(-e[1])%4)) + else:circ.append(e) + return Op(self.n,inverse(self.tab),circ) + def zero_state(self,basis=0): + N=1<>i)&1 for i in range(n)) + assert all(alpha[i]%2==(Q[i]>>i)&1 for i in range(n)) + return Op(n,tuple([(1<>i&1 else 0,1<>i&1 else 0) for i in range(n)]),[('C',q,sgn)]) +def xgate(n,b):return Op(n,tuple([(1<>i)&1)) for i in range(n)]),[('X',b)]) +def fourier(n,axes=None): + out=ident(n) + for i in range(n) if axes is None else axes:out=out.then(cgate(n,1<len(selected):picks.append(j);selected.append(x) + assert len(picks)==r and all(x>>r==0 for x in Bcols) + Br=transpose(selected,r);Bi=inv(Br,r);Dr=transpose([Dcols[j]&((1<= n) + if e[0] in ('ADD', 'COPY'): + e[2] += int(e[2] >= n) + return e + + def use_successor(event): + e = event.copy() + if e[1] == p: + e[1] = n + if e[0] in ('ADD', 'COPY') and e[2] == p: + e[2] = n + return e + + boundary, middle = basis(c, d, p, u), basis(a, b, p, f) + out = deepcopy(word) + out['public'] = n+1 + out['initial'].append(f) + out['final'].append(v) + out['final'][p] = f + out['program'] = inverse(boundary) + out['program'] += [shift_owned(e) for e in word['program'][:cut+1]] + out['program'] += [shift_owned(e) for e in middle] + out['program'] += [use_successor(shift_owned(e)) for e in inverse(middle)] + out['program'] += [use_successor(shift_owned(e)) for e in word['program'][cut+1:]] + out['program'] += [use_successor([*e[:-1], v]) for e in boundary] + return out + + +def construct(source, witnesses): + word = deepcopy(source) + baseline = L.replay(source) + receipts = [] + for h in witnesses: + word = split(word, h) + result = L.replay(word) + L.need(result['paid'] == baseline['paid'], 'Every paid Gaussian occurrence retained') + receipts.append({'cut_after': h['cut_after'], 'pivot': h['pivot'], + 'ranks': h['ranks'], 'public': word['public'], + 'events': len(word['program'])}) + return word, receipts diff --git a/research/native-retimed-helper-split/retained/native/local.py b/research/native-retimed-helper-split/retained/native/local.py new file mode 100644 index 0000000000..e6e28bacda --- /dev/null +++ b/research/native-retimed-helper-split/retained/native/local.py @@ -0,0 +1,206 @@ +"""Check the complete P104 word with an independent helper inventory. + +Adapted from Ali Romman's PR5544/5545. David Arias supplied the word; +Cinna Davis supplied private reuse; Gareth Davidson supplied composition. +Prepared by Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. +""" +from collections import Counter +from fractions import Fraction as Q +from functools import lru_cache +from hashlib import sha256 +from pathlib import Path +import gzip +import importlib.util +import json +import sys + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] + +def need(ok, why): + if not ok: + raise ValueError(why) + +def read(path): + raw = path.read_bytes() + return json.loads(gzip.decompress(raw) if path.suffix == '.gz' else raw) + +def load(path, name): + spec = importlib.util.spec_from_file_location(name, path) + module = importlib.util.module_from_spec(spec) + sys.modules[name] = module + spec.loader.exec_module(module) + return module + +def add(dst, src, q): + for k, v in tuple(src.items()): + value = dst.get(k, 0) + q*v + if value: + dst[k] = value + else: + dst.pop(k, None) + +def span(basis): + out = {0} + for v in basis: + need(type(v) is int and 0 < v < 512 and v not in out, 'Independent binary basis') + out |= {x ^ v for x in tuple(out)} + return frozenset(out) + +def replay(w): + public = w['public'] + need(type(public) is int and 735 <= public <= 750, 'Public inventory bound') + need(len(w['initial']) == len(w['final']) == public, 'Public boundary size') + need(len(w['program']) < 26000, 'Fixed operation bound') + frames = [span(x) for x in w['frames']] + rows = [{r:Q(1)} for r in range(public+8)] + current = list(w['initial']) + [None]*8 + paid, scalar, live_owned, peak = Counter(), 0, set(), 0 + lifetimes = 0 + for e in w['program']: + op, r = e[:2] + need(0 <= r < public+8, 'Role index') + if op == 'MOVE': + _, r, a, b, private = e + need(current[r] == a and (r in live_owned) == private, 'Transport source and ownership') + need(frames[b] < frames[a] if private else frames[a] < frames[b], 'Nested chronological transport') + paid[abs(len(w['frames'][b])-len(w['frames'][a]))] += 1 + current[r] = b + elif op == 'INIT': + need(r >= public and r not in live_owned, 'Owned initialization') + live_owned.add(r) + lifetimes += 1 + peak = max(peak, len(live_owned)) + rows[r] = {} + current[r] = e[2] + scalar += 2 + elif op == 'CLEAR': + need(r in live_owned and current[r] == e[2], 'Owned erasure at declared frame') + rows[r] = {} + current[r] = None + live_owned.remove(r) + scalar += 2 + else: + q, f = Q(e[-2]), e[-1] + need(q and current[r] == f, 'Scalar destination and coefficient') + n, d = abs(q.numerator), q.denominator + need(d & (d-1) == 0, 'Dyadic scalar coefficient') + need(abs(q)+1 < 2**16, 'Fixed scalar growth bound') + if op == 'SCALE': + need(n & (n-1) == 0, 'Dyadic unit SCALE') + rows[r] = {k:q*x for k,x in rows[r].items()} + scalar += 2*(abs(n.bit_length()-d.bit_length()) + int(q < 0)) + else: + s = e[2] + need(s != r and 0 <= s < public+8 and current[s] == f, 'Common scalar chart') + if op == 'COPY': + need(r in live_owned and not rows[r], 'COPY into cleared owned field') + rows[r] = {k:q*x for k,x in rows[s].items()} + else: + need(op == 'ADD', 'Scalar opcode') + add(rows[r], rows[s], q) + scalar += 2*(3+n.bit_length()-1+n.bit_count()+d.bit_length()-1) + need(not live_owned and peak == 1 and current[:public] == w['final'], 'All public and owned exits') + live = set(w['live']) + for r,row in enumerate(rows): + expected = {r:Q(1)} if r < public else {} + if r-112 in live: + expected[r-112] = Q(1) + need(row == expected, 'All public and owned rows') + main = live | {r+112 for r in live} + helpers = Counter(len(w['frames'][w['final'][r]])-len(w['frames'][w['initial'][r]]) for r in range(public) if r not in main) + need(len(live) == len(w['ports']) == 104 and len(main) == 208 and min(helpers) > 0, 'Independent productive inputs') + return {'paid':dict(paid), 'helpers':dict(helpers), 'public_inputs':public, 'owned_lifetimes':lifetimes, + 'peak_owned_fields':peak, 'real_scalar_allowance':scalar, 'endpoint_coefficients':(public+8)*(public+8), + 'paid_rank_mass':sum(r*count for r,count in paid.items())} + +def reverse_columns(w): + """Check the transpose with dense dyadic rows and the reverse chronology.""" + public = w['public'] + n = public+8 + rows = [[int(i == j) for j in range(n)] for i in range(n)] + exponents = [0]*n + for e in reversed(w['program']): + op,r = e[:2] + if op == 'MOVE': + continue + if op in ('INIT','CLEAR'): + rows[r] = [0]*n + exponents[r] = 0 + continue + q = Q(e[-2]) + qe = q.denominator.bit_length()-1 + if op == 'SCALE': + rows[r] = [q.numerator*x for x in rows[r]] + exponents[r] += qe + else: + s = e[2] + level = max(exponents[s], exponents[r]+qe) + a, b = 1 << (level-exponents[s]), q.numerator << (level-exponents[r]-qe) + rows[s] = [a*x+b*y for x,y in zip(rows[s],rows[r])] + exponents[s] = level + if op == 'COPY': + rows[r] = [0]*n + exponents[r] = 0 + r = s + while exponents[r] and not any(x & 1 for x in rows[r]): + rows[r] = [x//2 for x in rows[r]] + exponents[r] -= 1 + for r,row in enumerate(rows): + expected = [0]*n + if r < public: + expected[r] = 1 << exponents[r] + if r in w['live']: + expected[r+112] = 1 << exponents[r] + need(row == expected, 'Independent dense transpose columns') + return {'columns':n, 'coefficients':n*n, 'arithmetic':'Dense integer rows with binary denominators; reverse chronology'} + +def native(w): + n = w['public'] + C = load(ROOT/'research/p104-native-channel/vendor/clifford_exact.py', 'p104_productive_clifford') + V = load(ROOT/'research/p104-native-channel/vendor/native_verify.py', 'p104_productive_gaussian') + @lru_cache(None) + def chart(i): + return C.canonical_frame(9, tuple(w['frames'][i])) + recipes = {} + def check(a,b): + if (a,b) not in recipes: + recipe,_ = C.lower_child(chart(a).adjoint().then(chart(b))) + expected = V.adjoint(V.frame(w['frames'][a],9)) + V.frame(w['frames'][b],9) + V.equal(V.recipe(recipe),expected,'Native chart change and exact global phase') + need(recipe['rank'] == abs(len(w['frames'][a])-len(w['frames'][b])), 'Native boundary rank') + recipes[a,b] = recipe + return recipes[a,b] + for e in w['program']: + if e[0] == 'MOVE': + check(e[2],e[3]) + main = set(w['live']) | {r+112 for r in w['live']} + helper_profile = Counter() + for r in range(n): + if r not in main: + helper_profile[check(w['initial'][r],w['final'][r])['rank']] += 1 + adapters = [] + for r,q in zip(w['live'],w['ports']): + need(w['frames'][w['initial'][r]] == [q], 'Literal central port') + need(span(w['frames'][w['final'][r+112]]) == frozenset(x for x in range(512) if not (x&q).bit_count()%2), 'Literal output hyperplane') + tests = [ + (C.cgate(9,q,1).adjoint().then(chart(w['initial'][r])), V.adjoint((('C',q,1),))+V.frame(w['frames'][w['initial'][r]],9)), + (chart(w['final'][r+112]).adjoint().then(C.cgate(9,q,-1).then(C.fourier(9))), V.adjoint(V.frame(w['frames'][w['final'][r+112]],9))+(('C',q,-1),)+V.fourier(9))] + for actual,expected in tests: + recipe,_ = C.lower_child(actual) + need(recipe['rank'] == 0, 'Free intrinsic main adapter') + V.equal(V.recipe(recipe),expected,'Main endpoint phase') + adapters.append(recipe) + bad = json.loads(json.dumps(next(iter(recipes.values())))) + bad['left']['phase'] = (bad['left']['phase']+1)%4 + a,b = next(iter(recipes)) + try: + V.equal(V.recipe(bad),V.adjoint(V.frame(w['frames'][a],9))+V.frame(w['frames'][b],9),'Wrong phase control') + except ValueError: + pass + else: + raise ValueError('Wrong native phase accepted') + payload = [[a,b,recipes[a,b]] for a,b in sorted(recipes)] + adapters + return {'distinct_maps':len(recipes),'main_adapters':len(adapters),'helper_normalizers':2*sum(helper_profile.values()), + 'helpers':dict(helper_profile),'recipe_payload_sha256':sha256(json.dumps(payload,sort_keys=True,separators=(',',':')).encode()).hexdigest(), + 'wrong_phase_rejected':True, 'proof':'Every signed Pauli image and exact global phase; frame induction at every positive tensor width'} diff --git a/research/native-retimed-helper-split/retained/native/native_verify.py b/research/native-retimed-helper-split/retained/native/native_verify.py new file mode 100644 index 0000000000..2c209dfa9c --- /dev/null +++ b/research/native-retimed-helper-split/retained/native/native_verify.py @@ -0,0 +1,277 @@ +"""Check native operators with exact Gaussian dyadic arithmetic. + +The interpreter is adapted from the independent campaign native review. +It does not import the source-code producer or the Clifford compiler. +Research used OpenAI Codex under the user's direction. +""" + +from functools import lru_cache + + +def require(condition, label): + if not condition: + raise ValueError(label) + + +def parity(value): + return value.bit_count() % 2 + + +def mul(matrix, vector): + return sum(parity(row & vector) << i for i, row in enumerate(matrix)) + + +def transpose(matrix): + return tuple(sum(((row >> j) & 1) << i for i, row in enumerate(matrix)) for j in range(len(matrix))) + + +def inverse(matrix): + n = len(matrix) + rows = [row | (1 << (n+i)) for i, row in enumerate(matrix)] + for j in range(n): + pivot = next((i for i in range(j, n) if rows[i] >> j & 1), None) + require(pivot is not None, 'singular binary chart') + rows[j], rows[pivot] = rows[pivot], rows[j] + for i in range(n): + if i != j and rows[i] >> j & 1: + rows[i] ^= rows[j] + require([row & ((1 << n)-1) for row in rows] == [1 << i for i in range(n)], 'binary inverse') + return tuple(row >> n for row in rows) + + +def extend(vectors, n): + columns, pivots = [], {} + for value in tuple(vectors) + tuple(1 << i for i in range(n)): + reduced = value + while reduced: + j = reduced.bit_length()-1 + if j not in pivots: + pivots[j] = reduced + columns.append(value) + break + reduced ^= pivots[j] + require(len(columns) == n, 'frame basis extension') + return tuple(columns) + + +def adjoint(circuit): + out = [] + for gate in reversed(circuit): + if gate[0] == 'P': + out.append(('P', inverse(gate[1]))) + elif gate[0] == 'D': + out.append(('D', gate[1], tuple(-a % 4 for a in gate[2]))) + elif gate[0] == 'C': + out.append(('C', gate[1], -gate[2])) + elif gate[0] == 'phase': + out.append(('phase', -gate[1] % 4)) + else: + require(gate[0] == 'X', 'adjoint gate type') + out.append(gate) + return tuple(out) + + +def fourier(rank): + return tuple(('C', 1 << i, 1) for i in range(rank)) + + +def frame(vectors, n): + rank = len(vectors) + if rank == 0: + return () + if rank == n: + return fourier(n) + matrix = transpose(extend(vectors, n)) + columns = transpose(inverse(matrix)) + quadratic = tuple((1 << i) ^ sum(parity(a & b) << j for j, b in enumerate(columns)) for i, a in enumerate(columns)) + diagonal = tuple((row >> i) & 1 for i, row in enumerate(quadratic)) + chart = (('P', matrix), ('D', quadratic, diagonal)) + return adjoint(chart) + fourier(rank) + chart + + +def monomial(record): + matrix = tuple(record['matrix_rows']) + quadratic = tuple(record['quadratic_rows']) + linear = tuple(record['linear_Z4']) + require(transpose(quadratic) == quadratic, 'quadratic symmetry') + require(len(matrix) == len(quadratic) == len(linear) == 9, 'monomial dimension') + require(all(a % 2 == (quadratic[i] >> i) & 1 for i, a in enumerate(linear)), 'diagonal parity') + inverse(matrix) + return (('D', quadratic, linear), ('P', matrix), ('X', record['offset']), ('phase', record['phase'])) + + +def recipe(record): + rank = record['rank'] + require(isinstance(rank, int) and 0 <= rank <= 9, 'child rank') + if rank == 0: + require(record['right'] is None, 'rank zero right factor') + return monomial(record['left']) + return monomial(record['right']) + fourier(rank) + monomial(record['left']) + + +def tableau(circuit, n=9): + rows = [(1 << i, 0, 0) for i in range(n)] + [(0, 1 << i, 0) for i in range(n)] + for gate in circuit: + tag = gate[0] + out = [] + inverse_transpose = transpose(inverse(gate[1])) if tag == 'P' else None + for x, z, phase in rows: + if tag == 'P': + x, z = mul(gate[1], x), mul(inverse_transpose, z) + elif tag == 'X': + phase += 2 * parity(z & gate[1]) + elif tag == 'C': + if parity(z & gate[1]): + x ^= gate[1] + phase += 3 * gate[2] + elif tag == 'D': + quadratic, linear = gate[1:] + phase += sum(linear[i] for i in range(n) if x >> i & 1) + phase += 2 * sum(parity((quadratic[i] >> (i+1)) & (x >> (i+1))) for i in range(n) if x >> i & 1) + z ^= mul(quadratic, x) + else: + require(tag == 'phase', 'tableau gate type') + out.append((x, z, phase % 4)) + rows = out + return tuple(rows) + + +@lru_cache(maxsize=512) +def action(gate): + if gate[0] == 'P': + return tuple(mul(gate[1], x) for x in range(512)) + require(gate[0] == 'D', 'state action type') + quadratic, linear = gate[1:] + return tuple((sum(linear[i] for i in range(9) if x >> i & 1) + + 2 * sum(parity((quadratic[i] >> (i+1)) & (x >> (i+1))) for i in range(9) if x >> i & 1)) % 4 for x in range(512)) + + +def rotate(pair, power): + a, b = pair + return ((a, b), (-b, a), (-a, -b), (b, -a))[power % 4] + + +def state(circuit, basis=0): + value, denominator = {basis: (1, 0)}, 0 + for gate in circuit: + tag = gate[0] + result = {} + if tag == "C": + direction, sign = gate[1:] + for address, (a, b) in value.items(): + for target, pair in ((address, (a - sign*b, b + sign*a)), + (address ^ direction, (a + sign*b, b - sign*a))): + old = result.get(target, (0, 0)) + result[target] = (old[0] + pair[0], old[1] + pair[1]) + denominator += 1 + else: + for address, pair in value.items(): + if tag == "P": + target = mul(gate[1], address) + elif tag == "X": + target = address ^ gate[1] + else: + target = address + if tag == "D": + pair = rotate(pair, action(gate)[address]) + else: + require(tag == "phase", "Unknown Gaussian state gate") + pair = rotate(pair, gate[1]) + require(target not in result, "A monomial address map is not injective") + result[target] = pair + value = {address: pair for address, pair in result.items() if pair != (0, 0)} + while denominator and all((a | b) % 2 == 0 for a, b in value.values()): + denominator -= 1 + value = {address: (a//2, b//2) for address, (a, b) in value.items()} + return value, denominator + + +def equal(actual, expected, label): + require(tableau(actual) == tableau(expected), label + ": signed Pauli action") + require(state(actual) == state(expected), label + ": exact global phase") + + +def verify(data, certificate): + word = data["word"] + original, clean = data["programs"], data["clean_programs"] + source_recipes = data["recipes"] + residuals = data["residuals"]["recipes"] + native_tags = {"climb", "adapter", "residual_adapter"} + for orientation in ("forward", "backward"): + native = [event for event in clean[orientation] if event[0] in native_tags] + require(native == [event for event in original[orientation] if event[0] in native_tags], + "A retained native event changed") + require(len(native) == 5056, "The retained native event count changed") + frames = [frame(tuple(vectors), 9) for vectors in word["frames"]] + used = {(event[3], event[4]) for program in clean.values() + for event in program if event[0] == "climb"} + children = {(record["old"], record["new"]): record for record in source_recipes["children"]} + require(len(children) == len(source_recipes["children"]) and used <= set(children), + "The retained child recipe coverage is incomplete") + for old, new in sorted(used): + record = children[old, new] + require(record["rank"] == len(word["frames"][new]) - len(word["frames"][old]), + "A retained child has the wrong rank") + equal(recipe(record), adjoint(frames[old]) + frames[new], "Retained child") + endpoints = {(record["role"], record["port"]): record + for record in source_recipes["endpoint_adapters"]} + require(len(endpoints) == len(source_recipes["endpoint_adapters"]) + and set(endpoints) == {(role, p) for role in ("source", "target") for p in range(112)}, + "The endpoint adapter coverage is incomplete") + for (role, port), record in endpoints.items(): + direction = word["ports"][port] + conventional = (("C", direction, 1),) if role == "source" else ( + ("C", direction, -1),) + fourier(9) + index = word["start"][port] if role == "source" else word["final"][112 + port] + require(record["frame"] == index and record["rank"] == 0, "An endpoint frame changed") + equal(recipe(record), adjoint(conventional) + frames[index], "Endpoint adapter") + used_residuals = set() + for program in clean.values(): + for event in program: + if event[0] != "residual_adapter": + continue + _, position, register, entry, *tail = event + terminal = tail[0] if tail else 1 + key = str(entry) if terminal == 1 else str(entry) + ":" + str(terminal) + require(key in residuals and position in ("pre", "post"), "A residual binding changed") + require(entry == word["start"][register] and terminal == word["final"][register], + "A residual endpoint changed") + used_residuals.add(key) + for key in sorted(used_residuals): + record = residuals[key] + equal(recipe(record), adjoint(frames[record["frame"]]) + frames[record.get("terminal", 1)], + "Residual adapter") + records = certificate["input_recipes"] + ports = certificate["compensation_ports"] + require([record["port"] for record in records] == ports and len(records) == 8, + "The eight input recipes changed") + columns = 0 + for item in records: + port, label = item["port"], item["label"] + require(label == word["ports"][port] and item["canonical_start_frame_id"] == word["start"][port], + "An input recipe has the wrong supplier label") + record = item["recipe"] + require(record["rank"] == 1, "An input copy has the wrong child rank") + for side in ("left", "right"): + factor = record[side] + require(factor["quadratic_rows"] == [0] * 9 and factor["linear_Z4"] == [0] * 9 + and factor["offset"] == factor["phase"] == 0, + "An input factor is not an address permutation") + actual, expected = recipe(record), (("C", label, 1),) + equal(actual, expected, "Positive inherited input line") + for basis in range(512): + require(state(actual, basis) == state(expected, basis), "A complete input Gaussian column differs") + columns += 1 + negative = monomial(record["right"]) + (("C", 1, -1),) + monomial(record["left"]) + require(tableau(negative) != tableau(expected) or state(negative) != state(expected), + "An inverse input child was not detected") + phased = actual + (("phase", 1),) + require(tableau(phased) == tableau(actual) and state(phased) != state(expected), + "An input phase-only error was not detected") + return {"status": "PASS_EXACT_INPUT_NATIVE_FRAMES", "retained_native_events_per_orientation": 5056, + "retained_child_recipes": len(used), "endpoint_adapter_recipes": len(endpoints), + "residual_adapter_recipes": len(used_residuals), "new_input_recipes": len(records), + "new_exact_gaussian_columns": columns, "inverse_input_child_controls": len(records), + "phase_only_controls": len(records), "address_permutation_factors": 2 * len(records), + "method": "Independent signed Pauli and exact Gaussian interpretation; no compiler import", + "scope": "Positive inherited input frames before every retained adapter. No recursive hosting claim."} diff --git a/research/native-retimed-helper-split/retained/physical-review/NOTICE b/research/native-retimed-helper-split/retained/physical-review/NOTICE new file mode 100644 index 0000000000..0b9b488b10 --- /dev/null +++ b/research/native-retimed-helper-split/retained/physical-review/NOTICE @@ -0,0 +1,10 @@ +Independent finite physical/contact, native chronology, disjoint-field allocation, +ordinary-budget and complete-invoice audit: +Jerry Chen (@CubeJerry), with substantial OpenAI assistance. Apache-2.0. + +This audit does not claim a new construction, kappa, scientific admission or +an all-size theorem. The positive #6726 two-fragment construction is by zxv +with substantial OpenAI Codex assistance. Retain thu-nmrc, Ali Romman, +Cinna Davis, DreamingOfClouds, Jacob Alan Sussman, Cao Yifan and all original +source-specific predecessor credit. The verbatim original notice is retained +in frozen/PREDECESSOR-NOTICE. Original frozen scientific bytes are unchanged. diff --git a/research/native-retimed-helper-split/retained/physical-review/PROOF.md b/research/native-retimed-helper-split/retained/physical-review/PROOF.md new file mode 100644 index 0000000000..5a5844ee9a --- /dev/null +++ b/research/native-retimed-helper-split/retained/physical-review/PROOF.md @@ -0,0 +1,130 @@ +# Finite physical and invoice argument + +This is an independent application audit of the literal #6726 source at `435bbe91fb28cb1d7a569ca70c6c4e9eb302d486`, not a new construction or an unconditional integer-multiplication theorem. The implementation is `verify.py`; its data inputs are frozen and authenticated. No author implementation is executed by this verifier. + +## 1. Exact phase equality from parity evaluations + +Let `T_a` be translation by a binary address vector `a` and let + +`G_a = ((1+i)/2) I + ((1-i)/2) T_a`. + +On a binary Fourier character indexed by `z`, this Gaussian has eigenvalue `i^(a·z mod 2)`. A signed product of these commuting Gaussians is therefore described by + +`f(z) = Σ_a c_a (a·z mod 2) mod 4`. + +Every factor equals one at `z=0`. Thus there is no undetected global scalar phase in this representation. For Boolean coordinates, + +`a·z mod 2 = Σ_{i∈a} z_i − 2 Σ_{i