diff --git a/research/p104-joint-helper-cache-funding-bound/BLOCK-LIFT.md b/research/p104-joint-helper-cache-funding-bound/BLOCK-LIFT.md new file mode 100644 index 0000000000..65d2ee3320 --- /dev/null +++ b/research/p104-joint-helper-cache-funding-bound/BLOCK-LIFT.md @@ -0,0 +1,116 @@ +# Lifting joint funding to arbitrary finite array dimension + +**Written block-linear extension, checked by two separate adversarial reviews.** +The scalar derivation is lifted below to arbitrary finite array dimension. +This draft assigns fractional accounting weights to scalar columns solely +to lower-bound the cost of fully lost original helper fields. It does not +create fractional productive jobs or permit unpriced target decoding. + +Let F be an infinite field of characteristic zero, let V=F^D, D>=1, and let +all native input variables be full vectors in V. Original normalized source +maps have scalar rational coefficients, so the covector space belonging to +a scalar source-row space A is A tensor V*. Let U now be an arbitrary linear +subspace of helper covectors H tensor V*. In particular, its matrices may +couple different array entries and need not commute. The helper promise is +ker U; original retained helper vectors indexed by I remain jointly arbitrary. + +## Expanded-coordinate funding + +Each original helper field h has D entry-columns. Assign each such column +the accounting weight f(R_h)/D. A fully lost helper field pays the total +weight f(R_h). Surjectivity onto retained whole helper vectors forces +restriction of U, and every necessary subspace W within U, to the lost +entry-columns to be injective. Thus the lost fields contain a column basis +for W. Their actual target debit is at least the minimum expanded column-basis +weight, denoted b_D(W). + +If W=A tensor V*, each target-rank prefix has rank D times the scalar prefix +rank. The ordinary weighted-column greedy formula therefore gives + + b_D(A tensor V*) = beta_f(A). + +This exact identity includes all whole zero-MOVE constraints. For an actual +zero set S, the necessary subspace is Z tensor V*, where Z=span(S). + +## A whole newly enabled cache forces D new directions + +Suppose a cache E is not enabled by the zero constraints alone: +`c_E notin P_E+Z`. Exact deterministic reconstruction of the entire target +vector from the original history on the linear domain implies, for each +basis covector e_a of V*, + + c_E tensor e_a = p_a + u_a, + p_a in P_E tensor V*, u_a in U. + +The helper-only condition on u_a places it in L_E tensor V*, because +intersections of finite-dimensional subspaces commute with extension by V*. +The D vectors u_a are independent modulo Z tensor V*. Indeed, a nontrivial +combination would give `c_E tensor v` in `(P_E+Z) tensor V*` for nonzero v. +A scalar separating functional annihilating P_E+Z but taking c_E to one +would then send that inclusion to `v=0`, a contradiction. + +Therefore + + W_E = (Z tensor V*) + span(u_1,...,u_D) + +has rank D(rank Z+1). On the expanded target-rank prefix C_k tensor V*, its +rank is bounded by both D rank(Z|C_k)+D and D rank((Z+L_E)|C_k). Hence + + rank(W_E | expanded C_k) + <= D min(rank(Z|C_k)+1, rank((Z+L_E)|C_k)). + +Take the generic scalar row u in L_E outside Z from the scalar proof. +The space `(Z+span u) tensor V*` attains all these upper bounds and has the +same full rank as W_E. Larger cheap-prefix ranks make a minimum basis no +more expensive. Consequently + + b_D(W_E) >= beta_f(Z+span u) = gamma_E. + +One can prove the price comparison directly by summation by parts: at fixed +full rank, the greedy price is the largest-rank price times full rank minus +the sum of each increasing price gap times the corresponding prefix rank. +This avoids assuming that special and generic block column matroids coincide. + +Every newly enabled cache supplies its own D-direction necessity. The actual +debit is at least the maximum of the individual gamma_E values. It is not +necessary for their generic witnesses to be simultaneously realizable. + +## Local bounds and global composition + +The largest and two six-zero block proofs also lift. Their zero relations +become tensor spaces; their required disjoint unit coordinates become +D-dimensional disjoint coordinate blocks. Appending a new cache adds D +dimensions, with each additional column priced at least f(a)/D when the +entire relevant support has rank at least a. The resulting extra debit is +at least f(a), exactly the scalar bound. The smaller blocks use the gamma_E +inequality above. Thus every local scalar upper profile remains valid. + +The exact scalar group decomposition is a direct sum. Tensoring with V* +preserves that direct sum. Select the necessary zero and cache relation rows +within each tensor group and apply Laplace expansion to an expanded-column +basis determinant. The disjoint column partition in a nonzero term pays +at least the sum of local minimum expanded basis weights. Overlapping whole +helper supports do not double-count target credit: their D separate entries +carry weights summing to the single whole helper price. + +This proves the same fine envelope for arbitrary finite D and arbitrary +block-linear helper promises, including noncommuting matrix coefficients. +The source frame/phase/whole-job contract is still inherited; this argument +does not itself establish the selected native_all_columns assumption. + +## Boundaries that must remain explicit + +- Only entire original MOVEs are deleted or replaced. A proposal that splits + a MOVE into partially cached subjobs needs its own productive and paid types. +- Only fully retained original helper fields receive the original target price. + Other fields are fully debited. New decoded target prices are not inferred. +- Main arrays remain arbitrary independently of helpers. Original source rows + and earlier information sets are unchanged, though processing may use any + linear operators or deterministic functions compatible with the linear domain. +- This is finite-dimensional for every D; no infinite-dimensional limit or + topological duality is invoked. + +Prepared for Jerry Chen / @CubeJerry with substantial OpenAI assistance. +Classical tensor-space, duality, weighted-matroid and determinant facts are +not claimed as new. Separate independent algorithmic/mathematical reviews are included under extensions/. +Neither independent human nor formal proof-kernel acceptance is claimed. diff --git a/research/p104-joint-helper-cache-funding-bound/INDEPENDENT-REVIEW.md b/research/p104-joint-helper-cache-funding-bound/INDEPENDENT-REVIEW.md new file mode 100644 index 0000000000..968c101767 --- /dev/null +++ b/research/p104-joint-helper-cache-funding-bound/INDEPENDENT-REVIEW.md @@ -0,0 +1,69 @@ +# Independent review of the joint source envelope + +## Source and local algebra + +Fresh exact replay checks all 76,475 source instructions, actual ownership and +frame geometry. It derives 47 strict owned histories, 33 main-only separators, +and fourteen helper-only cache spaces by projection rank-nullity. The proposed +567-row/rank525 decomposition, 418 groups, largest-block identity and four +omission certificates, support minima and quarter-power zero funding were +independently reconstructed before packaging. + +A separate maximum-pivot rational engine independently rebuilds the helper +intersections and every prefix rank in the eight small groups. It checks +43 zero subsets, 89 cache grant cases and 91 obligation profiles. Exactly +801 increasing-concave generator inequalities certify their ceilings. Actual +wrong-sign, missing-case, wrong-gamma and wrong-L mutations are rejected. +The two six-zero groups have separate128-subset/384-case corroboration. The +largest group has a compact written identity/omission/support proof; its +16,384-subset search is supporting evidence rather than the universal proof. + +## Complete price independence + +The complete actual caller invoice is reconstructed from authenticated bytes: +17 native calls,22,461 productive fields,110,519 paid jobs and rank surplus1424. +Directed rational logarithm/Taylor bounds prove the fine profiles, decreasing +upper envelope, crossing bracket and full .0038 margin. Independently written +integer-power brackets certify the same .0038 margin through f(r)^5000=r^4981. +Decimal arithmetic supplies seeds only. Thirteen fixed-grid intervals with +thousandth-power endpoint certificates cover all of [.01,1], not just a grid. + +Source-byte, paid-rank, main-support, target-weight, component, call-count, +target-sign and inward-bracket mutations execute failure detection. Registered +normal/optimized and read-only Git-free export results appear in VALIDATION.json. + +## Universal extensions and adversarial review + +Two separate reviewers independently derived the finite block proof. A whole +cache forces D new directions modulo the zero tensor space; cheap-prefix +rank domination and weighted greedy summation lower-bound their debit by the +scalar generic minimum. Laplace expansion composes the local necessary spaces. +The weights f(R)/D only lower-bound fully lost original helper-field prices; +they do not create fractional physical jobs or partial productive credit. + +Distinct exact fixtures include noncommuting nontensor relations with strict +prefix loss. Whole-output, retained-surjectivity and direct-sum controls reject +invalid extensions. These finite examples corroborate the written universal +proof; they are not its proof by sampling. + +The root independently reviewed the common-tangent deduction and the primary +stratification theorem. One point preserves every finite exact dependency; +the decoder itself need not be differentiated. Rational-real normalized maps +justify realification. Critical points, discrete grids, nonregular encodings +and main-dependent promises have explicit counterexamples or exclusions. +Arbitrary complex-block sources are not inferred to have the same tensor form. + +## Remaining boundaries + +Only original normalized maps, histories, whole helper prices and whole MOVE +jobs are covered. The joint budget grants zero deletions and owned caches; +nonzero public caches are separate. Preparation, copying, restoration, storage, +retirement and ordinary work are waived optimistically. Charging them cannot +rescue a negative moment. Changed producer information, decoded target types, +partial jobs and discrete promises need their own complete argument. + +This is a scoped source-budget result on an unselected comparator. Its crossing +is not an attained exponent. All five foundational assumptions remain. There is +no independent human, formal-kernel or hosted-CI acceptance. Prepared for Jerry +Chen / @CubeJerry with substantial OpenAI assistance and predecessor credit in +SOURCES.json and NOTICE. diff --git a/research/p104-joint-helper-cache-funding-bound/LICENSE b/research/p104-joint-helper-cache-funding-bound/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/p104-joint-helper-cache-funding-bound/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/research/p104-joint-helper-cache-funding-bound/NOTICE b/research/p104-joint-helper-cache-funding-bound/NOTICE new file mode 100644 index 0000000000..bbcfcfb2be --- /dev/null +++ b/research/p104-joint-helper-cache-funding-bound/NOTICE @@ -0,0 +1,12 @@ +Prepared for Jerry Chen / CubeJerry with substantial OpenAI assistance. +Apache-2.0. The joint helper/cache funding proof, complete moment envelopes, +independent source and price checks, and packaging were produced during the +2026-11-13 research run. Credit Clear1nsight #7481 and its retained lineage for +the exact native word; Rohan Arun #7113 for the signed caller; ToikY #7307 for +prior zero-input/direct-CLEAR predicates. The preceding Jerry Chen / CubeJerry +global-helper and owned-history packages retain their credit. Classical linear +algebra, matroid, tensor, calculus and stratification results are not claimed +as new. The original source NOTICE is preserved unchanged under inputs/. + +No separate human or formal-kernel acceptance is claimed. The source PR is +unselected; no claimed bound of that PR is promoted by this package. diff --git a/research/p104-joint-helper-cache-funding-bound/PR-DESCRIPTION.md b/research/p104-joint-helper-cache-funding-bound/PR-DESCRIPTION.md new file mode 100644 index 0000000000..58244b1c26 --- /dev/null +++ b/research/p104-joint-helper-cache-funding-bound/PR-DESCRIPTION.md @@ -0,0 +1,88 @@ +## Exact result and why it matters + +Prove a complete optimistic ceiling for combining helper restrictions, +zero-transfer deletions and owned-history caches on exact #7481 with the +actual #7113 caller. **No new kappa.** Separate helper-only and cache-only +obstructions do not compose automatically: one relation can remove transfers +and make a history informative. This proof allocates their joint necessary +funding without spending lost target credit twice. + +For f(r)=r^(1-kappa) and0<=kappa<=.01, native saving is at most + +``` +F = f(5) + f(3) + 2*f(1) - 2*f(4). +``` + +The complete17-call upper moment M+17F is below **−25.25810999183538 at +kappa=.0038**. It decreases strictly on[0,.01]; its zero lies in +(.0037347911502843961,.0037347911502843965). This is an exclusion ceiling, +not an attained supplier exponent. Preparation, storage, processing, copying, +restoration and retirement are waived in this upper budget. + +The fine proof covers arbitrary finite block-linear helper promises, including +noncommuting entry-mixing operators. Common-tangent reductions also cover +smooth promises with a retained submersion and singular/reducible real +semialgebraic promises with open retained projection. Actual rational-real +normalized maps allow realification of complex arrays. The deterministic +history decoder need not be differentiable. + +A coarser theorem covers every nonempty main-independent helper promise +surjective onto retained original fields: native saving is at most72. +Thirteen rigorously bounded intervals prove M+17*72<0 throughout[.01,1]. + +## Sources, novelty and evidence + +Canonical base e54523517d0f03e58352e647c403a5af3e525a57; exact #7481 head +89eaa9d8cae37c1540de98f2d29a3abaabb96a2b. The native word, exact signed +caller, invoice and predecessor notice are bundled with original paths and +hashes. Scientific replay needs no network or external Git objects. This +package does not admit the unselected source proposal's claimed exponent. + +Fresh replay derives468 zero rows and14 eligible cache spaces. Their567 +rows have rank525 and418 direct-sum groups. A determinant expansion allocates +distinct entry-columns to local bills. Eleven groups contain caches; the +other407 use source-checked zero-row funding with predecessor credit. + +The checker covers43 small zero subsets/89 grant cases,128 six-zero +subsets/384 cases, the largest group's identity and four omissions, and2140 +zero-only subsets including all31 dependent cases. It rebuilds the complete +invoice:22461 productive fields,110519 paid jobs,17 native calls and linear +surplus1424. A separate max-pivot engine checks91 small obligation invoices +and801 concave-generator inequalities. An independent integer-power engine +checks the .0038 margin. Distinct exact block fixtures exercise noncommuting +nontensor relations, partial-output misuse and other invalid hypotheses. + +```sh +python3 -B scripts/research_package.py --package research/p104-joint-helper-cache-funding-bound +python3 -B scripts/check_research_commit.py --package research/p104-joint-helper-cache-funding-bound --check-modes +``` + +Expected marker: PASS_JOINT_HELPER_CACHE_FUNDING_NO_NEW_KAPPA. +VALIDATION.json records executed committed normal/optimized and read-only, +Git-free export checks. Source, support, price, component, count, sign, bracket, +whole-output, retained-surjectivity and direct-sum controls detect failures. +The universal written arguments are distinguished from finite examples. + +## Limitations, open questions and credit + +The theorem retains original histories/maps, whole MOVE jobs, original whole +helper prices and arbitrary independent main inputs. Every helper outside +the retained original coordinate set is fully debited. The fine theorem does +not cover arbitrary discrete/nonregular promises. Nonzero public caches, +imported observations, changed producer paths, partial jobs and decoded +productive interfaces remain distinct questions. No physical provider or +unconditional multiplication theorem is supplied; all five selected +foundational assumptions remain. + +Prepared for **Jerry Chen / @CubeJerry**, with substantial **OpenAI assistance** +in research, independent implementations, adversarial review and packaging. +Credit Clear1nsight #7481, Rohan Arun #7113, ToikY #7307 and all retained source +lineage. Earlier CubeJerry global-helper and owned-history packages are pinned +in SOURCES.json; this package adds their joint funding and block/nonlinear +extensions. Classical matroid, determinant, tensor, constant-rank and +stratification results retain their literature credit. Independent human, +formal-kernel and hosted-CI acceptance are unclaimed. + +Only this isolated package is added. The selected certificate and shared +implementation are unchanged. README.md and TASK.json record open next +questions; the full proof, input pins and review trail are included. diff --git a/research/p104-joint-helper-cache-funding-bound/PROOF.md b/research/p104-joint-helper-cache-funding-bound/PROOF.md new file mode 100644 index 0000000000..f6255ff2eb --- /dev/null +++ b/research/p104-joint-helper-cache-funding-bound/PROOF.md @@ -0,0 +1,378 @@ +# Joint funding of helper restrictions and owned-history caches + +## 1. Result and exact scope + +This is a necessary-budget obstruction for one source and one retained moment +criterion. It is not a multiplication lower bound, a new supplier, an attained +value of kappa, or a discharge of a foundational assumption. + +The canonical base is `e54523517d0f03e58352e647c403a5af3e525a57`. The native +word is the exact unselected #7481 word at +`89eaa9d8cae37c1540de98f2d29a3abaabb96a2b`, with compressed SHA256 +`acee323696b18914bd863d55341f92112b48d3d1dc1443c276efb6c396fcc0a9`. +The complete retained #7113 caller has **17**, not 18, native invocations. +Its exact input and invoice bytes are pinned in SOURCES.json. + +Let `f_k(r)=r^(1-k)` for positive ranks and `f_k(0)=0`. Let + + M(k) = sum_r (T_r-P_r) f_k(r) + +be the exact complete #7481 signed moment. We allow the following changes to +each native invocation, with their most favorable possible accounting: + +1. Restrict the 1,101 autonomous helper inputs, independently of all 400 main + inputs. A retained set I of original helper coordinates must remain jointly + arbitrary. Every other original helper target is fully debited at its old + rank price. Newly decoded target types receive no original-coordinate credit. +2. Delete any original MOVE whose normalized value is identically zero on the + promised input domain. All other original scalar contacts, frames, target + labels and chronological values retain their original meanings on that domain. +3. Replace an owned MOVE by its exact target value using only the original + strictly earlier history at its destination coframe. We grant the entire + history, unlimited storage, arbitrary deterministic processing, free helper + preparation, and free owned retirement. No imported observation or changed + producer history is included. Pooling equal-span frame aliases only enlarges + this information grant; it does not identify their physical operators. + +The fine theorem allows arbitrary finite arrays `V=F^D`, `D>=1`, over +`F=R` or `C`, and arbitrary homogeneous **block-linear** helper promises +`ker U`. Their matrices may mix entries and need not commute. Original +normalized source maps remain the same rational scalar maps tensored with +`Id_V`. Sections2–6 first give the scalar derivation; BLOCK-LIFT.md proves +that every necessary-debit and composition bound survives arbitrary blocks. +No fractional physical jobs or newly decoded target credits are introduced. + +The same fine bound holds for a main-independent C1 real helper submanifold +with a retained-coordinate submersion somewhere, or for a complex helper +submanifold with that property. A single common tangent preserves the finite +set of exact zero/cache dependencies without differentiating their decoders. +It also holds for any real-semialgebraic helper promise whose retained +projection contains a nonempty Euclidean open set: a regular stratum supplies +the required tangent. Complex arrays may be realified because the actual +normalized source coefficients are rational-real. The detailed reductions, +classical primary references and excluded discrete/nonregular cases are in +`extensions/TANGENT-PROOF.md`, `extensions/SEMIALGEBRAIC-PROOF.md`, and +`extensions/SCOPE-COUNTEREXAMPLES.md`. + +**Fine theorem.** For `0<=k<=.01`, the net native saving of any such modification +is at most + + F(k) = f_k(5) + f_k(3) + 2 f_k(1) - 2 f_k(4). + +Consequently the complete optimistic moment is at most `M(k)+17F(k)`. At +`k=.0038` this upper bound is less than `-25.25810999183538`. This upper +envelope is strictly decreasing on `[0,.01]` and has its unique zero in + + (0.0037347911502843961, 0.0037347911502843965). + +This is a ceiling for the stated strategy and criterion, not a feasible +exponent. In particular, no strict positive moment is possible from +`k=.003734792` through `.01` in the fine model. + +**Coarse theorem.** For `.01<=k<=1`, the same failure follows even for an +arbitrary nonempty main-independent helper promise surjective onto I, +including nonlinear and operator-valued preparations. Its net native saving +is at most 72, and exact interval bounds prove `M(k)+17*72<0` throughout that +whole interval. The fine linear/regularity hypotheses are not needed here. + +The all-input source contract is essential. Scalar information separators +apply on the rational/complex normalized domain, and on digital input domains +that contain the stated exact input differences. No restriction on main inputs +may remove those directions. Neither theorem claims a result about a special +caller promise that abandons this arbitrary-main contract. + +## 2. Source facts and the information obligation + +Fresh exact replay of the 76,475 native instructions gives 6,279 MOVEs. Exactly +468 have nonzero helper-only normalized rows; the other 5,811 have a nonzero +main coefficient and cannot vanish on a nonempty main-independent helper +promise. The 468 helper rows have rank 463 and nullity five. For every such +row e and each helper coordinate h in its support, + + paid_rank(e) <= original_helper_target_rank(h). + +The maximum paid rank among these rows is eight. Helper target ranks are +between one and nine. Rank prices are bound to actual independent frame bases +and nested entrance/exit or MOVE pairs; absolute dimension difference is used +only after that geometry is checked. + +There are 47 owned MOVEs. For 33, an exact earlier-history separator can be +chosen entirely on the 400 main coordinates. Fix any permitted helper +assignment and vary mains in this separator direction. The two runs have +identical earlier histories but different target values. Therefore no +deterministic function of those histories can replace the MOVE, even with an +arbitrary helper promise. This is an indistinguishability argument, not a +restriction of providers to linear arithmetic. + +Only these fourteen events remain possible after helper restriction: + + 30581 30593 35152 35448 35452 36346 36358 + 39875 39884 41646 42487 42500 44253 45656. + +Their paid ranks sum to 32. Their unrestricted earlier histories still miss +their targets. For each such event E, let c_E be its scalar target row, P_E +the span of its original strict history, and H the helper-coordinate row space. +Define + + L_E = (P_E + span(c_E)) intersect H. + +On a linear domain `all_mains x ker U`, exact deterministic recovery of c_E +from the observations P_E is equivalent to + + c_E in P_E + U. + +Indeed, deterministic recovery requires c_E to vanish on the kernel of the +observation map restricted to the linear domain. The annihilator identity for +that kernel gives the displayed row-space condition. Conversely the condition +supplies a scalar linear recovery formula. This implication is not valid for +arbitrary nonlinear helper promises, which is why a nonlinear promise needs the separate common-tangent +reduction rather than a direct row-space inference. + +An enabled cache therefore supplies a necessary relation +`u_E=c_E-p_E` in `U intersect L_E`. If `c_E` is not already in `P_E+Z`, this +relation lies outside Z. All source rows and histories in this argument are +reconstructed from the native bytes, rather than accepted from author tables. + +## 3. Original-coordinate funding + +For a row space V on the helper coordinates, define beta_f(V) as the minimum +sum of original target prices over a coordinate-column basis for V. This is +a lower bound on lost productive credit, not a cost of preparing V. + +Let J be the fully debited helper coordinates, the complement of retained I. +Surjectivity of the promised helper domain onto I forces restriction `V -> J` +to be injective whenever all rows of V vanish on that domain. Otherwise a +nonzero relation supported only on I would vanish on every retained input, +contradicting joint arbitrariness. Thus J contains a column basis for V and +its lost target price is at least beta_f(V). This reasoning does not require +the helper promise itself to be linear. + +Two elementary consequences will be used repeatedly. + +**Independent-row funding.** Suppose rows z_e are independent and every +nonzero column h in row e has target rank at least its paid rank r_e. A +nonzero determinant minor has a nonzero permutation term. That term matches +each row to a distinct supported column. For any increasing f, the basis +price is at least `sum_e f(r_e)`. + +**Basis extension.** If Z is contained in W, every column basis for W contains +a column basis for Z. In particular, `beta_f(W)>=beta_f(Z)`. If W has rank +`rank(Z)+1` and every nonzero column of W has target rank at least a, then + + beta_f(W) >= beta_f(Z) + f(a). + +The support hypothesis concerns the entire enlarged space, not only its +newly appended row. Additional constraints cannot reduce these lower bounds. + +For scalar constraints the price beta_f is computed exactly from prefix ranks. +Let C_a contain all helper columns with target rank at most a. The ordinary +linear-matroid exchange argument gives + + beta_f(V) = sum_(a=1)^9 + [rank(V restricted C_a)-rank(V restricted C_(a-1))] f(a). + +All prefix ranks are exact rational ranks. A modular lower rank alone has the +wrong direction for certifying a minimum-price lower bound. + +## 4. Why the local bills compose + +The fourteen L_E spaces have total basis-row count 99 and joint rank 96. +Adjoin their basis rows to the 468 zero-MOVE rows. The resulting 567 labeled +row occurrences have exact rank 525 and nullity 42. Fundamental-circuit +components, coarsened to keep each entire L_E together, give a direct sum of +418 row spaces. Eleven contain caches: ten genuinely mixed groups and the +cache-only group 41646. Their ranks sum to 101. The 407 zero-only groups have +rank sum 424: 403 singletons, three five-row/rank-four groups, and one +eleven-row/rank-nine group. + +Choose the actual deleted zero rows and one necessary witness for every +actual cache. Their spans V_g within these groups still form a direct sum. +Take any nonzero global column-basis determinant for their union. A Laplace +expansion by row groups has a nonzero term partitioning the selected columns +into local column bases. Therefore + + beta_f(direct_sum_g V_g) >= sum_g beta_f(V_g). + +This is an inequality; equality is not asserted. It remains valid when the +groups' column supports overlap. It also remains valid when U has additional +cross-group constraints, since the selected direct sum is a subspace of U. +This is the step that prevents spending the same sacrificed helper target +separately in several attractive local modifications. + +The zero-only groups have no positive gain for `0<=k<=.01`. Their independent +subsets are funded by support matching. All 31 dependent subset cases in the +four nonsingleton groups satisfy the exact rational inequality + + 6 * minimum_linear_column_basis_price >= 11 * paid_rank_sum. + +For ranks at most nine and `0<=k<=1/4`, `f_k(r)>=(6/11)r`; the integer control +`9*6^4<11^4` proves the endpoint. Also `f_k(r)<=r`. Thus the dependent subsets +are funded as well. The compact certificate is checked from source rows; +the previous global helper-funding package receives explicit predecessor credit. + +## 5. Necessary debit for newly enabled caches + +Fix one cache-containing group and a subset S of its zero-MOVE occurrences. +Write Z=span(S) and let A(S) be the caches already satisfying `c_E in P_E+Z`. +Credit all caches in A(S), even if an actual proposal would not use them. +Let N be the subset of other caches it additionally enables. There are at most +two cache sites in each group. + +For `N` empty, the optimistic gain is + + sum_(e in S) f(r_e) + sum_(E in A(S)) f(r_E) - beta_f(Z). + +For every E in N, the actual constraint space must contain +`Z+span(u_E)` for some `u_E in L_E outside Z`. Define + + gamma_E = min_(u in L_E outside Z) beta_f(Z+span(u)). + +The actual debit is at least `max_(E in N) gamma_E`. We charge that maximum +and grant all A(S) and N cache benefits. We do not assert that one row realizes +several caches, or that the independent minimum debits are simultaneously +attainable. Each is a necessary condition, so their maximum remains valid. + +The generic appended-row formula computes gamma_E. For any column set C, +the largest rank after appending one row from L_E is + + min(rank(Z restricted C)+1, + rank((Z+L_E) restricted C)). + +Whenever the rank can increase, the coefficient tuples that fail to increase +it form a proper linear subspace. Finitely many such sets cannot cover the +coefficient space over an infinite field. A generic rational row attains all +the prefix maxima simultaneously. Every special row outside Z has the same +full rank and no larger prefix ranks, hence no cheaper column basis. The +greedy prefix formula therefore gives gamma_E exactly. No bounded-height +physical preparation follows from this algebraic minimum. + +Taking the maximum over all S and all N covers every actual proposal. In +particular, choose S to be its complete set of zero deletions. A relaxed row +that happens to create additional zero rows does not receive silent extra +credit; those rows are covered in their proper S case. + +## 6. Local bounds and their finite certificates + +| Cache sites | Zero rows in group | Native gain upper bound on `[0,.01]` | +| --- | ---: | --- | +| 35152, 45656 | 14 | 0 | +| 42487 | 6 | 0 | +| 35448, 35452 | 6 | 0 | +| 30593 | 4 | 0 | +| 36358 | 4 | 0 | +| 30581 | 1 | 0 | +| 36346 | 1 | 0 | +| 39875, 39884 | 1 | `f(5)+f(1)-f(6)` | +| 44253 | 1 | 0 | +| 42500 | 1 | `f(1)+f(3)-f(4)` | +| 41646 | 0 | `f(6)-f(4)` | + +The largest group's fourteen zero rows are independent and supported only on +target ranks at least four. Cache35152 is outside their full quotient span. +Cache45656 is enabled by S exactly when S includes events45659,45661,45663 +and58936. An exact quotient identity proves sufficiency; omitting each required +event from the full set proves necessity. Three of those required zero rows +are disjoint rank-four target units, each with paid rank one. Consequently +the already-enabled cache case is bounded by `4f(1)-3f(4)<0`. + +If45656 is new, its entire L space and Z have support of target rank at least +four. Basis extension charges at least f(4) beyond beta(Z), even if both +caches are granted, giving `f(1)+f(2)-f(4)<0`. If only35152 is new, support +rank at least three charges f(3) for credit f(2), worsening the previous case. +These statements cover arbitrary constraint dimension. The original full +16,384-subset exploration is corroboration; the compact proof checks the +rank, support, quotient identity and four omission certificates directly. + +In both six-zero groups, the zero rows are independent and no cache is in +the full zero-row quotient span. For42487, the entire relevant support has +rank at least four, which pays its rank-four cache credit. In the pair, +L35448 has support minimum three and L35452 minimum four, while all zero +supports have minimum four. Low-only, high-only and both-new cases have +bounds `f(2)-f(3)`, `f(1)-f(4)` and `f(1)+f(2)-f(4)` respectively. These are +nonpositive throughout the interval. The elementary inequality +`4^(99/100)>3`, certified by `4^99>3^100`, supplies the only near-linear +price comparison beyond monotonicity. Independent enumeration checked all +128 subsets and384 new-cache-set cases. + +The remaining eight groups have only43 zero-row subsets in total. Exact +prefix ranks and the individual-gamma rule give89 cases. For each case a +recorded necessary-debit profile lies below the displayed ceiling throughout +`[0,.01]`. The interval check proves this, including ties at zero, by bounding +the derivative of the profile difference. If d(0) is its exact integer value +and B is a directed upper bound on d' throughout the interval, then + + d(k) <= d(0) + .01 * max(0,B) <= 0. + +The three nonzero upper profiles telescope to F(k). No profile in this table +is asserted to have a physical realization or free preparation. + +## 7. Complete moment and directed arithmetic + +The complete native and caller inventories are reconstructed from the pinned +word and caller and compared with the pinned invoice. They contain22,461 +productive fields and110,519 paid jobs, with linear-rank surplus1,424. +Each native modification repeats seventeen times; all other caller costs +are retained. Extra source acquisition, copying, restoration, recursive +children, ordinary work, precision and storage have been granted free, so +they cannot rescue a negative upper moment. + +The numerical certificate bounds logarithms using the positive atanh series +after range reduction to `[1,2]`, with an explicit geometric tail. It bounds +`exp(-x)` using the signed Taylor remainder: odd degree35 is a lower bound, +even degree36 an upper bound for every `x>=0`. Every rounding is outward in +exact rational arithmetic. Derivative bounds use +`d f_k(r)/dk = -log(r) f_k(r)` and interval endpoints with the correct signs. +An independent checker brackets powers at `.0038` through the integer identity +`f(r)^5000=r^4981`; decimal values merely seed brackets whose inequalities +are then certified by integer exponentiation. + +The fine envelope has derivative at most `-362106.78529987` on `[0,.01]`. +Its exact signs at the two stated rational crossing endpoints are opposite. +At `.0038`, its value is below `-25.25810999183538`; the required unmodified +net native saving exceeds3.48481964025734, whereas F(.0038) is below1.999049. +These are inequalities for the retained complete moment, not a new recurrence. + +## 8. Coarse exclusion without linear helper promises + +Let S be any set of zero-MOVE rows, and choose an independent row basis B +of S. Nullity is monotone under taking row subsets, so + + |S|-|B| <= 468-463 = 5. + +The lost original helper targets fund all rows in B by the matching argument, +even for nonlinear or array-operator promises. The remaining at most five +occurrences can earn at most `5 f_k(8)<=40` for `0<=k<=1`. The33 main-only +information separators remain valid for every helper assignment. Grant all +fourteen remaining caches, without charging any further target loss or +physical expense; their credit is at most32. Thus the native gain is at most72. + +It remains to verify the entire interval, not merely its endpoints. For each +closed rational interval `[a,b]` in the certificate, monotonicity in k gives +an upper bound on `M(k)+1224` by using upper `f_a(r)` for positive signed +invoice coefficients and lower `f_b(r)` for negative coefficients. The thirteen +certificate intervals meet exactly, begin at `.01`, and end at1. Their endpoints +have denominator1000; integer-power comparisons certify every endpoint price, +with decimal arithmetic used only to seed a candidate bracket. Every upper +bound is negative; the least negative is below `-170.4827884543`. This proves +the assertion throughout `[.01,1]`. Exact endpoint values alone would not +have sufficed. + +## 9. What remains open + +Changed producer histories can supply information absent from P_E. New +productive interfaces can change the target-debit rule. Main-dependent +promises can invalidate the main-only separators. Below `.01`, discrete +exact-grid or nonregular promises without an eligible common tangent remain +outside the fine theorem. Nonzero public-MOVE caches are also outside the +owned-cache budget. Those are explicit changes of hypothesis, not conclusions +of this proof. All five selected assumptions remain: native all-columns, +owned erasure, compiler closure, precision/tape, and analytic recovery. + +The source and signed caller retain Clear1nsight's #7481 and Rohan Arun's +#7113 lineage and all predecessor notices. The earlier Jerry Chen / @CubeJerry +helper-funding and owned-history packages supply prior scoped results; this +package adds their joint cost allocation and the fine/coarse envelopes. +Classical linear algebra, matroid exchange, determinant expansion and Taylor +remainder arguments are not claimed as new. Substantial OpenAI assistance +covered research, separate implementations, adversarial review and packaging. +Independent evidence here is not independent human or proof-kernel acceptance. diff --git a/research/p104-joint-helper-cache-funding-bound/README.md b/research/p104-joint-helper-cache-funding-bound/README.md new file mode 100644 index 0000000000..425e413a52 --- /dev/null +++ b/research/p104-joint-helper-cache-funding-bound/README.md @@ -0,0 +1,87 @@ +# Joint helper and owned-history funding on exact P104 + +**No new kappa.** This package bounds the combined use of helper restrictions, +zero MOVE deletions and owned-history caches on the exact unselected #7481 +word. It closes a composition question left open by the separate helper-only +and cache-only obstructions. All five selected foundational assumptions remain. + +For arbitrary finite-dimensional **block-linear helper promises**, retaining +arbitrary original whole helper arrays and the original histories, the native +saving is at most + + f(5) + f(3) + 2 f(1) - 2 f(4), f(r)=r^(1-kappa), + +throughout `0<=kappa<=.01`. The complete optimistic17-call moment at `.0038` +is below `-25.25810999`, even with all preparation, storage, ordinary work and +retirement free. Its upper envelope crosses zero between +`.0037347911502843961` and `.0037347911502843965`. This is an exclusion ceiling, +not an attained supplier exponent. + +A second, coarser argument allows **arbitrary** main-independent helper +promises surjective onto retained original coordinates, including nonlinear +and operator-valued ones. Rank-nullity and information separators limit its +native saving to72. Exact interval bounds exclude a positive complete moment +for every `.01<=kappa<=1` in that broader model. + +## Why this is different from the predecessors + +Helper restrictions can make previously unavailable histories informative, +and zero deletions and caches can share target debits. Separate negative +results do not automatically compose. Fresh reconstruction gives567 rows of +rank525 and a direct sum of418 groups. A determinant argument allocates target +funding across those groups without double spending it. Eleven groups contain +caches; the rest inherit source-checked zero-row funding. The proof handles +arbitrarily many constraints and arbitrary block operators, including +noncommuting operators, rather than a finite search over proposed relations. + +The fine calculation permits any deterministic processing of the granted +original history on the linear input domain. It does not assume the provider +was written as a linear formula. A common-tangent argument also covers C1 +smooth promises with a retained submersion, and singular/reducible real +semialgebraic promises whose retained projection contains an open set. The +proof preserves all finitely many zero/cache dependencies at one point and +never differentiates a decoder. Complex arrays use the actual source's +rational-real coefficients for realification. Discrete grids and arbitrary +nonregular promises do not inherit this fine result. + +## Exact sources and reproduction + +Canonical base: `e54523517d0f03e58352e647c403a5af3e525a57`. +Exact #7481 head: `89eaa9d8cae37c1540de98f2d29a3abaabb96a2b`. +The native word, signed17-call caller and complete invoice are bundled with +their exact source hashes. No network or external Git objects are required. + +```sh +python3 -I -W error -B research/p104-joint-helper-cache-funding-bound/verify.py +python3 -O -I -W error -B research/p104-joint-helper-cache-funding-bound/verify.py +python3 -B scripts/research_package.py --package research/p104-joint-helper-cache-funding-bound +python3 -B scripts/check_research_commit.py --package research/p104-joint-helper-cache-funding-bound --check-modes +``` + +Expected scientific marker: `PASS_JOINT_HELPER_CACHE_FUNDING_NO_NEW_KAPPA`. +VALIDATION.json records executed checks and remaining limitations. PROOF.md +contains the exact hypotheses, interval proofs and distinction between the +fine block/smooth/semialgebraic and coarse arbitrary-promise results. Source reconstruction and +integer-power price verification use separate methods. + +## Open next questions + +Can a changed, already-paid producer path deliver missing cache information +while restoring every affected original target? A useful attempt should name +the first outward read, the new observations, the final correction and the +complete bill before extending the search. + +Can nonzero public-MOVE replacements enabled by helper relations improve the +complete bill? The present joint theorem grants only owned-MOVE caches. +Discrete/nonregular promises, newly decoded productive types, partial jobs and +promises on mains also require different interfaces and their actual prices. + +## Credit + +Prepared for Jerry Chen / @CubeJerry with substantial OpenAI assistance. +Credit Clear1nsight's #7481, Rohan Arun's #7113 and the retained P104, Clifford, +compiler and caller lineage. The prior helper-only and main-only-probe packages +are pinned in SOURCES.json. Exact finite checks and written proof receive +separate descriptions; no independent human, formal-kernel or hosted-CI +acceptance is claimed. Apache-2.0; retain LICENSE, NOTICE and the predecessor +notice bundled with the source. diff --git a/research/p104-joint-helper-cache-funding-bound/SOURCES.json b/research/p104-joint-helper-cache-funding-bound/SOURCES.json new file mode 100644 index 0000000000..d47ea06453 --- /dev/null +++ b/research/p104-joint-helper-cache-funding-bound/SOURCES.json @@ -0,0 +1,105 @@ +{ + "schema_version": 1, + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "files": [ + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "3404fbdd5e7529a0674eef26114b5071e4586cec", + "sha256": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81" + }, + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "75d77b328ea02ded535e7f23aee5b1e55d0bb1a8", + "sha256": "154c3d30455d778fd3343b6b4851f0fa4665f0f7625b0adb3675e2bafbbf6bf1" + } + ], + "bundled_external_inputs": [ + { + "path": "research/p104-joint-helper-cache-funding-bound/inputs/WORD.json.gz", + "source_repository": "Clear1nsight/integer-mult-bounds", + "source_commit": "89eaa9d8cae37c1540de98f2d29a3abaabb96a2b", + "source_path": "research/p104-funded-485-1455-return/producer54/reroute/WORD.json.gz", + "source_git_blob": "77df4ad624f4ed3d4bb5e08b4ac1891534d2261d", + "sha256": "acee323696b18914bd863d55341f92112b48d3d1dc1443c276efb6c396fcc0a9" + }, + { + "path": "research/p104-joint-helper-cache-funding-bound/inputs/CALLER.json", + "source_repository": "Clear1nsight/integer-mult-bounds", + "source_commit": "89eaa9d8cae37c1540de98f2d29a3abaabb96a2b", + "source_path": "research/p104-funded-485-1455-return/inputs/pr7113/ODD-TYPE-AB-CALLER.json", + "source_git_blob": "9451ceaf6e8e037894680b549f3ef41c21b260d7", + "sha256": "255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc" + }, + { + "path": "research/p104-joint-helper-cache-funding-bound/inputs/PREDECESSOR-NOTICE", + "source_repository": "Clear1nsight/integer-mult-bounds", + "source_commit": "89eaa9d8cae37c1540de98f2d29a3abaabb96a2b", + "source_path": "research/p104-funded-485-1455-return/NOTICE", + "source_git_blob": "4133e9216529e7a1dbceb092a05db2300305d102", + "sha256": "78e060cbd33ebc4078cabf39e50191a977fb9eb5c41104533079e22da1d9d248" + }, + { + "path": "research/p104-joint-helper-cache-funding-bound/inputs/CURRENT-PRICE.json", + "source_repository": "Clear1nsight/integer-mult-bounds", + "source_commit": "89eaa9d8cae37c1540de98f2d29a3abaabb96a2b", + "source_path": "research/p104-funded-485-1455-return/producer54/validation_signed/adapted/CURRENT-PRICE.json", + "source_git_blob": "257ae8ae92fdf24c9bedbd92cfebc26925eda5a2", + "sha256": "86f71ccbc923db5d7a6753aa971c3a9c8a572680534498ed17be072cfa2aae6b" + } + ], + "dependency_policy": "These exact source exports are committed inside this package and need no external Git objects or network. Original PR heads are provenance, not claimed ancestors of this contribution. Scientific replays authenticate the native and caller SHA256 values.", + "predecessors": [ + { + "pr": "https://github.com/CrocSwap/integer-mult-bounds/pull/7481", + "head": "89eaa9d8cae37c1540de98f2d29a3abaabb96a2b", + "role": "Exact unselected native word and retained caller; this package does not independently admit its claimed kappa." + }, + { + "pr": "https://github.com/CrocSwap/integer-mult-bounds/pull/7113", + "head": "07a76c5e2738882c0cb322278e56f6cae3c9885d", + "role": "Signed17-call lineage, retained exact bytes in #7481." + }, + { + "pr": "https://github.com/CrocSwap/integer-mult-bounds/pull/7307", + "role": "Prior unchanged-owned-word zero-input/direct-CLEAR predicates; current theorem allows deleting original helper input coordinates and pays all lost productive credit." + }, + { + "url": "https://github.com/CubeJerry/integer-mult-bounds/commit/4f83ab5c0a9c505159031c1f86d2f428b0ea9583", + "role": "Verified global helper zero-MOVE funding package; reuse rank/matching/Laplace ideas with explicit credit, then derive new joint cache obligations." + }, + { + "url": "https://github.com/CubeJerry/integer-mult-bounds/commit/796b03407d4d05da0390ebc6b28ab98a98c4fa6d", + "role": "Verified owned-history and33 main-only probe package; joint funding addresses its open helper-restriction/caching combination." + } + ], + "mathematical_background": [ + { + "authors": "D. Drusvyatskiy, A. D. Ioffe, A. S. Lewis", + "title": "Generic Minimizing Behavior in Semialgebraic Optimization", + "doi": "10.1137/15M1020770", + "url": "https://people.orie.cornell.edu/aslewis/publications/16-generic.pdf", + "result": "Theorem 3.4: finite compatible analytic map stratifications with constant ranks and images strata. Root and separate reviewer read the primary theorem on 2026-11-13. Used only for the semialgebraic promise reduction." + }, + { + "author": "Ravi Vakil", + "title": "The Rising Sea, 2024 draft", + "url": "https://math.stanford.edu/~vakil/216blog/FOAGjul2724public.pdf", + "result": "21.6.1 and21.6.4, characteristic-zero generic smoothness; background for the complex algebraic corollary." + }, + { + "author": "The Stacks Project", + "url": "https://stacks.math.columbia.edu/tag/0322", + "result": "Characteristic-zero separability background." + } + ], + "independent_reviews": { + "reviewed_block_draft_sha256": "a927ec87fadddf97b6ef55db56e56d6650fd744b80bb2c49b0b6f89ee7a7c4b7", + "draft_checkpoint": "https://github.com/CubeJerry/integer-mult-bounds/tree/9d6fac4385f2d8d1466dca4bbc50500e45e08750/research/kappa-swarm-20261113/pending-packages/p104-joint-helper-cache-funding-bound", + "block_review_A_sha256": "f6aba58da7b0d5f7f31bbd674b06cc66a33c5144fca58c0cf31ad0f4f20e5200", + "block_review_B_sha256": "13165fefb367cbb497fb81d53a0aecbf9cf585f07d6e21fa0186a16121e249d7", + "original_independent_small_review_receipt_sha256": "e304ded3567166587604ea44b7f54eb6db8bf96b7d45920b42912548d74132cb", + "note": "The final BLOCK-LIFT.md changes the reviewed draft heading and provisional conclusion after both reviews accepted its proof. The supplied scripts are local independent methods, not human or kernel review." + } +} diff --git a/research/p104-joint-helper-cache-funding-bound/TASK.json b/research/p104-joint-helper-cache-funding-bound/TASK.json new file mode 100644 index 0000000000..40411bb991 --- /dev/null +++ b/research/p104-joint-helper-cache-funding-bound/TASK.json @@ -0,0 +1,91 @@ +{ + "schema_version": 1, + "task_id": "complex-new-helper-inventory", + "priority_revision": 8, + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "original_card": { + "id": "complex-new-helper-inventory", + "question": "Can a changed helper inventory earn productive credit that survives completion, compilation and the actual caller?", + "starting_points": [ + "docs/research/current-priorities.md", + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md" + ], + "methods": [ + "Construct and independently check one source-bound instance of the stated first experiment.", + "Seek an exact counterexample or target-specific complete-budget obstruction to that same proposed change." + ], + "acceptance_gate": "A source-bound arbitrary-input identity and legal producer/consumer boundary with the complete paid and productive target invoice, including restoration, ownership, native alignment and extra charges. Price under the actual current model; historical ceiling.py assumptions must be established before use. A favorable optimistic relaxation keeps a route open but is not a completed supplier. A scoped local result remains useful; expansion requires the family-level budget gate.", + "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": "Specify all arbitrary inputs, owned fields, restored outputs and a physically legal consumer. Compare complete P and T, including target debits and precision/stock costs. #5599 is a positive control for target refinement, not permission to split every helper for free. #5614 is a hypothetical compiler budget, not an emitted 145-split word. Stop at the first unpaid boundary or a failing optimistic full bill.", + "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": [ + "productive helper", + "target refinement", + "5599", + "5614" + ], + "existing_checks": [ + { + "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": "On exact #7481, prove the complete optimistic bound for combined helper restrictions, zero MOVE deletions and owned-history cache replacements. Fine0<=kappa<=.01 covers arbitrary finite block-linear promises, smooth promises with retained submersion, and semialgebraic promises with open retained projection. Coarse.01<=kappa<=1 covers every nonempty main-independent promise surjective onto retained original fields.", + "scope_change_reason": "The verified global zero-MOVE theorem and main-only cache obstructions leave a genuine composition question: helper restrictions can unlock nonzero cache replacements. Price their necessary constraints jointly instead of summing incompatible separate gains.", + "bottleneck_link": "A complete optimistic17-call moment gate, including all lost original helper target credit, can exclude this combined route before new physical preparation and storage costs are paid.", + "budget_minutes": 60, + "stop_rule": "Stop once source decomposition, local budget bounds, cross-component funding, exact interval envelopes and failure controls are independently checked. Changed histories, decoded targets and main-dependent promises require a separate assignment.", + "outcome": "negative-result", + "evidence": "PROOF.md, independent fresh source/union reconstruction, local rank certificates, complete invoice reconstruction, directed rational interval proof and independent integer-power brackets.", + "author": "Jerry Chen / CubeJerry", + "ai_assistance": "Substantial OpenAI assistance in research, separate exact rational and modular implementations, algebraic review and packaging. No independent human or formal acceptance claimed.", + "open_questions": [ + { + "question": "Can a changed original producer history deliver and restore a missing cache direction for less than the full moment allowance?", + "why_it_matters": "The theorem grants free computation on original histories, but additional information can change its linear spaces.", + "first_step": "Name the changed paid path and first outward read; include all affected public targets and final corrections.", + "blocked_by": "No new complete physical producer and caller is supplied." + }, + { + "question": "Can helper relations enable a useful nonzero public-MOVE cache with a complete original-target and physical bill?", + "why_it_matters": "The proved joint envelope prices owned caches only; public rewrites require a distinct physical interface.", + "first_step": "Screen exact main-only information obstructions, then price any surviving necessary relation and all preparation/restoration.", + "blocked_by": "No admitted public cache construction or complete new supplier is supplied." + }, + { + "question": "Can a genuinely discrete/nonregular helper promise beat the fine envelope under the actual precision and productive contracts?", + "why_it_matters": "Smooth and semialgebraic tangent reductions do not cover finite-grid encoding by set-theoretic decoders.", + "first_step": "Specify the exact alphabet, normalized bounds, precision growth, decoder and retained whole-target contract before claiming a saving.", + "blocked_by": "A finite decoding example is not a universal native source or an asymptotic compiler bound." + } + ], + "scope_history": [ + "Global zero-MOVE funding and owned-cache information obstructions were verified and published separately.", + "This package solves their joint original-coordinate funding problem for scalar-linear promises and gives a broader coarse nonlinear exclusion.", + "Independent block reviews prove a uniform finite-dimensional lift; common-tangent and semialgebraic stratification reductions extend the fine scope with explicit regularity and whole-field hypotheses." + ] +} diff --git a/research/p104-joint-helper-cache-funding-bound/VALIDATION.json b/research/p104-joint-helper-cache-funding-bound/VALIDATION.json new file mode 100644 index 0000000000..91ee97c611 --- /dev/null +++ b/research/p104-joint-helper-cache-funding-bound/VALIDATION.json @@ -0,0 +1,1445 @@ +{ + "mathematical_scope": "Written scalar, finite-block, common-tangent and semialgebraic proofs. Exact finite fixtures corroborate boundaries; no new kappa, physical source admission, human review or formal kernel acceptance.", + "normal_optimized_export_semantic_receipts_equal": true, + "portable_export": { + "declared_inputs_checked": 4, + "empty_path": true, + "exit_code": 0, + "files": 31, + "git_free": true, + "package_bytes_and_modes_unchanged": true, + "read_only_modes": true, + "seconds": 16.2, + "status": "PASS_READ_ONLY_GIT_FREE_EMPTY_PATH_EXPORT", + "stderr_empty": true, + "stdout_sha256": "3add3c0f9f0a31ee421fb8cd8347b2d2ffa0be70e92a78cac188571430d57ce0", + "tested_commit": "1e22df54e62f8a48807240609e40f285189c47c5" + }, + "registered_normal_and_optimized": "PASS_REGISTERED_RESEARCH_PACKAGE", + "scientific_receipt": { + "independent_block_fixtures": { + "dimensions": [ + 2, + 3 + ], + "fixtures": [ + { + "A": [ + [ + 0, + 1 + ], + [ + 0, + 0 + ] + ], + "B": [ + [ + 2, + -1 + ], + [ + 0, + 0 + ] + ], + "C": [ + [ + -1, + 0 + ], + [ + 0, + 1 + ] + ], + "D": 2, + "actual_prefix": [ + 0, + 2, + 3, + 3, + 4, + 4, + 4, + 4, + 4, + 4 + ], + "controls": { + "dependent_group_double_spend": "REJECTED", + "false_retained_surjectivity": "REJECTED", + "partial_output_full_credit": "REJECTED" + }, + "generic_prefix": [ + 0, + 2, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4 + ], + "laplace": { + "global_price": "5", + "sum_local_prices": "2" + }, + "noncommuting": true, + "partial_output_recovered": [ + true, + false + ], + "partial_price": "2", + "prices": [ + { + "block_basis": [ + 0, + 1, + 2, + 5 + ], + "block_price": "2", + "generator": 1, + "generic_basis": [ + 0, + 1, + 2, + 3 + ], + "scalar_gamma": "2" + }, + { + "block_basis": [ + 0, + 1, + 2, + 5 + ], + "block_price": "3", + "generator": 2, + "generic_basis": [ + 0, + 1, + 2, + 3 + ], + "scalar_gamma": "3" + }, + { + "block_basis": [ + 0, + 1, + 2, + 5 + ], + "block_price": "7/2", + "generator": 3, + "generic_basis": [ + 0, + 1, + 2, + 3 + ], + "scalar_gamma": "3" + }, + { + "block_basis": [ + 0, + 1, + 2, + 5 + ], + "block_price": "4", + "generator": 4, + "generic_basis": [ + 0, + 1, + 2, + 3 + ], + "scalar_gamma": "3" + }, + { + "block_basis": [ + 0, + 1, + 2, + 5 + ], + "block_price": "4", + "generator": 5, + "generic_basis": [ + 0, + 1, + 2, + 3 + ], + "scalar_gamma": "3" + }, + { + "block_basis": [ + 0, + 1, + 2, + 5 + ], + "block_price": "4", + "generator": 6, + "generic_basis": [ + 0, + 1, + 2, + 3 + ], + "scalar_gamma": "3" + }, + { + "block_basis": [ + 0, + 1, + 2, + 5 + ], + "block_price": "4", + "generator": 7, + "generic_basis": [ + 0, + 1, + 2, + 3 + ], + "scalar_gamma": "3" + }, + { + "block_basis": [ + 0, + 1, + 2, + 5 + ], + "block_price": "4", + "generator": 8, + "generic_basis": [ + 0, + 1, + 2, + 3 + ], + "scalar_gamma": "3" + }, + { + "block_basis": [ + 0, + 1, + 2, + 5 + ], + "block_price": "4", + "generator": 9, + "generic_basis": [ + 0, + 1, + 2, + 3 + ], + "scalar_gamma": "3" + } + ], + "rank_whole": 4, + "rank_zero": 2 + }, + { + "A": [ + [ + 0, + 1, + 0 + ], + [ + 0, + 0, + 1 + ], + [ + 0, + 0, + 0 + ] + ], + "B": [ + [ + 2, + -1, + 0 + ], + [ + 0, + 2, + -1 + ], + [ + 0, + 0, + 0 + ] + ], + "C": [ + [ + -1, + 0, + 0 + ], + [ + 0, + -1, + 0 + ], + [ + 0, + 0, + 1 + ] + ], + "D": 3, + "actual_prefix": [ + 0, + 3, + 5, + 5, + 6, + 6, + 6, + 6, + 6, + 6 + ], + "controls": { + "dependent_group_double_spend": "REJECTED", + "false_retained_surjectivity": "REJECTED", + "partial_output_full_credit": "REJECTED" + }, + "generic_prefix": [ + 0, + 3, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6 + ], + "laplace": { + "global_price": "5", + "sum_local_prices": "2" + }, + "noncommuting": true, + "partial_output_recovered": [ + true, + true, + false + ], + "partial_price": "7/3", + "prices": [ + { + "block_basis": [ + 0, + 1, + 2, + 3, + 4, + 8 + ], + "block_price": "2", + "generator": 1, + "generic_basis": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "scalar_gamma": "2" + }, + { + "block_basis": [ + 0, + 1, + 2, + 3, + 4, + 8 + ], + "block_price": "3", + "generator": 2, + "generic_basis": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "scalar_gamma": "3" + }, + { + "block_basis": [ + 0, + 1, + 2, + 3, + 4, + 8 + ], + "block_price": "10/3", + "generator": 3, + "generic_basis": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "scalar_gamma": "3" + }, + { + "block_basis": [ + 0, + 1, + 2, + 3, + 4, + 8 + ], + "block_price": "11/3", + "generator": 4, + "generic_basis": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "scalar_gamma": "3" + }, + { + "block_basis": [ + 0, + 1, + 2, + 3, + 4, + 8 + ], + "block_price": "11/3", + "generator": 5, + "generic_basis": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "scalar_gamma": "3" + }, + { + "block_basis": [ + 0, + 1, + 2, + 3, + 4, + 8 + ], + "block_price": "11/3", + "generator": 6, + "generic_basis": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "scalar_gamma": "3" + }, + { + "block_basis": [ + 0, + 1, + 2, + 3, + 4, + 8 + ], + "block_price": "11/3", + "generator": 7, + "generic_basis": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "scalar_gamma": "3" + }, + { + "block_basis": [ + 0, + 1, + 2, + 3, + 4, + 8 + ], + "block_price": "11/3", + "generator": 8, + "generic_basis": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "scalar_gamma": "3" + }, + { + "block_basis": [ + 0, + 1, + 2, + 3, + 4, + 8 + ], + "block_price": "11/3", + "generator": 9, + "generic_basis": [ + 0, + 1, + 2, + 3, + 4, + 5 + ], + "scalar_gamma": "3" + } + ], + "rank_whole": 6, + "rank_zero": 3 + } + ], + "scope": "Exact noncommuting non-tensor controls for the written finite block proof; no physical admission.", + "status": "PASS_EXACT_ADVERSARIAL_BLOCK_FIXTURES" + }, + "independent_integer_power": { + "brackets_sha256": "27dea35e146138479bed64adbaca77aa075b83243b5f97bafc87cd6f0dd61977", + "controls": { + "wrong_eighteen_calls": true, + "wrong_lower_integer_bracket": true, + "wrong_target_debit_sign": true + }, + "full": { + "decimal_display_only": [ + "-25.258109991835383588522658", + "-25.258109991835383588473069" + ], + "exact": [ + "-12629054995917691794261329/500000000000000000000000", + "-25258109991835383588473069/1000000000000000000000000" + ] + }, + "identity": "f(r)^5000=r^4981", + "kappa": "19/5000", + "price_brackets": 25, + "status": "PASS_INDEPENDENT_INTEGER_POWER_MARGIN" + }, + "independent_small_algebra": { + "all_ceiling_proofs_sha256": "b5874c6f85f9047a0b8a68f5d4b6f108ef974c3034eaf2b40ae0cec57a7e4630", + "all_pivot_quotient_control": true, + "all_profiles_sha256": "606f40b38c57bdcb60be030e67226afd26fe911688865b6932c3096b55af5f39", + "ceiling_profile": { + "1": 2, + "3": 1, + "4": -2, + "5": 1 + }, + "components": [ + { + "cache_sites": [ + 30581 + ], + "cases": 4, + "ceiling_profile": {}, + "ceiling_proofs_sha256": "daeaae85ed69631ef21a80dbf35bc91ce6158431b9661ef60defca1c8f9663a3", + "minimum_generator_margin": 0, + "profiles_sha256": "6a7cbaa016379308db13e16d1aefe6bbcca0a71fdd637cc8cf5a035c291387da", + "subsets": 2, + "zero_events": [ + 30540 + ] + }, + { + "cache_sites": [ + 30593 + ], + "cases": 32, + "ceiling_profile": {}, + "ceiling_proofs_sha256": "8823eeeba996940550de3935c51a7f5a549fb2915bfddfe9e6ba4f903be0ced4", + "minimum_generator_margin": 0, + "profiles_sha256": "3073d75759a1d005d5bc25e745b92ff73cbf051be89ab40bc7c2eb921e2dbccc", + "subsets": 16, + "zero_events": [ + 29930, + 46676, + 49095, + 49520 + ] + }, + { + "cache_sites": [ + 36346 + ], + "cases": 4, + "ceiling_profile": {}, + "ceiling_proofs_sha256": "85b3a02234027c6402fa0f547108e13ba1095672e340dd2d00f7bd368765c33d", + "minimum_generator_margin": 0, + "profiles_sha256": "0eaa183bd0213e1a51e92a2f15d2f0be1edfe1212e704b7561928fc28763cda3", + "subsets": 2, + "zero_events": [ + 36333 + ] + }, + { + "cache_sites": [ + 36358 + ], + "cases": 32, + "ceiling_profile": {}, + "ceiling_proofs_sha256": "ab8701f406f27e75b1124466450d25d4e5bfcc62249a21bbb7c7cda7383cb239", + "minimum_generator_margin": 0, + "profiles_sha256": "59bce71a82b4380d20a51a6f6f12cd2f756d7449dfcad13808da757df7cc5bd5", + "subsets": 16, + "zero_events": [ + 40226, + 47235, + 47444, + 51716 + ] + }, + { + "cache_sites": [ + 39875, + 39884 + ], + "cases": 8, + "ceiling_profile": { + "1": 1, + "5": 1, + "6": -1 + }, + "ceiling_proofs_sha256": "c9849042589756a85ff9d0ab8c887b005daff84be131d3761884be923f38f217", + "minimum_generator_margin": 0, + "profiles_sha256": "16302ae8747d0a12ef4af4c6c8faa841e876ce82ce7fa4b5d33bdda76814f86e", + "subsets": 2, + "zero_events": [ + 47227 + ] + }, + { + "cache_sites": [ + 41646 + ], + "cases": 2, + "ceiling_profile": { + "4": -1, + "6": 1 + }, + "ceiling_proofs_sha256": "4264b752961696bc3724f68fe18307d12e69797dcba613bfb4283d20a4fccaec", + "minimum_generator_margin": 0, + "profiles_sha256": "ad0326b7a945c0ed52f42381de0e54d7b9876c401adb89423821658a63f9599d", + "subsets": 1, + "zero_events": [] + }, + { + "cache_sites": [ + 42500 + ], + "cases": 3, + "ceiling_profile": { + "1": 1, + "3": 1, + "4": -1 + }, + "ceiling_proofs_sha256": "5008dc6c8fa0efbeb4e78eb0e7048d5b3582d2724ba832ef591285549bceef0c", + "minimum_generator_margin": 0, + "profiles_sha256": "9d27a0d26e01a11895a24d54a9db9e0f370cc136bf4aa9634c35f541f5ba6e40", + "subsets": 2, + "zero_events": [ + 76388 + ] + }, + { + "cache_sites": [ + 44253 + ], + "cases": 4, + "ceiling_profile": {}, + "ceiling_proofs_sha256": "baffbd7c9963558134a66fdd9f5a658e683b8f5cd854ae8183cd6a71faddb847", + "minimum_generator_margin": 0, + "profiles_sha256": "45c9479d2522275ea55d12702e7576a17ce5892af8111c8cbeff62aabcd94473", + "subsets": 2, + "zero_events": [ + 48894 + ] + } + ], + "fresh_source_rows_sha256": "bcacf80bc5b35645492778995eb0a51b6ca4c611e1c8a4aea8b0a87f0888a9c5", + "grant_cases": 89, + "method": "Independent maximum-pivot rational history intersections, all-pivot quotient eligibility, exact rank prefixes and nine increasing-concave generators min(r,k). No price module or saved matrices imported.", + "nine_generator_inequalities": 801, + "obligation_profiles": 91, + "scope": "The eight small components only. Fixed original whole helper targets and source histories. Global decomposition, other components, complete prices and physical admission remain separate.", + "source_sha256": "acee323696b18914bd863d55341f92112b48d3d1dc1443c276efb6c396fcc0a9", + "status": "PASS_INDEPENDENT_MAX_PIVOT_89_SMALL_CASES", + "zero_subsets": 43 + }, + "largest_component": { + "L_support_minima": { + "35152": 3, + "45656": 4 + }, + "all_zero_rows_independent": true, + "all_zero_support_rank_at_least_four": true, + "cache_MOVE_ranks": { + "35152": 2, + "45656": 1 + }, + "cache_sites": [ + 35152, + 45656 + ], + "four_omission_checks": 4, + "mandatory_R4_unit_coordinates": [ + 1344, + 1347, + 1346 + ], + "mandatory_R4_unit_events": [ + 45659, + 45661, + 45663 + ], + "rank5_fourth_event": 58936, + "site35152_misses_full_zero_quotient": true, + "site45656_hits_full_zero_quotient": true, + "site45656_required_zero_events": [ + 45659, + 45661, + 45663, + 58936 + ], + "site45656_witness": { + "45659": "-1/4", + "45661": "-1/4", + "45663": "-1/4", + "58936": "1" + }, + "zero_events": [ + 32681, + 39855, + 39857, + 39859, + 45659, + 45661, + 45663, + 45698, + 45701, + 45706, + 51637, + 57989, + 58936, + 76469 + ], + "zero_row_rank": 14, + "zero_supports_dominate_paid_ranks": true + }, + "output": "stdout only; no package files written", + "prices": { + "baseline_signed_profile": { + "1": -68095, + "137": 208, + "16": -416, + "17": 416, + "2": -14161, + "24": -416, + "25": 416, + "3": -13260, + "32": -416, + "33": 416, + "4": 51, + "40": -416, + "41": 416, + "48": -416, + "49": 416, + "5": -4488, + "56": -416, + "57": 416, + "6": 459, + "64": -208, + "65": 416, + "7": 153, + "73": 208, + "8": -197, + "9": 10856 + }, + "coarse": { + "integer_brackets": 301, + "integer_brackets_sha256": "38525d650edc88bf8846260b74b40db5cf915bcf9622d10e6000ea515a84079d", + "integer_power_exponent": 1000, + "interval": [ + "1/100", + "1" + ], + "native_cap": 72, + "partition": [ + { + "left": "1/100", + "right": "11/1000", + "upper": "-45962400765417/62500000000" + }, + { + "left": "11/1000", + "right": "13/1000", + "upper": "-64601877068091/100000000000" + }, + { + "left": "13/1000", + "right": "17/1000", + "upper": "-476060130433541/1000000000000" + }, + { + "left": "17/1000", + "right": "1/40", + "upper": "-170482788454327/1000000000000" + }, + { + "left": "1/40", + "right": "33/1000", + "upper": "-787344799125741/250000000000" + }, + { + "left": "33/1000", + "right": "41/1000", + "upper": "-301615446780953/50000000000" + }, + { + "left": "41/1000", + "right": "7/125", + "upper": "-5940733805221449/1000000000000" + }, + { + "left": "7/125", + "right": "71/1000", + "upper": "-11065327332669939/1000000000000" + }, + { + "left": "71/1000", + "right": "51/500", + "upper": "-10102552480109633/1000000000000" + }, + { + "left": "51/500", + "right": "133/1000", + "upper": "-1970535974012451/100000000000" + }, + { + "left": "133/1000", + "right": "257/1000", + "upper": "-1116502275720291/250000000000" + }, + { + "left": "257/1000", + "right": "101/200", + "upper": "-19806090009977599/1000000000000" + }, + { + "left": "101/200", + "right": "1", + "upper": "-11454560387366383/250000000000" + } + ], + "worst_upper": { + "decimal_display_only": [ + "-170.482788454327", + "-170.482788454327" + ], + "exact": [ + "-170482788454327/1000000000000", + "-170482788454327/1000000000000" + ] + } + }, + "fine_derivative": { + "decimal_display_only": [ + "-408824.81098589571726029999391193389", + "-362106.78529987135948974565166458970" + ], + "exact": [ + "-4088248109858957172602999939119338906002838767354756205568489844200638121909198646748601178831293422158969/10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "-452633481624839199362182064580737122217400677147615352559434576970374456548712325552683151817282517900191/1250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + ] + }, + "fine_interval": [ + "0", + "1/100" + ], + "full_at_0038": { + "decimal_display_only": [ + "-25.258109991835383588494826442062032", + "-25.258109991835383588494826442062032" + ], + "exact": [ + "-1262905499591769179424741322103101601814100732639339/50000000000000000000000000000000000000000000000000", + "-1262905499591769179424741322103101601814100732611299/50000000000000000000000000000000000000000000000000" + ] + }, + "full_upper_profile": { + "1": -68061, + "137": 208, + "16": -416, + "17": 416, + "2": -14161, + "24": -416, + "25": 416, + "3": -13243, + "32": -416, + "33": 416, + "4": 17, + "40": -416, + "41": 416, + "48": -416, + "49": 416, + "5": -4471, + "56": -416, + "57": 416, + "6": 459, + "64": -208, + "65": 416, + "7": 153, + "73": 208, + "8": -197, + "9": 10856 + }, + "invoice": { + "native_calls": 17, + "paid": { + "1": 68401, + "16": 416, + "2": 14518, + "24": 416, + "3": 14059, + "32": 416, + "4": 3774, + "40": 416, + "48": 416, + "5": 5848, + "56": 416, + "6": 272, + "64": 208, + "7": 170, + "8": 741, + "9": 32 + }, + "rank_surplus": 1424, + "target": { + "1": 306, + "137": 208, + "17": 416, + "2": 357, + "25": 416, + "3": 799, + "33": 416, + "4": 3825, + "41": 416, + "49": 416, + "5": 1360, + "57": 416, + "6": 731, + "65": 416, + "7": 323, + "73": 208, + "8": 544, + "9": 10888 + } + }, + "kappa_status": "No new kappa. This is an upper envelope, not a feasible supplier.", + "local_case_proofs_sha256": "3dfb10faab6d10df9e16ed2e5adcb639543762de2d0d251529b965a303ebcdd0", + "native_upper_profile": { + "1": 2, + "3": 1, + "4": -2, + "5": 1 + }, + "status": "PASS_COMPLETE_JOINT_POWER_ENVELOPES", + "uniform_local_cases": 473, + "upper_envelope_crossing": { + "decimal_display_only": [ + "0.0037347911502843961", + "0.0037347911502843965" + ], + "exact": [ + "37347911502843961/10000000000000000000", + "7469582300568793/2000000000000000000" + ] + } + }, + "semantic_controls": { + "controls": { + "forged_paid_rank_rejected": true, + "forged_target_weight_rejected": true, + "main_support_contamination_rejected": true, + "missing_component_rejected": true + }, + "status": "PASS_EXECUTED_NEGATIVE_CONTROLS" + }, + "six_zero_analytic_checks": [ + { + "L_support_minima": { + "42487": 4 + }, + "all_cache_targets_miss_full_zero_quotient": true, + "all_zero_rows_independent": true, + "all_zero_support_target_ranks_at_least_four": true, + "cache_sites": [ + 42487 + ], + "zero_events": [ + 31351, + 35683, + 43283, + 43285, + 46810, + 47178 + ], + "zero_row_rank": 6, + "zero_supports_dominate_paid_ranks": true + }, + { + "L_support_minima": { + "35448": 3, + "35452": 4 + }, + "all_cache_targets_miss_full_zero_quotient": true, + "all_zero_rows_independent": true, + "all_zero_support_target_ranks_at_least_four": true, + "cache_sites": [ + 35448, + 35452 + ], + "zero_events": [ + 34154, + 34156, + 46841, + 47000, + 48515, + 49195 + ], + "zero_row_rank": 6, + "zero_supports_dominate_paid_ranks": true + } + ], + "small_component_counts": [ + { + "cache_sites": [ + 30593 + ], + "cases": 32, + "subsets": 16 + }, + { + "cache_sites": [ + 36358 + ], + "cases": 32, + "subsets": 16 + }, + { + "cache_sites": [ + 30581 + ], + "cases": 4, + "subsets": 2 + }, + { + "cache_sites": [ + 36346 + ], + "cases": 4, + "subsets": 2 + }, + { + "cache_sites": [ + 39875, + 39884 + ], + "cases": 8, + "subsets": 2 + }, + { + "cache_sites": [ + 44253 + ], + "cases": 4, + "subsets": 2 + }, + { + "cache_sites": [ + 42500 + ], + "cases": 3, + "subsets": 2 + }, + { + "cache_sites": [ + 41646 + ], + "cases": 2, + "subsets": 1 + } + ], + "source": { + "all_owned_targets_miss_full_strict_history": 47, + "cache_eligible_events": [ + 30581, + 30593, + 35152, + 35448, + 35452, + 36346, + 36358, + 39875, + 39884, + 41646, + 42487, + 42500, + 44253, + 45656 + ], + "frame_geometry": { + "frame_count": 1096, + "helper_forward": 1101, + "helper_pairs": 1101, + "helper_reverse": 0, + "independent_frame_count": 1096, + "max_frame_dimension": 9, + "move_forward": 6255, + "move_pairs": 6279, + "move_reverse": 24 + }, + "helper_variables": 1101, + "history_model": "Strict earlier initial inputs and MOVE arrivals at equal normalized span; intervening scalar operations stay in that history span. Pooling equal-span aliases is an information overgrant only.", + "main_only_history_misses": 33, + "main_variables": 400, + "mainfree_nonzero_MOVEs": 468, + "operation_counts": { + "ADD": 66321, + "CLEAR": 74, + "COPY": 1, + "INIT": 74, + "MOVE": 6279, + "SCALE": 3726 + }, + "owned_MOVEs": 47, + "owned_fields": 68, + "program_events": 76475, + "public_variables": 1501, + "site_dimensions": { + "30581": 2, + "30593": 18, + "35152": 4, + "35448": 2, + "35452": 13, + "36346": 2, + "36358": 11, + "39875": 1, + "39884": 6, + "41646": 2, + "42487": 18, + "42500": 1, + "44253": 3, + "45656": 16 + }, + "source_payload_sha256": "64fca675b91298868e12f09423b47e0c2327cba7095e35c8919c1953b4ed68b8", + "source_rows_sha256": "bcacf80bc5b35645492778995eb0a51b6ca4c611e1c8a4aea8b0a87f0888a9c5", + "source_sha256": "acee323696b18914bd863d55341f92112b48d3d1dc1443c276efb6c396fcc0a9", + "status": "FRESH_READ_ONLY_NATIVE_REPLAY", + "sum_site_dimensions": 99 + }, + "source_mutation_rejected": true, + "status": "PASS_JOINT_HELPER_CACHE_FUNDING_NO_NEW_KAPPA", + "structure": { + "cache_L_basis_rows": 99, + "cache_L_dimension_sum": 99, + "cache_component_count": 11, + "cache_component_rank_sum": 101, + "cache_only_component_count": 1, + "coarsened_component_count": 418, + "fundamental_circuit_count": 42, + "max_zero_paid_rank": 8, + "mixed_cache_zero_component_count": 10, + "source_sha256": "acee323696b18914bd863d55341f92112b48d3d1dc1443c276efb6c396fcc0a9", + "status": "FRESH_EXACT_567_ROW_UNION", + "union_nullity": 42, + "union_rank": 525, + "union_rows": 567, + "zero_move_nullity": 5, + "zero_move_rank": 463, + "zero_move_rows": 468, + "zero_only_component_count": 407, + "zero_only_component_histogram": [ + { + "components": 403, + "rank": 1, + "rows": 1 + }, + { + "components": 3, + "rank": 4, + "rows": 5 + }, + { + "components": 1, + "rank": 9, + "rows": 11 + } + ], + "zero_only_rank_sum": 424 + }, + "tangent_scope_fixtures": { + "block_lift_is_mathematical_review_not_physical_admission": true, + "records": [ + { + "all_same_tangent_dependencies": true, + "fixture": "nonlinear_scalar_graph_two_caches_one_zero", + "retained_submersion_and_J_pivots": true, + "tested_rational_points": 5 + }, + { + "bad_observation_rank": 0, + "counterexample_to": "fixed-point lift without locally constant observation rank", + "fixture": "real_cubic_at_zero", + "target_differential_rank": 1 + }, + { + "counterexample_to": "using arbitrary critical point", + "fixture": "complex_smooth_graph_cusp_observation", + "global_decoder": "z/y away from origin,0 at origin" + }, + { + "complex_scalar_tangent_inference_rejected": true, + "does_not_refute_real_block_lift": true, + "fixture": "complex_conjugation_graph", + "real_block_factor": true + }, + { + "counterexample_to": "funding without retained-coordinate submersion", + "fixture": "smooth_graph_t_squared_t_at_zero" + }, + { + "continuous_linear_lift_impossible": true, + "deterministic_decoder_injective": true, + "fixture": "two_bit_exact_grid" + }, + { + "fixture": "nonregular_digit_graph_prefixes", + "infinite_graph_statement_proved_in_notes": true, + "prefixes_1_through_5_injective_cardinalities": [ + 4, + 16, + 64, + 256, + 1024 + ] + }, + { + "excluded_from_char0_theorem": true, + "fixture": "characteristic7_Frobenius", + "formal_observation_derivative": 0, + "pointwise_bijection": true + }, + { + "cases": [ + { + "D": 1, + "actual_W_basis_price": "1", + "actual_prefix_ranks": [ + 1, + 1, + 1 + ], + "full_relation_rank": 1, + "generic_gamma": "1", + "generic_prefix_ranks": [ + 1, + 1, + 1 + ], + "noncommuting": false, + "partial_output_control_rejected": false, + "whole_debited_field_price": "4" + }, + { + "D": 2, + "actual_W_basis_price": "2", + "actual_prefix_ranks": [ + 1, + 2, + 2 + ], + "full_relation_rank": 2, + "generic_gamma": "1", + "generic_prefix_ranks": [ + 2, + 2, + 2 + ], + "noncommuting": true, + "partial_output_control_rejected": true, + "whole_debited_field_price": "4" + }, + { + "D": 3, + "actual_W_basis_price": "5/3", + "actual_prefix_ranks": [ + 2, + 3, + 3 + ], + "full_relation_rank": 3, + "generic_gamma": "1", + "generic_prefix_ranks": [ + 3, + 3, + 3 + ], + "noncommuting": true, + "partial_output_control_rejected": true, + "whole_debited_field_price": "4" + } + ], + "fixture": "noncommuting_block_graphs_and_partial_output_guard" + }, + { + "dimensions_checked": [ + 1, + 2, + 3 + ], + "fixture": "tensor_Laplace_overlapping_helper_supports" + }, + { + "fixture": "main_dependent_helper_graph", + "product_hypothesis_required": true + } + ], + "scalar_positive_points": 5, + "status": "PASS_EXACT_POSITIVE_SCOPE_AND_BLOCK_FIXTURES", + "universal_claims_proved_in_notes_not_by_finite_samples": true + }, + "zero_only_quarter_certificate": { + "all_dependent_quarter_inequalities_pass": true, + "component_checks": [ + { + "dependent_subsets": 28, + "events": [ + 32944, + 32945, + 32947, + 32951, + 33081, + 33089, + 33091, + 33100, + 43387, + 43700, + 43804 + ], + "independent_subsets": 2019, + "minimum_dependent_integer_margin": 0, + "rank": 9, + "rows": 11 + }, + { + "dependent_subsets": 1, + "events": [ + 39588, + 43246, + 43254, + 43300, + 44903 + ], + "independent_subsets": 30, + "minimum_dependent_integer_margin": 27, + "rank": 4, + "rows": 5 + }, + { + "dependent_subsets": 1, + "events": [ + 39632, + 43186, + 43199, + 43201, + 43203 + ], + "independent_subsets": 30, + "minimum_dependent_integer_margin": 27, + "rank": 4, + "rows": 5 + }, + { + "dependent_subsets": 1, + "events": [ + 40084, + 42281, + 42315, + 42317, + 43600 + ], + "independent_subsets": 30, + "minimum_dependent_integer_margin": 27, + "rank": 4, + "rows": 5 + } + ], + "component_count": 407, + "dependent_component_count": 4, + "dependent_subsets_checked": 31, + "envelope": "9*6^4<11^4", + "independent_subsets_funded_by_support": 2109, + "minimum_dependent_integer_margin": 0, + "nonempty_subsets_checked": 2140, + "scope": "For 0<=kappa<=1/4, source zero-only helper rows only; full mixed/cache and high-kappa bounds are separate.", + "status": "PASS_SOURCE_DERIVED_ZERO_ONLY_QUARTER_FUNDING" + } + }, + "status": "PASS_REGISTERED_PAIR_AND_READ_ONLY_EXPORT", + "tested_scientific_commit": "1e22df54e62f8a48807240609e40f285189c47c5", + "unrun_obligations": [ + "All five selected foundational assumptions remain.", + "Nonzero public-MOVE caches, changed histories, decoded productive types and discrete/nonregular fine promises remain separate.", + "Hosted CI is not claimed." + ] +} diff --git a/research/p104-joint-helper-cache-funding-bound/VERIFY.json b/research/p104-joint-helper-cache-funding-bound/VERIFY.json new file mode 100644 index 0000000000..22a3ae07b6 --- /dev/null +++ b/research/p104-joint-helper-cache-funding-bound/VERIFY.json @@ -0,0 +1,39 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/p104-joint-helper-cache-funding-bound/inputs/WORD.json.gz", + "research/p104-joint-helper-cache-funding-bound/inputs/CALLER.json", + "research/p104-joint-helper-cache-funding-bound/inputs/CURRENT-PRICE.json", + "research/p104-joint-helper-cache-funding-bound/inputs/PREDECESSOR-NOTICE" + ], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-W", + "error", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 180, + "checks": "Fresh exact native/frame/history replay;567-row joint decomposition;473 uniform cache/zero cases;2140 zero-only subset controls;complete17-call invoice;directed fine and coarse envelopes;independent integer powers and max-pivot small-case checks;block/tangent scope fixtures and executed source/semantic mutations." + }, + { + "argv": [ + "{python}", + "-O", + "-I", + "-W", + "error", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 180, + "checks": "Fresh exact native/frame/history replay;567-row joint decomposition;473 uniform cache/zero cases;2140 zero-only subset controls;complete17-call invoice;directed fine and coarse envelopes;independent integer powers and max-pivot small-case checks;block/tangent scope fixtures and executed source/semantic mutations." + } + ] +} diff --git a/research/p104-joint-helper-cache-funding-bound/extensions/BLOCK-REVIEW-A.md b/research/p104-joint-helper-cache-funding-bound/extensions/BLOCK-REVIEW-A.md new file mode 100644 index 0000000000..1da800a591 --- /dev/null +++ b/research/p104-joint-helper-cache-funding-bound/extensions/BLOCK-REVIEW-A.md @@ -0,0 +1,115 @@ +# Independent review of the finite-dimensional block lift + +Review conclusion: the proposed block lifting follows under the stated +whole-job, fully debited helper, fixed normalized history hypotheses. The +proof below independently reconstructs the critical inequalities. It does +not establish native_all_columns, an implementation or a new kappa. +The reviewed draft's exact SHA256 is recorded in SOURCES.json. + +Let F be an infinite characteristic-zero field, V=F^D finite-dimensional, +and give each helper's D entry-columns accounting weight f(R_h)/D. These +are artificial lower-bound weights, NOT fractional jobs or a physical +rank/dimension scaling law. Source scalar row spaces A become A tensor V*. +Let U be an arbitrary block-linear helper-relation rowspace; matrices may +mix entries and need not commute. Main arrays remain independent. + +## Fully debited fields fund expanded-coordinate bases + +Surjectivity onto retained whole helper arrays makes restriction of U to +lost entry-columns injective: any covector supported only on retained +entries and annihilating the domain must be zero. The lost columns span +U and every necessary W contained in U. Some expanded column basis can +therefore be chosen from those columns. Its minimum price b_D(W) is at +most the actual debit sum_h f(R_h), because all D entry weights of a fully +lost helper sum to its single original price. No fractional target credit +is inferred. + +For W=A tensor V*, prefix ranks at helper target rank<=k are D times +scalar prefix ranks. Weighted-column greedy selection gives +b_D(A tensor V*)=beta_f(A). Whole zero MOVE deletion requires every one +of its D target entry covectors to lie in U, hence Z tensor V* is contained +in U for the actual whole zero set S. + +## A whole new cache requires D independent directions + +If c is not in P+Z, exact recovery of the WHOLE target array on the linear +domain gives, for every basis e_a of V*, + + c tensor e_a = p_a + u_a, + p_a in P tensor V*, u_a in U. + +This follows by linear kernel inclusion, even if the deterministic cache +function is nonlinear. Since u_a is helper-only, it belongs to +L tensor V*, L=(P+span(c)) intersect helper space. Tensoring finite vector +spaces commutes with these intersections (choose compatible bases). + +The u_a are independent modulo Z tensor V*. If their nonzero combination +belonged there, c tensor v would belong to (P+Z) tensor V* for nonzero v. +Choose a scalar functional lambda with lambda(P+Z)=0 and lambda(c)=1. +Contraction lambda tensor Id would give v=0, a contradiction. This is +where whole-output reconstruction matters. + +Thus W_E=Z tensor V*+span(u_a) has full rank D(rho+1). On each expanded +cheap-column prefix its rank is at most both D rank(Z_k)+D and +D rank((Z+L)_k). The generic scalar row u in L outside Z attains +min(rank Z_k+1,rank(Z+L)_k) simultaneously. Therefore its tensor space G +has the same full rank as W_E and at least as large every cheap prefix. + +At fixed full rank R, weighted greedy price is + + alpha_9 R - sum_{k=1}^8 (alpha_{k+1}-alpha_k) rank(prefix_k), + alpha_k=f(k)/D. + +The coefficients subtracted are nonnegative. Hence b_D(W_E)>=b_D(G) +=beta_f(Z+span(u))=gamma_E. This uses prefix domination, not an assertion +that arbitrary block column matroids equal the scalar tensor matroid. +The generic scalar row is only a lower debit witness; it need not be a +physical provider or simultaneously enable several caches. + +Every actual new cache supplies its own necessity; taking the maximum +of these individual gamma_E lower bounds is valid. If L is contained in +Z, that new-cache case is impossible. + +## Composition and specific support refinements + +The certified scalar source component spaces form a direct sum. Tensoring +preserves it. Select actual necessary W_g in each tensor component. +Their direct sum is contained in U even when U has additional constraints +mixing components. A nonzero expanded column-basis determinant, expanded +by row blocks, has a nonzero Laplace term assigning disjoint entry-column +sets to the groups. Thus b_D(U)>=sum_g b_D(W_g). Overlapping original +helper supports cause no double charge: each entry column is allocated +once and a fully lost field pays the sum of its D accounting weights. + +For a support-minimum refinement, a whole new cache adds D directions +beyond Z tensor V*. If all relevant columns have rank>=a, a basis for +W_E contains a basis for Z tensor V* and D further columns, each priced +at least f(a)/D. Their extra debit is at least f(a), matching the scalar +proof. Required disjoint unit helper coordinates become disjoint D-entry +blocks with the same total prices. The scalar local inequalities thus +survive, including the largest-block refinements. + +## Realification and adversarial boundaries + +This native source's normalized row coefficients are rational REAL +scalars. A complex D-array can therefore be represented by2D real entries +with source maps A tensor Id_(2D). Assign f(R_h)/(2D) to each real entry; +its whole complex helper still pays exactly f(R_h). Real-linear block +relations, including conjugation, are allowed by the same proof. This +would need a different source formulation if normalized coefficients +were arbitrary nonreal blocks rather than common real scalars. + +The essential boundaries are: entire original MOVEs/outputs only; fixed +original target prices; fully retained or fully debited original helper +fields; main arrays independent of helpers; unchanged source histories +and normalized scalar maps; finite D; and all original framework +assumptions retained. Partial output recovery cannot take full cache +credit. In the executed D2/D3 fixtures, D-1 relations have a basis debit +smaller than gamma_E but fail to reconstruct the missing output entry. +That is a counterexample to dropping the whole-output requirement. + +Exact fixtures exercise noncommuting blocks for D2,D3, prefix domination +strictness, whole-helper funding and Laplace composition with overlapping +helper supports. They pass in normal and optimized Python. These finite +fixtures support validation; the universal argument is the proof above. +No physical provider or compiler/grid admission follows from it. diff --git a/research/p104-joint-helper-cache-funding-bound/extensions/BLOCK-REVIEW-B.md b/research/p104-joint-helper-cache-funding-bound/extensions/BLOCK-REVIEW-B.md new file mode 100644 index 0000000000..655de9477a --- /dev/null +++ b/research/p104-joint-helper-cache-funding-bound/extensions/BLOCK-REVIEW-B.md @@ -0,0 +1,132 @@ +# Independent adversarial review of the finite block lift + +Conclusion: the block extension in the reviewed draft is valid under its +stated hypotheses. I found no counterexample. In particular, it covers +arbitrary finite-dimensional block-linear helper promises, with operators +that mix entries and need not commute, while retaining the scalar fine +funding ceiling. This is conditional source algebra and funding, not a +physical construction, an attained kappa, or an all-column admission proof. +The exact draft and source-proof hashes appear in `RESULT.json`. + +Let the scalar covector space split into main and helper coordinates, and +let V have finite dimension D. Original source row spaces become A tensor +V*. This is essential: the operators in the changed helper promise may be +arbitrary, but original source operations and observations remain the +normalized common-scalar maps. The promised domain is all mains times ker U +for a helper covector space U. The retained whole original helper arrays I +are jointly arbitrary. Lost fields are fully debited; no decoded target +credit or fractional physical job is inferred. + +## Funding and the full-array information condition + +If restriction of a necessary W contained in U to all lost entry-columns +were not injective, a nonzero covector supported only on I would vanish on +every retained input. Surjectivity onto I excludes this. Hence some column +basis of W lies in lost entry-columns. Giving each entry of helper h price +f(R_h)/D makes the total price of all its D entries exactly its original +field price. The actual lost credit therefore bounds the minimum expanded +column-basis price b_D(W) below. These fractional weights are only a lower +bound on a whole-field debit. + +Whole zero deletions require Z tensor V* contained in U. Tensor prefix +ranks multiply by D, so the ordinary greedy formula gives exactly +b_D(Z tensor V*)=beta_f(Z). + +Suppose c is not in P+Z, but a whole cache becomes reconstructible on the +linear domain. Deterministic recovery, even nonlinear processing, forces +every output covector c tensor e_a to vanish on the observation kernel. +Finite-dimensional annihilator duality gives + + c tensor e_a = p_a + u_a, + p_a in P tensor V*, u_a in U intersect (L tensor V*), + L=(P+span(c)) intersect helper covectors. + +This is a kernel implication for a linear domain; it does not assume the +processing itself is linear. Intersections commute with tensoring here by +choosing bases of finite-dimensional subspaces. The u_a are independent +modulo Z tensor V*. Otherwise a nonzero v would satisfy +c tensor v in (P+Z) tensor V*. A scalar linear functional annihilating P+Z +and taking c to one contracts that inclusion to v=0, a contradiction. + +Thus W=(Z tensor V*)+span(u_a) has D(rank Z+1) dimensions. On every cheap +helper-rank prefix C_k its projected rank is at most + + D min(rank(Z restricted C_k)+1, + rank((Z+L) restricted C_k)). + +Both bounds are necessary: appending D rows increases rank by at most D, +and W is inside (Z+L) tensor V*. Generic scalar u in L outside Z attains +all the scalar prefix maxima simultaneously. Each missed maximum is a +proper linear condition on u, and a finite union of proper linear spaces +cannot cover an infinite field. The tensor generic space has the same +full rank as W and no smaller cheap-prefix ranks. + +At fixed full rank, the weighted greedy price is largest-column-price +times rank minus the nonnegative price gaps times the cheap-prefix ranks. +Consequently b_D(W) >= gamma_E, the scalar generic lower debit. This needs +no equality of block and tensor matroids. Taking the maximum of individual +gamma_E lower bounds for several actual new caches is valid; simultaneous +attainability of their generic minimizers is unnecessary. + +## Local refinements and composition + +If the full enlarged space has all support ranks at least a, any column +basis of W contains a column basis of Z tensor V*, leaving D extra columns. +Each costs at least f(a)/D. This yields the same extra f(a) debit as the +scalar proof. The support condition must apply to the entire enlarged +space; checking only an appended row would be insufficient. The draft and +source-specific scalar proof use the former condition. Required disjoint +unit zero rows lift to disjoint D-entry blocks; their exact tensor basis +prices and already-enabled-cache conditions are unchanged. + +The certified scalar component spaces form a direct sum. Tensoring +preserves it, and actual necessary local spaces remain inside those tensor +components. A global basis determinant expanded by row groups has a +nonzero Laplace term partitioning its columns into local bases. Its price +is therefore at least the sum of local minimum basis prices. Overlapping +helper supports cause no double debit: distinct entry-columns in that +partition are paid only once. Additional cross-component relations in U +cannot remove the selected necessary direct-sum subspace. + +Because normalized source coefficients are rational real scalars, viewing +complex arrays as twice as many real entries preserves the common-scalar +source form. The same proof then includes real-linear operators such as +conjugation. This relies on that actual source property. It does not prove +an extension to arbitrary nonreal source blocks or infinite-dimensional +spaces, and it supplies no separate smooth/discrete-domain extension. + +## Exact executed fixtures and limitations + +`fixtures.py` independently constructs D=2 and D=3 examples with histories +y_i=m+X_i, zero relation X1-X2=0, and target m. Let A be the superdiagonal +shift, K=diag(2,...,2,0), B=K-A, C=Id-K. The extra relation is +A X1+B X2+C X3=0. Since A+B+C=Id, the full target is recovered as +A y1+B y2+C y3. A and B do not commute. The enlarged relation space has +rank 2D, while its prefix on helpers1 and2 has rank 2D-1, strictly below +the scalar generic tensor prefix 2D. This gives an actual non-tensor test +of the inequality, rather than merely tensor examples. + +For all nine min(r,k) tariffs, exhaustive expanded-column basis enumeration +agrees with greedy pricing and bounds the block debit below by scalar +gamma. With helper ranks1,2,4, the dimension-linear block prices are4 for +D2 and11/3 for D3, versus scalar gamma3. The generic scalar witness need +not be a physical preparation. A valid lost-field set {X1,X3} passes the +surjectivity rank condition; the cheaper set {X1,X2} fails it. Actual whole +field loss can therefore exceed the fractional accounting minimum. + +Two further adversarial controls matter. With only D-1 appended entry +relations, exactly D-1 target entries can be recovered, and the expanded +debit is below scalar gamma; the whole-output validator rejects that +proposal. For two independent tensor groups supported on the same helpers, +exhaustive pricing confirms the Laplace lower bound. Repeating the same +group instead is dependent and would permit a double spend; the direct-sum +validator rejects it. The tests execute in normal and optimized Python, +with identical logical results after omitting runtime. + +The universal proof is the dimension/rank/greedy/Laplace argument above; +finite fixtures are controls for its hypotheses and inequalities. The +conclusion remains conditional on the actual fixed source histories, +whole original MOVE credit, original whole helper prices, independent +arbitrary mains, and every foundational physical assumption. Changed +producer histories, partial cache jobs, decoded productive targets, or +promises on a discrete grid alone are outside this review. diff --git a/research/p104-joint-helper-cache-funding-bound/extensions/SCOPE-COUNTEREXAMPLES.md b/research/p104-joint-helper-cache-funding-bound/extensions/SCOPE-COUNTEREXAMPLES.md new file mode 100644 index 0000000000..badadb1dc6 --- /dev/null +++ b/research/p104-joint-helper-cache-funding-bound/extensions/SCOPE-COUNTEREXAMPLES.md @@ -0,0 +1,95 @@ +# Positive fixture and counterexamples to broader statements + +## Positive smooth nonlinear scalar graph + +Take helpers (a,b,c)=(t,t^2,t+t^2), retain a and fully debit b,c. With +independent main m, observation A1=(m,a) determines target t1=m+b by +phi1(s,t)=s+t^2. Observation A2=(m+a,m-a) determines target t2=m+c by +phi2(s,t)=s+((s-t)/2)^2. The linear zero row c-a-b vanishes identically. +At p the common helper tangent is (v,2p*v,(1+2p)*v). Linear providers are +B1=(1,2p) and B2=(1+p,-p). The retained projection is onto and the b,c +pivot columns form an identity matrix for the tangent annihilator. + +## Critical real point: constant-rank hypothesis at fixed p is necessary + +S={(t,t^3):t in R}, observe t^3, target t. Cube root is exact deterministic +recovery. At0 the tangent is(1,0), observation derivative0 and target +derivative1, so no tangent factor exists THERE. Rank is not locally +constant at0. At any nonzero point the factor exists; this does not +contradict the nearby-common-point existence theorem. + +## Smooth complex source, cusp observation at a critical point + +S={(t,t^2,t^3):t in C}, retain t, observe(t^2,t^3), target t. Recovery is +z/y when y!=0 and0 at(y,z)=0, globally well-defined on the observed cusp. +The source graph is smooth, but at0 the observation differential is zero +while the target differential is1. This disproves a fixed-critical-point +claim even over C. The observation rank changes near0. + +## Real-smooth complex promise is not complex-scalar linear + +S={(z,conjugate(z)):z in C}, retain z. Observing the second helper determines +the first by conjugation. This is a smooth real graph and its real tangent +is itself; its complex span is C^2. No nonzero complex-scalar equation +annihilates it, and the observation does not determine the first coordinate +on that complex span. The real tangent theorem remains valid. Applying a +complex-scalar funding theorem to it is invalid without a real/block lift. + +## Retained projection at an arbitrary critical point + +S={(t^2,t)}, retain the first coordinate. At0 the tangent projects to zero +on the retained coordinate even though the source graph is smooth. An +observation of the second coordinate has constant rank and determines +the first. The derivative factors but the retained-coordinate funding +conclusion fails: the tangent annihilator is supported on the retained +coordinate. A nearby nonzero point restores submersivity. + +## Discrete/exact-grid promises + +On S={0,1}^2, retain both coordinates. The linear observation x+2y is +injective and determines target x by parity. Any real linear domain +surjecting onto both retained coordinates is all R^2, where observation +kernel(-2,1) changes x. Thus no desired linear domain exists. The grid is +not a manifold with a retained submersion into R^2. More digits give the +same exact encoding issue; these fixtures do not propose a native decoder. + +## Nonregular promise with full retained-coordinate range + +For x,y in(0,1), take their canonical binary expansions, not eventually1. +Encode E(x,y) by base4 digits 2*b_n(x)+b_n(y). These digits are not eventually3, +so E is injective and digit decoding recovers x,y. Promise S is the graph +(x,y,E(x,y)); its projection onto retained(x,y) is the full open square. +Observe the single coordinate z and target both x,y. Deterministic recovery +exists, but no linear domain with retained projection rank2 can preserve +both targets through a one-dimensional observation. This graph has no +eligible smooth/submersive patch to which the theorem could apply. + +## Positive characteristic is not included + +Over an algebraically closed field of characteristic p, use S={(t,t^p)}. +Retain t and observe t^p. Frobenius is bijective on points, so a unique +set-theoretic pth-root decoder recovers t. Its differential is zero +EVERYWHERE, despite a nonzero target differential. Constant differential +rank in positive characteristic does not give the required fiber-curve +statement: scheme fibers are nonreduced. Characteristic0 is essential. + +## General arrays need a block-linear funding theorem + +For two-entry helpers X,Y, retain X and promise Y=P X with P a nonscalar +swap matrix. This is a smooth complex-linear graph. Observing Y recovers +X, but its tangent admits no nonzero scalar equation aX+bY=0, since +that would require aI+bP=0. It is block-linear, not in scalar C40's model. +This is a scope counterexample to identifying the tangent as scalar; +it does not assert the eventual block funding bound is false. + +## Main-independent helper promise is required + +If a helper instead obeys h=m for arbitrary main m, observing h recovers m. +Its tangent is the diagonal in(main,helper), not full-main times a fixed +helper tangent. The direct-product hypothesis cannot be silently removed. + +These are analytic/algebraic fixtures. Exact executable checks are in +fixtures.py, FIXTURES.json and CHECKS.json. No finite sample is claimed as +proof of a universal assertion. The subsequent block review explains why +conjugation and nonscalar block graphs are not counterexamples to the +expanded real/block funding route. diff --git a/research/p104-joint-helper-cache-funding-bound/extensions/SEMIALGEBRAIC-PROOF.md b/research/p104-joint-helper-cache-funding-bound/extensions/SEMIALGEBRAIC-PROOF.md new file mode 100644 index 0000000000..08cc01ed2d --- /dev/null +++ b/research/p104-joint-helper-cache-funding-bound/extensions/SEMIALGEBRAIC-PROOF.md @@ -0,0 +1,157 @@ +# Semialgebraic promises reduce to one common block-linear tangent + +## Claim and dependency + +Let `a` be the number of main fields. Fix a finite source with normalized real-linear history maps `A_e`, whole +target maps `c_e`, and linear rows `z_j` for MOVE values that are promised to +be zero. Let the helper promise be a semialgebraic set + +`S ⊆ (R^D)^H`, + +independent of all main inputs. Let `I` be the retained original helper fields, +and let `π_I:S→(R^D)^I` be coordinate projection. Assume `π_I(S)` contains a +nonempty Euclidean open set. Each cached whole target is assumed to be an +exact deterministic function of its fixed original history on +`(R^D)^a × S`; each `z_j` vanishes on the full main/helper product domain. + +Then one real block-linear tangent space preserves every cache and every zero +MOVE simultaneously, and its projection onto the retained original fields is +surjective. The implication to the joint fine source envelope uses the +separate all-block funding theorem: it upper-bounds the tangent's optimistic +gain, and tangent projection makes its minimum debit no larger than the +actual fully debited original coordinates. This is a reduction of the +semialgebraic promise to that linear funding theorem. It makes no source +admission, physical implementation, foundational-assumption, or new-κ claim. + +The proof applies to reducible, singular, nonclosed semialgebraic sets and +does not assume an initial smooth patch or a retained submersion. It does not +apply to arbitrary nonsemialgebraic promises with the same set-theoretic +projection property. + +## Select a stratum that sees an open retained image + +Write `n=D|I|` and identify the retained array coordinates with `R^n`. By +Tarski–Seidenberg, the image `π_I(S)` is semialgebraic. Apply the +Drusvyatskiy–Ioffe–Lewis stratification theorem (Theorem 3.4) to +`π_I:S→R^n`, choosing the target collection to include `π_I(S)`. It gives +finite analytic source and target stratifications such that: + +1. each source stratum `M` is a smooth semialgebraic manifold; +2. `π_I|M` has constant rank; and +3. `π_I(M)` is a target stratum. + +The target strata partition `π_I(S)`. A finite union of semialgebraic sets +of dimension below `n` has empty interior in `R^n`. Since `π_I(S)` contains +an open set, at least one target stratum inside `π_I(S)` has dimension `n`. +Because the source-stratum images cover `π_I(S)`, some source stratum `M` +maps onto such a full-dimensional target stratum. The constant-rank theorem +then gives + +`rank(dπ_I(p)|T_pM)=n` + +at every `p∈M`. In particular, `M` is a retained-submersion stratum. It need +not be a whole connected component of `S`; lower-dimensional and singular +parts of `S` can be left behind. + +This step is the reason an open projected image matters. Surjectivity onto +the entire retained space is sufficient but stronger than needed. + +## Choose one point regular for every fixed history map + +For each cache `e`, let + +`F_e(m,p)=A_e(m,p)`, for `(m,p)∈R^{D a}×M`. + +This is the restriction of a fixed real-linear map to a smooth semialgebraic +manifold. Its differential rank has finitely many values, and the level sets +of that rank are semialgebraic: in local semialgebraic charts the relevant +Jacobian minors are semialgebraic. The union of the relative interiors of +these finitely many rank level sets is open dense in `M`. Equivalently, one +may refine `M` by the finite tuple of ranks of all `F_e`; a top-dimensional +piece is relatively open in `M` and has every rank constant. + +There are finitely many history maps, so intersect their open dense +locally-constant-rank loci. Choose one `p∈M` in that intersection. The +retained projection still has rank `n` at `p`, since this selection only +restricts to a relatively open subset of `M`. Choose any main point `m`. +The full product manifold + +`N=R^{D a}×M` + +has tangent `W=R^{D a} ⊕ T_pM` at `(m,p)`, and every history map `F_e|N` +has locally constant rank near that point. One and the same `W` is used for +all caches and zero rows. + +## Exact recovery implies tangent factorization + +No smoothness of a cache decoder is needed. Let `g_e` be any deterministic +function satisfying + +`c_e(x)=g_e(A_e(x))` for every `x∈N`. + +Take a tangent vector `v∈ker(dA_e|W)`. The constant-rank fiber theorem gives +a smooth curve `γ` in `N`, through `(m,p)`, tangent to `v`, and contained in +the local fiber of `A_e`. Along `γ`, the observation is constant. Exact +deterministic recovery therefore makes `c_e(γ(t))` constant, so +`dc_e(v)=0`. Since `A_e` and `c_e` are ambient linear maps, their derivatives +on `W` are just their restrictions. Hence + +`ker(A_e|W) ⊆ ker(c_e|W)`. + +Define `B_e(A_e v)=c_e v` on `A_e(W)`. The kernel inclusion makes this +well-defined and linear; extend it linearly to the full observation space. +Thus `c_e|W=B_e A_e|W`. This argument applies at the chosen common point to +all finitely many history/target pairs, even if the original decoders are +discontinuous or nonunique away from their exact target values. + +Each promised zero row `z_j` vanishes on all of `N`; differentiating its +identically zero value gives `z_j|W=0`. + +The helper tangent `T=T_pM` projects onto all retained real array +coordinates. Set `U=T^⊥` in the real helper covector space. If a covector +`u∈U` restricts to zero on the fully debited helper coordinates `J=H\\I`, +then it is supported on `I`. For every `q_I∈R^{D|I|}`, submersion gives a +`v∈T` with `π_I(v)=q_I`; consequently `u(q_I)=0` for every `q_I`, and +`u=0`. Therefore restriction from `U` to the `J` columns is injective, so +the original fully debited fields contain a column basis of `U`. + +The tangent retains at least the original cache and zero-MOVE benefits, +while its minimum lost-helper target price is at most the price of all +fully debited coordinates `J`. So its optimistic net gain is no smaller +than the original promise's gain. Applying the all-block funding bound to +this single tangent yields the joint fine envelope for the stated +semialgebraic class. + +## Edge cases and exclusions + +### Empty retained set + +If `I=∅`, the target is `R^0={0}`. The open-image hypothesis is exactly +`S≠∅`; the retained differential has rank zero automatically. The tangent +argument still works, and `J=H`, so no original helper field is retained +from the funding debit. This vacuous projection case is explicit. + +### Finite grids + +For nonempty `I`, a finite grid projects to a finite subset of `R^n` and +contains no nonempty open set. The theorem makes no claim that such a grid is +equivalent to an open projected image or that discrete decoding can be +replaced by a tangent. When `I=∅`, a nonempty finite `S` satisfies the +vacuous open-image condition, but the debit includes every helper field. +Nonsemialgebraic encodings with an open retained projection are outside the +claim. + +### Complex arrays + +Treat `C^{D H}` as `R^{2 D H}`. For normalized source maps with rational-real +coefficients, their realifications are real-linear block maps and the +selected real tangent is block-linear. This deduction uses this source's common rational-real scalar maps; no generalization to arbitrary complex +normalized coefficient blocks is asserted. It does not identify a real tangent +with a complex-scalar subspace and does not invoke the scalar-linear complex theorem. The funding conclusion uses the corresponding +real block-linear funding theorem. + +The result does not cover promises depending on main inputs, approximate or +probabilistic recovery, changed histories/maps, or arbitrary nonsemialgebraic +sets. A finite-grid example with positive-dimensional retained coordinates +is excluded by the open-image hypothesis; it is not a counterexample to the +semialgebraic statement. diff --git a/research/p104-joint-helper-cache-funding-bound/extensions/SEMIALGEBRAIC-REVIEW.md b/research/p104-joint-helper-cache-funding-bound/extensions/SEMIALGEBRAIC-REVIEW.md new file mode 100644 index 0000000000..1a0e0d23a0 --- /dev/null +++ b/research/p104-joint-helper-cache-funding-bound/extensions/SEMIALGEBRAIC-REVIEW.md @@ -0,0 +1,80 @@ +# Adversarial review of the semialgebraic tangent extension + +## Result + +The reduction is valid under its stated hypotheses and under the separate +all-block funding theorem. Semialgebraicity supplies the missing common +regular stratum; the open image condition supplies a stratum whose retained +projection is a submersion. Exact recovery itself need not be semialgebraic, +continuous, or differentiable. + +The cited primary result is Drusvyatskiy, Ioffe, and Lewis, Theorem 3.4. It +states that a semialgebraic map admits compatible finite analytic +stratifications of source and target on which the restriction has constant +rank and maps source strata onto target strata. In applying it, include the +semialgebraic image `π_I(S)` in the target compatibility family. Because that +image contains a nonempty open set, at least one included target stratum is +full dimensional. At least one source stratum maps to it, and constant rank +then forces rank `D|I|` on that entire source stratum. + +The follow-on common-point step is also sound: restrict each of the finitely +many linear history maps to this semialgebraic smooth stratum. Its differential +rank level sets are semialgebraic and finite in number. The union of the +relative interiors of the rank level sets is dense, since the omitted +semialgebraic boundaries have smaller dimension. Intersect these finitely +dense open loci, then select one point. This preserves the full retained +projection rank and makes all history maps constant-rank near the same point. + +At that point, the constant-rank fiber-curve argument proves tangent-kernel +inclusion from exact deterministic recovery without differentiating a +decoder. Differentiating every promised linear zero row gives its tangent +annihilation. Main inputs stay a full independent factor, so the tangent +contains every main direction. The retained helper projection is surjective; +therefore the annihilator has injective restriction to the fully debited +helper columns. These are precisely the hypotheses needed to transfer the +optimistic funding bound from the tangent back to the original promise. + +## Boundary checks + +- **Reducible and singular sets:** allowed. The proof selects one source + stratum mapping to a full-dimensional retained target stratum; it does not + require irreducibility, a globally smooth promise, or a regular point in + every component. +- **Varying observation ranks:** allowed for a finite family. Semialgebraic + rank loci have a common open piece of the chosen stratum. The argument + would not justify an infinite family of independent cache obligations. +- **Critical points:** a bad singular point need not itself work. For example, + on `(t,t^3)` the observation `t^3` recovers target `t`; at `t=0` its + derivative cannot factor the target derivative. The semialgebraic stratum + argument chooses a regular point with `t≠0` instead. +- **Finite grids:** with `|I|>0`, a finite retained projection has empty + Euclidean interior, so the hypothesis fails. Surjectivity onto a chosen + finite grid is not the same as containing an open subset. If `I=∅`, a + nonempty finite promise does satisfy the vacuous `R^0` open-image + condition, but then every helper field belongs to the debited set `J`. +- **Nonsemialgebraic digit encodings:** a graph can project onto an open + square and permit exact nonlinear decoding while admitting no useful + tangent subspace. Such a graph is outside the semialgebraic hypothesis; + open projection alone is insufficient. +- **Main dependence:** excluded. If the helper promise couples helpers to + arbitrary mains, the tangent is not `R^{DM}⊕T_pS`, and the full-main + derivative argument fails. +- **Complex data:** realification yields a real block tangent, not a + complex-scalar tangent. The conclusion uses the real block funding theorem + for the realified fixed maps. The present source has common rational-real scalar coefficients, which + preserve the exact tensor row-space structure used in the block proof. + Arbitrary complex coefficient blocks need a separate application argument. +- **Funding dependency:** the tangent construction alone is not a numerical + exclusion. The joint fine envelope follows only when the independently + checked block-linear funding bound applies to the resulting real tangent. + It does not claim an implementable cache, a changed source, or an attained + exponent. + +## Primary theorem checked + +The PDF's Theorem 3.4 is the stratification theorem used here (journal pages +517–518). It gives compatible `C^ω` stratifications and constant rank for +the chosen semialgebraic map. The stronger semialgebraic Sard/minimization +results later in the article are not needed. The only further facts used are +standard semialgebraic dimension properties and the constant-rank fiber +theorem. diff --git a/research/p104-joint-helper-cache-funding-bound/extensions/SMALL-PRICE-REVIEW-B.md b/research/p104-joint-helper-cache-funding-bound/extensions/SMALL-PRICE-REVIEW-B.md new file mode 100644 index 0000000000..2b06c82aa6 --- /dev/null +++ b/research/p104-joint-helper-cache-funding-bound/extensions/SMALL-PRICE-REVIEW-B.md @@ -0,0 +1,52 @@ +# Independent price and eight-component review + +The exact-source reconstruction and integer-power price checks pass. This is +an arithmetic review of the stated optimistic envelope, not a physical word +or a multiplication exponent claim. Source/global decomposition hypotheses +remain the separate root/C review gates. + +`small.py` reads C31's freshly replayed actual source rows and history spaces, +checks the source hash and literal MOVE records, and independently recomputes +the helper-only history extension by main-projection rank-nullity. It uses +maximum pivots and quotient reduction across every pivot. For each of the 43 +zero subsets it recomputes the original-helper target-rank prefix ranks, +cache eligibility, and each individual new-cache prefix bound. It checks all +89 grant cases and 91 obligation invoices against the root receipt. No root +linear algebra or root price routine is imported. + +For each case, one necessary obligation suffices to prove the claimed cap on +the minimum of obligation upper bounds. `SMALL.json` records that obligation +and an exact proof valid for every 0 <= kappa <= 1/100. The proof either checks +all nine increasing-concave generators min(r,k), or uses the rational bound +9^(1/100) < 1023/1000, certified by 9*1000^100 < 1023^100. For a signed difference, +1000*sum(positive rank multiplicities) >= 1023*sum(negative rank multiplicities) +then proves nonnegativity throughout the interval. + +Five components have ceiling zero. The other three have ceilings +f(5)+f(1)-f(6), f(1)+f(3)-f(4), and f(6)-f(4), respectively, on cache sets +{39875,39884}, {42500}, and {41646}. Their sum is +F = f(5)+f(3)+2*f(1)-2*f(4). + +At kappa=19/5000, `powers.py` certifies each bracket using only integer +inequalities a^5000 <= r^4981*10^120000 < (a+1)^5000, with rational endpoints +a/10^24 and (a+1)/10^24. Decimal evaluation supplies an initial guess only. +All price signs follow from the checked integer inequalities. Exact integral +prices may have equal endpoints. `margin.py` authenticates the exact native +WORD, exact Git caller bytes, canonical payload, full invoice, and all 17 +native calls. It derives the baseline moment M from that invoice and proves + + -25.258109991835383588522658 + <= M+17*F <= + -25.258109991835383588473069 < -25.2581. + +The margin below -25.2581 is greater than 0.000009991835383588473069. The +upper envelope is a generous funding bound; its crossing is not asserted +achievable. All original-coordinate and whole-MOVE restrictions are retained. + +The actual validators reject a wrong target-debit sign, a missing case, +18 calls substituted for 17 in the stated margin test, and an invalid lower +price bracket. An all-pivot trap checks that a nonpivot coordinate does not +prematurely stop quotient reduction. Both verifiers pass under normal Python +and `python -O`; receipts agree after deleting elapsed time. Source pins, +file hashes and logical receipt hashes appear in `VALIDATION.json` and the +two result files. No existing frozen wave41 files were changed. diff --git a/research/p104-joint-helper-cache-funding-bound/extensions/SMOOTH-ARRAY-COROLLARY.md b/research/p104-joint-helper-cache-funding-bound/extensions/SMOOTH-ARRAY-COROLLARY.md new file mode 100644 index 0000000000..28b801442b --- /dev/null +++ b/research/p104-joint-helper-cache-funding-bound/extensions/SMOOTH-ARRAY-COROLLARY.md @@ -0,0 +1,46 @@ +# Common-tangent corollary for smooth helper arrays + +This applies the source/funding theorem and its finite block lift in +PROOF.md and BLOCK-LIFT.md, with separate adversarial reviews A and B. It does not introduce a kappa claim or prove any framework assumption. + +Let helper arrays lie in (F^D)^H, with a smooth promise submanifold S, and +let retained original whole fields I project submersively onto (F^D)^I +at some point. Main arrays remain arbitrary independently of S. Use the +same fixed finite normalized source observation/target maps as C40; these +are A_E tensor Id_D and c_E tensor Id_D. Exact whole cached targets must +be deterministic functions of their histories on the promise; every +deleted whole MOVE must vanish identically there. No regularity of the +cache functions is assumed. + +For F=R use a C1 real submanifold. For F=C one can use a complex submanifold; +a merely real-smooth promise in complex arrays is instead realified to +2D real entries, using this source's rational-real coefficient property. + +Choose one common locally constant-rank point in the open retained- +submersion locus, as proved in PROOF.md. The constant-rank fiber argument +applies to the full finite array coordinates and every whole target at +that same point. Its helper tangent is now arbitrary block-linear, with +annihilator U. Retained whole-field submersion makes the actual fully +debited helper set fund an expanded-column basis for U. All original +whole zero and cached-output benefits persist on that tangent domain. +The block-linear funding theorem bounds this tangent's optimistic payoff, +which is at least the original promise's payoff before preparation cost. +Consequently the same fine source-envelope bound extends to this smooth +array-promise class, under those hypotheses. + +No assumption that this tangent has identical scalar equations per array +entry is needed after the block lift. The earlier conjugation example +still refutes a complex-SCALAR tangent identification, while its real +block tangent is covered by this broader route. + +For an irreducible complex algebraic S dominating the retained array +coordinate space, characteristic-zero generic smoothness and finitely +many maximal-rank loci provide a common nonempty Zariski open of valid +points. Real algebraic promises need an actual real smooth/submersive +locus; complex dominance alone does not supply one. + +Arbitrary discrete/exact-grid promises, nonregular encodings, approximate +recovery, main-dependent promises, data-dependent histories, fractional +MOVE/output splitting and newly decoded target types remain outside this +statement. Finite-dimensional tangent variation and accounting weights +do not reprice a native rank r as Dr or establish an all-column theorem. diff --git a/research/p104-joint-helper-cache-funding-bound/extensions/TANGENT-PROOF.md b/research/p104-joint-helper-cache-funding-bound/extensions/TANGENT-PROOF.md new file mode 100644 index 0000000000..e8a2d0151d --- /dev/null +++ b/research/p104-joint-helper-cache-funding-bound/extensions/TANGENT-PROOF.md @@ -0,0 +1,131 @@ +# One common tangent preserves finite exact cache and zero dependencies + +## Proved local statement + +Let F=R and S be an embedded C1 submanifold without boundary of F^H, or +let F=C and S be a complex submanifold of C^H. Work at an interior point. +Let I be the original retained helper coordinates, J its complement, and +M=F^a times S, with all main inputs independent of the helper promise. +Fix finitely many F-linear observation maps A_e and F-linear targets t_e +on F^a plus F^H. Assume t_e is an exact deterministic function of A_e on +M locally: equivalently it is constant on each observation fiber. No +continuity or differentiability of the provider function is assumed. +Let finitely many linear zero rows z_j vanish identically on M. + +At q=(m,p), assume pi_I:S->F^I is a submersion, and each A_e restricted +to M has locally constant rank near q. Put T=T_p S and W=F^a plus T. +Then ONE W simultaneously has: + +1. surjective projection of T onto the retained original I coordinates; +2. z_j restricted to W equal to zero for every original zero job; +3. F-linear maps B_e with t_e|W=B_e A_e|W for every original cache. + +T is a homogeneous linear space of variations; p need not be zero or +belong to T. The resulting provider coefficients need not be rational. +The statement is about fixed original maps, not input-dependent histories. + +## Fiber-curve proof, without differentiating the provider + +For a constant-rank map f, every v in ker(df_q) is the velocity of a +C1 curve through q contained in f^{-1}(f(q)). One local proof chooses a +nonzero maximal Jacobian minor and uses the inverse function theorem to +make its r output coordinates the first r domain coordinates u. Write +the remaining domain coordinates v. Constant rank forces every other +output derivative in the v directions to vanish; on a small connected +coordinate box those outputs depend only on u. Fibers therefore contain +all curves with u fixed, realizing their entire differential kernel. +The holomorphic argument is the same over C. + +Apply this to A_e|M. Exact deterministic recovery makes t_e constant on +each such fiber curve, so dt_e annihilates ker(dA_e). Because A_e and t_e +are ambient linear maps, their derivatives are themselves restricted to +W. Thus ker(A_e|W) is contained in ker(t_e|W). Define B_e(A_e w)=t_e w; +this is well-defined and F-linear on A_e(W), and extends linearly to the +ambient observation space. The provider itself was never differentiated. +Differentiating z_j=0 on M gives z_j|W=0. The retained submersion gives +surjectivity onto I. The same p is used for every dependency. + +## Existence of one common regular point for finite smooth data + +The fixed-point constant-rank assumption cannot be dropped at an arbitrary +critical point. Nevertheless, if the retained projection is a submersion +somewhere and the exact dependencies hold on that neighborhood, a suitable +nearby common point always exists for finitely many maps. + +The locus where the rank of a continuous matrix/bundle map is locally +constant is open dense. In any nonempty open patch, choose a point where +the finite-valued rank is maximal. A nonzero maximal minor gives a smaller +open patch with that constant rank. Apply this to each restricted A_e +Jacobian. A finite intersection of these open dense sets meets the open +retained-submersion locus. For ambient linear A_e, its rank on F^a plus +T_pS depends only on p, not m. Thus one helper p works for arbitrary main +variations. This argument does not use Sard's theorem or a differentiable +cache decoder. It does not cover an infinite family of required maps. + +## Retained-coordinate funding + +Let U=T-perp be the F-linear annihilator in helper covectors. Restriction +U->F^J is injective: a covector supported only on I and zero on T must +vanish, since T projects onto all of F^I. Hence the J columns have full +row rank in U. A column basis can be chosen entirely from J, giving +beta_f(U)<=sum_{j in J} f(R_j). This is an upper bound on the tangent's +minimum target debit by the actually fully debited helper set. + +Every original zero/cache benefit survives on W, and the tangent may add +more. Thus the scalar-linear optimistic funding payoff of U is at least +the original payoff with the charged J targets, before preparation costs. +Any upper bound proved for all such linear U therefore bounds this smooth +nonlinear promise class as well. Preparation, circuit/grid admission and +ordinary costs are not constructed by this argument. + +C40's proof permits real/complex coefficients: rational source ranks and +minor zeros persist under characteristic-zero extension, and a rational +generic appended row attains all maximal finite prefix ranks. A special +real/complex row cannot have a smaller minimum basis price than that +generic lower debit. The exact dependency review is snapshotted in inputs/. +No numeric kappa improvement follows from this reduction. + +## Irreducible complex-algebraic corollary + +Let S be an irreducible reduced complex algebraic variety in C^H, with +coordinate projection to C^I dominant. Assume exact set-theoretic cache +functional dependencies on C^a times S (or a common nonempty Zariski open), +with the same fixed finite linear maps. There is a nonempty Zariski open +of common valid p in S's smooth locus. + +Indeed retained coordinates are algebraically independent in C(S). +In characteristic0 extend them to a separating transcendence basis; +their differentials are independent at the generic point. A nonzero +minor gives a dense open retained-submersion locus. Each observation +Jacobian has maximal rank on a dense open of the smooth locus. Intersect +these finitely many opens and choose a complex point there. Apply the +holomorphic fiber-curve proof. Irreducibility ensures the intersection is +nonempty. No differentiability or regularity of the decoder is needed. + +Primary background: Ravi Vakil, The Rising Sea (2024 draft),21.6.1 and +21.6.4, gives generic smoothness; Stacks tag0322 records characteristic-zero +separability. The fiber argument and simultaneous-point/funding deductions +above are supplied here. Positive characteristic is explicitly excluded. + +## Scalar arrays versus general array-valued promises + +The proved scalar application has S contained in F^H. It also applies to +a coordinatewise product promise S^D with normalized observations A_e +acting componentwise, A_e tensor Id_D. Use the diagonal basepoint(p,...,p). +Its tangent is (T_pS)^D and has the same scalar equations on every entry. +A one-column variation shows the scalar kernel inclusion, so the same B_e +works componentwise. No f(D*r), dimension scaling or new all-column rule +is introduced; all retained native pricing conventions remain unchanged. + +For arbitrary S contained in (F^D)^H, the tangent is block-linear. +BLOCK-LIFT.md now proves the required funding extension; its two independent +reviews are included alongside this note. Real-smooth complex promises use +realification to2D real entries, justified by this source's common rational-real +normalized coefficients. The conjugation example still refutes a complex-scalar +lift, while the real block theorem covers it. No infinite-dimensional claim is made. + +Arbitrary discrete/exact-grid promises, nonregular digit-encoding sets, +main-dependent helper promises, approximate recovery and changing native +maps are not covered. See COUNTEREXAMPLES.md. No physical source or kappa +is claimed. The independent block reviews are BLOCK-REVIEW-A.md and BLOCK-REVIEW-B.md; +the smooth-array corollary is in SMOOTH-ARRAY-COROLLARY.md. diff --git a/research/p104-joint-helper-cache-funding-bound/inputs/CALLER.json b/research/p104-joint-helper-cache-funding-bound/inputs/CALLER.json new file mode 100644 index 0000000000..9451ceaf6e --- /dev/null +++ b/research/p104-joint-helper-cache-funding-bound/inputs/CALLER.json @@ -0,0 +1 @@ +{"schema":"mixed-root-caller/1","stages":17,"ambient_rank":145,"roles":72,"types":{"A":{"form":"two-chain-HOST2","roles":36,"offset":0,"ports":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,16,18,19,20,21,22,23,24,25,26,28,29,30,31,32,33,36,37,38,39,40,41,43,44,45,46,48,49,50,51,52,53,54,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103],"alpha2":"-1","beta2":"0","diagonal":[[-1,0,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,0,0,0,0,0,0,0,0,0],[-1,0,0,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0],[-1,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0],[-1,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,0,0,0,0,0,0,0,0,0],[-1,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,1,1,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],[-1,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,1,1,0,0,0,0,0,0,0],[-1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0],[-1,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0],[-1,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,1,1,1,1,1,1,0,0,0],[-1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,0,0],[-1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,0],[-1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1],[-1,0,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,0,0,0,0,0,0,0,0,0],[-1,0,0,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0],[-1,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0],[-1,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,0,0,0,0,0,0,0,0,0],[-1,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,1,1,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],[-1,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,1,1,0,0,0,0,0,0,0],[-1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0],[-1,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0],[-1,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,1,1,1,1,1,1,0,0,0],[-1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,0,0],[-1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,0],[-1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1]]},"B":{"form":"hosted-HOST","roles":36,"offset":36,"ports":[15,17,27,34,35,42,47,55],"diagonal":[[-1,0,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,1,1,1,1,1,1,1,1],[-1,0,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0],[-1,0,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0],[-1,0,0,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0],[-1,0,0,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0],[-1,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0],[-1,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0],[-1,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0],[-1,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,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],[-1,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,1,1,1,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],[-1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0],[-1,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,1,1,1,1,1,1,1,1,1],[-1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,0],[-1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,0],[-1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,0,0],[-1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,0,0],[-1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0],[-1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0],[-1,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,1,1,1,1,1,0,0,0,0],[-1,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0],[-1,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0],[-1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0],[-1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0],[-1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0],[-1,0,0,0,0,0,0,0,0,0,1,1,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],[-1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0],[-1,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,1,0,0,0,0,0,0,0,0]],"pairs":[[0,1,"-1","1/2","-1/2"],[2,3,"-1","1/2","-1/2"],[4,5,"-1","1/2","-1/2"],[6,7,"-1","1/2","-1/2"],[8,9,"-1","1/2","-1/2"],[10,11,"-1","1/2","-1/2"],[12,13,"-1","1/2","-1/2"],[14,15,"-1","1/2","-1/2"],[16,17,"-1","1/2","-1/2"],[22,23,"-1","1/2","-1/2"],[24,25,"-1","1/2","-1/2"],[26,27,"-1","1/2","-1/2"],[28,29,"-1","1/2","-1/2"],[30,31,"-1","1/2","-1/2"],[32,33,"-1","1/2","-1/2"],[34,35,"-1","1/2","-1/2"],[36,37,"-1","1/2","-1/2"],[38,39,"-1","1/2","-1/2"]]}},"events":[["B","ADD",37,36,"7"],["B","ADD",38,36,"-1/2"],["B","ADD",39,36,"3/2"],["B","SCALE",36,"-2"],["B","ADD",36,37,"1"],["B","ADD",36,38,"2"],["B","ADD",36,39,"-2"],["B","IDLE_ONE",36,[1]],["B","ADD",36,39,"2"],["B","ADD",36,38,"-2"],["B","ADD",36,37,"-1"],["B","SCALE",36,"-1/2"],["B","ADD",39,36,"-3/2"],["B","ADD",38,36,"1/2"],["B","ADD",37,36,"-7"],["B","ADD",39,37,"-1/2"],["B","SCALE",37,"-2"],["B","ADD",37,38,"4"],["B","ADD",37,39,"-8"],["B","IDLE_ONE",37,[1]],["B","ADD",37,39,"8"],["B","ADD",37,38,"-4"],["B","SCALE",37,"-1/2"],["B","ADD",39,37,"1/2"],["B","ADD",37,36,"1"],["B","ADD",38,36,"1/2"],["B","ADD",39,36,"1/2"],["B","ADD",36,38,"-1"],["B","ADD",38,37,"1/2"],["B","SCALE",37,"-1/2"],["B","ADD",37,38,"2"],["B","ADD",37,39,"-1"],["B","SCALE",37,"-1/2"],["B","ADD",37,36,"-1/2"],["B","ADD",36,37,"1"],["B","LAMBDA",36,1],["A","SCALE",1,"-1"],["A","ADD",1,0,"1"],["A","ADD",19,18,"-1"],["A","SCALE",19,"-1"],["A","LAMBDA",1,1],["A","LAMBDA",19,-1],["A","SCALE",19,"-1"],["J",1,[1,0,18,19],[36,37,"-1","1/2"]],["A","LAMBDA",1,-1],["A","LAMBDA",19,1],["A","SCALE",19,"-1"],["A","ADD",0,1,"-1"],["A","ADD",18,19,"-1"],["A","SCALE",19,"-1"],["A","ADD",19,18,"1"],["A","ADD",1,0,"-1"],["A","SCALE",1,"-1"],["B","LAMBDA",36,-1],["B","SCALE",37,"-2"],["B","ADD",37,39,"1"],["B","ADD",37,38,"-2"],["B","SCALE",37,"-2"],["B","ADD",38,37,"-1/2"],["B","ADD",36,38,"1"],["B","ADD",39,36,"-1/2"],["B","ADD",38,36,"-1/2"],["B","ADD",37,36,"-1"],["B","ADD",37,36,"12/5"],["B","ADD",38,36,"1/5"],["B","ADD",39,36,"3/10"],["B","ADD",40,36,"-1/40"],["B","ADD",41,36,"3/40"],["B","SCALE",36,"-1/10"],["B","ADD",36,37,"-1"],["B","ADD",36,38,"-2"],["B","ADD",36,39,"6"],["B","ADD",36,40,"20"],["B","ADD",36,41,"8"],["B","IDLE_ONE",36,[2]],["B","ADD",36,41,"-8"],["B","ADD",36,40,"-20"],["B","ADD",36,39,"-6"],["B","ADD",36,38,"2"],["B","ADD",36,37,"1"],["B","SCALE",36,"-10"],["B","ADD",41,36,"-3/40"],["B","ADD",40,36,"1/40"],["B","ADD",39,36,"-3/10"],["B","ADD",38,36,"-1/5"],["B","ADD",37,36,"-12/5"],["B","ADD",37,36,"7/3"],["B","ADD",38,36,"1/6"],["B","ADD",39,36,"1/6"],["B","ADD",41,36,"1/12"],["B","SCALE",36,"1/3"],["B","ADD",36,37,"-2"],["B","ADD",36,38,"-8"],["B","ADD",36,39,"20"],["B","ADD",36,40,"68"],["B","ADD",36,41,"28"],["B","IDLE_ONE",36,[2]],["B","ADD",36,41,"-28"],["B","ADD",36,40,"-68"],["B","ADD",36,39,"-20"],["B","ADD",36,38,"8"],["B","ADD",36,37,"2"],["B","SCALE",36,"3"],["B","ADD",41,36,"-1/12"],["B","ADD",39,36,"-1/6"],["B","ADD",38,36,"-1/6"],["B","ADD",37,36,"-7/3"],["B","ADD",37,36,"3"],["B","ADD",38,36,"1/2"],["B","ADD",39,36,"3/2"],["B","ADD",40,36,"-1/2"],["B","ADD",41,36,"1/2"],["B","SCALE",36,"-1"],["B","ADD",36,37,"1/2"],["B","ADD",36,39,"-1"],["B","ADD",36,40,"-4"],["B","ADD",38,37,"-1/2"],["B","ADD",39,37,"-2"],["B","ADD",40,37,"1/2"],["B","SCALE",37,"1/2"],["B","ADD",37,38,"1"],["B","ADD",37,39,"-2"],["B","ADD",37,40,"-8"],["B","ADD",37,41,"-4"],["B","SCALE",37,"1/2"],["B","ADD",37,36,"-1/2"],["B","ADD",36,37,"1"],["B","LAMBDA",36,1],["A","SCALE",2,"-1"],["A","ADD",2,0,"1"],["A","ADD",1,0,"-2"],["A","ADD",19,18,"-2"],["A","ADD",20,18,"-1"],["A","SCALE",20,"-1"],["A","LAMBDA",2,1],["A","LAMBDA",20,-1],["A","SCALE",20,"-1"],["J",2,[2,0,18,20],[36,37,"-1","1/2"]],["A","LAMBDA",2,-1],["A","LAMBDA",20,1],["A","SCALE",20,"-1"],["A","ADD",0,2,"-1"],["A","ADD",18,20,"-1"],["A","SCALE",20,"-1"],["A","ADD",20,18,"1"],["A","ADD",19,18,"2"],["A","ADD",1,0,"2"],["A","ADD",2,0,"-1"],["A","SCALE",2,"-1"],["B","LAMBDA",36,-1],["B","SCALE",37,"2"],["B","ADD",37,41,"4"],["B","ADD",37,40,"8"],["B","ADD",37,39,"2"],["B","ADD",37,38,"-1"],["B","SCALE",37,"2"],["B","ADD",40,37,"-1/2"],["B","ADD",39,37,"2"],["B","ADD",38,37,"1/2"],["B","ADD",36,40,"4"],["B","ADD",36,39,"1"],["B","ADD",36,37,"-1/2"],["B","SCALE",36,"-1"],["B","ADD",41,36,"-1/2"],["B","ADD",40,36,"1/2"],["B","ADD",39,36,"-3/2"],["B","ADD",38,36,"-1/2"],["B","ADD",37,36,"-3"],["B","ADD",37,36,"7"],["B","ADD",38,36,"5/2"],["B","ADD",39,36,"19/2"],["B","ADD",40,36,"-5/4"],["B","ADD",41,36,"-9/4"],["B","ADD",42,36,"-1/2"],["B","ADD",43,36,"3/2"],["B","SCALE",36,"-2"],["B","ADD",36,37,"7"],["B","ADD",36,38,"26"],["B","ADD",36,39,"-66"],["B","ADD",36,40,"-212"],["B","ADD",36,41,"-132"],["B","ADD",36,42,"14"],["B","ADD",36,43,"-26"],["B","IDLE_ONE",36,[3]],["B","ADD",36,43,"26"],["B","ADD",36,42,"-14"],["B","ADD",36,41,"132"],["B","ADD",36,40,"212"],["B","ADD",36,39,"66"],["B","ADD",36,38,"-26"],["B","ADD",36,37,"-7"],["B","SCALE",36,"-1/2"],["B","ADD",43,36,"-3/2"],["B","ADD",42,36,"1/2"],["B","ADD",41,36,"9/4"],["B","ADD",40,36,"5/4"],["B","ADD",39,36,"-19/2"],["B","ADD",38,36,"-5/2"],["B","ADD",37,36,"-7"],["B","ADD",37,36,"22/3"],["B","ADD",38,36,"8/3"],["B","ADD",39,36,"61/6"],["B","ADD",40,36,"-4/3"],["B","ADD",41,36,"-29/12"],["B","ADD",42,36,"-1/2"],["B","ADD",43,36,"5/3"],["B","SCALE",36,"2/3"],["B","ADD",36,37,"2"],["B","ADD",36,38,"8"],["B","ADD",36,39,"-20"],["B","ADD",36,40,"-64"],["B","ADD",36,41,"-40"],["B","ADD",36,42,"4"],["B","ADD",36,43,"-8"],["B","IDLE_ONE",36,[3]],["B","ADD",36,43,"8"],["B","ADD",36,42,"-4"],["B","ADD",36,41,"40"],["B","ADD",36,40,"64"],["B","ADD",36,39,"20"],["B","ADD",36,38,"-8"],["B","ADD",36,37,"-2"],["B","SCALE",36,"3/2"],["B","ADD",43,36,"-5/3"],["B","ADD",42,36,"1/2"],["B","ADD",41,36,"29/12"],["B","ADD",40,36,"4/3"],["B","ADD",39,36,"-61/6"],["B","ADD",38,36,"-8/3"],["B","ADD",37,36,"-22/3"],["B","ADD",37,36,"1"],["B","ADD",38,36,"-1/2"],["B","ADD",39,36,"-5/2"],["B","ADD",40,36,"1/4"],["B","ADD",41,36,"3/4"],["B","ADD",42,36,"1/2"],["B","ADD",43,36,"1/2"],["B","ADD",36,38,"-1"],["B","ADD",36,39,"2"],["B","ADD",36,40,"6"],["B","ADD",36,41,"4"],["B","ADD",36,42,"-1"],["B","ADD",38,37,"-1/2"],["B","ADD",39,37,"-2"],["B","ADD",40,37,"1/4"],["B","ADD",41,37,"1/2"],["B","ADD",42,37,"1/2"],["B","SCALE",37,"-1/2"],["B","ADD",37,39,"-1"],["B","ADD",37,40,"-4"],["B","ADD",37,41,"-2"],["B","ADD",37,42,"2"],["B","ADD",37,43,"-1"],["B","SCALE",37,"-1/2"],["B","ADD",37,36,"-1/2"],["B","ADD",36,37,"1"],["B","LAMBDA",36,1],["A","SCALE",3,"-1"],["A","ADD",3,0,"1"],["A","ADD",1,0,"-2"],["A","ADD",2,0,"-2"],["A","ADD",19,18,"-2"],["A","ADD",20,18,"-2"],["A","ADD",21,18,"-1"],["A","SCALE",21,"-1"],["A","LAMBDA",3,1],["A","LAMBDA",21,-1],["A","SCALE",21,"-1"],["J",3,[3,0,18,21],[36,37,"-1","1/2"]],["A","LAMBDA",3,-1],["A","LAMBDA",21,1],["A","SCALE",21,"-1"],["A","ADD",0,3,"-1"],["A","ADD",18,21,"-1"],["A","SCALE",21,"-1"],["A","ADD",21,18,"1"],["A","ADD",20,18,"2"],["A","ADD",19,18,"2"],["A","ADD",2,0,"2"],["A","ADD",1,0,"2"],["A","ADD",3,0,"-1"],["A","SCALE",3,"-1"],["B","LAMBDA",36,-1],["B","SCALE",37,"-2"],["B","ADD",37,43,"1"],["B","ADD",37,42,"-2"],["B","ADD",37,41,"2"],["B","ADD",37,40,"4"],["B","ADD",37,39,"1"],["B","SCALE",37,"-2"],["B","ADD",42,37,"-1/2"],["B","ADD",41,37,"-1/2"],["B","ADD",40,37,"-1/4"],["B","ADD",39,37,"2"],["B","ADD",38,37,"1/2"],["B","ADD",36,42,"1"],["B","ADD",36,41,"-4"],["B","ADD",36,40,"-6"],["B","ADD",36,39,"-2"],["B","ADD",36,38,"1"],["B","ADD",43,36,"-1/2"],["B","ADD",42,36,"-1/2"],["B","ADD",41,36,"-3/4"],["B","ADD",40,36,"-1/4"],["B","ADD",39,36,"5/2"],["B","ADD",38,36,"1/2"],["B","ADD",37,36,"-1"],["B","ADD",37,36,"12/5"],["B","ADD",38,36,"1/5"],["B","ADD",39,36,"3/10"],["B","ADD",40,36,"-1/10"],["B","ADD",41,36,"1/20"],["B","ADD",42,36,"1/5"],["B","ADD",43,36,"3/10"],["B","ADD",44,36,"-1/40"],["B","ADD",45,36,"3/40"],["B","SCALE",36,"-1/10"],["B","ADD",36,37,"-1"],["B","ADD",36,38,"-2"],["B","ADD",36,39,"6"],["B","ADD",36,40,"20"],["B","ADD",36,41,"12"],["B","ADD",36,42,"-2"],["B","ADD",36,43,"6"],["B","ADD",36,44,"20"],["B","ADD",36,45,"8"],["B","IDLE_ONE",36,[4]],["B","ADD",36,45,"-8"],["B","ADD",36,44,"-20"],["B","ADD",36,43,"-6"],["B","ADD",36,42,"2"],["B","ADD",36,41,"-12"],["B","ADD",36,40,"-20"],["B","ADD",36,39,"-6"],["B","ADD",36,38,"2"],["B","ADD",36,37,"1"],["B","SCALE",36,"-10"],["B","ADD",45,36,"-3/40"],["B","ADD",44,36,"1/40"],["B","ADD",43,36,"-3/10"],["B","ADD",42,36,"-1/5"],["B","ADD",41,36,"-1/20"],["B","ADD",40,36,"1/10"],["B","ADD",39,36,"-3/10"],["B","ADD",38,36,"-1/5"],["B","ADD",37,36,"-12/5"],["B","ADD",37,36,"7/3"],["B","ADD",38,36,"1/6"],["B","ADD",39,36,"1/6"],["B","ADD",40,36,"-1/12"],["B","ADD",41,36,"1/12"],["B","ADD",42,36,"1/6"],["B","ADD",43,36,"1/6"],["B","ADD",45,36,"1/12"],["B","SCALE",36,"1/3"],["B","ADD",36,37,"-2"],["B","ADD",36,38,"-8"],["B","ADD",36,39,"20"],["B","ADD",36,40,"64"],["B","ADD",36,41,"40"],["B","ADD",36,42,"-8"],["B","ADD",36,43,"20"],["B","ADD",36,44,"68"],["B","ADD",36,45,"28"],["B","IDLE_ONE",36,[4]],["B","ADD",36,45,"-28"],["B","ADD",36,44,"-68"],["B","ADD",36,43,"-20"],["B","ADD",36,42,"8"],["B","ADD",36,41,"-40"],["B","ADD",36,40,"-64"],["B","ADD",36,39,"-20"],["B","ADD",36,38,"8"],["B","ADD",36,37,"2"],["B","SCALE",36,"3"],["B","ADD",45,36,"-1/12"],["B","ADD",43,36,"-1/6"],["B","ADD",42,36,"-1/6"],["B","ADD",41,36,"-1/12"],["B","ADD",40,36,"1/12"],["B","ADD",39,36,"-1/6"],["B","ADD",38,36,"-1/6"],["B","ADD",37,36,"-7/3"],["B","ADD",37,36,"3"],["B","ADD",38,36,"1/2"],["B","ADD",39,36,"3/2"],["B","ADD",40,36,"-1/4"],["B","ADD",41,36,"-1/4"],["B","ADD",42,36,"1/2"],["B","ADD",43,36,"3/2"],["B","ADD",44,36,"-1/2"],["B","ADD",45,36,"1/2"],["B","SCALE",36,"-1"],["B","ADD",36,37,"1/2"],["B","ADD",36,39,"-1"],["B","ADD",36,40,"-4"],["B","ADD",36,41,"-2"],["B","ADD",36,43,"-1"],["B","ADD",36,44,"-4"],["B","ADD",38,37,"-1/2"],["B","ADD",39,37,"-2"],["B","ADD",40,37,"1/4"],["B","ADD",41,37,"1/2"],["B","ADD",42,37,"-1/2"],["B","ADD",43,37,"-2"],["B","ADD",44,37,"1/2"],["B","SCALE",37,"1/2"],["B","ADD",37,38,"1"],["B","ADD",37,39,"-2"],["B","ADD",37,40,"-6"],["B","ADD",37,41,"-4"],["B","ADD",37,42,"1"],["B","ADD",37,43,"-2"],["B","ADD",37,44,"-8"],["B","ADD",37,45,"-4"],["B","SCALE",37,"1/2"],["B","ADD",37,36,"-1/2"],["B","ADD",36,37,"1"],["B","LAMBDA",36,1],["A","SCALE",4,"-1"],["A","ADD",4,0,"1"],["A","ADD",1,0,"-2"],["A","ADD",2,0,"-2"],["A","ADD",3,0,"-2"],["A","ADD",19,18,"-2"],["A","ADD",20,18,"-2"],["A","ADD",21,18,"-2"],["A","ADD",22,18,"-1"],["A","SCALE",22,"-1"],["A","LAMBDA",4,1],["A","LAMBDA",22,-1],["A","SCALE",22,"-1"],["J",4,[4,0,18,22],[36,37,"-1","1/2"]],["A","LAMBDA",4,-1],["A","LAMBDA",22,1],["A","SCALE",22,"-1"],["A","ADD",0,4,"-1"],["A","ADD",18,22,"-1"],["A","SCALE",22,"-1"],["A","ADD",22,18,"1"],["A","ADD",21,18,"2"],["A","ADD",20,18,"2"],["A","ADD",19,18,"2"],["A","ADD",3,0,"2"],["A","ADD",2,0,"2"],["A","ADD",1,0,"2"],["A","ADD",4,0,"-1"],["A","SCALE",4,"-1"],["B","LAMBDA",36,-1],["B","SCALE",37,"2"],["B","ADD",37,45,"4"],["B","ADD",37,44,"8"],["B","ADD",37,43,"2"],["B","ADD",37,42,"-1"],["B","ADD",37,41,"4"],["B","ADD",37,40,"6"],["B","ADD",37,39,"2"],["B","ADD",37,38,"-1"],["B","SCALE",37,"2"],["B","ADD",44,37,"-1/2"],["B","ADD",43,37,"2"],["B","ADD",42,37,"1/2"],["B","ADD",41,37,"-1/2"],["B","ADD",40,37,"-1/4"],["B","ADD",39,37,"2"],["B","ADD",38,37,"1/2"],["B","ADD",36,44,"4"],["B","ADD",36,43,"1"],["B","ADD",36,41,"2"],["B","ADD",36,40,"4"],["B","ADD",36,39,"1"],["B","ADD",36,37,"-1/2"],["B","SCALE",36,"-1"],["B","ADD",45,36,"-1/2"],["B","ADD",44,36,"1/2"],["B","ADD",43,36,"-3/2"],["B","ADD",42,36,"-1/2"],["B","ADD",41,36,"1/4"],["B","ADD",40,36,"1/4"],["B","ADD",39,36,"-3/2"],["B","ADD",38,36,"-1/2"],["B","ADD",37,36,"-3"],["B","ADD",37,36,"7"],["B","ADD",38,36,"5/2"],["B","ADD",39,36,"19/2"],["B","ADD",40,36,"-5/4"],["B","ADD",41,36,"-9/4"],["B","ADD",42,36,"5/2"],["B","ADD",43,36,"19/2"],["B","ADD",44,36,"-5/4"],["B","ADD",45,36,"-9/4"],["B","ADD",46,36,"-1/2"],["B","ADD",47,36,"3/2"],["B","SCALE",36,"-2"],["B","ADD",36,37,"7"],["B","ADD",36,38,"26"],["B","ADD",36,39,"-66"],["B","ADD",36,40,"-212"],["B","ADD",36,41,"-132"],["B","ADD",36,42,"26"],["B","ADD",36,43,"-66"],["B","ADD",36,44,"-212"],["B","ADD",36,45,"-132"],["B","ADD",36,46,"14"],["B","ADD",36,47,"-26"],["B","IDLE_ONE",36,[5]],["B","ADD",36,47,"26"],["B","ADD",36,46,"-14"],["B","ADD",36,45,"132"],["B","ADD",36,44,"212"],["B","ADD",36,43,"66"],["B","ADD",36,42,"-26"],["B","ADD",36,41,"132"],["B","ADD",36,40,"212"],["B","ADD",36,39,"66"],["B","ADD",36,38,"-26"],["B","ADD",36,37,"-7"],["B","SCALE",36,"-1/2"],["B","ADD",47,36,"-3/2"],["B","ADD",46,36,"1/2"],["B","ADD",45,36,"9/4"],["B","ADD",44,36,"5/4"],["B","ADD",43,36,"-19/2"],["B","ADD",42,36,"-5/2"],["B","ADD",41,36,"9/4"],["B","ADD",40,36,"5/4"],["B","ADD",39,36,"-19/2"],["B","ADD",38,36,"-5/2"],["B","ADD",37,36,"-7"],["B","ADD",37,36,"22/3"],["B","ADD",38,36,"8/3"],["B","ADD",39,36,"61/6"],["B","ADD",40,36,"-4/3"],["B","ADD",41,36,"-29/12"],["B","ADD",42,36,"8/3"],["B","ADD",43,36,"61/6"],["B","ADD",44,36,"-4/3"],["B","ADD",45,36,"-29/12"],["B","ADD",46,36,"-1/2"],["B","ADD",47,36,"5/3"],["B","SCALE",36,"2/3"],["B","ADD",36,37,"2"],["B","ADD",36,38,"8"],["B","ADD",36,39,"-20"],["B","ADD",36,40,"-64"],["B","ADD",36,41,"-40"],["B","ADD",36,42,"8"],["B","ADD",36,43,"-20"],["B","ADD",36,44,"-64"],["B","ADD",36,45,"-40"],["B","ADD",36,46,"4"],["B","ADD",36,47,"-8"],["B","IDLE_ONE",36,[5]],["B","ADD",36,47,"8"],["B","ADD",36,46,"-4"],["B","ADD",36,45,"40"],["B","ADD",36,44,"64"],["B","ADD",36,43,"20"],["B","ADD",36,42,"-8"],["B","ADD",36,41,"40"],["B","ADD",36,40,"64"],["B","ADD",36,39,"20"],["B","ADD",36,38,"-8"],["B","ADD",36,37,"-2"],["B","SCALE",36,"3/2"],["B","ADD",47,36,"-5/3"],["B","ADD",46,36,"1/2"],["B","ADD",45,36,"29/12"],["B","ADD",44,36,"4/3"],["B","ADD",43,36,"-61/6"],["B","ADD",42,36,"-8/3"],["B","ADD",41,36,"29/12"],["B","ADD",40,36,"4/3"],["B","ADD",39,36,"-61/6"],["B","ADD",38,36,"-8/3"],["B","ADD",37,36,"-22/3"],["B","ADD",37,36,"1"],["B","ADD",38,36,"-1/2"],["B","ADD",39,36,"-5/2"],["B","ADD",40,36,"1/4"],["B","ADD",41,36,"3/4"],["B","ADD",42,36,"-1/2"],["B","ADD",43,36,"-5/2"],["B","ADD",44,36,"1/4"],["B","ADD",45,36,"3/4"],["B","ADD",46,36,"1/2"],["B","ADD",47,36,"1/2"],["B","ADD",36,38,"-1"],["B","ADD",36,39,"2"],["B","ADD",36,40,"6"],["B","ADD",36,41,"4"],["B","ADD",36,42,"-1"],["B","ADD",36,43,"2"],["B","ADD",36,44,"6"],["B","ADD",36,45,"4"],["B","ADD",36,46,"-1"],["B","ADD",38,37,"-1/2"],["B","ADD",39,37,"-2"],["B","ADD",40,37,"1/4"],["B","ADD",41,37,"1/2"],["B","ADD",42,37,"-1/2"],["B","ADD",43,37,"-2"],["B","ADD",44,37,"1/4"],["B","ADD",45,37,"1/2"],["B","ADD",46,37,"1/2"],["B","SCALE",37,"-1/2"],["B","ADD",37,39,"-1"],["B","ADD",37,40,"-4"],["B","ADD",37,41,"-2"],["B","ADD",37,43,"-1"],["B","ADD",37,44,"-4"],["B","ADD",37,45,"-2"],["B","ADD",37,46,"2"],["B","ADD",37,47,"-1"],["B","SCALE",37,"-1/2"],["B","ADD",37,36,"-1/2"],["B","ADD",36,37,"1"],["B","LAMBDA",36,1],["A","SCALE",5,"-1"],["A","ADD",5,0,"1"],["A","ADD",1,0,"-2"],["A","ADD",2,0,"-2"],["A","ADD",3,0,"-2"],["A","ADD",4,0,"-2"],["A","ADD",19,18,"-2"],["A","ADD",20,18,"-2"],["A","ADD",21,18,"-2"],["A","ADD",22,18,"-2"],["A","ADD",23,18,"-1"],["A","SCALE",23,"-1"],["A","LAMBDA",5,1],["A","LAMBDA",23,-1],["A","SCALE",23,"-1"],["J",5,[5,0,18,23],[36,37,"-1","1/2"]],["A","LAMBDA",5,-1],["A","LAMBDA",23,1],["A","SCALE",23,"-1"],["A","ADD",0,5,"-1"],["A","ADD",18,23,"-1"],["A","SCALE",23,"-1"],["A","ADD",23,18,"1"],["A","ADD",22,18,"2"],["A","ADD",21,18,"2"],["A","ADD",20,18,"2"],["A","ADD",19,18,"2"],["A","ADD",4,0,"2"],["A","ADD",3,0,"2"],["A","ADD",2,0,"2"],["A","ADD",1,0,"2"],["A","ADD",5,0,"-1"],["A","SCALE",5,"-1"],["B","LAMBDA",36,-1],["B","SCALE",37,"-2"],["B","ADD",37,47,"1"],["B","ADD",37,46,"-2"],["B","ADD",37,45,"2"],["B","ADD",37,44,"4"],["B","ADD",37,43,"1"],["B","ADD",37,41,"2"],["B","ADD",37,40,"4"],["B","ADD",37,39,"1"],["B","SCALE",37,"-2"],["B","ADD",46,37,"-1/2"],["B","ADD",45,37,"-1/2"],["B","ADD",44,37,"-1/4"],["B","ADD",43,37,"2"],["B","ADD",42,37,"1/2"],["B","ADD",41,37,"-1/2"],["B","ADD",40,37,"-1/4"],["B","ADD",39,37,"2"],["B","ADD",38,37,"1/2"],["B","ADD",36,46,"1"],["B","ADD",36,45,"-4"],["B","ADD",36,44,"-6"],["B","ADD",36,43,"-2"],["B","ADD",36,42,"1"],["B","ADD",36,41,"-4"],["B","ADD",36,40,"-6"],["B","ADD",36,39,"-2"],["B","ADD",36,38,"1"],["B","ADD",47,36,"-1/2"],["B","ADD",46,36,"-1/2"],["B","ADD",45,36,"-3/4"],["B","ADD",44,36,"-1/4"],["B","ADD",43,36,"5/2"],["B","ADD",42,36,"1/2"],["B","ADD",41,36,"-3/4"],["B","ADD",40,36,"-1/4"],["B","ADD",39,36,"5/2"],["B","ADD",38,36,"1/2"],["B","ADD",37,36,"-1"],["B","ADD",37,36,"12/5"],["B","ADD",38,36,"1/5"],["B","ADD",39,36,"3/10"],["B","ADD",40,36,"-1/10"],["B","ADD",41,36,"1/20"],["B","ADD",42,36,"1/5"],["B","ADD",43,36,"3/10"],["B","ADD",44,36,"-1/10"],["B","ADD",45,36,"1/20"],["B","ADD",46,36,"1/5"],["B","ADD",47,36,"3/10"],["B","ADD",48,36,"-1/40"],["B","ADD",49,36,"3/40"],["B","SCALE",36,"-1/10"],["B","ADD",36,37,"-1"],["B","ADD",36,38,"-2"],["B","ADD",36,39,"6"],["B","ADD",36,40,"20"],["B","ADD",36,41,"12"],["B","ADD",36,42,"-2"],["B","ADD",36,43,"6"],["B","ADD",36,44,"20"],["B","ADD",36,45,"12"],["B","ADD",36,46,"-2"],["B","ADD",36,47,"6"],["B","ADD",36,48,"20"],["B","ADD",36,49,"8"],["B","IDLE_ONE",36,[6]],["B","ADD",36,49,"-8"],["B","ADD",36,48,"-20"],["B","ADD",36,47,"-6"],["B","ADD",36,46,"2"],["B","ADD",36,45,"-12"],["B","ADD",36,44,"-20"],["B","ADD",36,43,"-6"],["B","ADD",36,42,"2"],["B","ADD",36,41,"-12"],["B","ADD",36,40,"-20"],["B","ADD",36,39,"-6"],["B","ADD",36,38,"2"],["B","ADD",36,37,"1"],["B","SCALE",36,"-10"],["B","ADD",49,36,"-3/40"],["B","ADD",48,36,"1/40"],["B","ADD",47,36,"-3/10"],["B","ADD",46,36,"-1/5"],["B","ADD",45,36,"-1/20"],["B","ADD",44,36,"1/10"],["B","ADD",43,36,"-3/10"],["B","ADD",42,36,"-1/5"],["B","ADD",41,36,"-1/20"],["B","ADD",40,36,"1/10"],["B","ADD",39,36,"-3/10"],["B","ADD",38,36,"-1/5"],["B","ADD",37,36,"-12/5"],["B","ADD",37,36,"7/3"],["B","ADD",38,36,"1/6"],["B","ADD",39,36,"1/6"],["B","ADD",40,36,"-1/12"],["B","ADD",41,36,"1/12"],["B","ADD",42,36,"1/6"],["B","ADD",43,36,"1/6"],["B","ADD",44,36,"-1/12"],["B","ADD",45,36,"1/12"],["B","ADD",46,36,"1/6"],["B","ADD",47,36,"1/6"],["B","ADD",49,36,"1/12"],["B","SCALE",36,"1/3"],["B","ADD",36,37,"-2"],["B","ADD",36,38,"-8"],["B","ADD",36,39,"20"],["B","ADD",36,40,"64"],["B","ADD",36,41,"40"],["B","ADD",36,42,"-8"],["B","ADD",36,43,"20"],["B","ADD",36,44,"64"],["B","ADD",36,45,"40"],["B","ADD",36,46,"-8"],["B","ADD",36,47,"20"],["B","ADD",36,48,"68"],["B","ADD",36,49,"28"],["B","IDLE_ONE",36,[6]],["B","ADD",36,49,"-28"],["B","ADD",36,48,"-68"],["B","ADD",36,47,"-20"],["B","ADD",36,46,"8"],["B","ADD",36,45,"-40"],["B","ADD",36,44,"-64"],["B","ADD",36,43,"-20"],["B","ADD",36,42,"8"],["B","ADD",36,41,"-40"],["B","ADD",36,40,"-64"],["B","ADD",36,39,"-20"],["B","ADD",36,38,"8"],["B","ADD",36,37,"2"],["B","SCALE",36,"3"],["B","ADD",49,36,"-1/12"],["B","ADD",47,36,"-1/6"],["B","ADD",46,36,"-1/6"],["B","ADD",45,36,"-1/12"],["B","ADD",44,36,"1/12"],["B","ADD",43,36,"-1/6"],["B","ADD",42,36,"-1/6"],["B","ADD",41,36,"-1/12"],["B","ADD",40,36,"1/12"],["B","ADD",39,36,"-1/6"],["B","ADD",38,36,"-1/6"],["B","ADD",37,36,"-7/3"],["B","ADD",37,36,"3"],["B","ADD",38,36,"1/2"],["B","ADD",39,36,"3/2"],["B","ADD",40,36,"-1/4"],["B","ADD",41,36,"-1/4"],["B","ADD",42,36,"1/2"],["B","ADD",43,36,"3/2"],["B","ADD",44,36,"-1/4"],["B","ADD",45,36,"-1/4"],["B","ADD",46,36,"1/2"],["B","ADD",47,36,"3/2"],["B","ADD",48,36,"-1/2"],["B","ADD",49,36,"1/2"],["B","SCALE",36,"-1"],["B","ADD",36,37,"1/2"],["B","ADD",36,39,"-1"],["B","ADD",36,40,"-4"],["B","ADD",36,41,"-2"],["B","ADD",36,43,"-1"],["B","ADD",36,44,"-4"],["B","ADD",36,45,"-2"],["B","ADD",36,47,"-1"],["B","ADD",36,48,"-4"],["B","ADD",38,37,"-1/2"],["B","ADD",39,37,"-2"],["B","ADD",40,37,"1/4"],["B","ADD",41,37,"1/2"],["B","ADD",42,37,"-1/2"],["B","ADD",43,37,"-2"],["B","ADD",44,37,"1/4"],["B","ADD",45,37,"1/2"],["B","ADD",46,37,"-1/2"],["B","ADD",47,37,"-2"],["B","ADD",48,37,"1/2"],["B","SCALE",37,"1/2"],["B","ADD",37,38,"1"],["B","ADD",37,39,"-2"],["B","ADD",37,40,"-6"],["B","ADD",37,41,"-4"],["B","ADD",37,42,"1"],["B","ADD",37,43,"-2"],["B","ADD",37,44,"-6"],["B","ADD",37,45,"-4"],["B","ADD",37,46,"1"],["B","ADD",37,47,"-2"],["B","ADD",37,48,"-8"],["B","ADD",37,49,"-4"],["B","SCALE",37,"1/2"],["B","ADD",37,36,"-1/2"],["B","ADD",36,37,"1"],["B","LAMBDA",36,1],["A","SCALE",6,"-1"],["A","ADD",6,0,"1"],["A","ADD",1,0,"-2"],["A","ADD",2,0,"-2"],["A","ADD",3,0,"-2"],["A","ADD",4,0,"-2"],["A","ADD",5,0,"-2"],["A","ADD",19,18,"-2"],["A","ADD",20,18,"-2"],["A","ADD",21,18,"-2"],["A","ADD",22,18,"-2"],["A","ADD",23,18,"-2"],["A","ADD",24,18,"-1"],["A","SCALE",24,"-1"],["A","LAMBDA",6,1],["A","LAMBDA",24,-1],["A","SCALE",24,"-1"],["J",6,[6,0,18,24],[36,37,"-1","1/2"]],["A","LAMBDA",6,-1],["A","LAMBDA",24,1],["A","SCALE",24,"-1"],["A","ADD",0,6,"-1"],["A","ADD",18,24,"-1"],["A","SCALE",24,"-1"],["A","ADD",24,18,"1"],["A","ADD",23,18,"2"],["A","ADD",22,18,"2"],["A","ADD",21,18,"2"],["A","ADD",20,18,"2"],["A","ADD",19,18,"2"],["A","ADD",5,0,"2"],["A","ADD",4,0,"2"],["A","ADD",3,0,"2"],["A","ADD",2,0,"2"],["A","ADD",1,0,"2"],["A","ADD",6,0,"-1"],["A","SCALE",6,"-1"],["B","LAMBDA",36,-1],["B","SCALE",37,"2"],["B","ADD",37,49,"4"],["B","ADD",37,48,"8"],["B","ADD",37,47,"2"],["B","ADD",37,46,"-1"],["B","ADD",37,45,"4"],["B","ADD",37,44,"6"],["B","ADD",37,43,"2"],["B","ADD",37,42,"-1"],["B","ADD",37,41,"4"],["B","ADD",37,40,"6"],["B","ADD",37,39,"2"],["B","ADD",37,38,"-1"],["B","SCALE",37,"2"],["B","ADD",48,37,"-1/2"],["B","ADD",47,37,"2"],["B","ADD",46,37,"1/2"],["B","ADD",45,37,"-1/2"],["B","ADD",44,37,"-1/4"],["B","ADD",43,37,"2"],["B","ADD",42,37,"1/2"],["B","ADD",41,37,"-1/2"],["B","ADD",40,37,"-1/4"],["B","ADD",39,37,"2"],["B","ADD",38,37,"1/2"],["B","ADD",36,48,"4"],["B","ADD",36,47,"1"],["B","ADD",36,45,"2"],["B","ADD",36,44,"4"],["B","ADD",36,43,"1"],["B","ADD",36,41,"2"],["B","ADD",36,40,"4"],["B","ADD",36,39,"1"],["B","ADD",36,37,"-1/2"],["B","SCALE",36,"-1"],["B","ADD",49,36,"-1/2"],["B","ADD",48,36,"1/2"],["B","ADD",47,36,"-3/2"],["B","ADD",46,36,"-1/2"],["B","ADD",45,36,"1/4"],["B","ADD",44,36,"1/4"],["B","ADD",43,36,"-3/2"],["B","ADD",42,36,"-1/2"],["B","ADD",41,36,"1/4"],["B","ADD",40,36,"1/4"],["B","ADD",39,36,"-3/2"],["B","ADD",38,36,"-1/2"],["B","ADD",37,36,"-3"],["B","ADD",37,36,"7"],["B","ADD",38,36,"5/2"],["B","ADD",39,36,"19/2"],["B","ADD",40,36,"-5/4"],["B","ADD",41,36,"-9/4"],["B","ADD",42,36,"5/2"],["B","ADD",43,36,"19/2"],["B","ADD",44,36,"-5/4"],["B","ADD",45,36,"-9/4"],["B","ADD",46,36,"5/2"],["B","ADD",47,36,"19/2"],["B","ADD",48,36,"-5/4"],["B","ADD",49,36,"-9/4"],["B","ADD",50,36,"-1/2"],["B","ADD",51,36,"3/2"],["B","SCALE",36,"-2"],["B","ADD",36,37,"7"],["B","ADD",36,38,"26"],["B","ADD",36,39,"-66"],["B","ADD",36,40,"-212"],["B","ADD",36,41,"-132"],["B","ADD",36,42,"26"],["B","ADD",36,43,"-66"],["B","ADD",36,44,"-212"],["B","ADD",36,45,"-132"],["B","ADD",36,46,"26"],["B","ADD",36,47,"-66"],["B","ADD",36,48,"-212"],["B","ADD",36,49,"-132"],["B","ADD",36,50,"14"],["B","ADD",36,51,"-26"],["B","IDLE_ONE",36,[7]],["B","ADD",36,51,"26"],["B","ADD",36,50,"-14"],["B","ADD",36,49,"132"],["B","ADD",36,48,"212"],["B","ADD",36,47,"66"],["B","ADD",36,46,"-26"],["B","ADD",36,45,"132"],["B","ADD",36,44,"212"],["B","ADD",36,43,"66"],["B","ADD",36,42,"-26"],["B","ADD",36,41,"132"],["B","ADD",36,40,"212"],["B","ADD",36,39,"66"],["B","ADD",36,38,"-26"],["B","ADD",36,37,"-7"],["B","SCALE",36,"-1/2"],["B","ADD",51,36,"-3/2"],["B","ADD",50,36,"1/2"],["B","ADD",49,36,"9/4"],["B","ADD",48,36,"5/4"],["B","ADD",47,36,"-19/2"],["B","ADD",46,36,"-5/2"],["B","ADD",45,36,"9/4"],["B","ADD",44,36,"5/4"],["B","ADD",43,36,"-19/2"],["B","ADD",42,36,"-5/2"],["B","ADD",41,36,"9/4"],["B","ADD",40,36,"5/4"],["B","ADD",39,36,"-19/2"],["B","ADD",38,36,"-5/2"],["B","ADD",37,36,"-7"],["B","ADD",37,36,"22/3"],["B","ADD",38,36,"8/3"],["B","ADD",39,36,"61/6"],["B","ADD",40,36,"-4/3"],["B","ADD",41,36,"-29/12"],["B","ADD",42,36,"8/3"],["B","ADD",43,36,"61/6"],["B","ADD",44,36,"-4/3"],["B","ADD",45,36,"-29/12"],["B","ADD",46,36,"8/3"],["B","ADD",47,36,"61/6"],["B","ADD",48,36,"-4/3"],["B","ADD",49,36,"-29/12"],["B","ADD",50,36,"-1/2"],["B","ADD",51,36,"5/3"],["B","SCALE",36,"2/3"],["B","ADD",36,37,"2"],["B","ADD",36,38,"8"],["B","ADD",36,39,"-20"],["B","ADD",36,40,"-64"],["B","ADD",36,41,"-40"],["B","ADD",36,42,"8"],["B","ADD",36,43,"-20"],["B","ADD",36,44,"-64"],["B","ADD",36,45,"-40"],["B","ADD",36,46,"8"],["B","ADD",36,47,"-20"],["B","ADD",36,48,"-64"],["B","ADD",36,49,"-40"],["B","ADD",36,50,"4"],["B","ADD",36,51,"-8"],["B","IDLE_ONE",36,[7]],["B","ADD",36,51,"8"],["B","ADD",36,50,"-4"],["B","ADD",36,49,"40"],["B","ADD",36,48,"64"],["B","ADD",36,47,"20"],["B","ADD",36,46,"-8"],["B","ADD",36,45,"40"],["B","ADD",36,44,"64"],["B","ADD",36,43,"20"],["B","ADD",36,42,"-8"],["B","ADD",36,41,"40"],["B","ADD",36,40,"64"],["B","ADD",36,39,"20"],["B","ADD",36,38,"-8"],["B","ADD",36,37,"-2"],["B","SCALE",36,"3/2"],["B","ADD",51,36,"-5/3"],["B","ADD",50,36,"1/2"],["B","ADD",49,36,"29/12"],["B","ADD",48,36,"4/3"],["B","ADD",47,36,"-61/6"],["B","ADD",46,36,"-8/3"],["B","ADD",45,36,"29/12"],["B","ADD",44,36,"4/3"],["B","ADD",43,36,"-61/6"],["B","ADD",42,36,"-8/3"],["B","ADD",41,36,"29/12"],["B","ADD",40,36,"4/3"],["B","ADD",39,36,"-61/6"],["B","ADD",38,36,"-8/3"],["B","ADD",37,36,"-22/3"],["B","ADD",37,36,"1"],["B","ADD",38,36,"-1/2"],["B","ADD",39,36,"-5/2"],["B","ADD",40,36,"1/4"],["B","ADD",41,36,"3/4"],["B","ADD",42,36,"-1/2"],["B","ADD",43,36,"-5/2"],["B","ADD",44,36,"1/4"],["B","ADD",45,36,"3/4"],["B","ADD",46,36,"-1/2"],["B","ADD",47,36,"-5/2"],["B","ADD",48,36,"1/4"],["B","ADD",49,36,"3/4"],["B","ADD",50,36,"1/2"],["B","ADD",51,36,"1/2"],["B","ADD",36,38,"-1"],["B","ADD",36,39,"2"],["B","ADD",36,40,"6"],["B","ADD",36,41,"4"],["B","ADD",36,42,"-1"],["B","ADD",36,43,"2"],["B","ADD",36,44,"6"],["B","ADD",36,45,"4"],["B","ADD",36,46,"-1"],["B","ADD",36,47,"2"],["B","ADD",36,48,"6"],["B","ADD",36,49,"4"],["B","ADD",36,50,"-1"],["B","ADD",38,37,"-1/2"],["B","ADD",39,37,"-2"],["B","ADD",40,37,"1/4"],["B","ADD",41,37,"1/2"],["B","ADD",42,37,"-1/2"],["B","ADD",43,37,"-2"],["B","ADD",44,37,"1/4"],["B","ADD",45,37,"1/2"],["B","ADD",46,37,"-1/2"],["B","ADD",47,37,"-2"],["B","ADD",48,37,"1/4"],["B","ADD",49,37,"1/2"],["B","ADD",50,37,"1/2"],["B","SCALE",37,"-1/2"],["B","ADD",37,39,"-1"],["B","ADD",37,40,"-4"],["B","ADD",37,41,"-2"],["B","ADD",37,43,"-1"],["B","ADD",37,44,"-4"],["B","ADD",37,45,"-2"],["B","ADD",37,47,"-1"],["B","ADD",37,48,"-4"],["B","ADD",37,49,"-2"],["B","ADD",37,50,"2"],["B","ADD",37,51,"-1"],["B","SCALE",37,"-1/2"],["B","ADD",37,36,"-1/2"],["B","ADD",36,37,"1"],["B","LAMBDA",36,1],["A","SCALE",7,"-1"],["A","ADD",7,0,"1"],["A","ADD",1,0,"-2"],["A","ADD",2,0,"-2"],["A","ADD",3,0,"-2"],["A","ADD",4,0,"-2"],["A","ADD",5,0,"-2"],["A","ADD",6,0,"-2"],["A","ADD",19,18,"-2"],["A","ADD",20,18,"-2"],["A","ADD",21,18,"-2"],["A","ADD",22,18,"-2"],["A","ADD",23,18,"-2"],["A","ADD",24,18,"-2"],["A","ADD",25,18,"-1"],["A","SCALE",25,"-1"],["A","LAMBDA",7,1],["A","LAMBDA",25,-1],["A","SCALE",25,"-1"],["J",7,[7,0,18,25],[36,37,"-1","1/2"]],["A","LAMBDA",7,-1],["A","LAMBDA",25,1],["A","SCALE",25,"-1"],["A","ADD",0,7,"-1"],["A","ADD",18,25,"-1"],["A","SCALE",25,"-1"],["A","ADD",25,18,"1"],["A","ADD",24,18,"2"],["A","ADD",23,18,"2"],["A","ADD",22,18,"2"],["A","ADD",21,18,"2"],["A","ADD",20,18,"2"],["A","ADD",19,18,"2"],["A","ADD",6,0,"2"],["A","ADD",5,0,"2"],["A","ADD",4,0,"2"],["A","ADD",3,0,"2"],["A","ADD",2,0,"2"],["A","ADD",1,0,"2"],["A","ADD",7,0,"-1"],["A","SCALE",7,"-1"],["B","LAMBDA",36,-1],["B","SCALE",37,"-2"],["B","ADD",37,51,"1"],["B","ADD",37,50,"-2"],["B","ADD",37,49,"2"],["B","ADD",37,48,"4"],["B","ADD",37,47,"1"],["B","ADD",37,45,"2"],["B","ADD",37,44,"4"],["B","ADD",37,43,"1"],["B","ADD",37,41,"2"],["B","ADD",37,40,"4"],["B","ADD",37,39,"1"],["B","SCALE",37,"-2"],["B","ADD",50,37,"-1/2"],["B","ADD",49,37,"-1/2"],["B","ADD",48,37,"-1/4"],["B","ADD",47,37,"2"],["B","ADD",46,37,"1/2"],["B","ADD",45,37,"-1/2"],["B","ADD",44,37,"-1/4"],["B","ADD",43,37,"2"],["B","ADD",42,37,"1/2"],["B","ADD",41,37,"-1/2"],["B","ADD",40,37,"-1/4"],["B","ADD",39,37,"2"],["B","ADD",38,37,"1/2"],["B","ADD",36,50,"1"],["B","ADD",36,49,"-4"],["B","ADD",36,48,"-6"],["B","ADD",36,47,"-2"],["B","ADD",36,46,"1"],["B","ADD",36,45,"-4"],["B","ADD",36,44,"-6"],["B","ADD",36,43,"-2"],["B","ADD",36,42,"1"],["B","ADD",36,41,"-4"],["B","ADD",36,40,"-6"],["B","ADD",36,39,"-2"],["B","ADD",36,38,"1"],["B","ADD",51,36,"-1/2"],["B","ADD",50,36,"-1/2"],["B","ADD",49,36,"-3/4"],["B","ADD",48,36,"-1/4"],["B","ADD",47,36,"5/2"],["B","ADD",46,36,"1/2"],["B","ADD",45,36,"-3/4"],["B","ADD",44,36,"-1/4"],["B","ADD",43,36,"5/2"],["B","ADD",42,36,"1/2"],["B","ADD",41,36,"-3/4"],["B","ADD",40,36,"-1/4"],["B","ADD",39,36,"5/2"],["B","ADD",38,36,"1/2"],["B","ADD",37,36,"-1"],["B","ADD",37,36,"41/15"],["B","ADD",38,36,"11/30"],["B","ADD",39,36,"29/30"],["B","ADD",40,36,"-11/60"],["B","ADD",41,36,"-7/60"],["B","ADD",42,36,"11/30"],["B","ADD",43,36,"29/30"],["B","ADD",44,36,"-11/60"],["B","ADD",45,36,"-7/60"],["B","ADD",46,36,"11/30"],["B","ADD",47,36,"29/30"],["B","ADD",48,36,"-11/60"],["B","ADD",49,36,"-7/60"],["B","ADD",50,36,"7/30"],["B","ADD",51,36,"11/30"],["B","SCALE",36,"-2/15"],["B","ADD",36,37,"55"],["B","ADD",36,38,"218"],["B","ADD",36,39,"-546"],["B","ADD",36,40,"-1748"],["B","ADD",36,41,"-1092"],["B","ADD",36,42,"218"],["B","ADD",36,43,"-546"],["B","ADD",36,44,"-1748"],["B","ADD",36,45,"-1092"],["B","ADD",36,46,"218"],["B","ADD",36,47,"-546"],["B","ADD",36,48,"-1748"],["B","ADD",36,49,"-1092"],["B","ADD",36,50,"-982"],["B","ADD",36,51,"218"],["B","IDLE_ONE",36,[8]],["B","ADD",36,51,"-218"],["B","ADD",36,50,"982"],["B","ADD",36,49,"1092"],["B","ADD",36,48,"1748"],["B","ADD",36,47,"546"],["B","ADD",36,46,"-218"],["B","ADD",36,45,"1092"],["B","ADD",36,44,"1748"],["B","ADD",36,43,"546"],["B","ADD",36,42,"-218"],["B","ADD",36,41,"1092"],["B","ADD",36,40,"1748"],["B","ADD",36,39,"546"],["B","ADD",36,38,"-218"],["B","ADD",36,37,"-55"],["B","SCALE",36,"-15/2"],["B","ADD",51,36,"-11/30"],["B","ADD",50,36,"-7/30"],["B","ADD",49,36,"7/60"],["B","ADD",48,36,"11/60"],["B","ADD",47,36,"-29/30"],["B","ADD",46,36,"-11/30"],["B","ADD",45,36,"7/60"],["B","ADD",44,36,"11/60"],["B","ADD",43,36,"-29/30"],["B","ADD",42,36,"-11/30"],["B","ADD",41,36,"7/60"],["B","ADD",40,36,"11/60"],["B","ADD",39,36,"-29/30"],["B","ADD",38,36,"-11/30"],["B","ADD",37,36,"-41/15"],["B","ADD",36,38,"409/150"],["B","ADD",37,38,"-559/75"],["B","ADD",39,38,"-791/300"],["B","ADD",40,38,"1/2"],["B","ADD",41,38,"191/600"],["B","ADD",42,38,"-1"],["B","ADD",43,38,"-791/300"],["B","ADD",44,38,"1/2"],["B","ADD",45,38,"191/600"],["B","ADD",46,38,"-1"],["B","ADD",47,38,"-791/300"],["B","ADD",48,38,"1/2"],["B","ADD",49,38,"191/600"],["B","ADD",50,38,"-191/300"],["B","ADD",51,38,"-1"],["B","SCALE",38,"1/75"],["B","ADD",38,37,"-2"],["B","ADD",38,39,"20"],["B","ADD",38,40,"64"],["B","ADD",38,41,"40"],["B","ADD",38,42,"-8"],["B","ADD",38,43,"20"],["B","ADD",38,44,"64"],["B","ADD",38,45,"40"],["B","ADD",38,46,"-8"],["B","ADD",38,47,"20"],["B","ADD",38,48,"64"],["B","ADD",38,49,"40"],["B","ADD",38,50,"36"],["B","ADD",38,51,"-8"],["B","IDLE_ONE",38,[8]],["B","ADD",38,51,"8"],["B","ADD",38,50,"-36"],["B","ADD",38,49,"-40"],["B","ADD",38,48,"-64"],["B","ADD",38,47,"-20"],["B","ADD",38,46,"8"],["B","ADD",38,45,"-40"],["B","ADD",38,44,"-64"],["B","ADD",38,43,"-20"],["B","ADD",38,42,"8"],["B","ADD",38,41,"-40"],["B","ADD",38,40,"-64"],["B","ADD",38,39,"-20"],["B","ADD",38,37,"2"],["B","SCALE",38,"75"],["B","ADD",51,38,"1"],["B","ADD",50,38,"191/300"],["B","ADD",49,38,"-191/600"],["B","ADD",48,38,"-1/2"],["B","ADD",47,38,"791/300"],["B","ADD",46,38,"1"],["B","ADD",45,38,"-191/600"],["B","ADD",44,38,"-1/2"],["B","ADD",43,38,"791/300"],["B","ADD",42,38,"1"],["B","ADD",41,38,"-191/600"],["B","ADD",40,38,"-1/2"],["B","ADD",39,38,"791/300"],["B","ADD",37,38,"559/75"],["B","ADD",36,38,"-409/150"],["B","IDLE_ODD",68,[8],-1],["B","IDLE_ODD",69,[8],-1],["B","ADD",37,36,"11/5"],["B","ADD",38,36,"1/10"],["B","ADD",39,36,"-1/10"],["B","ADD",40,36,"-1/20"],["B","ADD",41,36,"3/20"],["B","ADD",42,36,"1/10"],["B","ADD",43,36,"-1/10"],["B","ADD",44,36,"-1/20"],["B","ADD",45,36,"3/20"],["B","ADD",46,36,"1/10"],["B","ADD",47,36,"-1/10"],["B","ADD",48,36,"-1/20"],["B","ADD",49,36,"3/20"],["B","ADD",50,36,"1/10"],["B","ADD",51,36,"-1/10"],["B","SCALE",36,"1/5"],["B","ADD",36,37,"-1/2"],["B","ADD",36,39,"1"],["B","ADD",36,40,"4"],["B","ADD",36,41,"2"],["B","ADD",36,43,"1"],["B","ADD",36,44,"4"],["B","ADD",36,45,"2"],["B","ADD",36,47,"1"],["B","ADD",36,48,"4"],["B","ADD",36,49,"2"],["B","ADD",36,51,"1"],["B","ADD",38,37,"-1/2"],["B","ADD",39,37,"-2"],["B","ADD",40,37,"1/4"],["B","ADD",41,37,"1/2"],["B","ADD",42,37,"-1/2"],["B","ADD",43,37,"-2"],["B","ADD",44,37,"1/4"],["B","ADD",45,37,"1/2"],["B","ADD",46,37,"-1/2"],["B","ADD",47,37,"-2"],["B","ADD",48,37,"1/4"],["B","ADD",49,37,"1/2"],["B","ADD",50,37,"-1/2"],["B","ADD",51,37,"-2"],["B","SCALE",37,"-5/2"],["B","ADD",37,38,"-1"],["B","ADD",37,39,"-2"],["B","ADD",37,40,"-10"],["B","ADD",37,41,"-4"],["B","ADD",37,42,"-1"],["B","ADD",37,43,"-2"],["B","ADD",37,44,"-10"],["B","ADD",37,45,"-4"],["B","ADD",37,46,"-1"],["B","ADD",37,47,"-2"],["B","ADD",37,48,"-10"],["B","ADD",37,49,"-4"],["B","ADD",37,50,"-1"],["B","ADD",37,51,"-2"],["B","SCALE",37,"-1/2"],["B","ADD",37,36,"-1"],["B","ADD",37,36,"-1/2"],["B","ADD",36,37,"1"],["B","LAMBDA",36,1],["A","SCALE",8,"-1"],["A","ADD",8,0,"1"],["A","ADD",1,0,"-2"],["A","ADD",2,0,"-2"],["A","ADD",3,0,"-2"],["A","ADD",4,0,"-2"],["A","ADD",5,0,"-2"],["A","ADD",6,0,"-2"],["A","ADD",7,0,"-2"],["A","ADD",19,18,"-2"],["A","ADD",20,18,"-2"],["A","ADD",21,18,"-2"],["A","ADD",22,18,"-2"],["A","ADD",23,18,"-2"],["A","ADD",24,18,"-2"],["A","ADD",25,18,"-2"],["A","ADD",26,18,"-1"],["A","SCALE",26,"-1"],["A","LAMBDA",8,1],["A","LAMBDA",26,-1],["A","SCALE",26,"-1"],["J",8,[8,0,18,26],[36,37,"-1","1/2"]],["A","LAMBDA",8,-1],["A","LAMBDA",26,1],["A","SCALE",26,"-1"],["A","ADD",0,8,"-1"],["A","ADD",18,26,"-1"],["A","SCALE",26,"-1"],["A","ADD",26,18,"1"],["A","ADD",25,18,"2"],["A","ADD",24,18,"2"],["A","ADD",23,18,"2"],["A","ADD",22,18,"2"],["A","ADD",21,18,"2"],["A","ADD",20,18,"2"],["A","ADD",19,18,"2"],["A","ADD",7,0,"2"],["A","ADD",6,0,"2"],["A","ADD",5,0,"2"],["A","ADD",4,0,"2"],["A","ADD",3,0,"2"],["A","ADD",2,0,"2"],["A","ADD",1,0,"2"],["A","ADD",8,0,"-1"],["A","SCALE",8,"-1"],["A","ADD",1,0,"-2"],["A","IDLE_ONE",1,[2,3,4,5,6,7,8]],["A","ADD",1,0,"2"],["A","ADD",2,0,"-2"],["A","IDLE_ONE",2,[3,4,5,6,7,8]],["A","ADD",2,0,"2"],["A","ADD",3,0,"-2"],["A","IDLE_ONE",3,[4,5,6,7,8]],["A","ADD",3,0,"2"],["A","ADD",4,0,"-2"],["A","IDLE_ONE",4,[5,6,7,8]],["A","ADD",4,0,"2"],["A","ADD",5,0,"-2"],["A","IDLE_ONE",5,[6,7,8]],["A","ADD",5,0,"2"],["A","ADD",6,0,"-2"],["A","IDLE_ONE",6,[7,8]],["A","ADD",6,0,"2"],["A","ADD",7,0,"-2"],["A","IDLE_ONE",7,[8]],["A","ADD",7,0,"2"],["A","ADD",19,18,"-2"],["A","IDLE_ONE",19,[2,3,4,5,6,7,8]],["A","ADD",19,18,"2"],["A","ADD",20,18,"-2"],["A","IDLE_ONE",20,[3,4,5,6,7,8]],["A","ADD",20,18,"2"],["A","ADD",21,18,"-2"],["A","IDLE_ONE",21,[4,5,6,7,8]],["A","ADD",21,18,"2"],["A","ADD",22,18,"-2"],["A","IDLE_ONE",22,[5,6,7,8]],["A","ADD",22,18,"2"],["A","ADD",23,18,"-2"],["A","IDLE_ONE",23,[6,7,8]],["A","ADD",23,18,"2"],["A","ADD",24,18,"-2"],["A","IDLE_ONE",24,[7,8]],["A","ADD",24,18,"2"],["A","ADD",25,18,"-2"],["A","IDLE_ONE",25,[8]],["A","ADD",25,18,"2"],["A","SWAP",0,18],["A","ADD",19,0,"-2"],["A","ADD",20,0,"-2"],["A","ADD",21,0,"-2"],["A","ADD",22,0,"-2"],["A","ADD",23,0,"-2"],["A","ADD",24,0,"-2"],["A","ADD",25,0,"-2"],["A","ADD",26,0,"-2"],["A","SWAP",1,19],["A","ADD",1,20,"-1"],["A","ADD",1,21,"1"],["A","ADD",1,22,"-1"],["A","ADD",1,23,"1"],["A","ADD",1,24,"-1"],["A","ADD",1,25,"1"],["A","ADD",1,26,"-1"],["A","ADD",1,27,"-1"],["A","ADD",1,28,"1"],["A","ADD",1,29,"-1"],["A","ADD",1,30,"1"],["A","ADD",1,31,"-1"],["A","ADD",1,32,"1"],["A","ADD",1,33,"-1"],["A","ADD",1,34,"1"],["A","ADD",1,35,"-1"],["A","LAMBDA",1,1],["A","QUERY",0,1,-1],["A","LAMBDA",1,-1],["A","ADD",0,1,"-1"],["A","ADD",1,35,"1"],["A","ADD",1,34,"-1"],["A","ADD",1,33,"1"],["A","ADD",1,32,"-1"],["A","ADD",1,31,"1"],["A","ADD",1,30,"-1"],["A","ADD",1,29,"1"],["A","ADD",1,28,"-1"],["A","ADD",1,27,"1"],["A","ADD",1,26,"1"],["A","ADD",1,25,"-1"],["A","ADD",1,24,"1"],["A","ADD",1,23,"-1"],["A","ADD",1,22,"1"],["A","ADD",1,21,"-1"],["A","ADD",1,20,"1"],["A","SWAP",1,19],["A","ADD",26,0,"2"],["A","ADD",25,0,"2"],["A","ADD",24,0,"2"],["A","ADD",23,0,"2"],["A","ADD",22,0,"2"],["A","ADD",21,0,"2"],["A","ADD",20,0,"2"],["A","ADD",19,0,"2"],["A","SWAP",0,18],["A","SWAP",0,19],["A","ADD",20,0,"-1"],["A","ADD",21,0,"-1"],["A","ADD",22,0,"-1"],["A","ADD",23,0,"-1"],["A","ADD",24,0,"-1"],["A","ADD",25,0,"-1"],["A","ADD",26,0,"-1"],["A","ADD",27,0,"-1"],["A","ADD",28,0,"-1"],["A","ADD",29,0,"-1"],["A","ADD",30,0,"-1"],["A","ADD",31,0,"-1"],["A","ADD",32,0,"-1"],["A","ADD",33,0,"-1"],["A","ADD",34,0,"-1"],["A","ADD",35,0,"-1"],["A","ADD",1,2,"-1"],["A","ADD",1,3,"1"],["A","ADD",1,4,"-1"],["A","ADD",1,5,"1"],["A","ADD",1,6,"-1"],["A","ADD",1,7,"1"],["A","ADD",1,8,"-1"],["A","ADD",1,9,"-1"],["A","ADD",1,10,"1"],["A","ADD",1,11,"-1"],["A","ADD",1,12,"1"],["A","ADD",1,13,"-1"],["A","ADD",1,14,"1"],["A","ADD",1,15,"-1"],["A","ADD",1,16,"1"],["A","ADD",1,17,"-1"],["A","ADD",1,18,"1"],["A","LAMBDA",1,1],["A","QUERY",0,1,-1],["A","LAMBDA",1,-1],["A","ADD",0,1,"-1"],["A","ADD",1,18,"-1"],["A","ADD",1,17,"1"],["A","ADD",1,16,"-1"],["A","ADD",1,15,"1"],["A","ADD",1,14,"-1"],["A","ADD",1,13,"1"],["A","ADD",1,12,"-1"],["A","ADD",1,11,"1"],["A","ADD",1,10,"-1"],["A","ADD",1,9,"1"],["A","ADD",1,8,"1"],["A","ADD",1,7,"-1"],["A","ADD",1,6,"1"],["A","ADD",1,5,"-1"],["A","ADD",1,4,"1"],["A","ADD",1,3,"-1"],["A","ADD",1,2,"1"],["A","ADD",35,0,"1"],["A","ADD",34,0,"1"],["A","ADD",33,0,"1"],["A","ADD",32,0,"1"],["A","ADD",31,0,"1"],["A","ADD",30,0,"1"],["A","ADD",29,0,"1"],["A","ADD",28,0,"1"],["A","ADD",27,0,"1"],["A","ADD",26,0,"1"],["A","ADD",25,0,"1"],["A","ADD",24,0,"1"],["A","ADD",23,0,"1"],["A","ADD",22,0,"1"],["A","ADD",21,0,"1"],["A","ADD",20,0,"1"],["A","SWAP",0,19],["A","ADD",1,0,"-2"],["A","ADD",2,0,"-2"],["A","ADD",3,0,"-2"],["A","ADD",4,0,"-2"],["A","ADD",5,0,"-2"],["A","ADD",6,0,"-2"],["A","ADD",7,0,"-2"],["A","ADD",8,0,"-2"],["A","ADD",19,0,"1"],["A","ADD",20,0,"1"],["A","ADD",21,0,"1"],["A","ADD",22,0,"1"],["A","ADD",23,0,"1"],["A","ADD",24,0,"1"],["A","ADD",25,0,"1"],["A","ADD",26,0,"1"],["A","ADD",27,0,"1"],["A","ADD",28,0,"1"],["A","ADD",29,0,"1"],["A","ADD",30,0,"1"],["A","ADD",31,0,"1"],["A","ADD",32,0,"1"],["A","ADD",33,0,"1"],["A","ADD",34,0,"1"],["A","ADD",35,0,"1"],["A","ADD",1,2,"-1"],["A","ADD",1,3,"1"],["A","ADD",1,4,"-1"],["A","ADD",1,5,"1"],["A","ADD",1,6,"-1"],["A","ADD",1,7,"1"],["A","ADD",1,8,"-1"],["A","ADD",1,9,"-1"],["A","ADD",1,10,"1"],["A","ADD",1,11,"-1"],["A","ADD",1,12,"1"],["A","ADD",1,13,"-1"],["A","ADD",1,14,"1"],["A","ADD",1,15,"-1"],["A","ADD",1,16,"1"],["A","ADD",1,17,"-1"],["A","LAMBDA",1,1],["A","QUERY",0,1,-1],["A","LAMBDA",1,-1],["A","ADD",0,1,"-1"],["A","ADD",1,17,"1"],["A","ADD",1,16,"-1"],["A","ADD",1,15,"1"],["A","ADD",1,14,"-1"],["A","ADD",1,13,"1"],["A","ADD",1,12,"-1"],["A","ADD",1,11,"1"],["A","ADD",1,10,"-1"],["A","ADD",1,9,"1"],["A","ADD",1,8,"1"],["A","ADD",1,7,"-1"],["A","ADD",1,6,"1"],["A","ADD",1,5,"-1"],["A","ADD",1,4,"1"],["A","ADD",1,3,"-1"],["A","ADD",1,2,"1"],["A","ADD",35,0,"-1"],["A","ADD",34,0,"-1"],["A","ADD",33,0,"-1"],["A","ADD",32,0,"-1"],["A","ADD",31,0,"-1"],["A","ADD",30,0,"-1"],["A","ADD",29,0,"-1"],["A","ADD",28,0,"-1"],["A","ADD",27,0,"-1"],["A","ADD",26,0,"-1"],["A","ADD",25,0,"-1"],["A","ADD",24,0,"-1"],["A","ADD",23,0,"-1"],["A","ADD",22,0,"-1"],["A","ADD",21,0,"-1"],["A","ADD",20,0,"-1"],["A","ADD",19,0,"-1"],["A","ADD",8,0,"2"],["A","ADD",7,0,"2"],["A","ADD",6,0,"2"],["A","ADD",5,0,"2"],["A","ADD",4,0,"2"],["A","ADD",3,0,"2"],["A","ADD",2,0,"2"],["A","ADD",1,0,"2"],["A","SWAP",0,1],["A","ADD",2,0,"-1"],["A","ADD",3,0,"-1"],["A","ADD",4,0,"-1"],["A","ADD",5,0,"-1"],["A","ADD",6,0,"-1"],["A","ADD",7,0,"-1"],["A","ADD",8,0,"-1"],["A","ADD",9,0,"-1"],["A","ADD",10,0,"-1"],["A","ADD",11,0,"-1"],["A","ADD",12,0,"-1"],["A","ADD",13,0,"-1"],["A","ADD",14,0,"-1"],["A","ADD",15,0,"-1"],["A","ADD",16,0,"-1"],["A","ADD",17,0,"-1"],["A","LAMBDA",1,1],["A","QUERY",0,1,-1],["A","LAMBDA",1,-1],["A","ADD",0,1,"-1"],["A","ADD",17,0,"1"],["A","ADD",16,0,"1"],["A","ADD",15,0,"1"],["A","ADD",14,0,"1"],["A","ADD",13,0,"1"],["A","ADD",12,0,"1"],["A","ADD",11,0,"1"],["A","ADD",10,0,"1"],["A","ADD",9,0,"1"],["A","ADD",8,0,"1"],["A","ADD",7,0,"1"],["A","ADD",6,0,"1"],["A","ADD",5,0,"1"],["A","ADD",4,0,"1"],["A","ADD",3,0,"1"],["A","ADD",2,0,"1"],["A","SWAP",0,1],["A","ADD",10,0,"2"],["A","IDLE_ONE",10,[9]],["A","ADD",10,0,"-2"],["A","ADD",11,0,"2"],["A","IDLE_ONE",11,[9,10]],["A","ADD",11,0,"-2"],["A","ADD",12,0,"2"],["A","IDLE_ONE",12,[9,10,11]],["A","ADD",12,0,"-2"],["A","ADD",13,0,"2"],["A","IDLE_ONE",13,[9,10,11,12]],["A","ADD",13,0,"-2"],["A","ADD",14,0,"2"],["A","IDLE_ONE",14,[9,10,11,12,13]],["A","ADD",14,0,"-2"],["A","ADD",15,0,"2"],["A","IDLE_ONE",15,[9,10,11,12,13,14]],["A","ADD",15,0,"-2"],["A","ADD",16,0,"2"],["A","IDLE_ONE",16,[9,10,11,12,13,14,15]],["A","ADD",16,0,"-2"],["A","ADD",17,0,"2"],["A","IDLE_ONE",17,[9,10,11,12,13,14,15,16]],["A","ADD",17,0,"-2"],["A","ADD",28,18,"2"],["A","IDLE_ONE",28,[9]],["A","ADD",28,18,"-2"],["A","ADD",29,18,"2"],["A","IDLE_ONE",29,[9,10]],["A","ADD",29,18,"-2"],["A","ADD",30,18,"2"],["A","IDLE_ONE",30,[9,10,11]],["A","ADD",30,18,"-2"],["A","ADD",31,18,"2"],["A","IDLE_ONE",31,[9,10,11,12]],["A","ADD",31,18,"-2"],["A","ADD",32,18,"2"],["A","IDLE_ONE",32,[9,10,11,12,13]],["A","ADD",32,18,"-2"],["A","ADD",33,18,"2"],["A","IDLE_ONE",33,[9,10,11,12,13,14]],["A","ADD",33,18,"-2"],["A","ADD",34,18,"2"],["A","IDLE_ONE",34,[9,10,11,12,13,14,15]],["A","ADD",34,18,"-2"],["A","ADD",35,18,"2"],["A","IDLE_ONE",35,[9,10,11,12,13,14,15,16]],["A","ADD",35,18,"-2"],["B","LAMBDA",36,-1],["B","ADD",37,36,"1"],["B","SCALE",37,"-2"],["B","ADD",37,51,"2"],["B","ADD",37,50,"1"],["B","ADD",37,49,"4"],["B","ADD",37,48,"10"],["B","ADD",37,47,"2"],["B","ADD",37,46,"1"],["B","ADD",37,45,"4"],["B","ADD",37,44,"10"],["B","ADD",37,43,"2"],["B","ADD",37,42,"1"],["B","ADD",37,41,"4"],["B","ADD",37,40,"10"],["B","ADD",37,39,"2"],["B","ADD",37,38,"1"],["B","SCALE",37,"-2/5"],["B","ADD",51,37,"2"],["B","ADD",50,37,"1/2"],["B","ADD",49,37,"-1/2"],["B","ADD",48,37,"-1/4"],["B","ADD",47,37,"2"],["B","ADD",46,37,"1/2"],["B","ADD",45,37,"-1/2"],["B","ADD",44,37,"-1/4"],["B","ADD",43,37,"2"],["B","ADD",42,37,"1/2"],["B","ADD",41,37,"-1/2"],["B","ADD",40,37,"-1/4"],["B","ADD",39,37,"2"],["B","ADD",38,37,"1/2"],["B","ADD",36,51,"-1"],["B","ADD",36,49,"-2"],["B","ADD",36,48,"-4"],["B","ADD",36,47,"-1"],["B","ADD",36,45,"-2"],["B","ADD",36,44,"-4"],["B","ADD",36,43,"-1"],["B","ADD",36,41,"-2"],["B","ADD",36,40,"-4"],["B","ADD",36,39,"-1"],["B","ADD",36,37,"1/2"],["B","SCALE",36,"5"],["B","ADD",51,36,"1/10"],["B","ADD",50,36,"-1/10"],["B","ADD",49,36,"-3/20"],["B","ADD",48,36,"1/20"],["B","ADD",47,36,"1/10"],["B","ADD",46,36,"-1/10"],["B","ADD",45,36,"-3/20"],["B","ADD",44,36,"1/20"],["B","ADD",43,36,"1/10"],["B","ADD",42,36,"-1/10"],["B","ADD",41,36,"-3/20"],["B","ADD",40,36,"1/20"],["B","ADD",39,36,"1/10"],["B","ADD",38,36,"-1/10"],["B","ADD",37,36,"-11/5"],["B","ADD",37,36,"41/15"],["B","ADD",38,36,"7/30"],["B","ADD",39,36,"11/30"],["B","SCALE",36,"-2/15"],["B","ADD",36,37,"-3"],["B","ADD",36,38,"62"],["B","ADD",36,39,"-14"],["B","IDLE_ONE",36,[2,3,4,5,6,7,8]],["B","ADD",36,39,"14"],["B","ADD",36,38,"-62"],["B","ADD",36,37,"3"],["B","SCALE",36,"-15/2"],["B","ADD",39,36,"-11/30"],["B","ADD",38,36,"-7/30"],["B","ADD",37,36,"-41/15"],["B","ADD",36,38,"13/3"],["B","ADD",37,38,"-71/6"],["B","ADD",39,38,"-19/12"],["B","SCALE",38,"1/3"],["B","ADD",38,37,"2"],["B","ADD",38,39,"8"],["B","IDLE_ONE",38,[2,3,4,5,6,7,8]],["B","ADD",38,39,"-8"],["B","ADD",38,37,"-2"],["B","SCALE",38,"3"],["B","ADD",39,38,"19/12"],["B","ADD",37,38,"71/6"],["B","ADD",36,38,"-13/3"],["B","ADD",37,36,"41/15"],["B","ADD",38,36,"11/30"],["B","ADD",39,36,"29/30"],["B","ADD",40,36,"-1/15"],["B","ADD",41,36,"-1/6"],["B","SCALE",36,"2/15"],["B","ADD",36,37,"6"],["B","ADD",36,38,"22"],["B","ADD",36,39,"-56"],["B","ADD",36,40,"-68"],["B","ADD",36,41,"-156"],["B","IDLE_ONE",36,[3,4,5,6,7,8]],["B","ADD",36,41,"156"],["B","ADD",36,40,"68"],["B","ADD",36,39,"56"],["B","ADD",36,38,"-22"],["B","ADD",36,37,"-6"],["B","SCALE",36,"15/2"],["B","ADD",41,36,"1/6"],["B","ADD",40,36,"1/15"],["B","ADD",39,36,"-29/30"],["B","ADD",38,36,"-11/30"],["B","ADD",37,36,"-41/15"],["B","ADD",36,37,"1"],["B","SWAP",36,37],["B","ADD",36,37,"-1"],["B","SWAP",36,37],["B","ADD",36,37,"-1"],["B","SWAP",36,37],["B","ADD",36,37,"-1"],["B","SWAP",36,37],["B","ADD",36,37,"-2"],["B","SWAP",36,37],["B","ADD",36,37,"-1"],["B","SWAP",36,37],["B","ADD",36,37,"-3"],["B","SWAP",36,37],["B","ADD",36,37,"-2"],["B","SWAP",36,37],["B","ADD",36,37,"-2"],["B","SWAP",36,37],["B","SWAP",36,38],["B","ADD",36,38,"-30"],["B","SWAP",36,38],["B","ADD",36,38,"-2"],["B","SWAP",36,38],["B","SWAP",36,39],["B","ADD",36,39,"-161"],["B","SWAP",36,39],["B","ADD",36,40,"1"],["B","SWAP",36,40],["B","ADD",36,40,"-1"],["B","SWAP",36,40],["B","ADD",36,40,"-10"],["B","SWAP",36,40],["B","SWAP",36,41],["B","ADD",36,41,"-28"],["B","SWAP",36,41],["B","SCALE",36,"4"],["B","ADD",36,37,"-93"],["B","ADD",36,38,"-347"],["B","ADD",36,39,"10"],["B","ADD",36,40,"12"],["B","ADD",36,41,"28"],["B","IDLE_ONE",36,[3,4,5,6,7,8]],["B","ADD",36,41,"-28"],["B","ADD",36,40,"-12"],["B","ADD",36,39,"-10"],["B","ADD",36,38,"347"],["B","ADD",36,37,"93"],["B","SCALE",36,"1/4"],["B","SWAP",36,41],["B","ADD",36,41,"28"],["B","SWAP",36,41],["B","SWAP",36,40],["B","ADD",36,40,"10"],["B","SWAP",36,40],["B","ADD",36,40,"1"],["B","SWAP",36,40],["B","ADD",36,40,"-1"],["B","SWAP",36,39],["B","ADD",36,39,"161"],["B","SWAP",36,39],["B","SWAP",36,38],["B","ADD",36,38,"2"],["B","SWAP",36,38],["B","ADD",36,38,"30"],["B","SWAP",36,38],["B","SWAP",36,37],["B","ADD",36,37,"2"],["B","SWAP",36,37],["B","ADD",36,37,"2"],["B","SWAP",36,37],["B","ADD",36,37,"3"],["B","SWAP",36,37],["B","ADD",36,37,"1"],["B","SWAP",36,37],["B","ADD",36,37,"2"],["B","SWAP",36,37],["B","ADD",36,37,"1"],["B","SWAP",36,37],["B","ADD",36,37,"1"],["B","SWAP",36,37],["B","ADD",36,37,"1"],["B","SWAP",36,37],["B","ADD",36,37,"-1"],["B","ADD",37,36,"41/15"],["B","ADD",38,36,"11/30"],["B","ADD",39,36,"29/30"],["B","ADD",40,36,"-11/60"],["B","ADD",41,36,"-7/60"],["B","ADD",42,36,"7/30"],["B","ADD",43,36,"11/30"],["B","SCALE",36,"-2/15"],["B","ADD",36,37,"55"],["B","ADD",36,38,"218"],["B","ADD",36,39,"-546"],["B","ADD",36,40,"-1748"],["B","ADD",36,41,"-1092"],["B","ADD",36,42,"-982"],["B","ADD",36,43,"218"],["B","IDLE_ONE",36,[4,5,6,7,8]],["B","ADD",36,43,"-218"],["B","ADD",36,42,"982"],["B","ADD",36,41,"1092"],["B","ADD",36,40,"1748"],["B","ADD",36,39,"546"],["B","ADD",36,38,"-218"],["B","ADD",36,37,"-55"],["B","SCALE",36,"-15/2"],["B","ADD",43,36,"-11/30"],["B","ADD",42,36,"-7/30"],["B","ADD",41,36,"7/60"],["B","ADD",40,36,"11/60"],["B","ADD",39,36,"-29/30"],["B","ADD",38,36,"-11/30"],["B","ADD",37,36,"-41/15"],["B","ADD",36,38,"409/150"],["B","ADD",37,38,"-559/75"],["B","ADD",39,38,"-791/300"],["B","ADD",40,38,"1/2"],["B","ADD",41,38,"191/600"],["B","ADD",42,38,"-191/300"],["B","ADD",43,38,"-1"],["B","SCALE",38,"1/75"],["B","ADD",38,37,"-2"],["B","ADD",38,39,"20"],["B","ADD",38,40,"64"],["B","ADD",38,41,"40"],["B","ADD",38,42,"36"],["B","ADD",38,43,"-8"],["B","IDLE_ONE",38,[4,5,6,7,8]],["B","ADD",38,43,"8"],["B","ADD",38,42,"-36"],["B","ADD",38,41,"-40"],["B","ADD",38,40,"-64"],["B","ADD",38,39,"-20"],["B","ADD",38,37,"2"],["B","SCALE",38,"75"],["B","ADD",43,38,"1"],["B","ADD",42,38,"191/300"],["B","ADD",41,38,"-191/600"],["B","ADD",40,38,"-1/2"],["B","ADD",39,38,"791/300"],["B","ADD",37,38,"559/75"],["B","ADD",36,38,"-409/150"],["B","ADD",37,36,"41/15"],["B","ADD",38,36,"11/30"],["B","ADD",39,36,"29/30"],["B","ADD",40,36,"-11/60"],["B","ADD",41,36,"-7/60"],["B","ADD",42,36,"11/30"],["B","ADD",43,36,"29/30"],["B","ADD",44,36,"-1/15"],["B","ADD",45,36,"-1/6"],["B","SCALE",36,"2/15"],["B","ADD",36,37,"55"],["B","ADD",36,38,"218"],["B","ADD",36,39,"-546"],["B","ADD",36,40,"-1748"],["B","ADD",36,41,"-1092"],["B","ADD",36,42,"218"],["B","ADD",36,43,"-546"],["B","ADD",36,44,"-656"],["B","ADD",36,45,"-1528"],["B","IDLE_ONE",36,[5,6,7,8]],["B","ADD",36,45,"1528"],["B","ADD",36,44,"656"],["B","ADD",36,43,"546"],["B","ADD",36,42,"-218"],["B","ADD",36,41,"1092"],["B","ADD",36,40,"1748"],["B","ADD",36,39,"546"],["B","ADD",36,38,"-218"],["B","ADD",36,37,"-55"],["B","SCALE",36,"15/2"],["B","ADD",45,36,"1/6"],["B","ADD",44,36,"1/15"],["B","ADD",43,36,"-29/30"],["B","ADD",42,36,"-11/30"],["B","ADD",41,36,"7/60"],["B","ADD",40,36,"11/60"],["B","ADD",39,36,"-29/30"],["B","ADD",38,36,"-11/30"],["B","ADD",37,36,"-41/15"],["B","ADD",36,38,"409/150"],["B","ADD",37,38,"-559/75"],["B","ADD",39,38,"-791/300"],["B","ADD",40,38,"1/2"],["B","ADD",41,38,"191/600"],["B","ADD",42,38,"-1"],["B","ADD",43,38,"-791/300"],["B","ADD",44,38,"109/600"],["B","ADD",45,38,"91/200"],["B","SCALE",38,"-1/75"],["B","ADD",38,37,"-2"],["B","ADD",38,39,"20"],["B","ADD",38,40,"64"],["B","ADD",38,41,"40"],["B","ADD",38,42,"-8"],["B","ADD",38,43,"20"],["B","ADD",38,44,"24"],["B","ADD",38,45,"56"],["B","IDLE_ONE",38,[5,6,7,8]],["B","ADD",38,45,"-56"],["B","ADD",38,44,"-24"],["B","ADD",38,43,"-20"],["B","ADD",38,42,"8"],["B","ADD",38,41,"-40"],["B","ADD",38,40,"-64"],["B","ADD",38,39,"-20"],["B","ADD",38,37,"2"],["B","SCALE",38,"-75"],["B","ADD",45,38,"-91/200"],["B","ADD",44,38,"-109/600"],["B","ADD",43,38,"791/300"],["B","ADD",42,38,"1"],["B","ADD",41,38,"-191/600"],["B","ADD",40,38,"-1/2"],["B","ADD",39,38,"791/300"],["B","ADD",37,38,"559/75"],["B","ADD",36,38,"-409/150"],["B","ADD",37,36,"41/15"],["B","ADD",38,36,"11/30"],["B","ADD",39,36,"29/30"],["B","ADD",40,36,"-11/60"],["B","ADD",41,36,"-7/60"],["B","ADD",42,36,"11/30"],["B","ADD",43,36,"29/30"],["B","ADD",44,36,"-11/60"],["B","ADD",45,36,"-7/60"],["B","ADD",46,36,"7/30"],["B","ADD",47,36,"11/30"],["B","SCALE",36,"-2/15"],["B","ADD",36,37,"55"],["B","ADD",36,38,"218"],["B","ADD",36,39,"-546"],["B","ADD",36,40,"-1748"],["B","ADD",36,41,"-1092"],["B","ADD",36,42,"218"],["B","ADD",36,43,"-546"],["B","ADD",36,44,"-1748"],["B","ADD",36,45,"-1092"],["B","ADD",36,46,"-982"],["B","ADD",36,47,"218"],["B","IDLE_ONE",36,[6,7,8]],["B","ADD",36,47,"-218"],["B","ADD",36,46,"982"],["B","ADD",36,45,"1092"],["B","ADD",36,44,"1748"],["B","ADD",36,43,"546"],["B","ADD",36,42,"-218"],["B","ADD",36,41,"1092"],["B","ADD",36,40,"1748"],["B","ADD",36,39,"546"],["B","ADD",36,38,"-218"],["B","ADD",36,37,"-55"],["B","SCALE",36,"-15/2"],["B","ADD",47,36,"-11/30"],["B","ADD",46,36,"-7/30"],["B","ADD",45,36,"7/60"],["B","ADD",44,36,"11/60"],["B","ADD",43,36,"-29/30"],["B","ADD",42,36,"-11/30"],["B","ADD",41,36,"7/60"],["B","ADD",40,36,"11/60"],["B","ADD",39,36,"-29/30"],["B","ADD",38,36,"-11/30"],["B","ADD",37,36,"-41/15"],["B","ADD",36,38,"409/150"],["B","ADD",37,38,"-559/75"],["B","ADD",39,38,"-791/300"],["B","ADD",40,38,"1/2"],["B","ADD",41,38,"191/600"],["B","ADD",42,38,"-1"],["B","ADD",43,38,"-791/300"],["B","ADD",44,38,"1/2"],["B","ADD",45,38,"191/600"],["B","ADD",46,38,"-191/300"],["B","ADD",47,38,"-1"],["B","SCALE",38,"1/75"],["B","ADD",38,37,"-2"],["B","ADD",38,39,"20"],["B","ADD",38,40,"64"],["B","ADD",38,41,"40"],["B","ADD",38,42,"-8"],["B","ADD",38,43,"20"],["B","ADD",38,44,"64"],["B","ADD",38,45,"40"],["B","ADD",38,46,"36"],["B","ADD",38,47,"-8"],["B","IDLE_ONE",38,[6,7,8]],["B","ADD",38,47,"8"],["B","ADD",38,46,"-36"],["B","ADD",38,45,"-40"],["B","ADD",38,44,"-64"],["B","ADD",38,43,"-20"],["B","ADD",38,42,"8"],["B","ADD",38,41,"-40"],["B","ADD",38,40,"-64"],["B","ADD",38,39,"-20"],["B","ADD",38,37,"2"],["B","SCALE",38,"75"],["B","ADD",47,38,"1"],["B","ADD",46,38,"191/300"],["B","ADD",45,38,"-191/600"],["B","ADD",44,38,"-1/2"],["B","ADD",43,38,"791/300"],["B","ADD",42,38,"1"],["B","ADD",41,38,"-191/600"],["B","ADD",40,38,"-1/2"],["B","ADD",39,38,"791/300"],["B","ADD",37,38,"559/75"],["B","ADD",36,38,"-409/150"],["B","ADD",37,36,"41/15"],["B","ADD",38,36,"11/30"],["B","ADD",39,36,"29/30"],["B","ADD",40,36,"-11/60"],["B","ADD",41,36,"-7/60"],["B","ADD",42,36,"11/30"],["B","ADD",43,36,"29/30"],["B","ADD",44,36,"-11/60"],["B","ADD",45,36,"-7/60"],["B","ADD",46,36,"11/30"],["B","ADD",47,36,"29/30"],["B","ADD",48,36,"-1/15"],["B","ADD",49,36,"-1/6"],["B","SCALE",36,"2/15"],["B","ADD",36,37,"55"],["B","ADD",36,38,"218"],["B","ADD",36,39,"-546"],["B","ADD",36,40,"-1748"],["B","ADD",36,41,"-1092"],["B","ADD",36,42,"218"],["B","ADD",36,43,"-546"],["B","ADD",36,44,"-1748"],["B","ADD",36,45,"-1092"],["B","ADD",36,46,"218"],["B","ADD",36,47,"-546"],["B","ADD",36,48,"-656"],["B","ADD",36,49,"-1528"],["B","IDLE_ONE",36,[7,8]],["B","ADD",36,49,"1528"],["B","ADD",36,48,"656"],["B","ADD",36,47,"546"],["B","ADD",36,46,"-218"],["B","ADD",36,45,"1092"],["B","ADD",36,44,"1748"],["B","ADD",36,43,"546"],["B","ADD",36,42,"-218"],["B","ADD",36,41,"1092"],["B","ADD",36,40,"1748"],["B","ADD",36,39,"546"],["B","ADD",36,38,"-218"],["B","ADD",36,37,"-55"],["B","SCALE",36,"15/2"],["B","ADD",49,36,"1/6"],["B","ADD",48,36,"1/15"],["B","ADD",47,36,"-29/30"],["B","ADD",46,36,"-11/30"],["B","ADD",45,36,"7/60"],["B","ADD",44,36,"11/60"],["B","ADD",43,36,"-29/30"],["B","ADD",42,36,"-11/30"],["B","ADD",41,36,"7/60"],["B","ADD",40,36,"11/60"],["B","ADD",39,36,"-29/30"],["B","ADD",38,36,"-11/30"],["B","ADD",37,36,"-41/15"],["B","ADD",36,38,"409/150"],["B","ADD",37,38,"-559/75"],["B","ADD",39,38,"-791/300"],["B","ADD",40,38,"1/2"],["B","ADD",41,38,"191/600"],["B","ADD",42,38,"-1"],["B","ADD",43,38,"-791/300"],["B","ADD",44,38,"1/2"],["B","ADD",45,38,"191/600"],["B","ADD",46,38,"-1"],["B","ADD",47,38,"-791/300"],["B","ADD",48,38,"109/600"],["B","ADD",49,38,"91/200"],["B","SCALE",38,"-1/75"],["B","ADD",38,37,"-2"],["B","ADD",38,39,"20"],["B","ADD",38,40,"64"],["B","ADD",38,41,"40"],["B","ADD",38,42,"-8"],["B","ADD",38,43,"20"],["B","ADD",38,44,"64"],["B","ADD",38,45,"40"],["B","ADD",38,46,"-8"],["B","ADD",38,47,"20"],["B","ADD",38,48,"24"],["B","ADD",38,49,"56"],["B","IDLE_ONE",38,[7,8]],["B","ADD",38,49,"-56"],["B","ADD",38,48,"-24"],["B","ADD",38,47,"-20"],["B","ADD",38,46,"8"],["B","ADD",38,45,"-40"],["B","ADD",38,44,"-64"],["B","ADD",38,43,"-20"],["B","ADD",38,42,"8"],["B","ADD",38,41,"-40"],["B","ADD",38,40,"-64"],["B","ADD",38,39,"-20"],["B","ADD",38,37,"2"],["B","SCALE",38,"-75"],["B","ADD",49,38,"-91/200"],["B","ADD",48,38,"-109/600"],["B","ADD",47,38,"791/300"],["B","ADD",46,38,"1"],["B","ADD",45,38,"-191/600"],["B","ADD",44,38,"-1/2"],["B","ADD",43,38,"791/300"],["B","ADD",42,38,"1"],["B","ADD",41,38,"-191/600"],["B","ADD",40,38,"-1/2"],["B","ADD",39,38,"791/300"],["B","ADD",37,38,"559/75"],["B","ADD",36,38,"-409/150"],["B","ADD",37,36,"41/16"],["B","ADD",52,36,"1/16"],["B","ADD",53,36,"9/32"],["B","SCALE",36,"-1/16"],["B","ADD",36,52,"-10"],["B","ADD",36,53,"6"],["B","IDLE_ONE",36,[16,15,14,13,12,11,10,9]],["B","ADD",36,53,"-6"],["B","ADD",36,52,"10"],["B","SCALE",36,"-16"],["B","ADD",53,36,"-9/32"],["B","ADD",52,36,"-1/16"],["B","ADD",37,36,"-41/16"],["B","ADD",36,37,"7/18"],["B","ADD",52,37,"-1/36"],["B","ADD",53,37,"-1/9"],["B","SCALE",37,"-1/18"],["B","ADD",37,52,"-22"],["B","ADD",37,53,"14"],["B","IDLE_ONE",37,[16,15,14,13,12,11,10,9]],["B","ADD",37,53,"-14"],["B","ADD",37,52,"22"],["B","SCALE",37,"-18"],["B","ADD",53,37,"1/9"],["B","ADD",52,37,"1/36"],["B","ADD",36,37,"-7/18"],["B","ADD",37,36,"41/16"],["B","ADD",52,36,"11/64"],["B","ADD",53,36,"29/64"],["B","ADD",54,36,"1/32"],["B","ADD",55,36,"5/64"],["B","SCALE",36,"-1/16"],["B","ADD",36,37,"5"],["B","ADD",36,52,"22"],["B","ADD",36,53,"-54"],["B","ADD",36,54,"32"],["B","ADD",36,55,"76"],["B","IDLE_ONE",36,[15,14,13,12,11,10,9]],["B","ADD",36,55,"-76"],["B","ADD",36,54,"-32"],["B","ADD",36,53,"54"],["B","ADD",36,52,"-22"],["B","ADD",36,37,"-5"],["B","SCALE",36,"-16"],["B","ADD",55,36,"-5/64"],["B","ADD",54,36,"-1/32"],["B","ADD",53,36,"-29/64"],["B","ADD",52,36,"-11/64"],["B","ADD",37,36,"-41/16"],["B","ADD",36,52,"29/5"],["B","ADD",37,52,"-223/15"],["B","ADD",53,52,"-79/30"],["B","ADD",54,52,"-11/60"],["B","ADD",55,52,"-9/20"],["B","SCALE",52,"1/15"],["B","ADD",52,37,"-1"],["B","ADD",52,53,"10"],["B","ADD",52,54,"-6"],["B","ADD",52,55,"-14"],["B","IDLE_ONE",52,[15,14,13,12,11,10,9]],["B","ADD",52,55,"14"],["B","ADD",52,54,"6"],["B","ADD",52,53,"-10"],["B","ADD",52,37,"1"],["B","SCALE",52,"15"],["B","ADD",55,52,"9/20"],["B","ADD",54,52,"11/60"],["B","ADD",53,52,"79/30"],["B","ADD",37,52,"223/15"],["B","ADD",36,52,"-29/5"],["B","ADD",37,36,"41/16"],["B","ADD",52,36,"11/64"],["B","ADD",53,36,"29/64"],["B","ADD",54,36,"9/64"],["B","ADD",55,36,"1/32"],["B","ADD",56,36,"1/16"],["B","ADD",57,36,"9/32"],["B","SCALE",36,"-1/16"],["B","ADD",36,37,"-5"],["B","ADD",36,52,"-22"],["B","ADD",36,53,"54"],["B","ADD",36,54,"-140"],["B","ADD",36,55,"-32"],["B","ADD",36,56,"-120"],["B","ADD",36,57,"76"],["B","IDLE_ONE",36,[14,13,12,11,10,9]],["B","ADD",36,57,"-76"],["B","ADD",36,56,"120"],["B","ADD",36,55,"32"],["B","ADD",36,54,"140"],["B","ADD",36,53,"-54"],["B","ADD",36,52,"22"],["B","ADD",36,37,"5"],["B","SCALE",36,"-16"],["B","ADD",57,36,"-9/32"],["B","ADD",56,36,"-1/16"],["B","ADD",55,36,"-1/32"],["B","ADD",54,36,"-9/64"],["B","ADD",53,36,"-29/64"],["B","ADD",52,36,"-11/64"],["B","ADD",37,36,"-41/16"],["B","ADD",36,52,"29/5"],["B","ADD",37,52,"-223/15"],["B","ADD",53,52,"-79/30"],["B","ADD",54,52,"-49/60"],["B","ADD",55,52,"-11/60"],["B","ADD",56,52,"-11/30"],["B","ADD",57,52,"-49/30"],["B","SCALE",52,"1/15"],["B","ADD",52,37,"1"],["B","ADD",52,53,"-10"],["B","ADD",52,54,"26"],["B","ADD",52,55,"6"],["B","ADD",52,56,"22"],["B","ADD",52,57,"-14"],["B","IDLE_ONE",52,[14,13,12,11,10,9]],["B","ADD",52,57,"14"],["B","ADD",52,56,"-22"],["B","ADD",52,55,"-6"],["B","ADD",52,54,"-26"],["B","ADD",52,53,"10"],["B","ADD",52,37,"-1"],["B","SCALE",52,"15"],["B","ADD",57,52,"49/30"],["B","ADD",56,52,"11/30"],["B","ADD",55,52,"11/60"],["B","ADD",54,52,"49/60"],["B","ADD",53,52,"79/30"],["B","ADD",37,52,"223/15"],["B","ADD",36,52,"-29/5"],["B","ADD",37,36,"41/16"],["B","ADD",52,36,"11/64"],["B","ADD",53,36,"29/64"],["B","ADD",54,36,"9/64"],["B","ADD",55,36,"1/32"],["B","ADD",56,36,"11/64"],["B","ADD",57,36,"29/64"],["B","ADD",58,36,"1/32"],["B","ADD",59,36,"5/64"],["B","SCALE",36,"-1/16"],["B","ADD",36,37,"5"],["B","ADD",36,52,"22"],["B","ADD",36,53,"-54"],["B","ADD",36,54,"140"],["B","ADD",36,55,"32"],["B","ADD",36,56,"22"],["B","ADD",36,57,"-54"],["B","ADD",36,58,"32"],["B","ADD",36,59,"76"],["B","IDLE_ONE",36,[13,12,11,10,9]],["B","ADD",36,59,"-76"],["B","ADD",36,58,"-32"],["B","ADD",36,57,"54"],["B","ADD",36,56,"-22"],["B","ADD",36,55,"-32"],["B","ADD",36,54,"-140"],["B","ADD",36,53,"54"],["B","ADD",36,52,"-22"],["B","ADD",36,37,"-5"],["B","SCALE",36,"-16"],["B","ADD",59,36,"-5/64"],["B","ADD",58,36,"-1/32"],["B","ADD",57,36,"-29/64"],["B","ADD",56,36,"-11/64"],["B","ADD",55,36,"-1/32"],["B","ADD",54,36,"-9/64"],["B","ADD",53,36,"-29/64"],["B","ADD",52,36,"-11/64"],["B","ADD",37,36,"-41/16"],["B","ADD",36,52,"29/5"],["B","ADD",37,52,"-223/15"],["B","ADD",53,52,"-79/30"],["B","ADD",54,52,"-49/60"],["B","ADD",55,52,"-11/60"],["B","ADD",56,52,"-1"],["B","ADD",57,52,"-79/30"],["B","ADD",58,52,"-11/60"],["B","ADD",59,52,"-9/20"],["B","SCALE",52,"1/15"],["B","ADD",52,37,"-1"],["B","ADD",52,53,"10"],["B","ADD",52,54,"-26"],["B","ADD",52,55,"-6"],["B","ADD",52,56,"-4"],["B","ADD",52,57,"10"],["B","ADD",52,58,"-6"],["B","ADD",52,59,"-14"],["B","IDLE_ONE",52,[13,12,11,10,9]],["B","ADD",52,59,"14"],["B","ADD",52,58,"6"],["B","ADD",52,57,"-10"],["B","ADD",52,56,"4"],["B","ADD",52,55,"6"],["B","ADD",52,54,"26"],["B","ADD",52,53,"-10"],["B","ADD",52,37,"1"],["B","SCALE",52,"15"],["B","ADD",59,52,"9/20"],["B","ADD",58,52,"11/60"],["B","ADD",57,52,"79/30"],["B","ADD",56,52,"1"],["B","ADD",55,52,"11/60"],["B","ADD",54,52,"49/60"],["B","ADD",53,52,"79/30"],["B","ADD",37,52,"223/15"],["B","ADD",36,52,"-29/5"],["B","ADD",37,36,"41/16"],["B","ADD",52,36,"11/64"],["B","ADD",53,36,"29/64"],["B","ADD",54,36,"9/64"],["B","ADD",55,36,"1/32"],["B","ADD",56,36,"11/64"],["B","ADD",57,36,"29/64"],["B","ADD",58,36,"9/64"],["B","ADD",59,36,"1/32"],["B","ADD",60,36,"1/16"],["B","ADD",61,36,"9/32"],["B","SCALE",36,"-1/16"],["B","ADD",36,37,"-5"],["B","ADD",36,52,"-22"],["B","ADD",36,53,"54"],["B","ADD",36,54,"-140"],["B","ADD",36,55,"-32"],["B","ADD",36,56,"-22"],["B","ADD",36,57,"54"],["B","ADD",36,58,"-140"],["B","ADD",36,59,"-32"],["B","ADD",36,60,"-120"],["B","ADD",36,61,"76"],["B","IDLE_ONE",36,[12,11,10,9]],["B","ADD",36,61,"-76"],["B","ADD",36,60,"120"],["B","ADD",36,59,"32"],["B","ADD",36,58,"140"],["B","ADD",36,57,"-54"],["B","ADD",36,56,"22"],["B","ADD",36,55,"32"],["B","ADD",36,54,"140"],["B","ADD",36,53,"-54"],["B","ADD",36,52,"22"],["B","ADD",36,37,"5"],["B","SCALE",36,"-16"],["B","ADD",61,36,"-9/32"],["B","ADD",60,36,"-1/16"],["B","ADD",59,36,"-1/32"],["B","ADD",58,36,"-9/64"],["B","ADD",57,36,"-29/64"],["B","ADD",56,36,"-11/64"],["B","ADD",55,36,"-1/32"],["B","ADD",54,36,"-9/64"],["B","ADD",53,36,"-29/64"],["B","ADD",52,36,"-11/64"],["B","ADD",37,36,"-41/16"],["B","ADD",36,52,"29/5"],["B","ADD",37,52,"-223/15"],["B","ADD",53,52,"-79/30"],["B","ADD",54,52,"-49/60"],["B","ADD",55,52,"-11/60"],["B","ADD",56,52,"-1"],["B","ADD",57,52,"-79/30"],["B","ADD",58,52,"-49/60"],["B","ADD",59,52,"-11/60"],["B","ADD",60,52,"-11/30"],["B","ADD",61,52,"-49/30"],["B","SCALE",52,"1/15"],["B","ADD",52,37,"1"],["B","ADD",52,53,"-10"],["B","ADD",52,54,"26"],["B","ADD",52,55,"6"],["B","ADD",52,56,"4"],["B","ADD",52,57,"-10"],["B","ADD",52,58,"26"],["B","ADD",52,59,"6"],["B","ADD",52,60,"22"],["B","ADD",52,61,"-14"],["B","IDLE_ONE",52,[12,11,10,9]],["B","ADD",52,61,"14"],["B","ADD",52,60,"-22"],["B","ADD",52,59,"-6"],["B","ADD",52,58,"-26"],["B","ADD",52,57,"10"],["B","ADD",52,56,"-4"],["B","ADD",52,55,"-6"],["B","ADD",52,54,"-26"],["B","ADD",52,53,"10"],["B","ADD",52,37,"-1"],["B","SCALE",52,"15"],["B","ADD",61,52,"49/30"],["B","ADD",60,52,"11/30"],["B","ADD",59,52,"11/60"],["B","ADD",58,52,"49/60"],["B","ADD",57,52,"79/30"],["B","ADD",56,52,"1"],["B","ADD",55,52,"11/60"],["B","ADD",54,52,"49/60"],["B","ADD",53,52,"79/30"],["B","ADD",37,52,"223/15"],["B","ADD",36,52,"-29/5"],["B","ADD",37,36,"41/16"],["B","ADD",52,36,"11/64"],["B","ADD",53,36,"29/64"],["B","ADD",54,36,"9/64"],["B","ADD",55,36,"1/32"],["B","ADD",56,36,"11/64"],["B","ADD",57,36,"29/64"],["B","ADD",58,36,"9/64"],["B","ADD",59,36,"1/32"],["B","ADD",60,36,"11/64"],["B","ADD",61,36,"29/64"],["B","ADD",62,36,"1/32"],["B","ADD",63,36,"5/64"],["B","SCALE",36,"-1/16"],["B","ADD",36,37,"5"],["B","ADD",36,52,"22"],["B","ADD",36,53,"-54"],["B","ADD",36,54,"140"],["B","ADD",36,55,"32"],["B","ADD",36,56,"22"],["B","ADD",36,57,"-54"],["B","ADD",36,58,"140"],["B","ADD",36,59,"32"],["B","ADD",36,60,"22"],["B","ADD",36,61,"-54"],["B","ADD",36,62,"32"],["B","ADD",36,63,"76"],["B","IDLE_ONE",36,[11,10,9]],["B","ADD",36,63,"-76"],["B","ADD",36,62,"-32"],["B","ADD",36,61,"54"],["B","ADD",36,60,"-22"],["B","ADD",36,59,"-32"],["B","ADD",36,58,"-140"],["B","ADD",36,57,"54"],["B","ADD",36,56,"-22"],["B","ADD",36,55,"-32"],["B","ADD",36,54,"-140"],["B","ADD",36,53,"54"],["B","ADD",36,52,"-22"],["B","ADD",36,37,"-5"],["B","SCALE",36,"-16"],["B","ADD",63,36,"-5/64"],["B","ADD",62,36,"-1/32"],["B","ADD",61,36,"-29/64"],["B","ADD",60,36,"-11/64"],["B","ADD",59,36,"-1/32"],["B","ADD",58,36,"-9/64"],["B","ADD",57,36,"-29/64"],["B","ADD",56,36,"-11/64"],["B","ADD",55,36,"-1/32"],["B","ADD",54,36,"-9/64"],["B","ADD",53,36,"-29/64"],["B","ADD",52,36,"-11/64"],["B","ADD",37,36,"-41/16"],["B","ADD",36,52,"29/5"],["B","ADD",37,52,"-223/15"],["B","ADD",53,52,"-79/30"],["B","ADD",54,52,"-49/60"],["B","ADD",55,52,"-11/60"],["B","ADD",56,52,"-1"],["B","ADD",57,52,"-79/30"],["B","ADD",58,52,"-49/60"],["B","ADD",59,52,"-11/60"],["B","ADD",60,52,"-1"],["B","ADD",61,52,"-79/30"],["B","ADD",62,52,"-11/60"],["B","ADD",63,52,"-9/20"],["B","SCALE",52,"1/15"],["B","ADD",52,37,"-1"],["B","ADD",52,53,"10"],["B","ADD",52,54,"-26"],["B","ADD",52,55,"-6"],["B","ADD",52,56,"-4"],["B","ADD",52,57,"10"],["B","ADD",52,58,"-26"],["B","ADD",52,59,"-6"],["B","ADD",52,60,"-4"],["B","ADD",52,61,"10"],["B","ADD",52,62,"-6"],["B","ADD",52,63,"-14"],["B","IDLE_ONE",52,[11,10,9]],["B","ADD",52,63,"14"],["B","ADD",52,62,"6"],["B","ADD",52,61,"-10"],["B","ADD",52,60,"4"],["B","ADD",52,59,"6"],["B","ADD",52,58,"26"],["B","ADD",52,57,"-10"],["B","ADD",52,56,"4"],["B","ADD",52,55,"6"],["B","ADD",52,54,"26"],["B","ADD",52,53,"-10"],["B","ADD",52,37,"1"],["B","SCALE",52,"15"],["B","ADD",63,52,"9/20"],["B","ADD",62,52,"11/60"],["B","ADD",61,52,"79/30"],["B","ADD",60,52,"1"],["B","ADD",59,52,"11/60"],["B","ADD",58,52,"49/60"],["B","ADD",57,52,"79/30"],["B","ADD",56,52,"1"],["B","ADD",55,52,"11/60"],["B","ADD",54,52,"49/60"],["B","ADD",53,52,"79/30"],["B","ADD",37,52,"223/15"],["B","ADD",36,52,"-29/5"],["B","ADD",37,36,"5/2"],["B","ADD",52,36,"1/8"],["B","ADD",53,36,"3/8"],["B","ADD",54,36,"1/8"],["B","ADD",56,36,"1/8"],["B","ADD",57,36,"3/8"],["B","ADD",58,36,"1/8"],["B","ADD",60,36,"1/8"],["B","ADD",61,36,"3/8"],["B","ADD",62,36,"1/8"],["B","ADD",65,36,"1/4"],["B","SCALE",36,"-5/2"],["B","ADD",36,37,"3"],["B","ADD",36,52,"2"],["B","ADD",36,53,"-10"],["B","ADD",36,54,"28"],["B","ADD",36,55,"8"],["B","ADD",36,56,"2"],["B","ADD",36,57,"-10"],["B","ADD",36,58,"28"],["B","ADD",36,59,"8"],["B","ADD",36,60,"2"],["B","ADD",36,61,"-10"],["B","ADD",36,62,"28"],["B","ADD",36,63,"8"],["B","ADD",36,64,"2"],["B","IDLE_ONE",36,[10,9]],["B","ADD",36,64,"-2"],["B","ADD",36,63,"-8"],["B","ADD",36,62,"-28"],["B","ADD",36,61,"10"],["B","ADD",36,60,"-2"],["B","ADD",36,59,"-8"],["B","ADD",36,58,"-28"],["B","ADD",36,57,"10"],["B","ADD",36,56,"-2"],["B","ADD",36,55,"-8"],["B","ADD",36,54,"-28"],["B","ADD",36,53,"10"],["B","ADD",36,52,"-2"],["B","ADD",36,37,"-3"],["B","SCALE",36,"-2/5"],["B","ADD",65,36,"-1/4"],["B","ADD",62,36,"-1/8"],["B","ADD",61,36,"-3/8"],["B","ADD",60,36,"-1/8"],["B","ADD",58,36,"-1/8"],["B","ADD",57,36,"-3/8"],["B","ADD",56,36,"-1/8"],["B","ADD",54,36,"-1/8"],["B","ADD",53,36,"-3/8"],["B","ADD",52,36,"-1/8"],["B","ADD",37,36,"-5/2"],["B","ADD",37,36,"2"],["B","ADD",52,36,"-1/4"],["B","ADD",53,36,"-1/4"],["B","ADD",55,36,"-1/4"],["B","ADD",56,36,"-1/4"],["B","ADD",57,36,"-1/4"],["B","ADD",59,36,"-1/4"],["B","ADD",60,36,"-1/4"],["B","ADD",61,36,"-1/4"],["B","ADD",63,36,"-1/4"],["B","ADD",64,36,"-1/2"],["B","SCALE",36,"5"],["B","ADD",36,37,"2"],["B","ADD",36,52,"8"],["B","ADD",36,53,"-20"],["B","ADD",36,54,"52"],["B","ADD",36,55,"12"],["B","ADD",36,56,"8"],["B","ADD",36,57,"-20"],["B","ADD",36,58,"52"],["B","ADD",36,59,"12"],["B","ADD",36,60,"8"],["B","ADD",36,61,"-20"],["B","ADD",36,62,"52"],["B","ADD",36,63,"12"],["B","ADD",36,64,"18"],["B","ADD",36,65,"-20"],["B","IDLE_ONE",36,[10,9]],["B","ADD",36,65,"20"],["B","ADD",36,64,"-18"],["B","ADD",36,63,"-12"],["B","ADD",36,62,"-52"],["B","ADD",36,61,"20"],["B","ADD",36,60,"-8"],["B","ADD",36,59,"-12"],["B","ADD",36,58,"-52"],["B","ADD",36,57,"20"],["B","ADD",36,56,"-8"],["B","ADD",36,55,"-12"],["B","ADD",36,54,"-52"],["B","ADD",36,53,"20"],["B","ADD",36,52,"-8"],["B","ADD",36,37,"-2"],["B","SCALE",36,"1/5"],["B","ADD",64,36,"1/2"],["B","ADD",63,36,"1/4"],["B","ADD",61,36,"1/4"],["B","ADD",60,36,"1/4"],["B","ADD",59,36,"1/4"],["B","ADD",57,36,"1/4"],["B","ADD",56,36,"1/4"],["B","ADD",55,36,"1/4"],["B","ADD",53,36,"1/4"],["B","ADD",52,36,"1/4"],["B","ADD",37,36,"-2"],["B","ADD",37,36,"9/5"],["B","ADD",52,36,"-2/5"],["B","ADD",53,36,"-1/2"],["B","ADD",54,36,"-1/20"],["B","ADD",55,36,"-7/20"],["B","ADD",56,36,"-2/5"],["B","ADD",57,36,"-1/2"],["B","ADD",58,36,"-1/20"],["B","ADD",59,36,"-7/20"],["B","ADD",60,36,"-2/5"],["B","ADD",61,36,"-1/2"],["B","ADD",62,36,"-1/20"],["B","ADD",63,36,"-7/20"],["B","ADD",64,36,"-1/5"],["B","ADD",66,36,"-2/5"],["B","ADD",67,36,"7/40"],["B","SCALE",36,"-1/2"],["B","ADD",36,37,"-4"],["B","ADD",36,52,"-6"],["B","ADD",36,53,"20"],["B","ADD",36,54,"-54"],["B","ADD",36,55,"-14"],["B","ADD",36,56,"-6"],["B","ADD",36,57,"20"],["B","ADD",36,58,"-54"],["B","ADD",36,59,"-14"],["B","ADD",36,60,"-6"],["B","ADD",36,61,"20"],["B","ADD",36,62,"-54"],["B","ADD",36,63,"-14"],["B","ADD",36,64,"-6"],["B","ADD",36,65,"20"],["B","ADD",36,66,"40"],["B","ADD",36,67,"100"],["B","IDLE_ONE",36,[9]],["B","ADD",36,67,"-100"],["B","ADD",36,66,"-40"],["B","ADD",36,65,"-20"],["B","ADD",36,64,"6"],["B","ADD",36,63,"14"],["B","ADD",36,62,"54"],["B","ADD",36,61,"-20"],["B","ADD",36,60,"6"],["B","ADD",36,59,"14"],["B","ADD",36,58,"54"],["B","ADD",36,57,"-20"],["B","ADD",36,56,"6"],["B","ADD",36,55,"14"],["B","ADD",36,54,"54"],["B","ADD",36,53,"-20"],["B","ADD",36,52,"6"],["B","ADD",36,37,"4"],["B","SCALE",36,"-2"],["B","ADD",67,36,"-7/40"],["B","ADD",66,36,"2/5"],["B","ADD",64,36,"1/5"],["B","ADD",63,36,"7/20"],["B","ADD",62,36,"1/20"],["B","ADD",61,36,"1/2"],["B","ADD",60,36,"2/5"],["B","ADD",59,36,"7/20"],["B","ADD",58,36,"1/20"],["B","ADD",57,36,"1/2"],["B","ADD",56,36,"2/5"],["B","ADD",55,36,"7/20"],["B","ADD",54,36,"1/20"],["B","ADD",53,36,"1/2"],["B","ADD",52,36,"2/5"],["B","ADD",37,36,"-9/5"],["B","ADD",36,54,"-52/3"],["B","ADD",37,54,"92/3"],["B","ADD",52,54,"-22/3"],["B","ADD",53,54,"-28/3"],["B","ADD",55,54,"-19/3"],["B","ADD",56,54,"-22/3"],["B","ADD",57,54,"-28/3"],["B","ADD",58,54,"-1"],["B","ADD",59,54,"-19/3"],["B","ADD",60,54,"-22/3"],["B","ADD",61,54,"-28/3"],["B","ADD",62,54,"-1"],["B","ADD",63,54,"-19/3"],["B","ADD",64,54,"-8/3"],["B","ADD",65,54,"2/3"],["B","ADD",66,54,"-22/3"],["B","ADD",67,54,"3"],["B","SCALE",54,"-20/3"],["B","ADD",54,37,"2"],["B","ADD",54,52,"8"],["B","ADD",54,53,"-20"],["B","ADD",54,55,"12"],["B","ADD",54,56,"8"],["B","ADD",54,57,"-20"],["B","ADD",54,58,"52"],["B","ADD",54,59,"12"],["B","ADD",54,60,"8"],["B","ADD",54,61,"-20"],["B","ADD",54,62,"52"],["B","ADD",54,63,"12"],["B","ADD",54,64,"8"],["B","ADD",54,65,"-20"],["B","ADD",54,66,"-30"],["B","ADD",54,67,"-80"],["B","IDLE_ONE",54,[9]],["B","ADD",54,67,"80"],["B","ADD",54,66,"30"],["B","ADD",54,65,"20"],["B","ADD",54,64,"-8"],["B","ADD",54,63,"-12"],["B","ADD",54,62,"-52"],["B","ADD",54,61,"20"],["B","ADD",54,60,"-8"],["B","ADD",54,59,"-12"],["B","ADD",54,58,"-52"],["B","ADD",54,57,"20"],["B","ADD",54,56,"-8"],["B","ADD",54,55,"-12"],["B","ADD",54,53,"20"],["B","ADD",54,52,"-8"],["B","ADD",54,37,"-2"],["B","SCALE",54,"-3/20"],["B","ADD",67,54,"-3"],["B","ADD",66,54,"22/3"],["B","ADD",65,54,"-2/3"],["B","ADD",64,54,"8/3"],["B","ADD",63,54,"19/3"],["B","ADD",62,54,"1"],["B","ADD",61,54,"28/3"],["B","ADD",60,54,"22/3"],["B","ADD",59,54,"19/3"],["B","ADD",58,54,"1"],["B","ADD",57,54,"28/3"],["B","ADD",56,54,"22/3"],["B","ADD",55,54,"19/3"],["B","ADD",53,54,"28/3"],["B","ADD",52,54,"22/3"],["B","ADD",37,54,"-92/3"],["B","ADD",36,54,"52/3"],["B","IDLE_ODD",70,[9],-1],["B","IDLE_ODD",71,[9],-1],["B","ADD",37,36,"5/3"],["B","ADD",52,36,"-1/2"],["B","ADD",53,36,"-2/3"],["B","ADD",54,36,"-1/12"],["B","ADD",55,36,"-5/12"],["B","ADD",56,36,"-1/2"],["B","ADD",57,36,"-2/3"],["B","ADD",58,36,"-1/12"],["B","ADD",59,36,"-5/12"],["B","ADD",60,36,"-1/2"],["B","ADD",61,36,"-2/3"],["B","ADD",62,36,"-1/12"],["B","ADD",63,36,"-5/12"],["B","ADD",65,36,"1/6"],["B","ADD",66,36,"-2/3"],["B","ADD",67,36,"1/4"],["B","SCALE",36,"-1/3"],["B","ADD",36,37,"1"],["B","ADD",36,52,"-2"],["B","ADD",36,53,"2"],["B","ADD",36,54,"-4"],["B","ADD",36,56,"-2"],["B","ADD",36,57,"2"],["B","ADD",36,58,"-4"],["B","ADD",36,60,"-2"],["B","ADD",36,61,"2"],["B","ADD",36,62,"-4"],["B","ADD",36,64,"-2"],["B","ADD",36,65,"2"],["B","ADD",36,66,"-2"],["B","ADD",52,37,"-3/4"],["B","ADD",53,37,"-5/4"],["B","ADD",54,37,"-1/4"],["B","ADD",55,37,"-1/2"],["B","ADD",56,37,"-3/4"],["B","ADD",57,37,"-5/4"],["B","ADD",58,37,"-1/4"],["B","ADD",59,37,"-1/2"],["B","ADD",60,37,"-3/4"],["B","ADD",61,37,"-5/4"],["B","ADD",62,37,"-1/4"],["B","ADD",63,37,"-1/2"],["B","ADD",64,37,"3/2"],["B","ADD",65,37,"5/4"],["B","ADD",66,37,"-1/2"],["B","SCALE",37,"-3/4"],["B","ADD",37,53,"1"],["B","ADD",37,54,"-3"],["B","ADD",37,55,"-1"],["B","ADD",37,57,"1"],["B","ADD",37,58,"-3"],["B","ADD",37,59,"-1"],["B","ADD",37,61,"1"],["B","ADD",37,62,"-3"],["B","ADD",37,63,"-1"],["B","ADD",37,65,"1"],["B","ADD",37,66,"2"],["B","ADD",37,67,"4"],["B","SCALE",37,"1"],["B","ADD",37,36,"1/2"],["B","ADD",37,36,"-1/2"],["B","ADD",36,37,"1"],["B","LAMBDA",36,1],["A","ADD",9,0,"1"],["A","ADD",10,0,"2"],["A","ADD",11,0,"2"],["A","ADD",12,0,"2"],["A","ADD",13,0,"2"],["A","ADD",14,0,"2"],["A","ADD",15,0,"2"],["A","ADD",16,0,"2"],["A","ADD",17,0,"2"],["A","SCALE",0,"-1"],["A","ADD",27,18,"1"],["A","ADD",28,18,"2"],["A","ADD",29,18,"2"],["A","ADD",30,18,"2"],["A","ADD",31,18,"2"],["A","ADD",32,18,"2"],["A","ADD",33,18,"2"],["A","ADD",34,18,"2"],["A","ADD",35,18,"2"],["A","SCALE",18,"-1"],["A","LAMBDA",9,1],["A","LAMBDA",27,-1],["A","SCALE",27,"-1"],["J",9,[9,0,18,27],[36,37,"-1","1/2"]],["A","LAMBDA",9,-1],["A","LAMBDA",27,1],["A","SCALE",27,"-1"],["A","ADD",0,9,"-1"],["A","ADD",18,27,"-1"],["A","SCALE",18,"-1"],["A","ADD",35,18,"-2"],["A","ADD",34,18,"-2"],["A","ADD",33,18,"-2"],["A","ADD",32,18,"-2"],["A","ADD",31,18,"-2"],["A","ADD",30,18,"-2"],["A","ADD",29,18,"-2"],["A","ADD",28,18,"-2"],["A","ADD",27,18,"-1"],["A","SCALE",0,"-1"],["A","ADD",17,0,"-2"],["A","ADD",16,0,"-2"],["A","ADD",15,0,"-2"],["A","ADD",14,0,"-2"],["A","ADD",13,0,"-2"],["A","ADD",12,0,"-2"],["A","ADD",11,0,"-2"],["A","ADD",10,0,"-2"],["A","ADD",9,0,"-1"],["B","LAMBDA",36,-1],["B","ADD",37,36,"-1/2"],["B","SCALE",37,"1"],["B","ADD",37,67,"-4"],["B","ADD",37,66,"-2"],["B","ADD",37,65,"-1"],["B","ADD",37,63,"1"],["B","ADD",37,62,"3"],["B","ADD",37,61,"-1"],["B","ADD",37,59,"1"],["B","ADD",37,58,"3"],["B","ADD",37,57,"-1"],["B","ADD",37,55,"1"],["B","ADD",37,54,"3"],["B","ADD",37,53,"-1"],["B","SCALE",37,"-4/3"],["B","ADD",66,37,"1/2"],["B","ADD",65,37,"-5/4"],["B","ADD",64,37,"-3/2"],["B","ADD",63,37,"1/2"],["B","ADD",62,37,"1/4"],["B","ADD",61,37,"5/4"],["B","ADD",60,37,"3/4"],["B","ADD",59,37,"1/2"],["B","ADD",58,37,"1/4"],["B","ADD",57,37,"5/4"],["B","ADD",56,37,"3/4"],["B","ADD",55,37,"1/2"],["B","ADD",54,37,"1/4"],["B","ADD",53,37,"5/4"],["B","ADD",52,37,"3/4"],["B","ADD",36,66,"2"],["B","ADD",36,65,"-2"],["B","ADD",36,64,"2"],["B","ADD",36,62,"4"],["B","ADD",36,61,"-2"],["B","ADD",36,60,"2"],["B","ADD",36,58,"4"],["B","ADD",36,57,"-2"],["B","ADD",36,56,"2"],["B","ADD",36,54,"4"],["B","ADD",36,53,"-2"],["B","ADD",36,52,"2"],["B","ADD",36,37,"-1"],["B","SCALE",36,"-3"],["B","ADD",67,36,"-1/4"],["B","ADD",66,36,"2/3"],["B","ADD",65,36,"-1/6"],["B","ADD",63,36,"5/12"],["B","ADD",62,36,"1/12"],["B","ADD",61,36,"2/3"],["B","ADD",60,36,"1/2"],["B","ADD",59,36,"5/12"],["B","ADD",58,36,"1/12"],["B","ADD",57,36,"2/3"],["B","ADD",56,36,"1/2"],["B","ADD",55,36,"5/12"],["B","ADD",54,36,"1/12"],["B","ADD",53,36,"2/3"],["B","ADD",52,36,"1/2"],["B","ADD",37,36,"-5/3"],["B","ADD",37,36,"7/5"],["B","ADD",52,36,"-7/10"],["B","ADD",53,36,"-1"],["B","ADD",54,36,"-3/20"],["B","ADD",55,36,"-11/20"],["B","ADD",56,36,"-7/10"],["B","ADD",57,36,"-1"],["B","ADD",58,36,"-3/20"],["B","ADD",59,36,"-11/20"],["B","ADD",60,36,"-7/10"],["B","ADD",61,36,"-1"],["B","ADD",62,36,"-3/20"],["B","ADD",63,36,"-11/20"],["B","ADD",64,36,"2/5"],["B","ADD",65,36,"1/2"],["B","ADD",66,36,"-3/5"],["B","ADD",67,36,"1/5"],["B","SCALE",36,"-2"],["B","ADD",36,37,"-69"],["B","ADD",36,52,"-296"],["B","ADD",36,53,"730"],["B","ADD",36,54,"-1894"],["B","ADD",36,55,"-434"],["B","ADD",36,56,"-296"],["B","ADD",36,57,"730"],["B","ADD",36,58,"-1894"],["B","ADD",36,59,"-434"],["B","ADD",36,60,"-296"],["B","ADD",36,61,"730"],["B","ADD",36,62,"-1894"],["B","ADD",36,63,"-434"],["B","ADD",36,64,"-296"],["B","ADD",36,65,"730"],["B","ADD",36,66,"710"],["B","ADD",36,67,"1440"],["B","IDLE_ONE",36,[10]],["B","ADD",36,67,"-1440"],["B","ADD",36,66,"-710"],["B","ADD",36,65,"-730"],["B","ADD",36,64,"296"],["B","ADD",36,63,"434"],["B","ADD",36,62,"1894"],["B","ADD",36,61,"-730"],["B","ADD",36,60,"296"],["B","ADD",36,59,"434"],["B","ADD",36,58,"1894"],["B","ADD",36,57,"-730"],["B","ADD",36,56,"296"],["B","ADD",36,55,"434"],["B","ADD",36,54,"1894"],["B","ADD",36,53,"-730"],["B","ADD",36,52,"296"],["B","ADD",36,37,"69"],["B","SCALE",36,"-1/2"],["B","ADD",67,36,"-1/5"],["B","ADD",66,36,"3/5"],["B","ADD",65,36,"-1/2"],["B","ADD",64,36,"-2/5"],["B","ADD",63,36,"11/20"],["B","ADD",62,36,"3/20"],["B","ADD",61,36,"1"],["B","ADD",60,36,"7/10"],["B","ADD",59,36,"11/20"],["B","ADD",58,36,"3/20"],["B","ADD",57,36,"1"],["B","ADD",56,36,"7/10"],["B","ADD",55,36,"11/20"],["B","ADD",54,36,"3/20"],["B","ADD",53,36,"1"],["B","ADD",52,36,"7/10"],["B","ADD",37,36,"-7/5"],["B","ADD",36,55,"-11/6"],["B","ADD",37,55,"31/12"],["B","ADD",52,55,"-61/48"],["B","ADD",53,55,"-29/16"],["B","ADD",54,55,"-13/48"],["B","ADD",56,55,"-61/48"],["B","ADD",57,55,"-29/16"],["B","ADD",58,55,"-13/48"],["B","ADD",59,55,"-1"],["B","ADD",60,55,"-61/48"],["B","ADD",61,55,"-29/16"],["B","ADD",62,55,"-13/48"],["B","ADD",63,55,"-1"],["B","ADD",64,55,"17/24"],["B","ADD",65,55,"43/48"],["B","ADD",66,55,"-53/48"],["B","ADD",67,55,"143/384"],["B","SCALE",55,"5/48"],["B","ADD",55,37,"-2"],["B","ADD",55,52,"-8"],["B","ADD",55,53,"20"],["B","ADD",55,54,"-52"],["B","ADD",55,56,"-8"],["B","ADD",55,57,"20"],["B","ADD",55,58,"-52"],["B","ADD",55,59,"-12"],["B","ADD",55,60,"-8"],["B","ADD",55,61,"20"],["B","ADD",55,62,"-52"],["B","ADD",55,63,"-12"],["B","ADD",55,64,"-8"],["B","ADD",55,65,"20"],["B","ADD",55,66,"20"],["B","ADD",55,67,"40"],["B","IDLE_ONE",55,[10]],["B","ADD",55,67,"-40"],["B","ADD",55,66,"-20"],["B","ADD",55,65,"-20"],["B","ADD",55,64,"8"],["B","ADD",55,63,"12"],["B","ADD",55,62,"52"],["B","ADD",55,61,"-20"],["B","ADD",55,60,"8"],["B","ADD",55,59,"12"],["B","ADD",55,58,"52"],["B","ADD",55,57,"-20"],["B","ADD",55,56,"8"],["B","ADD",55,54,"52"],["B","ADD",55,53,"-20"],["B","ADD",55,52,"8"],["B","ADD",55,37,"2"],["B","SCALE",55,"48/5"],["B","ADD",67,55,"-143/384"],["B","ADD",66,55,"53/48"],["B","ADD",65,55,"-43/48"],["B","ADD",64,55,"-17/24"],["B","ADD",63,55,"1"],["B","ADD",62,55,"13/48"],["B","ADD",61,55,"29/16"],["B","ADD",60,55,"61/48"],["B","ADD",59,55,"1"],["B","ADD",58,55,"13/48"],["B","ADD",57,55,"29/16"],["B","ADD",56,55,"61/48"],["B","ADD",54,55,"13/48"],["B","ADD",53,55,"29/16"],["B","ADD",52,55,"61/48"],["B","ADD",37,55,"-31/12"],["B","ADD",36,55,"11/6"],["B","ADD",37,36,"3"],["B","ADD",52,36,"1/2"],["B","ADD",53,36,"1"],["B","ADD",54,36,"1/4"],["B","ADD",55,36,"1/4"],["B","ADD",56,36,"1/2"],["B","ADD",57,36,"1"],["B","ADD",58,36,"1/4"],["B","ADD",59,36,"1/4"],["B","ADD",60,36,"1/2"],["B","ADD",61,36,"1"],["B","ADD",62,36,"1/4"],["B","ADD",63,36,"1/4"],["B","ADD",64,36,"-2"],["B","ADD",65,36,"-3/2"],["B","ADD",67,36,"1/2"],["B","SCALE",36,"2"],["B","ADD",36,52,"4"],["B","ADD",36,53,"-8"],["B","ADD",36,54,"20"],["B","ADD",36,55,"4"],["B","ADD",36,56,"4"],["B","ADD",36,57,"-8"],["B","ADD",36,58,"20"],["B","ADD",36,59,"4"],["B","ADD",36,60,"4"],["B","ADD",36,61,"-8"],["B","ADD",36,62,"20"],["B","ADD",36,63,"4"],["B","ADD",36,64,"4"],["B","ADD",36,65,"-8"],["B","ADD",36,66,"-6"],["B","ADD",36,67,"-16"],["B","ADD",52,37,"-3/4"],["B","ADD",53,37,"-5/4"],["B","ADD",54,37,"-1/4"],["B","ADD",55,37,"-1/2"],["B","ADD",56,37,"-3/4"],["B","ADD",57,37,"-5/4"],["B","ADD",58,37,"-1/4"],["B","ADD",59,37,"-1/2"],["B","ADD",60,37,"-3/4"],["B","ADD",61,37,"-5/4"],["B","ADD",62,37,"-1/4"],["B","ADD",63,37,"-1/2"],["B","ADD",64,37,"3/2"],["B","ADD",65,37,"5/4"],["B","ADD",66,37,"-1/4"],["B","ADD",67,37,"-1/4"],["B","SCALE",37,"1/8"],["B","ADD",37,52,"-2"],["B","ADD",37,53,"7/2"],["B","ADD",37,54,"-17/2"],["B","ADD",37,55,"-3/2"],["B","ADD",37,56,"-2"],["B","ADD",37,57,"7/2"],["B","ADD",37,58,"-17/2"],["B","ADD",37,59,"-3/2"],["B","ADD",37,60,"-2"],["B","ADD",37,61,"7/2"],["B","ADD",37,62,"-17/2"],["B","ADD",37,63,"-3/2"],["B","ADD",37,64,"-2"],["B","ADD",37,65,"7/2"],["B","ADD",37,66,"1"],["B","ADD",37,67,"4"],["B","SCALE",37,"-2"],["B","ADD",37,36,"-1/2"],["B","ADD",37,36,"-1/2"],["B","ADD",36,37,"1"],["B","LAMBDA",36,1],["A","ADD",10,0,"1"],["A","ADD",11,0,"2"],["A","ADD",12,0,"2"],["A","ADD",13,0,"2"],["A","ADD",14,0,"2"],["A","ADD",15,0,"2"],["A","ADD",16,0,"2"],["A","ADD",17,0,"2"],["A","SCALE",0,"-1"],["A","ADD",28,18,"1"],["A","ADD",29,18,"2"],["A","ADD",30,18,"2"],["A","ADD",31,18,"2"],["A","ADD",32,18,"2"],["A","ADD",33,18,"2"],["A","ADD",34,18,"2"],["A","ADD",35,18,"2"],["A","SCALE",18,"-1"],["A","LAMBDA",10,1],["A","LAMBDA",28,-1],["A","SCALE",28,"-1"],["J",10,[10,0,18,28],[36,37,"-1","1/2"]],["A","LAMBDA",10,-1],["A","LAMBDA",28,1],["A","SCALE",28,"-1"],["A","ADD",0,10,"-1"],["A","ADD",18,28,"-1"],["A","SCALE",18,"-1"],["A","ADD",35,18,"-2"],["A","ADD",34,18,"-2"],["A","ADD",33,18,"-2"],["A","ADD",32,18,"-2"],["A","ADD",31,18,"-2"],["A","ADD",30,18,"-2"],["A","ADD",29,18,"-2"],["A","ADD",28,18,"-1"],["A","SCALE",0,"-1"],["A","ADD",17,0,"-2"],["A","ADD",16,0,"-2"],["A","ADD",15,0,"-2"],["A","ADD",14,0,"-2"],["A","ADD",13,0,"-2"],["A","ADD",12,0,"-2"],["A","ADD",11,0,"-2"],["A","ADD",10,0,"-1"],["B","LAMBDA",36,-1],["B","ADD",37,36,"1/2"],["B","SCALE",37,"-1/2"],["B","ADD",37,67,"-4"],["B","ADD",37,66,"-1"],["B","ADD",37,65,"-7/2"],["B","ADD",37,64,"2"],["B","ADD",37,63,"3/2"],["B","ADD",37,62,"17/2"],["B","ADD",37,61,"-7/2"],["B","ADD",37,60,"2"],["B","ADD",37,59,"3/2"],["B","ADD",37,58,"17/2"],["B","ADD",37,57,"-7/2"],["B","ADD",37,56,"2"],["B","ADD",37,55,"3/2"],["B","ADD",37,54,"17/2"],["B","ADD",37,53,"-7/2"],["B","ADD",37,52,"2"],["B","SCALE",37,"8"],["B","ADD",67,37,"1/4"],["B","ADD",66,37,"1/4"],["B","ADD",65,37,"-5/4"],["B","ADD",64,37,"-3/2"],["B","ADD",63,37,"1/2"],["B","ADD",62,37,"1/4"],["B","ADD",61,37,"5/4"],["B","ADD",60,37,"3/4"],["B","ADD",59,37,"1/2"],["B","ADD",58,37,"1/4"],["B","ADD",57,37,"5/4"],["B","ADD",56,37,"3/4"],["B","ADD",55,37,"1/2"],["B","ADD",54,37,"1/4"],["B","ADD",53,37,"5/4"],["B","ADD",52,37,"3/4"],["B","ADD",36,67,"16"],["B","ADD",36,66,"6"],["B","ADD",36,65,"8"],["B","ADD",36,64,"-4"],["B","ADD",36,63,"-4"],["B","ADD",36,62,"-20"],["B","ADD",36,61,"8"],["B","ADD",36,60,"-4"],["B","ADD",36,59,"-4"],["B","ADD",36,58,"-20"],["B","ADD",36,57,"8"],["B","ADD",36,56,"-4"],["B","ADD",36,55,"-4"],["B","ADD",36,54,"-20"],["B","ADD",36,53,"8"],["B","ADD",36,52,"-4"],["B","SCALE",36,"1/2"],["B","ADD",67,36,"-1/2"],["B","ADD",65,36,"3/2"],["B","ADD",64,36,"2"],["B","ADD",63,36,"-1/4"],["B","ADD",62,36,"-1/4"],["B","ADD",61,36,"-1"],["B","ADD",60,36,"-1/2"],["B","ADD",59,36,"-1/4"],["B","ADD",58,36,"-1/4"],["B","ADD",57,36,"-1"],["B","ADD",56,36,"-1/2"],["B","ADD",55,36,"-1/4"],["B","ADD",54,36,"-1/4"],["B","ADD",53,36,"-1"],["B","ADD",52,36,"-1/2"],["B","ADD",37,36,"-3"],["B","ADD",37,36,"2/3"],["B","ADD",52,36,"-5/4"],["B","ADD",53,36,"-23/12"],["B","ADD",54,36,"-1/3"],["B","ADD",55,36,"-11/12"],["B","ADD",56,36,"-5/4"],["B","ADD",57,36,"-23/12"],["B","ADD",58,36,"-1/3"],["B","ADD",59,36,"-11/12"],["B","ADD",60,36,"-5/4"],["B","ADD",61,36,"-23/12"],["B","ADD",62,36,"-1/3"],["B","ADD",63,36,"-11/12"],["B","ADD",64,36,"-1/3"],["B","SCALE",36,"2/3"],["B","ADD",36,37,"-12"],["B","ADD",36,52,"-52"],["B","ADD",36,53,"128"],["B","ADD",36,54,"-332"],["B","ADD",36,55,"-76"],["B","ADD",36,56,"-52"],["B","ADD",36,57,"128"],["B","ADD",36,58,"-332"],["B","ADD",36,59,"-76"],["B","ADD",36,60,"-52"],["B","ADD",36,61,"128"],["B","ADD",36,62,"-332"],["B","ADD",36,63,"-76"],["B","ADD",36,64,"-28"],["B","ADD",36,65,"76"],["B","IDLE_ONE",36,[11]],["B","ADD",36,65,"-76"],["B","ADD",36,64,"28"],["B","ADD",36,63,"76"],["B","ADD",36,62,"332"],["B","ADD",36,61,"-128"],["B","ADD",36,60,"52"],["B","ADD",36,59,"76"],["B","ADD",36,58,"332"],["B","ADD",36,57,"-128"],["B","ADD",36,56,"52"],["B","ADD",36,55,"76"],["B","ADD",36,54,"332"],["B","ADD",36,53,"-128"],["B","ADD",36,52,"52"],["B","ADD",36,37,"12"],["B","SCALE",36,"3/2"],["B","ADD",64,36,"1/3"],["B","ADD",63,36,"11/12"],["B","ADD",62,36,"1/3"],["B","ADD",61,36,"23/12"],["B","ADD",60,36,"5/4"],["B","ADD",59,36,"11/12"],["B","ADD",58,36,"1/3"],["B","ADD",57,36,"23/12"],["B","ADD",56,36,"5/4"],["B","ADD",55,36,"11/12"],["B","ADD",54,36,"1/3"],["B","ADD",53,36,"23/12"],["B","ADD",52,36,"5/4"],["B","ADD",37,36,"-2/3"],["B","ADD",36,53,"-14/27"],["B","ADD",37,53,"46/135"],["B","ADD",52,53,"-88/135"],["B","ADD",54,53,"-47/270"],["B","ADD",55,53,"-43/90"],["B","ADD",56,53,"-88/135"],["B","ADD",57,53,"-1"],["B","ADD",58,53,"-47/270"],["B","ADD",59,53,"-43/90"],["B","ADD",60,53,"-88/135"],["B","ADD",61,53,"-1"],["B","ADD",62,53,"-47/270"],["B","ADD",63,53,"-43/90"],["B","ADD",64,53,"-22/135"],["B","ADD",65,53,"1/135"],["B","SCALE",53,"-4/135"],["B","ADD",53,37,"-1"],["B","ADD",53,52,"-4"],["B","ADD",53,54,"-26"],["B","ADD",53,55,"-6"],["B","ADD",53,56,"-4"],["B","ADD",53,57,"10"],["B","ADD",53,58,"-26"],["B","ADD",53,59,"-6"],["B","ADD",53,60,"-4"],["B","ADD",53,61,"10"],["B","ADD",53,62,"-26"],["B","ADD",53,63,"-6"],["B","ADD",53,64,"-2"],["B","ADD",53,65,"6"],["B","IDLE_ONE",53,[11]],["B","ADD",53,65,"-6"],["B","ADD",53,64,"2"],["B","ADD",53,63,"6"],["B","ADD",53,62,"26"],["B","ADD",53,61,"-10"],["B","ADD",53,60,"4"],["B","ADD",53,59,"6"],["B","ADD",53,58,"26"],["B","ADD",53,57,"-10"],["B","ADD",53,56,"4"],["B","ADD",53,55,"6"],["B","ADD",53,54,"26"],["B","ADD",53,52,"4"],["B","ADD",53,37,"1"],["B","SCALE",53,"-135/4"],["B","ADD",65,53,"-1/135"],["B","ADD",64,53,"22/135"],["B","ADD",63,53,"43/90"],["B","ADD",62,53,"47/270"],["B","ADD",61,53,"1"],["B","ADD",60,53,"88/135"],["B","ADD",59,53,"43/90"],["B","ADD",58,53,"47/270"],["B","ADD",57,53,"1"],["B","ADD",56,53,"88/135"],["B","ADD",55,53,"43/90"],["B","ADD",54,53,"47/270"],["B","ADD",52,53,"88/135"],["B","ADD",37,53,"-46/135"],["B","ADD",36,53,"14/27"],["B","ADD",37,36,"3"],["B","ADD",52,36,"1/2"],["B","ADD",53,36,"1"],["B","ADD",54,36,"1/4"],["B","ADD",55,36,"1/4"],["B","ADD",56,36,"1/2"],["B","ADD",57,36,"1"],["B","ADD",58,36,"1/4"],["B","ADD",59,36,"1/4"],["B","ADD",60,36,"1/2"],["B","ADD",61,36,"1"],["B","ADD",62,36,"1/4"],["B","ADD",63,36,"1/4"],["B","ADD",65,36,"1/2"],["B","SCALE",36,"-2"],["B","ADD",36,52,"-4"],["B","ADD",36,53,"8"],["B","ADD",36,54,"-20"],["B","ADD",36,55,"-4"],["B","ADD",36,56,"-4"],["B","ADD",36,57,"8"],["B","ADD",36,58,"-20"],["B","ADD",36,59,"-4"],["B","ADD",36,60,"-4"],["B","ADD",36,61,"8"],["B","ADD",36,62,"-20"],["B","ADD",36,63,"-4"],["B","ADD",36,64,"-6"],["B","ADD",36,65,"8"],["B","ADD",52,37,"-3/4"],["B","ADD",53,37,"-5/4"],["B","ADD",54,37,"-1/4"],["B","ADD",55,37,"-1/2"],["B","ADD",56,37,"-3/4"],["B","ADD",57,37,"-5/4"],["B","ADD",58,37,"-1/4"],["B","ADD",59,37,"-1/2"],["B","ADD",60,37,"-3/4"],["B","ADD",61,37,"-5/4"],["B","ADD",62,37,"-1/4"],["B","ADD",63,37,"-1/2"],["B","ADD",64,37,"-1/4"],["B","ADD",65,37,"-1/4"],["B","SCALE",37,"-1/8"],["B","ADD",37,52,"-2"],["B","ADD",37,53,"9/2"],["B","ADD",37,54,"-23/2"],["B","ADD",37,55,"-5/2"],["B","ADD",37,56,"-2"],["B","ADD",37,57,"9/2"],["B","ADD",37,58,"-23/2"],["B","ADD",37,59,"-5/2"],["B","ADD",37,60,"-2"],["B","ADD",37,61,"9/2"],["B","ADD",37,62,"-23/2"],["B","ADD",37,63,"-5/2"],["B","ADD",37,64,"-2"],["B","ADD",37,65,"5/2"],["B","SCALE",37,"2"],["B","ADD",37,36,"-1/2"],["B","ADD",37,36,"-1/2"],["B","ADD",36,37,"1"],["B","LAMBDA",36,1],["A","ADD",11,0,"1"],["A","ADD",12,0,"2"],["A","ADD",13,0,"2"],["A","ADD",14,0,"2"],["A","ADD",15,0,"2"],["A","ADD",16,0,"2"],["A","ADD",17,0,"2"],["A","SCALE",0,"-1"],["A","ADD",29,18,"1"],["A","ADD",30,18,"2"],["A","ADD",31,18,"2"],["A","ADD",32,18,"2"],["A","ADD",33,18,"2"],["A","ADD",34,18,"2"],["A","ADD",35,18,"2"],["A","SCALE",18,"-1"],["A","LAMBDA",11,1],["A","LAMBDA",29,-1],["A","SCALE",29,"-1"],["J",11,[11,0,18,29],[36,37,"-1","1/2"]],["A","LAMBDA",11,-1],["A","LAMBDA",29,1],["A","SCALE",29,"-1"],["A","ADD",0,11,"-1"],["A","ADD",18,29,"-1"],["A","SCALE",18,"-1"],["A","ADD",35,18,"-2"],["A","ADD",34,18,"-2"],["A","ADD",33,18,"-2"],["A","ADD",32,18,"-2"],["A","ADD",31,18,"-2"],["A","ADD",30,18,"-2"],["A","ADD",29,18,"-1"],["A","SCALE",0,"-1"],["A","ADD",17,0,"-2"],["A","ADD",16,0,"-2"],["A","ADD",15,0,"-2"],["A","ADD",14,0,"-2"],["A","ADD",13,0,"-2"],["A","ADD",12,0,"-2"],["A","ADD",11,0,"-1"],["B","LAMBDA",36,-1],["B","ADD",37,36,"1/2"],["B","SCALE",37,"1/2"],["B","ADD",37,65,"-5/2"],["B","ADD",37,64,"2"],["B","ADD",37,63,"5/2"],["B","ADD",37,62,"23/2"],["B","ADD",37,61,"-9/2"],["B","ADD",37,60,"2"],["B","ADD",37,59,"5/2"],["B","ADD",37,58,"23/2"],["B","ADD",37,57,"-9/2"],["B","ADD",37,56,"2"],["B","ADD",37,55,"5/2"],["B","ADD",37,54,"23/2"],["B","ADD",37,53,"-9/2"],["B","ADD",37,52,"2"],["B","SCALE",37,"-8"],["B","ADD",65,37,"1/4"],["B","ADD",64,37,"1/4"],["B","ADD",63,37,"1/2"],["B","ADD",62,37,"1/4"],["B","ADD",61,37,"5/4"],["B","ADD",60,37,"3/4"],["B","ADD",59,37,"1/2"],["B","ADD",58,37,"1/4"],["B","ADD",57,37,"5/4"],["B","ADD",56,37,"3/4"],["B","ADD",55,37,"1/2"],["B","ADD",54,37,"1/4"],["B","ADD",53,37,"5/4"],["B","ADD",52,37,"3/4"],["B","ADD",36,65,"-8"],["B","ADD",36,64,"6"],["B","ADD",36,63,"4"],["B","ADD",36,62,"20"],["B","ADD",36,61,"-8"],["B","ADD",36,60,"4"],["B","ADD",36,59,"4"],["B","ADD",36,58,"20"],["B","ADD",36,57,"-8"],["B","ADD",36,56,"4"],["B","ADD",36,55,"4"],["B","ADD",36,54,"20"],["B","ADD",36,53,"-8"],["B","ADD",36,52,"4"],["B","SCALE",36,"-1/2"],["B","ADD",65,36,"-1/2"],["B","ADD",63,36,"-1/4"],["B","ADD",62,36,"-1/4"],["B","ADD",61,36,"-1"],["B","ADD",60,36,"-1/2"],["B","ADD",59,36,"-1/4"],["B","ADD",58,36,"-1/4"],["B","ADD",57,36,"-1"],["B","ADD",56,36,"-1/2"],["B","ADD",55,36,"-1/4"],["B","ADD",54,36,"-1/4"],["B","ADD",53,36,"-1"],["B","ADD",52,36,"-1/2"],["B","ADD",37,36,"-3"],["B","ADD",36,52,"14"],["B","ADD",37,52,"-34"],["B","ADD",53,52,"-4"],["B","ADD",54,52,"-3/2"],["B","ADD",55,52,"1/2"],["B","ADD",56,52,"-1"],["B","ADD",57,52,"-4"],["B","ADD",58,52,"-3/2"],["B","ADD",59,52,"1/2"],["B","ADD",60,52,"-1"],["B","ADD",61,52,"-4"],["B","ADD",62,52,"-1/2"],["B","ADD",63,52,"1"],["B","SCALE",52,"-1"],["B","ADD",52,36,"1"],["B","ADD",52,37,"1"],["B","ADD",52,53,"-6"],["B","ADD",52,54,"16"],["B","ADD",52,55,"4"],["B","ADD",52,56,"2"],["B","ADD",52,57,"-6"],["B","ADD",52,58,"16"],["B","ADD",52,59,"4"],["B","ADD",52,60,"2"],["B","ADD",52,61,"-6"],["B","ADD",52,62,"14"],["B","ADD",52,63,"6"],["B","IDLE_ONE",52,[12]],["B","ADD",52,63,"-6"],["B","ADD",52,62,"-14"],["B","ADD",52,61,"6"],["B","ADD",52,60,"-2"],["B","ADD",52,59,"-4"],["B","ADD",52,58,"-16"],["B","ADD",52,57,"6"],["B","ADD",52,56,"-2"],["B","ADD",52,55,"-4"],["B","ADD",52,54,"-16"],["B","ADD",52,53,"6"],["B","ADD",52,37,"-1"],["B","ADD",52,36,"-1"],["B","SCALE",52,"-1"],["B","ADD",63,52,"-1"],["B","ADD",62,52,"1/2"],["B","ADD",61,52,"4"],["B","ADD",60,52,"1"],["B","ADD",59,52,"-1/2"],["B","ADD",58,52,"3/2"],["B","ADD",57,52,"4"],["B","ADD",56,52,"1"],["B","ADD",55,52,"-1/2"],["B","ADD",54,52,"3/2"],["B","ADD",53,52,"4"],["B","ADD",37,52,"34"],["B","ADD",36,52,"-14"],["B","ADD",37,36,"5/2"],["B","ADD",52,36,"1/8"],["B","ADD",53,36,"3/8"],["B","ADD",54,36,"1/8"],["B","ADD",56,36,"1/8"],["B","ADD",57,36,"3/8"],["B","ADD",58,36,"1/8"],["B","ADD",60,36,"1/8"],["B","ADD",61,36,"3/8"],["B","ADD",62,36,"1/16"],["B","ADD",63,36,"-1/16"],["B","SCALE",36,"1/8"],["B","ADD",36,37,"-1"],["B","ADD",36,52,"-4"],["B","ADD",36,53,"10"],["B","ADD",36,54,"-26"],["B","ADD",36,55,"-6"],["B","ADD",36,56,"-4"],["B","ADD",36,57,"10"],["B","ADD",36,58,"-26"],["B","ADD",36,59,"-6"],["B","ADD",36,60,"-4"],["B","ADD",36,61,"10"],["B","ADD",36,62,"-24"],["B","ADD",36,63,"-10"],["B","IDLE_ONE",36,[12]],["B","ADD",36,63,"10"],["B","ADD",36,62,"24"],["B","ADD",36,61,"-10"],["B","ADD",36,60,"4"],["B","ADD",36,59,"6"],["B","ADD",36,58,"26"],["B","ADD",36,57,"-10"],["B","ADD",36,56,"4"],["B","ADD",36,55,"6"],["B","ADD",36,54,"26"],["B","ADD",36,53,"-10"],["B","ADD",36,52,"4"],["B","ADD",36,37,"1"],["B","SCALE",36,"8"],["B","ADD",63,36,"1/16"],["B","ADD",62,36,"-1/16"],["B","ADD",61,36,"-3/8"],["B","ADD",60,36,"-1/8"],["B","ADD",58,36,"-1/8"],["B","ADD",57,36,"-3/8"],["B","ADD",56,36,"-1/8"],["B","ADD",54,36,"-1/8"],["B","ADD",53,36,"-3/8"],["B","ADD",52,36,"-1/8"],["B","ADD",37,36,"-5/2"],["B","SWAP",36,37],["B","ADD",52,36,"-3/4"],["B","ADD",53,36,"-5/4"],["B","ADD",54,36,"-1/4"],["B","ADD",55,36,"-1/2"],["B","ADD",56,36,"-3/4"],["B","ADD",57,36,"-5/4"],["B","ADD",58,36,"-1/4"],["B","ADD",59,36,"-1/2"],["B","ADD",60,36,"-3/4"],["B","ADD",61,36,"-5/4"],["B","ADD",62,36,"-1/4"],["B","ADD",63,36,"-1/4"],["B","SCALE",36,"-1/2"],["B","ADD",36,37,"1/2"],["B","ADD",36,52,"1"],["B","ADD",36,53,"-3"],["B","ADD",36,54,"8"],["B","ADD",36,55,"2"],["B","ADD",36,56,"1"],["B","ADD",36,57,"-3"],["B","ADD",36,58,"8"],["B","ADD",36,59,"2"],["B","ADD",36,60,"1"],["B","ADD",36,61,"-3"],["B","ADD",36,62,"6"],["B","ADD",36,63,"2"],["B","ADD",52,37,"-7/4"],["B","ADD",53,37,"-11/4"],["B","ADD",54,37,"-1/2"],["B","ADD",55,37,"-5/4"],["B","ADD",56,37,"-7/4"],["B","ADD",57,37,"-11/4"],["B","ADD",58,37,"-1/2"],["B","ADD",59,37,"-5/4"],["B","ADD",60,37,"-7/4"],["B","ADD",61,37,"-11/4"],["B","ADD",62,37,"-3/4"],["B","ADD",63,37,"-1/4"],["B","SCALE",37,"1/2"],["B","ADD",37,52,"-1"],["B","ADD",37,53,"1"],["B","ADD",37,54,"-2"],["B","ADD",37,56,"-1"],["B","ADD",37,57,"1"],["B","ADD",37,58,"-2"],["B","ADD",37,60,"-1"],["B","ADD",37,61,"1"],["B","ADD",37,62,"-2"],["B","ADD",37,63,"-2"],["B","SCALE",37,"-1/2"],["B","ADD",37,36,"-1/2"],["B","ADD",36,37,"1"],["B","LAMBDA",36,1],["A","ADD",12,0,"1"],["A","ADD",13,0,"2"],["A","ADD",14,0,"2"],["A","ADD",15,0,"2"],["A","ADD",16,0,"2"],["A","ADD",17,0,"2"],["A","SCALE",0,"-1"],["A","ADD",30,18,"1"],["A","ADD",31,18,"2"],["A","ADD",32,18,"2"],["A","ADD",33,18,"2"],["A","ADD",34,18,"2"],["A","ADD",35,18,"2"],["A","SCALE",18,"-1"],["A","LAMBDA",12,1],["A","LAMBDA",30,-1],["A","SCALE",30,"-1"],["J",12,[12,0,18,30],[36,37,"-1","1/2"]],["A","LAMBDA",12,-1],["A","LAMBDA",30,1],["A","SCALE",30,"-1"],["A","ADD",0,12,"-1"],["A","ADD",18,30,"-1"],["A","SCALE",18,"-1"],["A","ADD",35,18,"-2"],["A","ADD",34,18,"-2"],["A","ADD",33,18,"-2"],["A","ADD",32,18,"-2"],["A","ADD",31,18,"-2"],["A","ADD",30,18,"-1"],["A","SCALE",0,"-1"],["A","ADD",17,0,"-2"],["A","ADD",16,0,"-2"],["A","ADD",15,0,"-2"],["A","ADD",14,0,"-2"],["A","ADD",13,0,"-2"],["A","ADD",12,0,"-1"],["B","LAMBDA",36,-1],["B","SCALE",37,"-2"],["B","ADD",37,63,"2"],["B","ADD",37,62,"2"],["B","ADD",37,61,"-1"],["B","ADD",37,60,"1"],["B","ADD",37,58,"2"],["B","ADD",37,57,"-1"],["B","ADD",37,56,"1"],["B","ADD",37,54,"2"],["B","ADD",37,53,"-1"],["B","ADD",37,52,"1"],["B","SCALE",37,"2"],["B","ADD",63,37,"1/4"],["B","ADD",62,37,"3/4"],["B","ADD",61,37,"11/4"],["B","ADD",60,37,"7/4"],["B","ADD",59,37,"5/4"],["B","ADD",58,37,"1/2"],["B","ADD",57,37,"11/4"],["B","ADD",56,37,"7/4"],["B","ADD",55,37,"5/4"],["B","ADD",54,37,"1/2"],["B","ADD",53,37,"11/4"],["B","ADD",52,37,"7/4"],["B","ADD",36,63,"-2"],["B","ADD",36,62,"-6"],["B","ADD",36,61,"3"],["B","ADD",36,60,"-1"],["B","ADD",36,59,"-2"],["B","ADD",36,58,"-8"],["B","ADD",36,57,"3"],["B","ADD",36,56,"-1"],["B","ADD",36,55,"-2"],["B","ADD",36,54,"-8"],["B","ADD",36,53,"3"],["B","ADD",36,52,"-1"],["B","ADD",36,37,"-1/2"],["B","SCALE",36,"-2"],["B","ADD",63,36,"1/4"],["B","ADD",62,36,"1/4"],["B","ADD",61,36,"5/4"],["B","ADD",60,36,"3/4"],["B","ADD",59,36,"1/2"],["B","ADD",58,36,"1/4"],["B","ADD",57,36,"5/4"],["B","ADD",56,36,"3/4"],["B","ADD",55,36,"1/2"],["B","ADD",54,36,"1/4"],["B","ADD",53,36,"5/4"],["B","ADD",52,36,"3/4"],["B","SWAP",36,37],["B","ADD",37,36,"7/4"],["B","ADD",52,36,"-7/16"],["B","ADD",53,36,"-9/16"],["B","ADD",54,36,"-1/16"],["B","ADD",55,36,"-3/8"],["B","ADD",56,36,"-7/16"],["B","ADD",57,36,"-9/16"],["B","ADD",58,36,"-1/16"],["B","ADD",59,36,"-3/8"],["B","ADD",60,36,"-1/8"],["B","ADD",61,36,"1/4"],["B","SCALE",36,"-1/4"],["B","ADD",36,52,"2"],["B","ADD",36,53,"-4"],["B","ADD",36,54,"10"],["B","ADD",36,55,"2"],["B","ADD",36,56,"2"],["B","ADD",36,57,"-4"],["B","ADD",36,58,"10"],["B","ADD",36,59,"2"],["B","ADD",36,60,"2"],["B","ADD",36,61,"-2"],["B","IDLE_ONE",36,[13]],["B","ADD",36,61,"2"],["B","ADD",36,60,"-2"],["B","ADD",36,59,"-2"],["B","ADD",36,58,"-10"],["B","ADD",36,57,"4"],["B","ADD",36,56,"-2"],["B","ADD",36,55,"-2"],["B","ADD",36,54,"-10"],["B","ADD",36,53,"4"],["B","ADD",36,52,"-2"],["B","SCALE",36,"-4"],["B","ADD",61,36,"-1/4"],["B","ADD",60,36,"1/8"],["B","ADD",59,36,"3/8"],["B","ADD",58,36,"1/16"],["B","ADD",57,36,"9/16"],["B","ADD",56,36,"7/16"],["B","ADD",55,36,"3/8"],["B","ADD",54,36,"1/16"],["B","ADD",53,36,"9/16"],["B","ADD",52,36,"7/16"],["B","ADD",37,36,"-7/4"],["B","ADD",37,36,"2"],["B","ADD",52,36,"-1/4"],["B","ADD",53,36,"-1/4"],["B","ADD",55,36,"-1/4"],["B","ADD",56,36,"-1/4"],["B","ADD",57,36,"-1/4"],["B","ADD",59,36,"-1/4"],["B","ADD",61,36,"1/2"],["B","ADD",36,37,"1"],["B","ADD",36,52,"4"],["B","ADD",36,53,"-10"],["B","ADD",36,54,"26"],["B","ADD",36,55,"6"],["B","ADD",36,56,"4"],["B","ADD",36,57,"-10"],["B","ADD",36,58,"26"],["B","ADD",36,59,"6"],["B","ADD",36,60,"2"],["B","ADD",36,61,"-6"],["B","IDLE_ONE",36,[13]],["B","ADD",36,61,"6"],["B","ADD",36,60,"-2"],["B","ADD",36,59,"-6"],["B","ADD",36,58,"-26"],["B","ADD",36,57,"10"],["B","ADD",36,56,"-4"],["B","ADD",36,55,"-6"],["B","ADD",36,54,"-26"],["B","ADD",36,53,"10"],["B","ADD",36,52,"-4"],["B","ADD",36,37,"-1"],["B","ADD",61,36,"-1/2"],["B","ADD",59,36,"1/4"],["B","ADD",57,36,"1/4"],["B","ADD",56,36,"1/4"],["B","ADD",55,36,"1/4"],["B","ADD",53,36,"1/4"],["B","ADD",52,36,"1/4"],["B","ADD",37,36,"-2"],["B","ADD",37,36,"2"],["B","ADD",52,36,"-1/4"],["B","ADD",53,36,"-1/4"],["B","ADD",55,36,"-1/4"],["B","ADD",56,36,"-1/4"],["B","ADD",57,36,"-1/4"],["B","ADD",59,36,"-1/4"],["B","ADD",60,36,"-1/4"],["B","ADD",61,36,"1/4"],["B","SCALE",36,"-1/2"],["B","ADD",36,37,"1/2"],["B","ADD",36,52,"-1"],["B","ADD",36,53,"1"],["B","ADD",36,54,"-2"],["B","ADD",36,56,"-1"],["B","ADD",36,57,"1"],["B","ADD",36,58,"-2"],["B","ADD",36,60,"-3"],["B","ADD",36,61,"1"],["B","ADD",52,37,"-3/4"],["B","ADD",53,37,"-5/4"],["B","ADD",54,37,"-1/4"],["B","ADD",55,37,"-1/2"],["B","ADD",56,37,"-3/4"],["B","ADD",57,37,"-5/4"],["B","ADD",58,37,"-1/4"],["B","ADD",59,37,"-1/2"],["B","ADD",60,37,"-1/4"],["B","ADD",61,37,"-1/4"],["B","SCALE",37,"-1/2"],["B","ADD",37,52,"-1"],["B","ADD",37,53,"3"],["B","ADD",37,54,"-8"],["B","ADD",37,55,"-2"],["B","ADD",37,56,"-1"],["B","ADD",37,57,"3"],["B","ADD",37,58,"-8"],["B","ADD",37,59,"-2"],["B","ADD",37,60,"-1"],["B","ADD",37,61,"1"],["B","SCALE",37,"1/2"],["B","ADD",37,36,"-1/2"],["B","ADD",36,37,"1"],["B","LAMBDA",36,1],["A","ADD",13,0,"1"],["A","ADD",14,0,"2"],["A","ADD",15,0,"2"],["A","ADD",16,0,"2"],["A","ADD",17,0,"2"],["A","SCALE",0,"-1"],["A","ADD",31,18,"1"],["A","ADD",32,18,"2"],["A","ADD",33,18,"2"],["A","ADD",34,18,"2"],["A","ADD",35,18,"2"],["A","SCALE",18,"-1"],["A","LAMBDA",13,1],["A","LAMBDA",31,-1],["A","SCALE",31,"-1"],["J",13,[13,0,18,31],[36,37,"-1","1/2"]],["A","LAMBDA",13,-1],["A","LAMBDA",31,1],["A","SCALE",31,"-1"],["A","ADD",0,13,"-1"],["A","ADD",18,31,"-1"],["A","SCALE",18,"-1"],["A","ADD",35,18,"-2"],["A","ADD",34,18,"-2"],["A","ADD",33,18,"-2"],["A","ADD",32,18,"-2"],["A","ADD",31,18,"-1"],["A","SCALE",0,"-1"],["A","ADD",17,0,"-2"],["A","ADD",16,0,"-2"],["A","ADD",15,0,"-2"],["A","ADD",14,0,"-2"],["A","ADD",13,0,"-1"],["B","LAMBDA",36,-1],["B","SCALE",37,"2"],["B","ADD",37,61,"-1"],["B","ADD",37,60,"1"],["B","ADD",37,59,"2"],["B","ADD",37,58,"8"],["B","ADD",37,57,"-3"],["B","ADD",37,56,"1"],["B","ADD",37,55,"2"],["B","ADD",37,54,"8"],["B","ADD",37,53,"-3"],["B","ADD",37,52,"1"],["B","SCALE",37,"-2"],["B","ADD",61,37,"1/4"],["B","ADD",60,37,"1/4"],["B","ADD",59,37,"1/2"],["B","ADD",58,37,"1/4"],["B","ADD",57,37,"5/4"],["B","ADD",56,37,"3/4"],["B","ADD",55,37,"1/2"],["B","ADD",54,37,"1/4"],["B","ADD",53,37,"5/4"],["B","ADD",52,37,"3/4"],["B","ADD",36,61,"-1"],["B","ADD",36,60,"3"],["B","ADD",36,58,"2"],["B","ADD",36,57,"-1"],["B","ADD",36,56,"1"],["B","ADD",36,54,"2"],["B","ADD",36,53,"-1"],["B","ADD",36,52,"1"],["B","ADD",36,37,"-1/2"],["B","SCALE",36,"-2"],["B","ADD",61,36,"-1/4"],["B","ADD",60,36,"1/4"],["B","ADD",59,36,"1/4"],["B","ADD",57,36,"1/4"],["B","ADD",56,36,"1/4"],["B","ADD",55,36,"1/4"],["B","ADD",53,36,"1/4"],["B","ADD",52,36,"1/4"],["B","ADD",37,36,"-2"],["B","ADD",36,52,"14"],["B","ADD",37,52,"-34"],["B","ADD",53,52,"-4"],["B","ADD",54,52,"-3/2"],["B","ADD",55,52,"1/2"],["B","ADD",56,52,"-1"],["B","ADD",57,52,"-4"],["B","ADD",58,52,"-1/2"],["B","ADD",59,52,"1"],["B","SCALE",52,"-1"],["B","ADD",52,36,"1"],["B","ADD",52,37,"1"],["B","ADD",52,53,"-6"],["B","ADD",52,54,"16"],["B","ADD",52,55,"4"],["B","ADD",52,56,"2"],["B","ADD",52,57,"-6"],["B","ADD",52,58,"14"],["B","ADD",52,59,"6"],["B","IDLE_ONE",52,[14]],["B","ADD",52,59,"-6"],["B","ADD",52,58,"-14"],["B","ADD",52,57,"6"],["B","ADD",52,56,"-2"],["B","ADD",52,55,"-4"],["B","ADD",52,54,"-16"],["B","ADD",52,53,"6"],["B","ADD",52,37,"-1"],["B","ADD",52,36,"-1"],["B","SCALE",52,"-1"],["B","ADD",59,52,"-1"],["B","ADD",58,52,"1/2"],["B","ADD",57,52,"4"],["B","ADD",56,52,"1"],["B","ADD",55,52,"-1/2"],["B","ADD",54,52,"3/2"],["B","ADD",53,52,"4"],["B","ADD",37,52,"34"],["B","ADD",36,52,"-14"],["B","ADD",37,36,"5/2"],["B","ADD",52,36,"1/8"],["B","ADD",53,36,"3/8"],["B","ADD",54,36,"1/8"],["B","ADD",56,36,"1/8"],["B","ADD",57,36,"3/8"],["B","ADD",58,36,"1/16"],["B","ADD",59,36,"-1/16"],["B","SCALE",36,"1/8"],["B","ADD",36,37,"-1"],["B","ADD",36,52,"-4"],["B","ADD",36,53,"10"],["B","ADD",36,54,"-26"],["B","ADD",36,55,"-6"],["B","ADD",36,56,"-4"],["B","ADD",36,57,"10"],["B","ADD",36,58,"-24"],["B","ADD",36,59,"-10"],["B","IDLE_ONE",36,[14]],["B","ADD",36,59,"10"],["B","ADD",36,58,"24"],["B","ADD",36,57,"-10"],["B","ADD",36,56,"4"],["B","ADD",36,55,"6"],["B","ADD",36,54,"26"],["B","ADD",36,53,"-10"],["B","ADD",36,52,"4"],["B","ADD",36,37,"1"],["B","SCALE",36,"8"],["B","ADD",59,36,"1/16"],["B","ADD",58,36,"-1/16"],["B","ADD",57,36,"-3/8"],["B","ADD",56,36,"-1/8"],["B","ADD",54,36,"-1/8"],["B","ADD",53,36,"-3/8"],["B","ADD",52,36,"-1/8"],["B","ADD",37,36,"-5/2"],["B","SWAP",36,37],["B","ADD",52,36,"-3/4"],["B","ADD",53,36,"-5/4"],["B","ADD",54,36,"-1/4"],["B","ADD",55,36,"-1/2"],["B","ADD",56,36,"-3/4"],["B","ADD",57,36,"-5/4"],["B","ADD",58,36,"-1/4"],["B","ADD",59,36,"-1/4"],["B","SCALE",36,"-1/2"],["B","ADD",36,37,"1/2"],["B","ADD",36,52,"1"],["B","ADD",36,53,"-3"],["B","ADD",36,54,"8"],["B","ADD",36,55,"2"],["B","ADD",36,56,"1"],["B","ADD",36,57,"-3"],["B","ADD",36,58,"6"],["B","ADD",36,59,"2"],["B","ADD",52,37,"-7/4"],["B","ADD",53,37,"-11/4"],["B","ADD",54,37,"-1/2"],["B","ADD",55,37,"-5/4"],["B","ADD",56,37,"-7/4"],["B","ADD",57,37,"-11/4"],["B","ADD",58,37,"-3/4"],["B","ADD",59,37,"-1/4"],["B","SCALE",37,"1/2"],["B","ADD",37,52,"-1"],["B","ADD",37,53,"1"],["B","ADD",37,54,"-2"],["B","ADD",37,56,"-1"],["B","ADD",37,57,"1"],["B","ADD",37,58,"-2"],["B","ADD",37,59,"-2"],["B","SCALE",37,"-1/2"],["B","ADD",37,36,"-1/2"],["B","ADD",36,37,"1"],["B","LAMBDA",36,1],["A","ADD",14,0,"1"],["A","ADD",15,0,"2"],["A","ADD",16,0,"2"],["A","ADD",17,0,"2"],["A","SCALE",0,"-1"],["A","ADD",32,18,"1"],["A","ADD",33,18,"2"],["A","ADD",34,18,"2"],["A","ADD",35,18,"2"],["A","SCALE",18,"-1"],["A","LAMBDA",14,1],["A","LAMBDA",32,-1],["A","SCALE",32,"-1"],["J",14,[14,0,18,32],[36,37,"-1","1/2"]],["A","LAMBDA",14,-1],["A","LAMBDA",32,1],["A","SCALE",32,"-1"],["A","ADD",0,14,"-1"],["A","ADD",18,32,"-1"],["A","SCALE",18,"-1"],["A","ADD",35,18,"-2"],["A","ADD",34,18,"-2"],["A","ADD",33,18,"-2"],["A","ADD",32,18,"-1"],["A","SCALE",0,"-1"],["A","ADD",17,0,"-2"],["A","ADD",16,0,"-2"],["A","ADD",15,0,"-2"],["A","ADD",14,0,"-1"],["B","LAMBDA",36,-1],["B","SCALE",37,"-2"],["B","ADD",37,59,"2"],["B","ADD",37,58,"2"],["B","ADD",37,57,"-1"],["B","ADD",37,56,"1"],["B","ADD",37,54,"2"],["B","ADD",37,53,"-1"],["B","ADD",37,52,"1"],["B","SCALE",37,"2"],["B","ADD",59,37,"1/4"],["B","ADD",58,37,"3/4"],["B","ADD",57,37,"11/4"],["B","ADD",56,37,"7/4"],["B","ADD",55,37,"5/4"],["B","ADD",54,37,"1/2"],["B","ADD",53,37,"11/4"],["B","ADD",52,37,"7/4"],["B","ADD",36,59,"-2"],["B","ADD",36,58,"-6"],["B","ADD",36,57,"3"],["B","ADD",36,56,"-1"],["B","ADD",36,55,"-2"],["B","ADD",36,54,"-8"],["B","ADD",36,53,"3"],["B","ADD",36,52,"-1"],["B","ADD",36,37,"-1/2"],["B","SCALE",36,"-2"],["B","ADD",59,36,"1/4"],["B","ADD",58,36,"1/4"],["B","ADD",57,36,"5/4"],["B","ADD",56,36,"3/4"],["B","ADD",55,36,"1/2"],["B","ADD",54,36,"1/4"],["B","ADD",53,36,"5/4"],["B","ADD",52,36,"3/4"],["B","SWAP",36,37],["B","ADD",37,36,"7/4"],["B","ADD",52,36,"-7/16"],["B","ADD",53,36,"-9/16"],["B","ADD",54,36,"-1/16"],["B","ADD",55,36,"-3/8"],["B","ADD",56,36,"-1/8"],["B","ADD",57,36,"1/4"],["B","SCALE",36,"-1/4"],["B","ADD",36,52,"2"],["B","ADD",36,53,"-4"],["B","ADD",36,54,"10"],["B","ADD",36,55,"2"],["B","ADD",36,56,"2"],["B","ADD",36,57,"-2"],["B","IDLE_ONE",36,[15]],["B","ADD",36,57,"2"],["B","ADD",36,56,"-2"],["B","ADD",36,55,"-2"],["B","ADD",36,54,"-10"],["B","ADD",36,53,"4"],["B","ADD",36,52,"-2"],["B","SCALE",36,"-4"],["B","ADD",57,36,"-1/4"],["B","ADD",56,36,"1/8"],["B","ADD",55,36,"3/8"],["B","ADD",54,36,"1/16"],["B","ADD",53,36,"9/16"],["B","ADD",52,36,"7/16"],["B","ADD",37,36,"-7/4"],["B","ADD",37,36,"2"],["B","ADD",52,36,"-1/4"],["B","ADD",53,36,"-1/4"],["B","ADD",55,36,"-1/4"],["B","ADD",57,36,"1/2"],["B","ADD",36,37,"1"],["B","ADD",36,52,"4"],["B","ADD",36,53,"-10"],["B","ADD",36,54,"26"],["B","ADD",36,55,"6"],["B","ADD",36,56,"2"],["B","ADD",36,57,"-6"],["B","IDLE_ONE",36,[15]],["B","ADD",36,57,"6"],["B","ADD",36,56,"-2"],["B","ADD",36,55,"-6"],["B","ADD",36,54,"-26"],["B","ADD",36,53,"10"],["B","ADD",36,52,"-4"],["B","ADD",36,37,"-1"],["B","ADD",57,36,"-1/2"],["B","ADD",55,36,"1/4"],["B","ADD",53,36,"1/4"],["B","ADD",52,36,"1/4"],["B","ADD",37,36,"-2"],["B","ADD",37,36,"2"],["B","ADD",52,36,"-1/4"],["B","ADD",53,36,"-1/4"],["B","ADD",55,36,"-1/4"],["B","ADD",56,36,"-1/4"],["B","ADD",57,36,"1/4"],["B","SCALE",36,"-1/2"],["B","ADD",36,37,"1/2"],["B","ADD",36,52,"-1"],["B","ADD",36,53,"1"],["B","ADD",36,54,"-2"],["B","ADD",36,56,"-3"],["B","ADD",36,57,"1"],["B","ADD",52,37,"-3/4"],["B","ADD",53,37,"-5/4"],["B","ADD",54,37,"-1/4"],["B","ADD",55,37,"-1/2"],["B","ADD",56,37,"-1/4"],["B","ADD",57,37,"-1/4"],["B","SCALE",37,"-1/2"],["B","ADD",37,52,"-1"],["B","ADD",37,53,"3"],["B","ADD",37,54,"-8"],["B","ADD",37,55,"-2"],["B","ADD",37,56,"-1"],["B","ADD",37,57,"1"],["B","SCALE",37,"1/2"],["B","ADD",37,36,"-1/2"],["B","ADD",36,37,"1"],["B","LAMBDA",36,1],["A","ADD",15,0,"1"],["A","ADD",16,0,"2"],["A","ADD",17,0,"2"],["A","SCALE",0,"-1"],["A","ADD",33,18,"1"],["A","ADD",34,18,"2"],["A","ADD",35,18,"2"],["A","SCALE",18,"-1"],["A","LAMBDA",15,1],["A","LAMBDA",33,-1],["A","SCALE",33,"-1"],["J",15,[15,0,18,33],[36,37,"-1","1/2"]],["A","LAMBDA",15,-1],["A","LAMBDA",33,1],["A","SCALE",33,"-1"],["A","ADD",0,15,"-1"],["A","ADD",18,33,"-1"],["A","SCALE",18,"-1"],["A","ADD",35,18,"-2"],["A","ADD",34,18,"-2"],["A","ADD",33,18,"-1"],["A","SCALE",0,"-1"],["A","ADD",17,0,"-2"],["A","ADD",16,0,"-2"],["A","ADD",15,0,"-1"],["B","LAMBDA",36,-1],["B","SCALE",37,"2"],["B","ADD",37,57,"-1"],["B","ADD",37,56,"1"],["B","ADD",37,55,"2"],["B","ADD",37,54,"8"],["B","ADD",37,53,"-3"],["B","ADD",37,52,"1"],["B","SCALE",37,"-2"],["B","ADD",57,37,"1/4"],["B","ADD",56,37,"1/4"],["B","ADD",55,37,"1/2"],["B","ADD",54,37,"1/4"],["B","ADD",53,37,"5/4"],["B","ADD",52,37,"3/4"],["B","ADD",36,57,"-1"],["B","ADD",36,56,"3"],["B","ADD",36,54,"2"],["B","ADD",36,53,"-1"],["B","ADD",36,52,"1"],["B","ADD",36,37,"-1/2"],["B","SCALE",36,"-2"],["B","ADD",57,36,"-1/4"],["B","ADD",56,36,"1/4"],["B","ADD",55,36,"1/4"],["B","ADD",53,36,"1/4"],["B","ADD",52,36,"1/4"],["B","ADD",37,36,"-2"],["B","ADD",36,52,"14"],["B","ADD",37,52,"-34"],["B","ADD",53,52,"-4"],["B","ADD",54,52,"-1/2"],["B","ADD",55,52,"1"],["B","SCALE",52,"-1"],["B","ADD",52,36,"1"],["B","ADD",52,37,"1"],["B","ADD",52,53,"-6"],["B","ADD",52,54,"14"],["B","ADD",52,55,"6"],["B","IDLE_ONE",52,[16]],["B","ADD",52,55,"-6"],["B","ADD",52,54,"-14"],["B","ADD",52,53,"6"],["B","ADD",52,37,"-1"],["B","ADD",52,36,"-1"],["B","SCALE",52,"-1"],["B","ADD",55,52,"-1"],["B","ADD",54,52,"1/2"],["B","ADD",53,52,"4"],["B","ADD",37,52,"34"],["B","ADD",36,52,"-14"],["B","ADD",37,36,"5/2"],["B","ADD",52,36,"1/8"],["B","ADD",53,36,"3/8"],["B","ADD",54,36,"1/16"],["B","ADD",55,36,"-1/16"],["B","SCALE",36,"1/8"],["B","ADD",36,37,"-1"],["B","ADD",36,52,"-4"],["B","ADD",36,53,"10"],["B","ADD",36,54,"-24"],["B","ADD",36,55,"-10"],["B","IDLE_ONE",36,[16]],["B","ADD",36,55,"10"],["B","ADD",36,54,"24"],["B","ADD",36,53,"-10"],["B","ADD",36,52,"4"],["B","ADD",36,37,"1"],["B","SCALE",36,"8"],["B","ADD",55,36,"1/16"],["B","ADD",54,36,"-1/16"],["B","ADD",53,36,"-3/8"],["B","ADD",52,36,"-1/8"],["B","ADD",37,36,"-5/2"],["B","SWAP",36,37],["B","ADD",52,36,"-3/4"],["B","ADD",53,36,"-5/4"],["B","ADD",54,36,"-1/4"],["B","ADD",55,36,"-1/4"],["B","SCALE",36,"-1/2"],["B","ADD",36,37,"1/2"],["B","ADD",36,52,"1"],["B","ADD",36,53,"-3"],["B","ADD",36,54,"6"],["B","ADD",36,55,"2"],["B","ADD",52,37,"-7/4"],["B","ADD",53,37,"-11/4"],["B","ADD",54,37,"-3/4"],["B","ADD",55,37,"-1/4"],["B","SCALE",37,"1/2"],["B","ADD",37,52,"-1"],["B","ADD",37,53,"1"],["B","ADD",37,54,"-2"],["B","ADD",37,55,"-2"],["B","SCALE",37,"-1/2"],["B","ADD",37,36,"-1/2"],["B","ADD",36,37,"1"],["B","LAMBDA",36,1],["A","ADD",16,0,"1"],["A","ADD",17,0,"2"],["A","SCALE",0,"-1"],["A","ADD",34,18,"1"],["A","ADD",35,18,"2"],["A","SCALE",18,"-1"],["A","LAMBDA",16,1],["A","LAMBDA",34,-1],["A","SCALE",34,"-1"],["J",16,[16,0,18,34],[36,37,"-1","1/2"]],["A","LAMBDA",16,-1],["A","LAMBDA",34,1],["A","SCALE",34,"-1"],["A","ADD",0,16,"-1"],["A","ADD",18,34,"-1"],["A","SCALE",18,"-1"],["A","ADD",35,18,"-2"],["A","ADD",34,18,"-1"],["A","SCALE",0,"-1"],["A","ADD",17,0,"-2"],["A","ADD",16,0,"-1"],["B","LAMBDA",36,-1],["B","SCALE",37,"-2"],["B","ADD",37,55,"2"],["B","ADD",37,54,"2"],["B","ADD",37,53,"-1"],["B","ADD",37,52,"1"],["B","SCALE",37,"2"],["B","ADD",55,37,"1/4"],["B","ADD",54,37,"3/4"],["B","ADD",53,37,"11/4"],["B","ADD",52,37,"7/4"],["B","ADD",36,55,"-2"],["B","ADD",36,54,"-6"],["B","ADD",36,53,"3"],["B","ADD",36,52,"-1"],["B","ADD",36,37,"-1/2"],["B","SCALE",36,"-2"],["B","ADD",55,36,"1/4"],["B","ADD",54,36,"1/4"],["B","ADD",53,36,"5/4"],["B","ADD",52,36,"3/4"],["B","SWAP",36,37],["B","ADD",37,36,"7/4"],["B","ADD",52,36,"-1/8"],["B","ADD",53,36,"1/4"],["B","SCALE",36,"-1/4"],["B","ADD",36,37,"-1"],["B","ADD",36,53,"4"],["B","IDLE_ONE",36,[17]],["B","ADD",36,53,"-4"],["B","ADD",36,37,"1"],["B","SCALE",36,"-4"],["B","ADD",53,36,"-1/4"],["B","ADD",52,36,"1/8"],["B","ADD",37,36,"-7/4"],["B","ADD",37,36,"5/3"],["B","ADD",52,36,"-1/6"],["B","ADD",53,36,"1/6"],["B","SCALE",36,"-1/3"],["B","ADD",36,37,"1"],["B","ADD",36,52,"2"],["B","ADD",36,53,"-6"],["B","IDLE_ONE",36,[17]],["B","ADD",36,53,"6"],["B","ADD",36,52,"-2"],["B","ADD",36,37,"-1"],["B","SCALE",36,"-3"],["B","ADD",53,36,"-1/6"],["B","ADD",52,36,"1/6"],["B","ADD",37,36,"-5/3"],["B","ADD",37,36,"2"],["B","ADD",52,36,"-1/4"],["B","ADD",53,36,"1/4"],["B","SCALE",36,"-1/2"],["B","ADD",36,37,"1/2"],["B","ADD",36,52,"-3"],["B","ADD",36,53,"1"],["B","ADD",52,37,"-1/4"],["B","ADD",53,37,"-1/4"],["B","SCALE",37,"-1/2"],["B","ADD",37,52,"-1"],["B","ADD",37,53,"1"],["B","SCALE",37,"1/2"],["B","ADD",37,36,"-1/2"],["B","ADD",36,37,"1"],["B","LAMBDA",36,1],["A","ADD",17,0,"1"],["A","SCALE",0,"-1"],["A","ADD",35,18,"1"],["A","SCALE",18,"-1"],["A","LAMBDA",17,1],["A","LAMBDA",35,-1],["A","SCALE",35,"-1"],["J",17,[17,0,18,35],[36,37,"-1","1/2"]],["A","LAMBDA",17,-1],["A","LAMBDA",35,1],["A","SCALE",35,"-1"],["A","ADD",0,17,"-1"],["A","ADD",18,35,"-1"],["A","SCALE",18,"-1"],["A","ADD",35,18,"-1"],["A","SCALE",0,"-1"],["A","ADD",17,0,"-1"],["A","LAMBDA",0,-1],["A","LAMBDA",1,-1],["A","LAMBDA",2,-1],["A","LAMBDA",3,-1],["A","LAMBDA",4,-1],["A","LAMBDA",5,-1],["A","LAMBDA",6,-1],["A","LAMBDA",7,-1],["A","LAMBDA",8,-1],["A","LAMBDA",9,-1],["A","LAMBDA",10,-1],["A","LAMBDA",11,-1],["A","LAMBDA",12,-1],["A","LAMBDA",13,-1],["A","LAMBDA",14,-1],["A","LAMBDA",15,-1],["A","LAMBDA",16,-1],["A","LAMBDA",17,-1],["A","LAMBDA",18,-1],["A","LAMBDA",19,-1],["A","LAMBDA",20,-1],["A","LAMBDA",21,-1],["A","LAMBDA",22,-1],["A","LAMBDA",23,-1],["A","LAMBDA",24,-1],["A","LAMBDA",25,-1],["A","LAMBDA",26,-1],["A","LAMBDA",27,-1],["A","LAMBDA",28,-1],["A","LAMBDA",29,-1],["A","LAMBDA",30,-1],["A","LAMBDA",31,-1],["A","LAMBDA",32,-1],["A","LAMBDA",33,-1],["A","LAMBDA",34,-1],["A","LAMBDA",35,-1],["B","LAMBDA",36,-1],["B","SCALE",37,"2"],["B","ADD",37,53,"-1"],["B","ADD",37,52,"1"],["B","SCALE",37,"-2"],["B","ADD",53,37,"1/4"],["B","ADD",52,37,"1/4"],["B","ADD",36,53,"-1"],["B","ADD",36,52,"3"],["B","ADD",36,37,"-1/2"],["B","SCALE",36,"-2"],["B","ADD",53,36,"-1/4"],["B","ADD",52,36,"1/4"],["B","ADD",37,36,"-2"],["B","LAMBDA",36,-1],["B","LAMBDA",37,-1],["B","LAMBDA",38,-1],["B","LAMBDA",39,-1],["B","LAMBDA",40,-1],["B","LAMBDA",41,-1],["B","LAMBDA",42,-1],["B","LAMBDA",43,-1],["B","LAMBDA",44,-1],["B","LAMBDA",45,-1],["B","LAMBDA",46,-1],["B","LAMBDA",47,-1],["B","LAMBDA",48,-1],["B","LAMBDA",49,-1],["B","LAMBDA",50,-1],["B","LAMBDA",51,-1],["B","LAMBDA",52,-1],["B","LAMBDA",53,-1],["B","LAMBDA",54,-1],["B","LAMBDA",55,-1],["B","LAMBDA",56,-1],["B","LAMBDA",57,-1],["B","LAMBDA",58,-1],["B","LAMBDA",59,-1],["B","LAMBDA",60,-1],["B","LAMBDA",61,-1],["B","LAMBDA",62,-1],["B","LAMBDA",63,-1],["B","LAMBDA",64,-1],["B","LAMBDA",65,-1],["B","LAMBDA",66,-1],["B","LAMBDA",67,-1]],"ops_note":"QSELF(x, k): R[x] *= q^k, one paid rank-1 job on one register (new op; not in the retained alphabet).; source interval457..575 replaced by a three-QUERY even-basis factorization; no QSELF"} \ No newline at end of file diff --git a/research/p104-joint-helper-cache-funding-bound/inputs/CURRENT-PRICE.json b/research/p104-joint-helper-cache-funding-bound/inputs/CURRENT-PRICE.json new file mode 100644 index 0000000000..257ae8ae92 --- /dev/null +++ b/research/p104-joint-helper-cache-funding-bound/inputs/CURRENT-PRICE.json @@ -0,0 +1,188 @@ +{ + "before": { + "T": { + "1": 306, + "2": 357, + "3": 799, + "4": 3825, + "5": 1360, + "6": 731, + "7": 323, + "8": 544, + "9": 10888, + "17": 416, + "25": 416, + "33": 416, + "41": 416, + "49": 416, + "57": 416, + "65": 416, + "73": 208, + "137": 208 + }, + "P": { + "1": 68384, + "2": 14518, + "3": 14076, + "4": 3791, + "5": 5848, + "6": 255, + "7": 170, + "8": 741, + "9": 32, + "16": 416, + "24": 416, + "32": 416, + "40": 416, + "48": 416, + "56": 416, + "64": 208 + }, + "S": 1424, + "raw_crossing": "0.0036467778728355110496245725074441658504988860380025741815520316035", + "empty_root_credits": 0, + "no_E_credit_crossing": "0.0036467778728355110496245725074441658504988860380025741815520316035" + }, + "after": { + "T": { + "1": 306, + "2": 357, + "3": 799, + "4": 3825, + "5": 1360, + "6": 731, + "7": 323, + "8": 544, + "9": 10888, + "17": 416, + "25": 416, + "33": 416, + "41": 416, + "49": 416, + "57": 416, + "65": 416, + "73": 208, + "137": 208 + }, + "P": { + "1": 68401, + "2": 14518, + "3": 14059, + "4": 3774, + "5": 5848, + "6": 272, + "7": 170, + "8": 741, + "9": 32, + "16": 416, + "24": 416, + "32": 416, + "40": 416, + "48": 416, + "56": 416, + "64": 208 + }, + "S": 1424, + "raw_crossing": "0.0036470810396895982354524541917252032931768348483229951940359712551", + "empty_root_credits": 0, + "no_E_credit_crossing": "0.0036470810396895982354524541917252032931768348483229951940359712551" + }, + "gate": { + "claim": "3647081039689/1000000000000000", + "tested": "364708103968907/100000000000000000", + "raw_bracket": [ + "9117702599223995588631135479313/2500000000000000000000000000000000", + "36470810396895982354524541917253/10000000000000000000000000000000000" + ], + "moment_margins": { + "9117702599223995588631135479313/2500000000000000000000000000000000": [ + "2552404205134447224811265390885091094222983481699/2000000000000000000000000000000000000000000000000000000000000000000000000000000", + "15952526282090295155070408693031819338893651585701/12500000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "36470810396895982354524541917253/10000000000000000000000000000000000": [ + "-3747671541654325187997846117146688402096807822287201/100000000000000000000000000000000000000000000000000000000000000000000000000000000", + "-3747671541654325187997846117146688402096807783075603/100000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "364708103968907/100000000000000000": [ + "20470664919627317352953773328492047309141627866507286205177628952238717/100000000000000000000000000000000000000000000000000000000000000000000000000000000", + "639708278738353667279805416515376478410675870828352693911800905973847/3125000000000000000000000000000000000000000000000000000000000000000000000000000" + ] + }, + "moment_margin_float": { + "9117702599223995588631135479313/2500000000000000000000000000000000": [ + 1.2762021025672237e-30, + 1.2762021025672237e-30 + ], + "36470810396895982354524541917253/10000000000000000000000000000000000": [ + -3.747671541654325e-29, + -3.747671541654325e-29 + ], + "364708103968907/100000000000000000": [ + 2.0470664919627316e-10, + 2.0470664919627316e-10 + ] + }, + "derivative_upper": -381457.87517035805, + "alpha": [ + 0.9999999999999993, + 0.9999999999999993 + ], + "gamma": [ + 0.940778980218907, + 0.940778980218907 + ], + "delta": [ + 0.908146701489294, + 0.908146701489294 + ], + "minimum_log_power": 2237, + "written_log_power": 2238, + "compiler_gap": "1/100000000000000000", + "H": "16517900000000000000000", + "BIT_pin": "376669/100000000", + "BIT_margin": "11960896031093/100000000000000000", + "outer": { + "strict_count": 54, + "functional_count": 4, + "minimum_margin": "1/1000000000000000000", + "BIT_just_below_effective_rejected": true + }, + "input_lift": { + "margins": { + "3647081039689/1000000000000000": [ + "124427723005414052128280552763192813542803160481861621077229540331045243139943/100000000000000000000000000000000000000000000000000000000000000000000000000000000", + "124427723005414052128280552763192813542803160481861621077229540331045243141929/100000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "364708103968907/100000000000000000": [ + "12442772300541633836890092378904400372020874030806091395524415512585716477679/10000000000000000000000000000000000000000000000000000000000000000000000000000000", + "31106930751354084592225230947261000930052185077015228488811038781464291194693/25000000000000000000000000000000000000000000000000000000000000000000000000000000" + ] + }, + "interval_kappa_cap": "376669/100000000", + "derivative_upper_on_required_interval": "-2299831290525933154178526076272396899996972093654613095735772838275432653960006518819/2500000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "source_BIT_wide_crude_bound_would_be": "-2299831290525933154178526076272396899996972093654613095735772838275432653960006518819/2500000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + } + }, + "price": { + "claim_decimal": "0.003647081039689", + "previous_claim": "729355574567/200000000000000", + "gain": "3.03166854E-7", + "gain_exact": "151583427/500000000000000", + "raw_bracket": [ + "0.0036470810396895982354524541917252", + "0.0036470810396895982354524541917253" + ], + "independent_raw_bracket": [ + "0.0036470810396895982354524541917252", + "0.00364708103968959823545245419172521" + ], + "candidate_margin_at_old_upper": [ + "11748607412826761257541487122359781837767335823225740776906074479788105327737451/100000000000000000000000000000000000000000000000000000000000000000000000000000000", + "2349721482565352251508297424471956367553467164645148155381214895957621072505473/20000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "baseline_rejects_new_claim": true + }, + "native_baseline_rejects_new_claim": true, + "old_native": "5044adee019f073f286789ccb688ffca76d42b60518242bb4daea818d33d337a", + "new_native": "64fca675b91298868e12f09423b47e0c2327cba7095e35c8919c1953b4ed68b8" +} diff --git a/research/p104-joint-helper-cache-funding-bound/inputs/PREDECESSOR-NOTICE b/research/p104-joint-helper-cache-funding-bound/inputs/PREDECESSOR-NOTICE new file mode 100644 index 0000000000..4133e92165 --- /dev/null +++ b/research/p104-joint-helper-cache-funding-bound/inputs/PREDECESSOR-NOTICE @@ -0,0 +1,16 @@ +Apache-2.0. Clear1nsight, with substantial OpenAI Codex assistance. +ChatGPT Pro audited the adjacent signed-swap approach and recommended checking +full input and output defects at a coframe. The literal witness was found by +the local chart-component scan and checked over the rationals. + +Exact #7314 and its recursive sources are retained with their original notices. +Credit Clear1nsight for #7314 and #7274, Rohan Arun for #7277 and the signed +#7113 caller, ToikY for the #7312 public MOVE contact study, the independent +#7317 replay, #7329's scalar-contraction bound and the directed price engines. +The earlier compensated fusion #6529 and the work it credits supply a related +precedent. Credit dillona, Ali Romman, Jerry Chen / CubeJerry, DreamingOfClouds, +and all contributors named in the retained sources. + +Successor helper449 paid high-readout correction: Rohan Arun with substantial OpenAI Codex assistance. Extends Clear1nsight helper319 construction, retains all nested notices and authors. Apache-2.0. + +Funded485/1455 successor,2026-11-13: the new two-shear encoding, funded itinerary change, proof and initial full replay were developed with verified GPT-6 Pro. Clear1nsight with OpenAI Codex assistance audited, integrated, independently replayed and prepared this contribution. The preceding paragraphs describe retained predecessor work; their chart-component authorship claim does not describe this successor. All source notices remain unchanged under inputs/. No independent human or formal-kernel acceptance is claimed. diff --git a/research/p104-joint-helper-cache-funding-bound/inputs/WORD.json.gz b/research/p104-joint-helper-cache-funding-bound/inputs/WORD.json.gz new file mode 100644 index 0000000000..77df4ad624 Binary files /dev/null and b/research/p104-joint-helper-cache-funding-bound/inputs/WORD.json.gz differ diff --git a/research/p104-joint-helper-cache-funding-bound/verifier/block_fixtures.py b/research/p104-joint-helper-cache-funding-bound/verifier/block_fixtures.py new file mode 100644 index 0000000000..d6878ba170 --- /dev/null +++ b/research/p104-joint-helper-cache-funding-bound/verifier/block_fixtures.py @@ -0,0 +1,96 @@ +#!/usr/bin/env python3 +"""Independent exact adversarial fixtures for the finite block funding lift.""" +from fractions import Fraction as Q +from itertools import combinations +import json +def need(ok,label): + if not ok:raise ValueError(label) +def axpy(a,b,q): + for h,v in b.items(): + z=a.get(h,0)+q*v + if z:a[h]=z + else:a.pop(h,None) +def reduce(row,b): + row=row.copy() + for p in sorted(b,reverse=True): + if row.get(p):axpy(row,b[p],-row[p]) + return row +def basis(rows): + b={} + for row in rows: + v=reduce(row,b) + if v: + p=max(v);b[p]={h:Q(a)/v[p] for h,a in v.items()} + return b +def restrict(rows,cols): + cols=set(cols);return [{h:a for h,a in r.items() if h in cols} for r in rows] +def rank(rows):return len(basis(rows)) +def tensor(rows,D):return [{D*h+a:Q(v) for h,v in row.items()} for row in rows for a in range(D)] +def prefix(rows,R,D):return [rank(restrict(rows,[D*h+a for h,r in enumerate(R) if r<=k for a in range(D)])) for k in range(10)] +def greedy(rows,R,D,weights): + p=prefix(rows,R,D) + return sum((Q(p[k]-p[k-1],D)*weights[k] for k in range(1,10)),Q(0)) +def exhaustive(rows,R,D,weights): + d=rank(rows);candidates=[] + for cols in combinations(range(len(R)*D),d): + if rank(restrict(rows,cols))==d: + candidates.append((sum((Q(weights[R[c//D]],D) for c in cols),Q(0)),list(cols))) + need(candidates,'column basis exists');return min(candidates) +def rejects(action,label): + try:action() + except ValueError:return + raise ValueError('negative control accepted: '+label) +def mm(A,B):return [[sum(A[i][k]*B[k][j] for k in range(len(A))) for j in range(len(A))] for i in range(len(A))] +def blockrows(blocks,D):return [{D*h+j:Q(M[a][j]) for h,M in enumerate(blocks) for j in range(D) if M[a][j]} for a in range(D)] +def I(D):return [[int(i==j) for j in range(D)] for i in range(D)] +def run(): + results=[] + for D in [2,3]: + ident=I(D) + A=[[int(j==i+1) for j in range(D)] for i in range(D)] + K=[[2*int(i==j and i=genericprice,'block price cannot beat scalar gamma') + prices.append(dict(generator=k,block_price=str(blockprice),scalar_gamma=str(genericprice),block_basis=cols,generic_basis=gcols)) + lost13=[D*h+a for h in [0,2] for a in range(D)] + lost12=[D*h+a for h in [0,1] for a in range(D)] + need(rank(restrict(W,lost13))==rank(W),'whole-field debit contains a basis') + rejects(lambda:need(rank(restrict(W,lost12))==rank(W),'retained whole X3 arbitrary'),'false retained surjectivity') + partial=tensor([{0:Q(1)}],D)[:-1];partialW=Z+partial + recovered=[not reduce(c,basis(P+partialW)) for c in target] + need(sum(recovered)==D-1,'partial cache recovers only D-1 entries') + rejects(lambda:need(all(recovered),'whole output required'),'partial-output full credit') + weights={r:Q(r) for r in range(1,10)} + pp,_=exhaustive(partialW,R,D,weights) + need(pp=local1+local2,'Laplace composition despite overlapping supports') + rejects(lambda:need(rank(G1+G1)==rank(G1)+rank(G1),'direct sum required'),'double-spent dependent groups') + results.append(dict(D=D,A=A,B=B,C=C,noncommuting=True,rank_zero=rank(Z),rank_whole=rank(W),actual_prefix=wp,generic_prefix=gp,prices=prices,partial_output_recovered=recovered,partial_price=str(pp),laplace=dict(global_price=str(whole),sum_local_prices=str(local1+local2)),controls=dict(false_retained_surjectivity='REJECTED',partial_output_full_credit='REJECTED',dependent_group_double_spend='REJECTED'))) + return dict(status='PASS_EXACT_ADVERSARIAL_BLOCK_FIXTURES',dimensions=[2,3],fixtures=results, + scope='Exact noncommuting non-tensor controls for the written finite block proof; no physical admission.') + +if __name__=='__main__': + print(json.dumps(run(),indent=2,sort_keys=True)) diff --git a/research/p104-joint-helper-cache-funding-bound/verifier/engine.py b/research/p104-joint-helper-cache-funding-bound/verifier/engine.py new file mode 100644 index 0000000000..f94bd0810f --- /dev/null +++ b/research/p104-joint-helper-cache-funding-bound/verifier/engine.py @@ -0,0 +1,929 @@ +"""Read-only exact verifier for the #7481 joint helper/cache bound. + +Public API: + rebuild(word_path) -> fresh source replay document + structure(replay_doc) -> exact row-union/component document + local_bounds(replay_doc, structure_doc) -> exact local prefix certificates + +No function writes files or reads a repository/workspace snapshot. The only +native source input is the pinned compressed WORD. Fractions and standard +library modules are used throughout. +""" +from collections import Counter, defaultdict +from copy import deepcopy +from fractions import Fraction as Q +from hashlib import sha256 +import gzip +import json +from math import gcd +from pathlib import Path + + +WORD_SHA256 = "acee323696b18914bd863d55341f92112b48d3d1dc1443c276efb6c396fcc0a9" +PAYLOAD_SHA256 = "64fca675b91298868e12f09423b47e0c2327cba7095e35c8919c1953b4ed68b8" +ELIGIBLE_CACHE_EVENTS = [ + 30581, 30593, 35152, 35448, 35452, 36346, 36358, + 39875, 39884, 41646, 42487, 42500, 44253, 45656, +] +CACHE_GROUPS = [ + [30581], [30593], [35152, 45656], [35448, 35452], [36346], + [36358], [39875, 39884], [41646], [42487], [42500], [44253], +] +ZERO_ONLY_QUARTER = "6*min_column_basis_target_rank_sum >= 11*paid_rank_sum" + + +def need(condition, label): + if not condition: + raise ValueError(label) + + +def add(dst, src, factor=Q(1)): + """In-place sparse rational row addition: dst += factor * src.""" + for h, value in src.items(): + result = dst.get(h, Q(0)) + factor * value + if result: + dst[h] = result + else: + dst.pop(h, None) + + +def reduce_row(row, basis): + out = row.copy() + for pivot in sorted(basis): + if out.get(pivot): + add(out, basis[pivot], -out[pivot]) + return out + + +def insert(basis, row): + out = reduce_row(row, basis) + if not out: + return False + pivot = min(out) + scale = out[pivot] + basis[pivot] = {h: value / scale for h, value in out.items()} + return True + + +def echelon(rows): + basis = {} + for row in rows: + insert(basis, row) + return basis + + +def encode_row(row): + return {str(h): str(value) for h, value in sorted(row.items()) if value} + + +def encode_basis(basis): + return {str(p): encode_row(row) for p, row in sorted(basis.items())} + + +def _source_rows_digest(mainfree_moves, sites): + payload = { + "mainfree_moves": [{"event": r["event"], "owner": r["owner"], + "owned": r["owned"], "rank": r["rank"], "row": encode_row(r["row"])} + for r in sorted(mainfree_moves, key=lambda x: x["event"])], + "sites": [{"event": event, "owner": sites[event]["owner"], + "source": sites[event]["source"], "destination": sites[event]["destination"], + "target_rank": sites[event]["target_rank"], "target": encode_row(sites[event]["target"]), + "history_basis": encode_basis(sites[event]["history_basis"]), + "L_basis": encode_basis(sites[event]["L_basis"])} for event in sorted(sites)], + } + return sha256(json.dumps(payload, sort_keys=True, separators=(",", ":")).encode()).hexdigest() + + +def frame_span(basis): + """Return the exact F2 span of an encoded native frame basis.""" + span = {0} + for vector in basis: + old = tuple(span) + span.update(value ^ vector for value in old) + need(len(span) == 1 << len(basis), "frame basis is F2 independent") + return frozenset(span) + + +def kernel_lifts(rows, project): + """Basis of the kernel on a row span, plus rank of the projected image.""" + image = {} + image_lifts = {} + kernel = {} + for original in rows: + projected = project(original) + lift = original.copy() + for pivot in sorted(image): + coefficient = projected.get(pivot) + if coefficient: + factor = -coefficient + add(projected, image[pivot], factor) + add(lift, image_lifts[pivot], factor) + if projected: + pivot = min(projected) + scale = projected[pivot] + image[pivot] = {h: value / scale for h, value in projected.items()} + image_lifts[pivot] = {h: value / scale for h, value in lift.items()} + else: + insert(kernel, lift) + return kernel, len(image) + + +def _integer_dual_separator(history, target, coordinates): + """Find integral t with history*t=0 and target*t!=0 in column order.""" + row_basis = echelon(history) + pivots = set(row_basis) + free = [h for h in coordinates if h not in pivots] + for free_pivot in free: + vector = {free_pivot: Q(1)} + for pivot in sorted(row_basis, reverse=True): + value = sum((coefficient * vector.get(h, Q(0)) + for h, coefficient in row_basis[pivot].items() if h != pivot), Q(0)) + if value: + vector[pivot] = -value + dot = sum((target.get(h, Q(0)) * vector.get(h, Q(0)) for h in coordinates), Q(0)) + if dot: + denominator = 1 + for value in vector.values(): + denominator = denominator * value.denominator // gcd(denominator, value.denominator) + integers = {h: int(value * denominator) for h, value in vector.items() if value} + common = 0 + for value in integers.values(): + common = gcd(common, abs(value)) + if common > 1: + integers = {h: value // common for h, value in integers.items()} + need(all(not sum((row.get(h, Q(0)) * integers.get(h, 0) + for h in coordinates), Q(0)) for row in history), + "separator annihilates every source history row") + target_dot = sum((target.get(h, Q(0)) * integers.get(h, 0) + for h in coordinates), Q(0)) + need(target_dot, "separator distinguishes the target row") + return {h: value for h, value in sorted(integers.items()) if value}, str(target_dot) + raise ValueError("main-history row-space miss has a dual separator") + + +def rebuild(word_path): + """Reconstruct exact source rows, 47 strict histories, and 14 L_E spaces.""" + raw = Path(word_path).read_bytes() + need(sha256(raw).hexdigest() == WORD_SHA256, "exact #7481 native WORD bytes") + word = json.loads(gzip.decompress(raw)) + payload = sha256(json.dumps(word, sort_keys=True, separators=(",", ":")).encode()).hexdigest() + need(payload == PAYLOAD_SHA256, "canonical source payload") + need(word.get("schema") and len(word["frames"]) == 1096, "native source schema and frame count") + + # Validate every frame basis before using dimension differences as prices. + spans = [frame_span(frame) for frame in word["frames"]] + frame_dims = [len(frame) for frame in word["frames"]] + need(max(frame_dims) == 9, "frame dimension ceiling") + frame_geometry = {"frame_count": len(spans), "independent_frame_count": 0, + "max_frame_dimension": max(frame_dims)} + frame_geometry["independent_frame_count"] = len(spans) + + public_count = int(word["public"]) + mains = (set(word["live"]) | {h + 112 for h in word["live"]} | + set(word["hosted"]["X2"]) | set(word["hosted"]["Y2"])) + helpers = set(range(public_count)) - mains + need((len(mains), len(helpers)) == (400, 1101), "source main/helper partition") + + instructions = word["program"] + move_instructions = [(i, ins) for i, ins in enumerate(instructions) if ins[0] == "MOVE"] + need(len(move_instructions) == 6279, "all native MOVE instructions") + move_forward = move_reverse = 0 + for _, ins in move_instructions: + old, new = ins[2:4] + old_span, new_span = spans[old], spans[new] + need(old_span <= new_span or new_span <= old_span, "every MOVE frame pair nested") + if old_span <= new_span: + move_forward += 1 + else: + move_reverse += 1 + helper_forward = helper_reverse = 0 + helper_ranks = {} + for h in sorted(helpers): + old, new = word["initial"][h], word["final"][h] + old_span, new_span = spans[old], spans[new] + need(old_span <= new_span or new_span <= old_span, + "every helper entrance/final pair nested") + if old_span <= new_span: + helper_forward += 1 + else: + helper_reverse += 1 + helper_ranks[h] = abs(frame_dims[old] - frame_dims[new]) + need((move_forward, move_reverse) == (6255, 24), "MOVE nesting census") + need((helper_forward, helper_reverse) == (1101, 0), "helper entrance/final nesting census") + need(all(1 <= rank <= 9 for rank in helper_ranks.values()), "helper target rank domain") + frame_geometry.update(move_pairs=6279, move_forward=move_forward, + move_reverse=move_reverse, + helper_pairs=1101, helper_forward=helper_forward, + helper_reverse=helper_reverse) + + destination_keys = {spans[ins[3]] for _, ins in move_instructions if ins[4]} + arrivals = {key: [] for key in destination_keys} + rows = [{h: Q(1)} for h in range(public_count)] + [None] * int(word["owned_fields"]) + charts = list(word["initial"]) + [None] * int(word["owned_fields"]) + for h, frame in enumerate(word["initial"]): + key = spans[frame] + if key in arrivals: + arrivals[key].append((-1, rows[h].copy())) + + cuts = {} + mainfree_moves = [] + operation_counts = Counter() + for event, ins in enumerate(instructions): + operation_counts[ins[0]] += 1 + op, owner = ins[:2] + if op == "MOVE": + old, new = ins[2:4] + need(charts[owner] == old and rows[owner] is not None, "MOVE source chart/value") + source_row = rows[owner].copy() + if source_row and set(source_row) <= helpers: + mainfree_moves.append({"event": event, "owner": owner, "owned": bool(ins[4]), + "rank": abs(frame_dims[old] - frame_dims[new]), "row": source_row.copy()}) + if ins[4]: + cuts[event] = {"event": event, "owner": owner, "source": old, + "destination": new, "target_rank": abs(frame_dims[old] - frame_dims[new]), + "target": source_row.copy()} + rows[owner] = source_row + charts[owner] = new + key = spans[new] + if key in arrivals: + arrivals[key].append((event, source_row.copy())) + elif op == "INIT": + need(owner >= public_count and charts[owner] is None and rows[owner] is None, + "owned INIT lifecycle") + charts[owner], rows[owner] = ins[2], {} + elif op == "CLEAR": + need(owner >= public_count and charts[owner] == ins[2] and rows[owner] is not None, + "owned CLEAR lifecycle") + charts[owner], rows[owner] = None, None + elif op == "SCALE": + need(charts[owner] == ins[3] and rows[owner] is not None, "SCALE coframe") + coefficient = Q(ins[2]) + need(coefficient, "nonzero SCALE coefficient") + rows[owner] = {h: coefficient * value for h, value in rows[owner].items() + if coefficient * value} + elif op in ("ADD", "COPY"): + donor = ins[2] + need(owner != donor and charts[owner] == charts[donor] == ins[4], + "coframed ordinary contact") + need(rows[owner] is not None and rows[donor] is not None, + "ordinary contact has live rows") + if op == "COPY": + need(owner >= public_count and not rows[owner], "COPY begins at zero owned destination") + add(rows[owner], rows[donor], Q(ins[3])) + else: + raise ValueError("unknown native operation: " + repr(op)) + need(charts == list(word["final"]) + [None] * int(word["owned_fields"]), + "final owner chart map") + need(len(cuts) == 47, "all 47 owned MOVE cuts") + need(sum(operation_counts.values()) == len(instructions), "complete event replay") + + sites = {} + cut_records = [] + main_only_events = [] + all_full_history_misses = [] + for event, cut in sorted(cuts.items()): + key = spans[cut["destination"]] + old_basis = {} + earlier_rows = [] + for time, row in arrivals[key]: + if time < event: + earlier_rows.append(row) + insert(old_basis, row) + target = cut["target"] + target_residual = reduce_row(target, old_basis) + need(target_residual, f"owned target outside full strict history event={event} " + f"target_support={len(target)} history_rank={len(old_basis)} " + f"residual_support={len(target_residual)} arrivals={len(earlier_rows)}") + old_main = echelon({h: value for h, value in row.items() if h in mains} + for row in old_basis.values()) + target_main = {h: value for h, value in target.items() if h in mains} + need(target_main, "every owned target has a nonzero main projection") + main_rem = reduce_row(target_main, old_main) + if main_rem: + main_only_events.append(event) + main_history_separator, target_dot = _integer_dual_separator( + list(old_main.values()), target_main, sorted(mains)) + else: + main_history_separator = None + target_dot = None + all_full_history_misses.append(event) + + if event in ELIGIBLE_CACHE_EVENTS: + need(word["program"][event] == ["MOVE", cut["owner"], cut["source"], + cut["destination"], True], "cache MOVE literal") + extended = {p: row.copy() for p, row in old_basis.items()} + need(reduce_row(target, extended), "eligible target history miss") + insert(extended, target) + lifted, main_rank = kernel_lifts(list(extended.values()), + lambda row: {h: value for h, value in row.items() if h in mains}) + need(len(lifted) == len(extended) - main_rank, "L_E projection rank-nullity") + need(all(set(row) <= helpers for row in lifted.values()), "L_E is helper-only") + need(all(reduce_row(row, extended) == {} for row in lifted.values()), + "L_E lies in P_E plus target") + site = {**cut, "strict_history_rank": len(old_basis), + "history_basis": old_basis, "L_basis": lifted, + "L_dimension": len(lifted), + "support": sorted(set().union(*(set(row) for row in lifted.values())))} + need(site["support"], "eligible cache space has nonempty helper support") + sites[event] = site + cut_records.append({"event": event, "owner": cut["owner"], "source": cut["source"], + "destination": cut["destination"], "target_rank": cut["target_rank"], + "strict_history_rank": len(old_basis), "full_history_miss": True, + "main_target_support": len(target_main), "main_history_miss": bool(main_rem), + "main_separator": main_history_separator, "separator_target_dot": target_dot}) + + need(sorted(sites) == ELIGIBLE_CACHE_EVENTS, "exact 47-to-14 main-projection survivor set") + need(len(main_only_events) == 33, "33 main-history-only obstructions") + need(set(main_only_events).isdisjoint(sites), "main-only misses not cache-eligible") + need(len(all_full_history_misses) == 47, "all 47 strict history misses") + need(len(mainfree_moves) == 468, "all 468 nonzero main-free MOVE rows") + need(all(x["row"] and set(x["row"]) <= helpers for x in mainfree_moves), + "source-derived main-free MOVE row support") + + receipt = { + "status": "FRESH_READ_ONLY_NATIVE_REPLAY", + "source_sha256": WORD_SHA256, + "source_payload_sha256": PAYLOAD_SHA256, + "program_events": len(instructions), "public_variables": public_count, + "main_variables": len(mains), "helper_variables": len(helpers), + "owned_fields": int(word["owned_fields"]), "owned_MOVEs": len(cuts), + "mainfree_nonzero_MOVEs": len(mainfree_moves), + "all_owned_targets_miss_full_strict_history": len(all_full_history_misses), + "main_only_history_misses": len(main_only_events), + "cache_eligible_events": sorted(sites), + "site_dimensions": {e: sites[e]["L_dimension"] for e in sorted(sites)}, + "sum_site_dimensions": sum(s["L_dimension"] for s in sites.values()), + "source_rows_sha256": _source_rows_digest(mainfree_moves, sites), + "history_model": "Strict earlier initial inputs and MOVE arrivals at equal normalized span; intervening scalar operations stay in that history span. Pooling equal-span aliases is an information overgrant only.", + "frame_geometry": frame_geometry, + "operation_counts": dict(sorted(operation_counts.items())), + } + return {"receipt": receipt, "word": word, "spans": spans, + "main_coordinates": sorted(mains), "helper_coordinates": sorted(helpers), + "helper_target_ranks": helper_ranks, "mainfree_moves": mainfree_moves, + "owned_cut_records": cut_records, "main_only_events": sorted(main_only_events), + "sites": sites} + + +class _DSU: + def __init__(self, size): + self.parent = list(range(size)) + self.size = [1] * size + + def find(self, value): + while self.parent[value] != value: + self.parent[value] = self.parent[self.parent[value]] + value = self.parent[value] + return value + + def union(self, left, right): + left, right = self.find(left), self.find(right) + if left == right: + return + if self.size[left] < self.size[right]: + left, right = right, left + self.parent[right] = left + self.size[left] += self.size[right] + + +def structure(replay_doc): + """Build exact zero-row/L_E union and fundamental-circuit components.""" + need(replay_doc["receipt"]["source_sha256"] == WORD_SHA256, "fresh replay source receipt") + need(replay_doc["receipt"].get("source_rows_sha256") == + _source_rows_digest(replay_doc["mainfree_moves"], replay_doc["sites"]), + "source-derived row and history digest") + word = replay_doc["word"] + frame_dims = [len(frame) for frame in word["frames"]] + targets = replay_doc["helper_target_ranks"] + expected_targets = {h: abs(frame_dims[word["initial"][h]] - frame_dims[word["final"][h]]) + for h in replay_doc["helper_coordinates"]} + need(targets == expected_targets, "helper target weights recomputed from native entrance/final frames") + zero_records = sorted(replay_doc["mainfree_moves"], key=lambda item: item["event"]) + need(len(zero_records) == 468 and len({r["event"] for r in zero_records}) == 468, + "unique complete zero MOVE set") + zero_rows = [r["row"] for r in zero_records] + for record in zero_records: + ins = word["program"][record["event"]] + need(ins[0] == "MOVE" and ins[1] == record["owner"] and + bool(ins[4]) == record["owned"], "zero row source event identity") + need(record["rank"] == abs(frame_dims[ins[2]] - frame_dims[ins[3]]), + "zero MOVE paid rank recomputed from nested source frames") + zero_rank = len(echelon(zero_rows)) + need(zero_rank == 463, "exact zero MOVE row rank") + need(all(row and set(row) <= set(targets) for row in zero_rows), "zero MOVE helper-only rows") + need(all(1 <= targets[h] <= 9 for row in zero_rows for h in row), + "zero MOVE support helper ranks") + need(all(record["rank"] <= targets[h] for record in zero_records for h in record["row"]), + "every zero MOVE support target rank funds paid rank") + zero_max_rank = max(record["rank"] for record in zero_records) + need(zero_max_rank == 8, "coarse zero MOVE rank cap") + + # Ground-set order is source event order followed by fresh L_E pivots. + labels = [] + rows = [] + for record in zero_records: + labels.append({"kind": "zero_move", "event": record["event"], + "owner": record["owner"], "rank": record["rank"]}) + rows.append(record["row"].copy()) + site_indices = defaultdict(list) + site_order = sorted(replay_doc["sites"]) + for event in site_order: + for pivot, row in sorted(replay_doc["sites"][event]["L_basis"].items()): + site_indices[event].append(len(rows)) + labels.append({"kind": "cache_basis", "site": event, "pivot": pivot}) + rows.append(row.copy()) + need(len(rows) == 567 and sum(len(s["L_basis"]) for s in replay_doc["sites"].values()) == 99, + "567 source-derived rows equal 468 zero plus 99 L basis rows") + + pivots = {} + pivot_expressions = {} + basis_indices = [] + dsu = _DSU(len(rows)) + circuits = [] + for index, original in enumerate(rows): + value = original.copy() + expression = {index: Q(1)} + for pivot in sorted(pivots): + coefficient = value.get(pivot) + if coefficient: + add(value, pivots[pivot], -coefficient) + add(expression, pivot_expressions[pivot], -coefficient) + if value: + pivot = min(value) + scale = value[pivot] + pivots[pivot] = {h: coefficient / scale for h, coefficient in value.items()} + pivot_expressions[pivot] = {i: coefficient / scale for i, coefficient in expression.items()} + basis_indices.append(index) + else: + need(expression.get(index) == 1, "fundamental relation own coefficient") + support = sorted(i for i, coefficient in expression.items() if coefficient) + need(index in support and len(support) >= 2, "nontrivial fundamental circuit") + for other in support: + if other != index: + dsu.union(index, other) + circuits.append({"dependent_index": index, "support": support}) + union_rank = len(basis_indices) + need(union_rank == 525 and len(circuits) == 42, "exact union rank and nullity") + + # Coarsen fundamental-circuit components so every whole cache space stays together. + for indices in site_indices.values(): + for index in indices[1:]: + dsu.union(indices[0], index) + members_by_root = defaultdict(list) + for index in range(len(rows)): + members_by_root[dsu.find(index)].append(index) + components = [] + for members in members_by_root.values(): + cache_sites = sorted({labels[i]["site"] for i in members if labels[i]["kind"] == "cache_basis"}) + zero_events = sorted(labels[i]["event"] for i in members if labels[i]["kind"] == "zero_move") + component_rank = len(echelon(rows[i] for i in members)) + components.append({"cache_sites": cache_sites, "zero_events": zero_events, + "row_count": len(members), "rank": component_rank, + "ground_indices": sorted(members)}) + components.sort(key=lambda c: (not bool(c["cache_sites"]), c["cache_sites"], c["zero_events"])) + cache_components = [c for c in components if c["cache_sites"]] + zero_only = [c for c in components if not c["cache_sites"]] + need([c["cache_sites"] for c in cache_components] == CACHE_GROUPS, + "source-derived cache grouping") + need(len(components) == 418 and len(cache_components) == 11 and len(zero_only) == 407, + "coarsened source components") + need(sum(c["rank"] for c in components) == union_rank, + "coarsened row spaces form a direct sum") + zero_histogram = Counter((c["row_count"], c["rank"]) for c in zero_only) + need(zero_histogram == Counter({(1, 1): 403, (5, 4): 3, (11, 9): 1}), + "zero-only component histogram") + need(sum(c["rank"] for c in cache_components) == 101 and + sum(c["rank"] for c in zero_only) == 424, "component rank partition") + union_receipt = { + "status": "FRESH_EXACT_567_ROW_UNION", + "source_sha256": WORD_SHA256, + "zero_move_rows": len(zero_records), "zero_move_rank": zero_rank, + "zero_move_nullity": len(zero_records) - zero_rank, + "max_zero_paid_rank": zero_max_rank, + "cache_L_basis_rows": len(rows) - len(zero_records), + "cache_L_dimension_sum": 99, + "union_rows": len(rows), "union_rank": union_rank, + "union_nullity": len(rows) - union_rank, + "fundamental_circuit_count": len(circuits), + "coarsened_component_count": len(components), + "cache_component_count": len(cache_components), + "mixed_cache_zero_component_count": sum(bool(c["zero_events"]) for c in cache_components), + "cache_only_component_count": sum(not c["zero_events"] for c in cache_components), + "zero_only_component_count": len(zero_only), + "cache_component_rank_sum": sum(c["rank"] for c in cache_components), + "zero_only_rank_sum": sum(c["rank"] for c in zero_only), + "zero_only_component_histogram": [ + {"rows": nrows, "rank": rank, "components": count} + for (nrows, rank), count in sorted(zero_histogram.items())], + } + return {"receipt": union_receipt, "labels": labels, "rows": rows, + "circuits": circuits, "components": components, + "cache_components": cache_components, "zero_only_components": zero_only, + "helper_target_ranks": targets} + + +def _validate_structure_doc(replay_doc, structure_doc): + """Reject altered/missing/duplicated rows or component partitions.""" + expected_labels = [] + expected_rows = [] + zero_records = sorted(replay_doc["mainfree_moves"], key=lambda r: r["event"]) + for record in zero_records: + expected_labels.append({"kind": "zero_move", "event": record["event"], + "owner": record["owner"], "rank": record["rank"]}) + expected_rows.append(record["row"]) + expected_site_indices = {} + for event in sorted(replay_doc["sites"]): + expected_site_indices[event] = [] + for pivot, row in sorted(replay_doc["sites"][event]["L_basis"].items()): + expected_site_indices[event].append(len(expected_rows)) + expected_labels.append({"kind": "cache_basis", "site": event, "pivot": pivot}) + expected_rows.append(row) + need(structure_doc["labels"] == expected_labels, "complete unique ground-set labels") + need(structure_doc["rows"] == expected_rows, "ground rows match fresh source replay") + need(structure_doc["receipt"]["source_sha256"] == WORD_SHA256, "structure source binding") + components = structure_doc["components"] + seen = [] + rank_sum = 0 + for component in components: + indices = component["ground_indices"] + need(len(indices) == component["row_count"] and len(indices) == len(set(indices)), + "component unique row indices") + need(all(isinstance(i, int) and 0 <= i < len(expected_rows) for i in indices), + "component ground-set index range") + seen.extend(indices) + actual_rank = len(echelon(expected_rows[i] for i in indices)) + need(actual_rank == component["rank"], "component exact rank recomputed") + rank_sum += actual_rank + need(sorted(seen) == list(range(len(expected_rows))), "component partition has no missing or duplicate rows") + need(rank_sum == structure_doc["receipt"]["union_rank"] == 525, + "component ranks reconstruct exact union rank") + cache_components = [c for c in components if c["cache_sites"]] + zero_only = [c for c in components if not c["cache_sites"]] + need([c["cache_sites"] for c in cache_components] == CACHE_GROUPS, + "component cache-site partition") + need(len(cache_components) == 11 and len(zero_only) == 407, + "cache and zero-only component counts") + return True + + +def _restricted_rank(rows, allowed_columns): + return len(echelon({h: coefficient for h, coefficient in row.items() if h in allowed_columns} + for row in rows)) + + +def _prefix_profile(rows, target_ranks): + columns_by_rank = {k: {h for h, rank in target_ranks.items() if rank <= k} + for k in range(10)} + prefix = [_restricted_rank(rows, columns_by_rank[k]) for k in range(10)] + need(prefix[0] == 0 and all(a <= b for a, b in zip(prefix, prefix[1:])), + "monotone exact prefix ranks") + return prefix, {k: prefix[k] - prefix[k-1] for k in range(1, 10) + if prefix[k] != prefix[k-1]} + + +def _site_enabled(site, zero_basis): + combined = {p: row.copy() for p, row in site["history_basis"].items()} + for row in zero_basis.values(): + insert(combined, row) + return not reduce_row(site["target"], combined) + + +def _min_column_basis(rows, target_ranks): + prefix, profile = _prefix_profile(rows, target_ranks) + linear_price = sum(rank * count for rank, count in profile.items()) + return prefix, profile, linear_price + + +def _local_component(replay_doc, component, target_ranks, deadline_counter=None): + events = component["cache_sites"] + zero_events = component["zero_events"] + zeros_by_event = {row["event"]: row for row in replay_doc["mainfree_moves"]} + zero_rows = [zeros_by_event[event]["row"] for event in zero_events] + zero_ranks = {event: int(zeros_by_event[event]["rank"]) for event in zero_events} + sites = replay_doc["sites"] + subset_docs = [] + for mask in range(1 << len(zero_events)): + indices = [i for i in range(len(zero_events)) if mask >> i & 1] + selected_events = [zero_events[i] for i in indices] + Z_rows = [zero_rows[i] for i in indices] + Z = echelon(Z_rows) + beta_prefix, beta, _ = _min_column_basis(list(Z.values()), target_ranks) + enabled = [event for event in events if _site_enabled(sites[event], Z)] + newable = [event for event in events if event not in enabled] + gamma = {} + for event in newable: + L = list(sites[event]["L_basis"].values()) + union_prefix, _ = _prefix_profile(list(Z.values()) + L, target_ranks) + generic_prefix = [min(beta_prefix[k] + 1, union_prefix[k]) for k in range(10)] + need(generic_prefix[0] == 0 and generic_prefix[9] == len(Z) + 1, + "generic one-row increment has exact full rank") + need(all(a <= b for a, b in zip(generic_prefix, generic_prefix[1:])), + "generic prefix rank monotonicity") + gamma[event] = {k: generic_prefix[k] - generic_prefix[k-1] + for k in range(1, 10) + if generic_prefix[k] != generic_prefix[k-1]} + + case_rows = [] + for nmask in range(1 << len(newable)): + new = [event for j, event in enumerate(newable) if nmask >> j & 1] + credits = Counter(zero_ranks[event] for event in selected_events) + credits.update(sites[event]["target_rank"] for event in enabled + new) + obligations = [(None, beta)] if not new else [(event, gamma[event]) for event in new] + all_obligations = [] + for witness, debit in obligations: + signed = credits.copy() + signed.subtract(debit) + signed = {rank: amount for rank, amount in signed.items() if amount} + all_obligations.append({"witness": witness, + "signed_profile": dict(sorted(signed.items()))}) + case_rows.append({"mask": mask, "newly_granted": new, + "all_necessary_obligations": all_obligations}) + subset_docs.append({"mask": mask, "zero_events": selected_events, + "beta_prefix_ranks": beta_prefix, "beta_profile": beta, + "enabled_sites": enabled, "new_sites": newable, + "gamma_profiles": gamma, "cases": case_rows}) + return {"cache_sites": events, "zero_events": zero_events, + "subset_count": len(subset_docs), + "case_count": sum(len(s["cases"]) for s in subset_docs), + "subsets": subset_docs} + + +def _verify_largest(replay_doc, component, targets): + need(component["cache_sites"] == [35152, 45656], "largest component identity") + expected_zeros = [32681, 39855, 39857, 39859, 45659, 45661, 45663, + 45698, 45701, 45706, 51637, 57989, 58936, 76469] + need(component["zero_events"] == expected_zeros, "largest component source event list") + rows_by_event = {row["event"]: row for row in replay_doc["mainfree_moves"]} + zero_rows = [rows_by_event[event]["row"] for event in expected_zeros] + need(len(echelon(zero_rows)) == 14, "largest fourteen zero rows independent") + need(all(rows_by_event[event]["rank"] <= targets[h] + for event in expected_zeros for h in rows_by_event[event]["row"]), + "largest zero support rank domination") + need(all(targets[h] >= 4 for event in expected_zeros + for h in rows_by_event[event]["row"]), "largest zero supports have target rank at least four") + sites = replay_doc["sites"] + need({event: sites[event]["target_rank"] for event in (35152,45656)} == + {35152: 2, 45656: 1}, "largest cache native MOVE ranks") + support_min = {event: min(targets[h] for h in sites[event]["support"]) + for event in (35152,45656)} + need(support_min == {35152: 3, 45656: 4}, "largest cache L support minima") + + def quotient(event): + site = sites[event] + base = {p: row.copy() for p, row in site["history_basis"].items()} + residual_rows = [reduce_row(row, base) for row in zero_rows] + target_residual = reduce_row(site["target"], base) + return residual_rows, target_residual + + rows351, target351 = quotient(35152) + need(reduce_row(target351, echelon(rows351)), "35152 full zero quotient still misses") + rows456, target456 = quotient(45656) + needed = [45659,45661,45663,58936] + index = {event:i for i,event in enumerate(expected_zeros)} + basis = echelon(rows456) + expression = {} + residual = target456.copy() + # Keep a row-coordinate expression while reducing the target. + pivots = {} + exprs = {} + for i, row in enumerate(rows456): + v = row.copy(); expr = {i: Q(1)} + for p in sorted(pivots): + if v.get(p): + coefficient = v[p] + add(v, pivots[p], -coefficient) + add(expr, exprs[p], -coefficient) + if v: + p = min(v); scale = v[p] + pivots[p] = {h: value/scale for h, value in v.items()} + exprs[p] = {j: value/scale for j, value in expr.items()} + for p in sorted(pivots): + if residual.get(p): + coefficient = residual[p] + add(residual, pivots[p], -coefficient) + add(expression, exprs[p], coefficient) + need(not residual, "45656 full zero quotient hit") + witness = {expected_zeros[i]: coefficient for i, coefficient in expression.items() if coefficient} + need(set(witness) == set(needed), "exact four-row 45656 identity support") + for event in needed: + omitted = [row for other, row in zip(expected_zeros, rows456) if other != event] + need(reduce_row(target456, echelon(omitted)), "each required zero row is essential") + + unit_events = [45659,45661,45663] + unit_coordinates = [] + for event in unit_events: + row = rows_by_event[event]["row"] + need(len(row) == 1 and next(iter(row.values())) == 1 and rows_by_event[event]["rank"] == 1, + "required disjoint unit zero row") + coordinate = next(iter(row)) + need(targets[coordinate] == 4 and all(coordinate not in rows_by_event[other]["row"] + for other in expected_zeros if other != event), "unit helper coordinate has target rank four and no cross-use") + unit_coordinates.append(coordinate) + need(len(set(unit_coordinates)) == 3, "three distinct mandatory R4 unit columns") + need(rows_by_event[58936]["rank"] == 5 and all(targets[h] >= 5 + for h in rows_by_event[58936]["row"]), "fourth required row rank5 supported at rank>=5") + return {"cache_sites": [35152,45656], "zero_events": expected_zeros, + "zero_row_rank": 14, "all_zero_rows_independent": True, + "zero_supports_dominate_paid_ranks": True, "all_zero_support_rank_at_least_four": True, + "cache_MOVE_ranks": {"35152": 2, "45656": 1}, + "L_support_minima": {str(e): support_min[e] for e in support_min}, + "site35152_misses_full_zero_quotient": True, + "site45656_hits_full_zero_quotient": True, + "site45656_required_zero_events": needed, + "site45656_witness": {str(e): str(v) for e,v in sorted(witness.items())}, + "four_omission_checks": len(needed), + "mandatory_R4_unit_events": unit_events, + "mandatory_R4_unit_coordinates": unit_coordinates, + "rank5_fourth_event": 58936} + + +def _verify_six_zero(replay_doc, component, targets): + expected = { + (42487,): [31351,35683,43283,43285,46810,47178], + (35448,35452): [34154,34156,46841,47000,48515,49195], + } + key = tuple(component["cache_sites"]) + need(key in expected and component["zero_events"] == expected[key], "six-zero source group") + rows_by_event = {row["event"]: row for row in replay_doc["mainfree_moves"]} + zero_rows = [rows_by_event[event]["row"] for event in component["zero_events"]] + need(len(echelon(zero_rows)) == 6, "six zero rows independent") + need(all(rows_by_event[event]["rank"] <= targets[h] + for event in component["zero_events"] for h in rows_by_event[event]["row"]), + "six-zero support target ranks dominate paid rank") + need(all(targets[h] >= 4 for event in component["zero_events"] + for h in rows_by_event[event]["row"]), + "every six-zero support coordinate has target rank at least four") + sites = replay_doc["sites"] + for event in key: + P = sites[event]["history_basis"] + Zbasis = echelon(zero_rows) + combined = {p:row.copy() for p,row in P.items()} + for row in Zbasis.values(): insert(combined,row) + need(reduce_row(sites[event]["target"], combined), + "six-zero cache misses the full zero quotient") + minima = {event: min(targets[h] for h in sites[event]["support"]) for event in key} + expected_min = ({42487:4} if key == (42487,) else {35448:3, 35452:4}) + need(minima == expected_min, "six-zero cache L support minima") + return {"cache_sites": list(key), "zero_events": component["zero_events"], + "zero_row_rank": 6, "all_zero_rows_independent": True, + "zero_supports_dominate_paid_ranks": True, + "all_cache_targets_miss_full_zero_quotient": True, + "all_zero_support_target_ranks_at_least_four": True, + "L_support_minima": {str(e): minima[e] for e in minima}} + + +def _quarter_zero_certificate(replay_doc, structure_doc): + targets = replay_doc["helper_target_ranks"] + row_by_event = {row["event"]: row for row in replay_doc["mainfree_moves"]} + checked = independent = dependent = 0 + dependent_margins = [] + per_component = [] + for component in structure_doc["zero_only_components"]: + events = component["zero_events"] + if len(events) == 1: + continue + component_dependent = component_independent = 0 + component_margin = None + for mask in range(1, 1 << len(events)): + selected = [events[i] for i in range(len(events)) if mask >> i & 1] + subset = [row_by_event[event]["row"] for event in selected] + rank = len(echelon(subset)) + paid = sum(row_by_event[event]["rank"] for event in selected) + prefix, profile = _prefix_profile(subset, targets) + basis_rank = prefix[-1] + need(basis_rank == rank, "prefix rank agrees with exact selected row rank") + target_sum = sum(k * count for k, count in profile.items()) + if rank == len(selected): + independent += 1; component_independent += 1 + need(target_sum >= paid, "support matching funds independent zero-row subset") + else: + dependent += 1; component_dependent += 1 + margin = 6 * target_sum - 11 * paid + dependent_margins.append(margin) + component_margin = margin if component_margin is None else min(component_margin, margin) + need(margin >= 0, "quarter-power funding for dependent zero-row subset") + checked += 1 + per_component.append({"events": events, "rows": len(events), "rank": component["rank"], + "independent_subsets": component_independent, + "dependent_subsets": component_dependent, + "minimum_dependent_integer_margin": component_margin}) + need(checked == 2140 and independent == 2109 and dependent == 31, + "complete 2140-subset zero-only certificate") + need(9 * 6**4 < 11**4, "strict quarter-power envelope") + return {"status": "PASS_SOURCE_DERIVED_ZERO_ONLY_QUARTER_FUNDING", + "component_count": len(structure_doc["zero_only_components"]), + "dependent_component_count": 4, "nonempty_subsets_checked": checked, + "independent_subsets_funded_by_support": independent, + "dependent_subsets_checked": dependent, + "all_dependent_quarter_inequalities_pass": True, + "minimum_dependent_integer_margin": min(dependent_margins), + "envelope": "9*6^4<11^4", + "component_checks": per_component, + "scope": "For 0<=kappa<=1/4, source zero-only helper rows only; full mixed/cache and high-kappa bounds are separate."} + + +def local_bounds(replay_doc, structure_doc): + """Return exact local rank-profile obligations and source checks, no prices.""" + need(replay_doc["receipt"]["source_sha256"] == structure_doc["receipt"]["source_sha256"] == WORD_SHA256, + "local source binding") + _validate_structure_doc(replay_doc, structure_doc) + need(len(structure_doc["cache_components"]) == 11, "full cache component set") + targets = replay_doc["helper_target_ranks"] + components_by_sites = {tuple(c["cache_sites"]): c for c in structure_doc["cache_components"]} + largest = _verify_largest(replay_doc, components_by_sites[(35152,45656)], targets) + six = [_verify_six_zero(replay_doc, components_by_sites[key], targets) + for key in ((42487,), (35448,35452))] + small_keys = [(30593,), (36358,), (30581,), (36346,), (39875,39884), + (44253,), (42500,), (41646,)] + small = [_local_component(replay_doc, components_by_sites[key], targets) for key in small_keys] + need(sum(c["subset_count"] for c in small) == 43, "all eight small zero subsets") + need(sum(c["case_count"] for c in small) == 89, "all eight small prefix cases") + six_profiles = [_local_component(replay_doc, components_by_sites[tuple(c["cache_sites"])], targets) + for c in six] + need(sum(c["subset_count"] for c in six_profiles) == 128 and + sum(c["case_count"] for c in six_profiles) == 384, + "all 128 six-zero subsets and 384 cache-set cases") + quarter = _quarter_zero_certificate(replay_doc, structure_doc) + return {"status": "PASS_SOURCE_DERIVED_LOCAL_PREFIX_OBLIGATIONS", + "source_sha256": WORD_SHA256, + "largest_component": largest, + "six_zero_analytic_checks": six, + "six_zero_prefix_profiles": six_profiles, + "eight_small_components": small, + "zero_only_quarter_certificate": quarter, + "scope": "Exact source-derived scalar row-space and prefix-rank obligations. Pricing, cross-block envelopes, physical cache schedules, and any attained kappa are external and not asserted."} + + +def negative_controls(replay_doc, structure_doc): + """Execute mutations against semantic rank/support/component validators.""" + controls = {} + + bad_rank = deepcopy(replay_doc) + first = bad_rank["mainfree_moves"][0] + first["rank"] = min(bad_rank["helper_target_ranks"][h] for h in first["row"]) + 1 + bad_rank["receipt"]["source_rows_sha256"] = _source_rows_digest( + bad_rank["mainfree_moves"], bad_rank["sites"]) + try: + structure(bad_rank) + except ValueError as error: + controls["forged_paid_rank_rejected"] = str(error) == \ + "zero MOVE paid rank recomputed from nested source frames" + else: + controls["forged_paid_rank_rejected"] = False + need(controls["forged_paid_rank_rejected"], "paid rank mutation control executes and rejects") + + bad_support = deepcopy(replay_doc) + first = bad_support["mainfree_moves"][0] + main_coordinate = bad_support["main_coordinates"][0] + need(main_coordinate not in first["row"], "support mutation control coordinate") + first["row"][main_coordinate] = Q(1) + bad_support["receipt"]["source_rows_sha256"] = _source_rows_digest( + bad_support["mainfree_moves"], bad_support["sites"]) + try: + structure(bad_support) + except ValueError as error: + controls["main_support_contamination_rejected"] = str(error) == \ + "zero MOVE helper-only rows" + else: + controls["main_support_contamination_rejected"] = False + need(controls["main_support_contamination_rejected"], "support mutation control executes and rejects") + + bad_weight = deepcopy(replay_doc) + coordinate = next(iter(bad_weight["helper_target_ranks"])) + actual = bad_weight["helper_target_ranks"][coordinate] + bad_weight["helper_target_ranks"][coordinate] = actual - 1 if actual > 1 else actual + 1 + try: + structure(bad_weight) + except ValueError as error: + controls["forged_target_weight_rejected"] = str(error) == \ + "helper target weights recomputed from native entrance/final frames" + else: + controls["forged_target_weight_rejected"] = False + need(controls["forged_target_weight_rejected"], "target weight mutation control executes and rejects") + + bad_component = deepcopy(structure_doc) + bad_component["components"].pop() + try: + _validate_structure_doc(replay_doc, bad_component) + except ValueError as error: + controls["missing_component_rejected"] = str(error) == \ + "component partition has no missing or duplicate rows" + else: + controls["missing_component_rejected"] = False + need(controls["missing_component_rejected"], "component mutation control executes and rejects") + return {"status": "PASS_EXECUTED_NEGATIVE_CONTROLS", "controls": controls} + + +def to_jsonable(value): + """Convert exact internal docs to deterministic JSON-compatible values.""" + if isinstance(value, Q): + return str(value) + if isinstance(value, dict): + return {str(key): to_jsonable(item) for key, item in sorted(value.items(), key=lambda kv: str(kv[0]))} + if isinstance(value, (list, tuple)): + return [to_jsonable(item) for item in value] + if isinstance(value, (set, frozenset)): + return [to_jsonable(item) for item in sorted(value)] + if isinstance(value, Counter): + return to_jsonable(dict(value)) + return value diff --git a/research/p104-joint-helper-cache-funding-bound/verifier/independent_small.py b/research/p104-joint-helper-cache-funding-bound/verifier/independent_small.py new file mode 100644 index 0000000000..a83391a780 --- /dev/null +++ b/research/p104-joint-helper-cache-funding-bound/verifier/independent_small.py @@ -0,0 +1,143 @@ +"""Independent max-pivot check of all 89 small-component funding cases. + +Callable only: run(replay_doc, structure_doc, local_doc). No file access, +source mutation, primary-engine import, price import, or saved-row dependency. +This ports Jerry Chen / CubeJerry's independent wave44 exact-Q reconstruction; +its original pinned author work is preserved in worker-b/integer-price-0038. +""" +from collections import Counter +from fractions import Fraction as Q +from hashlib import sha256 +import json + +WORD_SHA256='acee323696b18914bd863d55341f92112b48d3d1dc1443c276efb6c396fcc0a9' +CAPS={(39875,39884):{5:1,1:1,6:-1},(42500,):{1:1,3:1,4:-1},(41646,):{6:1,4:-1}} +SMALL_KEYS={(30593,),(36358,),(30581,),(36346,),(39875,39884),(44253,),(42500,),(41646,)} + +def _need(ok,label): + if not ok:raise ValueError('independent small: '+label) +def _row(row):return {int(h):Q(a) for h,a in row.items() if a} +def _rows(rows):return [_row(r) for r in (rows.values() if isinstance(rows,dict) else rows)] +def _add(a,b,q): + for h,v in b.items(): + z=a.get(h,0)+q*v + if z:a[h]=z + else:a.pop(h,None) +def _normal(row,basis): + v=row.copy() + for p in sorted(basis,reverse=True): + if v.get(p):_add(v,basis[p],-v[p]) + return v +def _echelon(rows): + b={} + for row in rows: + v=_normal(row,b) + if v: + p=max(v);b[p]={h:a/v[p] for h,a in v.items()} + return b +def _helper_extension(history,target,mains): + image={};helper={} + for row in list(history.values())+[target]: + full=row.copy();v={h:a for h,a in row.items() if h in mains} + for p in sorted(image,reverse=True): + if v.get(p): + q=v[p];_add(v,image[p][0],-q);_add(full,image[p][1],-q) + if v: + p=max(v);q=1/v[p] + image[p]=({h:a*q for h,a in v.items()},{h:a*q for h,a in full.items()}) + else:helper=_echelon(list(helper.values())+[full]) + _need(len(helper)+len(image)==len(history)+1,'helper-intersection rank-nullity') + return helper +def _prefix(rows,targets): + p=[len(_echelon({h:a for h,a in row.items() if targets[h]<=k} for row in rows)) for k in range(10)] + _need(p[0]==0 and all(a<=b for a,b in zip(p,p[1:])),'prefix ranks') + return p +def _profile(p):return {k:p[k]-p[k-1] for k in range(1,10) if p[k]!=p[k-1]} +def _counts(profile):return {int(k):v for k,v in profile.items() if v} +def _digest(value):return sha256(json.dumps(value,sort_keys=True,separators=(',',':')).encode()).hexdigest() + +def run(replay_doc,structure_doc,local_doc): + """Rebuild all small obligations and prove their nine-generator ceilings.""" + _need(replay_doc['receipt']['source_sha256']==structure_doc['receipt']['source_sha256']==local_doc['source_sha256']==WORD_SHA256,'source binding') + _need(_normal({9:Q(1),4:Q(3)},{4:{4:Q(1),2:Q(2)}})=={9:Q(1),2:Q(-6)},'all-pivot quotient trap') + word=replay_doc['word'];mains=set(replay_doc['main_coordinates']);helpers=set(replay_doc['helper_coordinates']) + actual_mains=set(word['live'])|{h+112 for h in word['live']}|set(word['hosted']['X2'])|set(word['hosted']['Y2']) + _need(mains==actual_mains and helpers==set(range(word['public']))-actual_mains,'actual main/helper coordinate split') + targets={h:abs(len(word['frames'][word['final'][h]])-len(word['frames'][word['initial'][h]])) for h in helpers} + _need(targets==replay_doc['helper_target_ranks'] and len(helpers)==1101 and len(mains)==400,'original target coordinates/ranks') + _need(all(1<=r<=9 for r in targets.values()),'target rank domain') + zeros={r['event']:r for r in replay_doc['mainfree_moves']} + _need(len(zeros)==len(replay_doc['mainfree_moves'])==468,'unique complete zero-row collection') + selected=[c for c in structure_doc['cache_components'] if len(c['zero_events'])<=4] + primary={tuple(c['cache_sites']):c for c in local_doc['eight_small_components']} + _need(len(selected)==len(primary)==len(local_doc['eight_small_components'])==8 and {tuple(c['cache_sites']) for c in selected}==set(primary)==SMALL_KEYS,'eight small component identities') + components=[];all_profiles=[];all_proofs=[];case_count=subset_count=obligation_count=0 + for component in sorted(selected,key=lambda c:tuple(c['cache_sites'])): + events=tuple(component['cache_sites']);zevents=component['zero_events'];cap=CAPS.get(events,{}) + rc=primary[events] + _need(rc['zero_events']==zevents and rc['subset_count']==len(rc['subsets'])==1<>i&1];Z=[raw[i] for i in inds] + prefix=_prefix(Z,targets);beta=_profile(prefix) + enabled=[e for e in events if not _normal(sites[e]['t'],_echelon(sites[e]['z'][i] for i in inds))] + remaining=[e for e in events if e not in enabled] + sr=rc['subsets'][mask] + _need(sr['mask']==mask and sr['zero_events']==[zevents[i] for i in inds],'subset mask and zero events') + _need(sr['beta_prefix_ranks']==prefix and _counts(sr['beta_profile'])==beta,'independent beta profile') + _need(sr['enabled_sites']==enabled and sr['new_sites']==remaining,'quotient eligibility') + gamma={} + for e in remaining: + union=_prefix(Z+list(sites[e]['L'].values()),targets) + gp=[min(prefix[k]+1,union[k]) for k in range(10)] + _need(gp[0]==0 and gp[-1]==prefix[-1]+1 and all(a<=b for a,b in zip(gp,gp[1:])),'generic new witness ranks') + gamma[e]=_profile(gp) + _need({int(e):_counts(p) for e,p in sr['gamma_profiles'].items()}==gamma,'independent gamma profiles') + cases={tuple(c['newly_granted']):c for c in sr['cases']} + _need(len(cases)==len(sr['cases'])==1<>j&1) + expected=cases[new];_need(expected['mask']==mask,'grant mask') + credits=Counter(zeros[zevents[i]]['rank'] for i in inds) + credits.update(sites[e]['rank'] for e in enabled+list(new)) + obligations=[(e,gamma[e]) for e in new] if new else [(None,beta)] + actual=expected['all_necessary_obligations'];proof=None;profiles=[] + _need([o['witness'] for o in actual]==[e for e,p in obligations],'complete obligation witnesses') + for o,(e,debit) in zip(actual,obligations): + delta=credits.copy();delta.subtract(debit);delta={r:n for r,n in delta.items() if n} + _need(_counts(o['signed_profile'])==delta,'independent signed obligation invoice') + diff=Counter(cap);diff.subtract(delta) + margins=[sum(n*min(r,k) for r,n in diff.items()) for k in range(1,10)] + if min(margins)>=0 and proof is None:proof={'witness':e,'nine_generator_margins':margins} + profiles.append({'witness':e,'profile':delta});obligation_count+=1 + _need(proof is not None,'one necessary obligation proves component ceiling') + cone_min=min(proof['nine_generator_margins']) if cone_min is None else min(cone_min,*proof['nine_generator_margins']) + local_profiles.append({'mask':mask,'new':new,'profiles':profiles});local_proofs.append({'mask':mask,'new':new,**proof}) + local_cases+=1;case_count+=1 + subset_count+=1 + _need(local_cases==rc['case_count'],'component case count') + components.append({'cache_sites':list(events),'zero_events':zevents.copy(),'subsets':1<N:a-=1 + while pow(a+1,5000)<=N:a+=1 + low=pow(a,5000);high=pow(a+1,5000) + need(low<=N=0 else b);hi+=c*(b if c>=0 else a) + return lo,hi +def display(interval): + with localcontext() as ctx: + ctx.prec=45 + dec=[str(Decimal(q.numerator)/Decimal(q.denominator)) for q in interval] + return dict(exact=list(map(str,interval)),decimal_display_only=dec) diff --git a/research/p104-joint-helper-cache-funding-bound/verifier/pricing.py b/research/p104-joint-helper-cache-funding-bound/verifier/pricing.py new file mode 100644 index 0000000000..ca7ee35865 --- /dev/null +++ b/research/p104-joint-helper-cache-funding-bound/verifier/pricing.py @@ -0,0 +1,242 @@ +#!/usr/bin/env python3 +"""Directed rational price and interval proof for the joint funding envelope. + +This is a research aid, not a compiler, source admission or kappa proposal. +No floating-point operation influences an interval or sign decision. +""" +from decimal import Decimal, localcontext +from fractions import Fraction as Q +from functools import lru_cache +from hashlib import sha256 +from collections import Counter +import json + +PIN = "86f71ccbc923db5d7a6753aa971c3a9c8a572680534498ed17be072cfa2aae6b" +DEN = 10**50 + + +def need(ok, why): + if not ok: + raise ValueError(why) + + +def down(x): + return Q((x.numerator * DEN) // x.denominator, DEN) + + +def up(x): + return -down(-x) + + +def log_series(x, terms=64): + """For 1 <= x <= 2, positive atanh series and a geometric tail bound.""" + need(1 <= x <= 2, "log range reduction") + z = (x-1)/(x+1) + z2, power, s = z*z, z, Q(0) + for j in range(terms): + s += 2*power/(2*j+1) + power *= z2 + # Remaining denominators are >=2*terms+1. + error = 2*power / ((2*terms+1)*(1-z2)) + return down(s), up(s+error) + + +@lru_cache(None) +def log_interval(r): + need(isinstance(r, int) and r >= 1, "positive integral rank") + a = r.bit_length()-1 + lo2, hi2 = log_series(Q(2)) + lo, hi = log_series(Q(r, 1 << a)) + return down(a*lo2+lo), up(a*hi2+hi) + + +def exponential_minus(x, degree): + """Finite Taylor polynomial; odd lower and even upper for x>=0.""" + need(x >= 0, "nonnegative exponential argument") + term = total = Q(1) + for k in range(1, degree+1): + term *= -x/k + total += term + return total + + +@lru_cache(None) +def price(r, kappa): + if r == 0: + return Q(0), Q(0) + need(1 <= r <= 137 and 0 <= kappa <= Q(1, 100), "declared pricing domain") + lo, hi = log_interval(r) + # exp(-x) decreases. Taylor's signed remainder bounds hold for all x>=0. + low = r*exponential_minus(kappa*hi, 35) + high = r*exponential_minus(kappa*lo, 36) + return down(low), up(high) + + +def moment(signed, kappa): + lo = hi = Q(0) + for r, count in signed.items(): + a, b = price(int(r), kappa) + lo += count*(a if count >= 0 else b) + hi += count*(b if count >= 0 else a) + return lo, hi + + +def display(interval): + with localcontext() as ctx: + ctx.prec = 35 + approximate = [str(Decimal(x.numerator)/Decimal(x.denominator)) for x in interval] + return {"exact": list(map(str, interval)), "decimal_display_only": approximate} + + +def derivative(profile): + """Enclose a profile derivative uniformly on 0<=kappa<=.01.""" + lo = hi = Q(0) + for r, n in profile.items(): + a, b = log_interval(r) + low, high = -b*r, -a*price(r, Q(1, 100))[0] + lo += n*(low if n >= 0 else high) + hi += n*(high if n >= 0 else low) + return lo, hi + + +def reconstruct_invoice(replay, caller_path, invoice_path): + raw = caller_path.read_bytes() + need(sha256(raw).hexdigest() == + "255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc", "exact caller bytes") + caller = json.loads(raw) + calls = sum(e[0] == "J" for e in caller["events"]) + need(calls == caller["stages"] == 17, "actual signed seventeen calls") + target, paid = Counter(), Counter() + for item in caller["types"].values(): + ports = len(item["ports"]) + for diagonal in item["diagonal"]: + target[1+8*sum(diagonal[2:])] += ports + for event in caller["events"]: + if event[0] == "J": + continue + ports = len(caller["types"][event[0]]["ports"]) + if event[1] == "QUERY": + paid[1] += ports + elif event[1] in ("IDLE_ONE", "IDLE_ODD"): + paid[8*len(event[3])+int(event[1] == "IDLE_ODD")] += ports + for rank in replay["helper_target_ranks"].values(): + target[rank] += calls + word = replay["word"] + for event in word["program"]: + if event[0] == "MOVE": + paid[abs(len(word["frames"][event[2]])-len(word["frames"][event[3]]))] += calls + raw = invoice_path.read_bytes() + need(sha256(raw).hexdigest() == PIN, "exact complete invoice bytes") + invoice = json.loads(raw) + payload = sha256(json.dumps(word, sort_keys=True, separators=(",", ":")).encode()).hexdigest() + need(payload == invoice["new_native"], "invoice/native payload binding") + need(target == Counter({int(r): n for r, n in invoice["after"]["T"].items()}), "reconstructed complete productive invoice") + need(paid == Counter({int(r): n for r, n in invoice["after"]["P"].items()}), "reconstructed complete paid invoice") + base = {r: target[r]-paid[r] for r in target.keys() | paid.keys() if target[r] != paid[r]} + need((sum(target.values()), sum(paid.values()), sum(r*n for r, n in base.items())) + == (22461, 110519, 1424), "complete invoice counts and rank surplus") + return base, calls, {"target": dict(sorted(target.items())), "paid": dict(sorted(paid.items())), + "native_calls": calls, "rank_surplus": 1424} + + +_COARSE_DENOMINATOR = 10**12 +_COARSE_POWER = _COARSE_DENOMINATOR**1000 +_COARSE_CERTIFICATES = {} + + +@lru_cache(None) +def coarse_price(r, index): + """Integer-power certificate at kappa=index/1000; Decimal only seeds it.""" + need(1 <= r <= 137 and 10 <= index <= 1000, "coarse fixed-grid price domain") + if r == 1 or index == 1000: + return Q(1), Q(1) + with localcontext() as ctx: + ctx.prec = 70 + exponent = Decimal(1000-index)/Decimal(1000) + seed = int(Decimal(r)**exponent * _COARSE_DENOMINATOR) + a, b = seed-1, seed+1 + exact = r**(1000-index)*_COARSE_POWER + need(a > 0 and a**1000 <= exact <= b**1000, "exact coarse integer-power bracket") + _COARSE_CERTIFICATES[r, index] = [a, b] + return Q(a, _COARSE_DENOMINATOR), Q(b, _COARSE_DENOMINATOR) + + +def coarse_cover(base, calls, cap): + # Fixed rational grid: every bracket has exponent denominator1000. + indices = [10, 11, 13, 17, 25, 33, 41, 56, 71, 102, 133, 257, 505, 1000] + records = [] + for a, b in zip(indices, indices[1:]): + upper = Q(calls*cap) + for r, n in base.items(): + upper += n*(coarse_price(r, a)[1] if n > 0 else coarse_price(r, b)[0]) + need(upper < 0, "every coarse interval excludes a positive moment") + records.append({"left": str(Q(a, 1000)), "right": str(Q(b, 1000)), "upper": str(upper)}) + need(records[0]["left"] == "1/100" and records[-1]["right"] == "1", "coarse complete endpoints") + need(all(a["right"] == b["left"] for a, b in zip(records, records[1:])), "coarse cover has no gaps") + certificate = [[r, k, ab] for (r, k), ab in sorted(_COARSE_CERTIFICATES.items())] + return {"interval": ["1/100", "1"], "native_cap": cap, + "partition": records, "integer_power_exponent": 1000, + "integer_brackets": len(certificate), + "integer_brackets_sha256": sha256(json.dumps(certificate, separators=(",", ":")).encode()).hexdigest(), + "worst_upper": display((max(Q(x["upper"]) for x in records),)*2)} + + +def prove(replay, structure, local, caller_path, invoice_path): + base, calls, invoice = reconstruct_invoice(replay, caller_path, invoice_path) + need(local["zero_only_quarter_certificate"]["dependent_subsets_checked"] == 31, "zero-only quarter funding prerequisite") + need(4**99 > 3**100, "near-linear rank-four analytic comparison") + ceilings = {(39875, 39884): {5: 1, 1: 1, 6: -1}, + (42500,): {1: 1, 3: 1, 4: -1}, (41646,): {6: 1, 4: -1}} + certificates = [] + total = Counter() + components = local["eight_small_components"]+local["six_zero_prefix_profiles"] + for component in components: + ceiling = ceilings.get(tuple(component["cache_sites"]), {}) + total.update(ceiling) + for subset in component["subsets"]: + for case in subset["cases"]: + accepted = [] + for ob in case["all_necessary_obligations"]: + diff = Counter({int(r): n for r, n in ob["signed_profile"].items()}) + diff.subtract(ceiling) + diff = {r: n for r, n in diff.items() if n} + value0 = sum(r*n for r, n in diff.items()) + slope_upper = derivative(diff)[1] + bound = value0+Q(1, 100)*max(Q(0), slope_upper) + if bound <= 0: + accepted.append({"witness": ob["witness"], "profile": dict(sorted(diff.items())), + "zero_value": value0, "slope_upper": str(slope_upper), "bound": str(bound)}) + need(accepted, "uniform local upper profile on whole fine interval") + certificates.append({"sites": component["cache_sites"], "mask": case["mask"], + "new": case["newly_granted"], "proof": accepted[0]}) + need(len(certificates) == 473, "89 small plus384 six-zero uniform cases") + total = {r: n for r, n in total.items() if n} + need(total == {5: 1, 1: 2, 4: -2, 3: 1}, "telescoped native upper envelope") + envelope = Counter(base) + envelope.update({r: calls*n for r, n in total.items()}) + envelope = {r: n for r, n in envelope.items() if n} + slope = derivative(envelope) + need(slope[1] < 0, "strictly decreasing fine envelope") + goal = moment(envelope, Q(19, 5000)) + need(goal[1] < -Q(252581, 10000), "complete0038 fine moment") + crossing = Q("0.0037347911502843961"), Q("0.0037347911502843965") + need(moment(envelope, crossing[0])[0] > 0 and moment(envelope, crossing[1])[1] < 0, + "fine upper-envelope crossing bracket") + rows = replay["mainfree_moves"] + need(len(rows) == 468, "complete zero-row set") + need(all(r["rank"] <= replay["helper_target_ranks"][h] for r in rows for h in r["row"]), + "all independent zero subsets have support matching") + zero_rank = structure["receipt"]["zero_move_rank"] + need(zero_rank == 463, "zero-row nullity prerequisite") + cap = (len(rows)-zero_rank)*max(r["rank"] for r in rows)+sum(s["target_rank"] for s in replay["sites"].values()) + need(cap == 72 and len(replay["sites"]) == 14, "coarse full native cap") + return {"status": "PASS_COMPLETE_JOINT_POWER_ENVELOPES", + "invoice": invoice, "baseline_signed_profile": dict(sorted(base.items())), + "native_upper_profile": dict(sorted(total.items())), + "full_upper_profile": dict(sorted(envelope.items())), + "uniform_local_cases": len(certificates), + "local_case_proofs_sha256": sha256(json.dumps(certificates, sort_keys=True, separators=(",", ":")).encode()).hexdigest(), + "fine_interval": ["0", "1/100"], "fine_derivative": display(slope), + "full_at_0038": display(goal), "upper_envelope_crossing": display(crossing), + "coarse": coarse_cover(base, calls, cap), + "kappa_status": "No new kappa. This is an upper envelope, not a feasible supplier."} diff --git a/research/p104-joint-helper-cache-funding-bound/verifier/run.py b/research/p104-joint-helper-cache-funding-bound/verifier/run.py new file mode 100644 index 0000000000..e81f494434 --- /dev/null +++ b/research/p104-joint-helper-cache-funding-bound/verifier/run.py @@ -0,0 +1,67 @@ +#!/usr/bin/env python3 +"""Isolated CLI and callable API for the read-only exact verifier.""" +import importlib.util +import json +from pathlib import Path +import sys + + +_ENGINE_PATH = Path(__file__).with_name("engine.py") +_SPEC = importlib.util.spec_from_file_location("p104_joint_funding_engine", _ENGINE_PATH) +_ENGINE = importlib.util.module_from_spec(_SPEC) +sys.modules[_SPEC.name] = _ENGINE +_SPEC.loader.exec_module(_ENGINE) + + +def rebuild(word_path): + return _ENGINE.rebuild(word_path) + + +def structure(replay_doc): + return _ENGINE.structure(replay_doc) + + +def local_bounds(replay_doc, structure_doc): + return _ENGINE.local_bounds(replay_doc, structure_doc) + + +def negative_controls(replay_doc, structure_doc): + return _ENGINE.negative_controls(replay_doc, structure_doc) + + +def verify(word_path): + replay_doc = rebuild(word_path) + structure_doc = structure(replay_doc) + controls = negative_controls(replay_doc, structure_doc) + local_doc = local_bounds(replay_doc, structure_doc) + source_receipt = dict(replay_doc["receipt"]) + source_receipt["executed_mutation_controls"] = controls["controls"] + return {"source": source_receipt, + "structure": structure_doc["receipt"], + "controls": controls, + "local": { + "status": local_doc["status"], + "largest": local_doc["largest_component"], + "six_zero": local_doc["six_zero_analytic_checks"], + "small_component_counts": [ + {"cache_sites": c["cache_sites"], "subsets": c["subset_count"], + "cases": c["case_count"]} for c in local_doc["eight_small_components"]], + "small_subset_count": sum(c["subset_count"] for c in local_doc["eight_small_components"]), + "small_case_count": sum(c["case_count"] for c in local_doc["eight_small_components"]), + "six_zero_profile_counts": [ + {"cache_sites": c["cache_sites"], "subsets": c["subset_count"], + "cases": c["case_count"]} for c in local_doc["six_zero_prefix_profiles"]], + "zero_only_quarter": local_doc["zero_only_quarter_certificate"], + }} + + +def main(argv=None): + args = list(sys.argv[1:] if argv is None else argv) + if len(args) != 1: + raise SystemExit("usage: run.py /absolute/path/to/WORD.json.gz") + result = verify(args[0]) + print(json.dumps(_ENGINE.to_jsonable(result), sort_keys=True, indent=2)) + + +if __name__ == "__main__": + main() diff --git a/research/p104-joint-helper-cache-funding-bound/verifier/scope_fixtures.py b/research/p104-joint-helper-cache-funding-bound/verifier/scope_fixtures.py new file mode 100644 index 0000000000..c0c9fc528c --- /dev/null +++ b/research/p104-joint-helper-cache-funding-bound/verifier/scope_fixtures.py @@ -0,0 +1,96 @@ +#!/usr/bin/env python3 +"""Exact finite fixtures for tangent hypotheses and finite block funding. + +The universal statements are proved in the notes, not inferred from samples. +""" +from fractions import Fraction as Q +from itertools import combinations +import json +def need(ok,label): + if not ok:raise ValueError(label) +def rank(rows): + basis={} + for original in rows: + row=list(map(Q,original)) + for p,v in sorted(basis.items()): + if row[p]: + a=row[p];row=[x-a*y for x,y in zip(row,v)] + p=next((j for j,v in enumerate(row) if v),None) + if p is not None: + a=row[p];basis[p]=[v/a for v in row] + return len(basis) +def transpose(A):return list(map(list,zip(*A))) +def mm(A,B):return [[sum((x*y for x,y in zip(row,col)),Q(0)) for col in zip(*B)] for row in A] +def inspan(v,rows):return rank(rows+[v])==rank(rows) +def basisprice(rows,weights): + r=rank(rows);n=len(weights);best=None + for cols in combinations(range(n),r): + if rank([[row[j] for j in cols] for row in rows])==r: + value=sum((weights[j] for j in cols),Q(0)) + if best is None or value>k)&1)+((y>>k)&1))*(4**k) + codes.add(code) + need(len(codes)==4**n,'digit interleaving injective at finite prefix');digit_counts.append(len(codes)) + records.append({'fixture':'nonregular_digit_graph_prefixes','prefixes_1_through_5_injective_cardinalities':digit_counts,'infinite_graph_statement_proved_in_notes':True}) + prime=7;need(len({pow(t,prime,prime) for t in range(prime)})==prime and prime%prime==0,'Frobenius point bijection with zero formal derivative') + records.append({'fixture':'characteristic7_Frobenius','pointwise_bijection':True,'formal_observation_derivative':0,'excluded_from_char0_theorem':True}) + block=[] + for D in (1,2,3): + cut=(D+1)//2;M=[[Q(i==j and i=1 and basisprice(U,weights)<=4,'block basis debit bounds') + actual_prefix=[] + for k in (1,3,9): + cols=[h*D+j for h,r in enumerate((9,1,3)) if r<=k for j in range(D)];actual_prefix.append(rank([[row[j] for j in cols] for row in W]));need(actual_prefix[-1]<=D,'generic scalar tensor cheap-prefix dominates') + partial=W[:-1] + if D>1: + history=[] + for j in range(D,3*D): + row=[Q(0)]*(3*D);row[j]=1;history.append(row) + missing=[Q(0)]*(3*D);missing[D-1]=1 + need(rank(partial)==D-1 and basisprice(partial,weights)<1 and not inspan(missing,history+partial),'partial output cannot be charged as a full cache');need(mm(M,N)!=mm(N,M),'noncommuting block operators exercised') + block.append({'D':D,'noncommuting':D>1,'full_relation_rank':D,'actual_prefix_ranks':actual_prefix,'generic_prefix_ranks':[D,D,D],'actual_W_basis_price':str(cost),'generic_gamma':'1','whole_debited_field_price':'4','partial_output_control_rejected':D>1}) + records.append({'fixture':'noncommuting_block_graphs_and_partial_output_guard','cases':block}) + for D in (1,2,3): + W1=[];W2=[] + for j in range(D): + a=[Q(0)]*(2*D);b=a.copy();a[j]=a[D+j]=1;b[j]=1;b[D+j]=-1;W1.append(a);W2.append(b) + weights=[Q(1,D)]*D+[Q(3,D)]*D;need(rank(W1+W2)==2*D,'tensor components direct sum');need(basisprice(W1+W2,weights)>=basisprice(W1,weights)+basisprice(W2,weights),'Laplace lower bound with overlapping helper supports') + records.append({'fixture':'tensor_Laplace_overlapping_helper_supports','dimensions_checked':[1,2,3]}) + need(rank([[1,1]])==1,'main-helper diagonal');need([[0]]!=[[1]],'main-dependent helper promise is not product tangent') + records.append({'fixture':'main_dependent_helper_graph','product_hypothesis_required':True}) + out={'status':'PASS_EXACT_POSITIVE_SCOPE_AND_BLOCK_FIXTURES','scalar_positive_points':5,'records':records,'block_lift_is_mathematical_review_not_physical_admission':True,'universal_claims_proved_in_notes_not_by_finite_samples':True} + return out +if __name__=='__main__':print(json.dumps(run(),indent=2,sort_keys=True)) diff --git a/research/p104-joint-helper-cache-funding-bound/verify.py b/research/p104-joint-helper-cache-funding-bound/verify.py new file mode 100644 index 0000000000..5550f8a463 --- /dev/null +++ b/research/p104-joint-helper-cache-funding-bound/verify.py @@ -0,0 +1,114 @@ +#!/usr/bin/env python3 +"""Read-only source, funding and independent price checks; one stdout receipt.""" +from fractions import Fraction as Q +from hashlib import sha256 +import importlib.util +import json +from pathlib import Path +import sys +import tempfile + +ROOT = Path(__file__).resolve().parent +WORD = ROOT / "inputs/WORD.json.gz" +CALLER = ROOT / "inputs/CALLER.json" +INVOICE = ROOT / "inputs/CURRENT-PRICE.json" +WORD_SHA = "acee323696b18914bd863d55341f92112b48d3d1dc1443c276efb6c396fcc0a9" +NOTICE_SHA = "78e060cbd33ebc4078cabf39e50191a977fb9eb5c41104533079e22da1d9d248" + + +def need(ok, label): + if not ok: + raise ValueError(label) + + +def load(name, relative): + spec = importlib.util.spec_from_file_location(name, ROOT / relative) + module = importlib.util.module_from_spec(spec) + sys.modules[name] = module + spec.loader.exec_module(module) + return module + + +def rejects(call, expected): + try: + call() + except (AssertionError, ValueError) as error: + need(expected in str(error), "mutation rejected for intended reason") + return True + raise ValueError("mutation was incorrectly accepted: " + expected) + + +def independent_integer_margin(prices, power): + base = {int(r): n for r, n in prices["baseline_signed_profile"].items()} + native = {5: 1, 3: 1, 1: 2, 4: -2} + ranks = base.keys() | native.keys() + full = {r: base.get(r, 0) + 17*native.get(r, 0) for r in ranks} + interval = power.moment(full) + threshold = -Q(252581, 10000) + need(interval[1] < threshold, "independent exact integer-power full margin") + other = tuple(map(Q, prices["full_at_0038"]["exact"])) + need(max(interval[0], other[0]) <= min(interval[1], other[1]), + "independent power and Taylor intervals overlap") + wrong_count = power.moment({r: base.get(r, 0) + 18*native.get(r, 0) for r in ranks}) + need(wrong_count[0] > threshold, "incorrect eighteen-call margin rejected") + wrong_native = {5: 1, 3: 1, 1: 2, 4: 2} + wrong_sign = power.moment({r: base.get(r, 0) + 17*wrong_native.get(r, 0) for r in ranks}) + need(wrong_sign[0] > 0, "incorrect target-debit sign rejected") + certificate = power.CERTIFICATES[4] + exact = 4**4981 * power.DP + need((certificate["lower_numerator"]+1)**5000 > exact, + "inward lower integer-price bracket rejected") + certs = [power.CERTIFICATES[r] for r in sorted(power.CERTIFICATES)] + return {"status": "PASS_INDEPENDENT_INTEGER_POWER_MARGIN", + "kappa": "19/5000", "identity": "f(r)^5000=r^4981", + "full": power.display(interval), "price_brackets": len(certs), + "brackets_sha256": sha256(json.dumps(certs, sort_keys=True, separators=(",", ":")).encode()).hexdigest(), + "controls": {"wrong_eighteen_calls": True, "wrong_target_debit_sign": True, + "wrong_lower_integer_bracket": True}} + + +def main(): + need(sha256(WORD.read_bytes()).hexdigest() == WORD_SHA, "native source pin") + need(sha256((ROOT / "inputs/PREDECESSOR-NOTICE").read_bytes()).hexdigest() == NOTICE_SHA, + "retained predecessor notice pin") + engine = load("joint_funding_source", "verifier/engine.py") + pricing = load("joint_funding_pricing", "verifier/pricing.py") + power = load("joint_funding_integer_prices", "verifier/integer_prices.py") + scope_fixtures = load("joint_funding_scope_fixtures", "verifier/scope_fixtures.py") + block_fixtures = load("joint_funding_block_fixtures", "verifier/block_fixtures.py") + independent_small = load("joint_funding_independent_small", "verifier/independent_small.py") + replay = engine.rebuild(WORD) + structure = engine.structure(replay) + local = engine.local_bounds(replay, structure) + independent_local = independent_small.run(replay, structure, local) + semantic_controls = engine.negative_controls(replay, structure) + prices = pricing.prove(replay, structure, local, CALLER, INVOICE) + power_check = independent_integer_margin(prices, power) + raw = bytearray(WORD.read_bytes()) + raw[len(raw)//2] ^= 1 + with tempfile.TemporaryDirectory(prefix="joint-funding-source-control-") as temp: + changed = Path(temp) / "changed.gz" + changed.write_bytes(raw) + source_mutation = rejects(lambda: engine.rebuild(changed), "native WORD bytes") + receipt = { + "status": "PASS_JOINT_HELPER_CACHE_FUNDING_NO_NEW_KAPPA", + "source": replay["receipt"], "structure": structure["receipt"], + "largest_component": local["largest_component"], + "six_zero_analytic_checks": local["six_zero_analytic_checks"], + "small_component_counts": [ + {"cache_sites": c["cache_sites"], "subsets": c["subset_count"], "cases": c["case_count"]} + for c in local["eight_small_components"]], + "zero_only_quarter_certificate": local["zero_only_quarter_certificate"], + "prices": prices, "independent_integer_power": power_check, + "source_mutation_rejected": source_mutation, + "semantic_controls": semantic_controls, + "tangent_scope_fixtures": scope_fixtures.run(), + "independent_block_fixtures": block_fixtures.run(), + "independent_small_algebra": independent_local, + "output": "stdout only; no package files written", + } + print(json.dumps(engine.to_jsonable(receipt), indent=2, sort_keys=True)) + + +if __name__ == "__main__": + main()