diff --git a/research/p104-whitehead-native-objects/LICENSE b/research/p104-whitehead-native-objects/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/p104-whitehead-native-objects/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-whitehead-native-objects/NOTICE b/research/p104-whitehead-native-objects/NOTICE new file mode 100644 index 0000000000..9f00cae7bb --- /dev/null +++ b/research/p104-whitehead-native-objects/NOTICE @@ -0,0 +1,4 @@ +Whitehead native objects: a t = -1 hosted word on the #6936 mixed word, a helper-free d = 0 native on P104, the connected rho = 1 root, and the exact price targets (no new kappa above #6936). +Prepared by DreamingOfClouds with Claude Opus 5.5 (Anthropic), via Claude Code. Apache-2.0. + +check.py and checks/ read only files inside this package (data/). Standard library only. diff --git a/research/p104-whitehead-native-objects/PROOF.md b/research/p104-whitehead-native-objects/PROOF.md new file mode 100644 index 0000000000..4956b7e63f --- /dev/null +++ b/research/p104-whitehead-native-objects/PROOF.md @@ -0,0 +1,140 @@ +# Whitehead native objects and price targets: construction, checks, targets, routes + +Tags: [R] replayed by `check.py` or `checks/check_joint_w.py` in this package; [B] recorded from the build of the object and not rerun here; [Q] quoted from an earlier analysis, not recomputed here; [J] judgement. Nothing here has been reviewed by a human. No kappa claim above #6936. + +## 0. Summary + +1. **The the hosted Whitehead word [R].** #6936's mixed word with the outer Whitehead (W) stage on its 8 hosted ports. At stages 1 and 18 those ports run a native with X = x - 2y, Y = x/2 (alpha = -2, beta = 1/2, t = -1, d = 0 raw). Exact kappa **.0035927413806393823240**, S = 1504, D = 421735.2023, **-0.9451%** against #6936. The 16 other stages, the root of the 96 two-chain ports and their natives are #6936's. +2. **A helper-free d = 0 native on all 104 ports [R].** Exact, two engines, 100 mutants. Public 1652.63 R0, owned 208. It is not a candidate: the replacement budget allows 172.78 (outer) / 175.86 (rho = 1) owned. +3. **The connected rho = 1 all-Whitehead root [R].** 18 stages at t = -1, every requirement of the root checker passes. +4. **The targets [R arithmetic, Q ledger].** Break-even 0.1099 / 0.1395 UP per port-call; replacement budget `owned <= 111.573 + T - dpub`; pass line 1.66 owned per port. +5. **Closed and open routes** with their scope: sections 5 and 6. + +## 1. Objects + +### 1.1 The hosted pair and the Whitehead stage + +A hosted stage is two consecutive unit reflections T = I - 2xy^T of the root, with alpha = y_u . x_v and beta = y_v . x_u, t = alpha beta. In the basis (x_u, x_v) the caller needs the plane block W = [[1, -2 alpha], [-2 beta, 1 + 4t]] (the product of the two unit reflections); the native's -1 sector must be conjugate to it by a dyadic matrix. At t = -1 the hosted native has d = 0: T[Y,K] = 0 with no helper content left in Y. [R] `window_native.py` checks that a dyadic conjugator exists for (alpha, beta) = (-2, 1/2) and (-1, 1); the two are one gauge apart (alpha lambda, beta / lambda with lambda = 2). + +The roots: `rootw1g.json` is the type B root of #6936's word with W stages 1 and 18 (outer, w = 1), t = -1 exactly at those two stages and t = -1/2 elsewhere, in the gauge of #6936's root. `root_h.json` (no W stage) and `rootw1.json` (ungauged W root) are controls and must fail. [R] + +### 1.2 The the Whitehead native, caller and invoice + +| file | sha256 (first 16) | +|---|---| +| data/mmW.json.gz (the Whitehead native) | 13019ac4b8a2f051 | +| data/mm.json.gz (#6936's native) | 273e81f176f00168 | +| data/joint_caller_w.json (caller) | 148356dca93357e5 | +| data/rootw1g.json (type B root) | 0e6622d7d27b0e30 | +| data/w.joint.invoice.json | a538d4ea1825fbde | +| data/mm.chain.invoice.json (#6936's invoice) | 2cef5b86ac7d1a7e | + +Full hashes are in `data/OBJECTS.json`. + +- **Native.** Per hosted port, one prefix: INIT an owned register at Z; add y; MOVE it from Z to the line S(q), an owned UP of rank 1; subtract it from x; CLEAR. That is 8 more owned UPs than #6936's native (rank mass 56 to 64). [R] `verify_host3w.py` replays 71,184 events in exact Fractions with the odd certificate S = 1125, 0 bad endpoint rows, owned UP {1: 18, 2: 4, 3: 1, 4: 6, 5: 1, 6: 1}; #6936's native re-passes (71,144 events, UP {1: 10, ...}, 0 bad rows). A control that declares alpha = -1 for the Whitehead native has 16 bad rows. +- **Caller.** One stream of 78 roles, each contact naming its native (#6936's at 16 stages, the W native at stages 1 and 18); the A events are #6936's caller verbatim. [R] `check_joint_w.py`: the stream replays mod p at the four central characters to the block-diagonal target (12 evaluations, 6,084 entries each, 0 bad); each type alone also replays; each stage's pair read from the root equals its native's; controls reject a W stage served by the wrong native (9 bad), the ungauged root (292 bad), a wrong root entry, a wrong alpha; the invoice is rebuilt from emitted events and, independently, from the two roots plus the natives, term for term. +- **Invoice move [R].** T: 8 x {145} -> 8 x {129} (the hub-2 drop on the hosted ports' mask incidence); P: -16 x {8} (idle runs) and +16 x {1} (8 carriers x 2 W calls). S 1520 -> 1504. +- **Price [Q for the split, R for the totals].** Hub alone (a W root with no UP, illegal at t = -1) would be +0.1167%; the UP alone is -1.0605%. Each paid rank-1 UP costs about -0.066% (about 1/1520); each port-W-call of hub saves +0.0073%. The UP costs about 9 times the hub saving per port. w = 2, 3 outer W stages: -1.896%, -2.853% (priced, the root callers built exactly, the natives not rebuilt). +- **Recorded, not rerun [B].** Second exact engine mod 2^61 - 1 with 174 mutants (126 standard and 48 on the 16 carrier ADDs), 0 accepted; physical streams on two further primes (all 512 characters, raw identity XX = YY = D on all 104 ports); stage and joint physical contacts; 3,234 native chart maps; relaxed verifier accepts, strict rejects at exactly 31 events (the 23 of #6936 and the 8 carriers); raw counts literal 807,429,216, actual 820,670,236, upper 836,955,424, all under 1e9; outer interval engines with minimum logarithm power 2204 (2203 fails). + +### 1.3 The 104-port window native + +`data/window_native.json.gz`, sha256 56c803aaf5383342. 1,456 events, no helper. [R] `checks/window_native.py` regenerates it from the construction below and requires equality with the shipped object, then: + +- **Construction.** Take a perfect matching on the dot-0 graph of the ports (52 pairs). For each pair (a, b): two owned rank-1 registers read x_a and x_b at the lines , , go UP to and DOWN to the other line, and are subtracted into the partner's X register (X_b := x_a, X_a := x_b), then cleared. Y_b is moved into the window , which lies inside q_b-perp because q_a . q_b = 0, and X_a += delta Y_b, Y_b += gamma X_a with gamma = beta, delta = -1/beta. That removes y and makes Y_b = beta x_b. The mains then rise to their final frames and a gate at the full frame swaps X_a and X_b back. d = 0 is free (the window swap); the cost is the beta crossing, **2 owned rank-1 moves per port (UP 1, DOWN 1)**. +- **Exact replay.** 0 violations, 0 bad rows; public paid {1: 104, 7: 104, 8: 104}; owned UP {1: 104}, DOWN {1: 104}; peak owned 2; 104 lifetimes. The mod 2^61 - 1 replay on 4 random inputs has 0 bad entries. The 208 x 208 transfer matrix is exact: T[Y,Y] = 0 on all 10,816 entries, T[Y,X] = beta I, T[X,X] = I, T[X,Y] = alpha I, invertible, det per port 1, every row on its own (x_p, y_p). The mains start at (X) and {0} (Y) and end at the full space and q-perp, for all 104. +- **Price.** Public 1652.628 (rule: `sum P r^(1-k)`, k = .0036270188296, helpers credited at their rise, mains' T not credited); owned 208; the floor with 208 one-hop mains and no helper is 208 x 8^(1-k) = 1651.497, so the public layer is 1.131 above it. Every integer partition of every progress 1..8 costs at least its one-hop cost, so the floor holds for any public layer under these pins (it says nothing about owned mass). +- **Mutants.** 100 single edits at pairs 0, 25, 51 (coefficient, frame, order, drop and duplicate, wrong partner) and four wrong-target judgements: 97 rejected; the 3 accepted are one mutation (C2's exchange before C1's), the same equivalence at each pair, because the two owned registers are independent after both copies. +- **Frame law.** Valid under the owned-ascent allowance only (section 2); the strict owned rule rejects exactly the 104 UPs. Owned lifetimes 104 and peak 2 also exceed the old 11-lifetime pin, like the other hosted words. + +### 1.4 The connected rho = 1 root + +`data/r1_W18_t3.json`, sha256 e2bd8b71f9e6670a. [R] `rootcheck_w.py`: ALL_REQ_PASS. At rho = 1 every reflection is the scalar -1, G_ij = sgn(i - j), the dual product (-1)^N = -1 needs N odd; layout [9 W stages][3 thin][9 W stages], N = 39, n = 38, L = 18, hub of one field. Checked: isotropy; T_{N-1}...T_0 = -I; stage units consecutive, disjoint, ordered; units inside masks; masks commute with the prefix before and after; the symbolic whole-job identity M(D) = -diag(prod D^eps) over all 18 stage variables; every variable credited on its whole mask; t = -1 exactly at every hosted pair; x, y dyadic (largest entry 2); rank G = n = 38; x and y span; Gram digraph strongly connected; span{x_i y_j} of rank 1444 = 38^2 (irreducible, not a direct sum). A wrong X entry is rejected. + +- **Price [B/Q].** D per port 1816.63 R0 (T 6408.60 less line credit 4591.98; the lines are a built line system of mutually orthogonal dual lines, LP bound equal to the greedy construction); change -422.19 per port; S = 1624 - 1872 c (S = 48 x 36 - 104 at c = 0). Free-native ceiling (c = 0) **+19.33%** (kappa .0043280); outer w = 8 +11.17%; outer w = 1 +1.54%. +- Singles at some stages (a mixed root) never raise the break-even: the all-W root has the largest c* (0.1395; 16 W calls 0.1394, 12 0.1370, 8 0.1268, 6 0.1129, 4 0.0796, 2 none) [Q]. Odd numbers of W stages did not build. + +## 2. Declared assumption: owned ascent + +The change, relative to the strict native rule "owned MOVE descends": an owned MOVE between nested frames may go either way (`frames[b] < frames[a] or frames[a] < frames[b]`), paid |change in dimension| as for a descent; public MOVEs still ascend strictly. The two words here depend on it: the hosted Whitehead word has 31 owned UP events (18 + 4 + 1 + 6 + 1 + 1, rank mass 64, 8 more than #6936's 56 over 23 events), the window native 104 (rank 1 each). [R] `verify_host3w.py` and `window_native.py` count them; the strict rule rejects exactly those. + +Cost: a rise and a fall between the same two frames apply C_b C_a^{-1} and its inverse, of the same rank, so the paid rank is direction-free; an owned register is never an input, earns no target and is cleared before return, so a rise creates no credit. This is assumption A6 as declared in #6883 and its precedents (the nested-centre transport of the retained P112 native, whose backward word accumulates into an owned centre, moves it up by rank 3 and 5, reads it and clears it). The numbers here are conditional on A6 exactly as #6934 and #6936 are. + +## 3. Exact targets + +Notation: k = .0036270188296 (#6936), rank-1 owned row = 1 R0, rank r owned row = r^(1-k). + +**Break-even per port-call c\*** (extra owned UP per port per W call, added on top of #6936's native; all 104 ports run t = -1; exact decimal solve against #6936's invoice) [Q table, R arithmetic of T / 104]: + +| shape | W calls | change in D per port | c = 0 gain | c\* | +|---|---|---|---|---| +| outer w = 1 | 2 | -61.44 | +1.538% | **0.1099** | +| outer w = 2 | 4 | -120.89 | +3.07% | 0.1081 | +| outer w = 8 | 16 | -407.29 | +11.17% | 0.0911 | +| direct sum J = 1 | 2 | -65.43 | +1.64% | 0.1170 | +| rho = 1 all-W, 9 \| 9 | 18 | -422.19 | +19.33% | **0.1395** | + +The BIT cap (+4.15% relative to #6932) is reached at c = 0.1108 (corrected from 0.1096): below about 0.11 the gain is cap-limited, so the usable window for the full capped gain is c <= 0.11, for any gain c <= 0.1395 (rho = 1). First-order rule: c\* = S0 dD / (D0 calls) with S0 = 1520, D0 = 4059.87 per port. T1's carrier costs 1.00. + +**Replacement budget** [Q constants, R arithmetic]. A native F that replaces #6936's native at every W call must satisfy + +`bill_pub(F) + bill_own(F) <= bill_pub(mm) + bill_own(mm) + T`, i.e. `owned_R0(F) <= 111.573 + T - dpub`, `dpub = bill_pub(F) - 1702.405`, + +where mm is #6936's native at the ledger basis (public 1702.405, owned 111.573 = 56 UP + 56 DOWN, total 1813.98), and `T = 104 c*` = 11.426 R0 per call (outer w = 1, F0 = 22.853 over 2 calls) or 14.513 (rho = 1, F0 = 261.236 over 18). Linearisation: bill_pub ~ S cost + k D, within 0.1 R0; 276 R0 of public D saved buys one owned S, and every public S saved buys one. Reference points: if F's public layer is the Gram-based layer's (1680.12, dpub = -22.29) the owned allowance is 145.29 / 148.37; with mm's public layer 123.00 / 126.09; with the helper-free layer here (dpub = -49.78) **172.78 / 175.86**. If 22.29 R0 of hosting D is charged to F as well, 150.5 / 153.6. + +**Pass line.** With the helper-free public layer: owned <= **1.661 per port per W call** (outer), **1.691** (rho = 1); 1.447 / 1.477 with the hosting charge. The window native has 2.0: over by 35.22 / 32.14 R0 per call, +46.65 against mm in total, +20.72 against the Gram-based layer with 104 owned UP. It cannot be closed on the public side: at owned 208 the public layer would need to be at most 1617.4 / 1620.5, below the floor 1651.50. + +**Gram-based layer replacing mm** [Q]. Public 1680.12 plus owned 55.79 plus 104 owned UP = 1839.91, +25.93 per call over mm, over T by 14.51 (outer) and 11.42 (rho = 1): exact kappa -2.011% (outer w = 1), -4.268% (w = 2), -21.42% (rho = 1). Rank-1 UP break-even u\* = 89.49 (outer), 92.58 (rho = 1); on this public layer a mass-104 owned layer is dead, and a native with under about 89 to 92 owned UP passes. + +**Scope of the ledger.** The ledger basis treats all 104 ports as hosted. the hosted Whitehead word's built word has 96 ports at t = 0 with #6936's literal native, so the literal bill differs by the 96 ports' second chain (1524.46 R0 of mains). The budget T does not depend on the choice; only the absolute bill of mm does, and the literal bill must not be applied to an all-hosted F. + +## 4. Errors corrected on the way (for readers of earlier statements) + +- "The d = 0 correction may cost up to about 123 S, not 11" is the right baseline for a replacement, but it holds only if the new native's non-W work shares owned lifetimes with the old; #6936's owned layer sits at the published P104 floor of 56 per stage, and no sharing exists on it (0 of 54 owned lifetimes co-rest with Y_p and later X_p, on all 8 ports). The kills of the Gram-based-layer-verbatim objects stand: they were either that layer verbatim or failed on rank alone (>= 52). +- Lemma M (an owned read-run with row support U and column support V costs MOVE mass >= rank_F2 Gram(q_U, q_V)) needs the two-phase hypothesis (each x read once with a fixed coefficient, every read before every effective write); born at Z it is **>= rank + 1 per run**. +- An explanation of the 56-unit owned layer as 14 runs of 4 was wrong (19 lifetimes, 24 DOWN moves of rank 1..5; 14 is the defect rank). +- "A block-diagonal P needs rank >= 13" holds only when every block is an orthonormal set (the largest orthonormal port set on P104 is 8, so at least 13 blocks); a general block-diagonal P can be as low as rank 8. The shape 13 runs of 8 ports in dim-4 spans does not occur on P104. A floor of 65 owned for a hybrid is 88 on P104 (137 with the rank law). +- The cost of splitting an 8-dim hop depends on the cut: 1+7 costs 0.0109, 2+6 0.0162, 3+5 0.0191, 4+4 0.0200. + +## 5. Closed routes (scope in brackets; each [Q] unless marked) + +| route | result | scope | +|---|---|---| +| Owned-UP carriers on #6936's native (this word) | -0.9451% with 8 ports, -1.896% / -2.853% with w = 2 / 3 [R] | #6936's native, hosted ports, its caller | +| Piggyback on #6936's owned lifetimes | 0 of 54 [B] | native verbatim, pure-x window | +| Public helpers as free carriers | 0 of 8 ports close the clean-up pattern: after h reaches X_p's frame it never co-rests with Y_p again [B] | native verbatim; escapes: a clean-up register other than Y_p, an a = 0 variant | +| Amortise the UP across W calls | impossible in the native/caller format (per-call replay, fresh data; block-diagonal additivity at rho = 1) | format fixed by the caller | +| Drop the hosted ports' R part | at most 165 R0 against 1977.5 needed | single deletions on #6936's native | +| a = 0 / d = 0 per-port mixes | rank floor 94, crossings 104 | Gram-based public layers | +| Public edits near Y | impossible on those frames; P-edits cap at 52; exchanges keep T_pub[Y,K] at 104 | Gram-based layer | +| Frame-empty dump | at least 2 S per port in exact toys | its toys (the general "rank >= m" sentence is false) | +| Post-map shape | 104 UP + 104 DOWN, 0 of 104 mergeable | final state of the Gram-based layer | +| Shared landing as rank packing | weight discount <= 1.57% | owned-carrier cleaning | +| R-before-F on the Gram-based layer | 0 legal pairs; 104 needed | its F | +| Flat composites, any M; real orthogonal P; Gaussian orthogonal P on the dot-0 pattern | >= 52 | flat mains, real ring | +| Windowed native with one owned register per crossing (this package) | 208 owned against 172.78 / 175.86 [R] | d = 0 by window swap, no helpers, X-Y contacts only; public side cannot close it | +| Fusing m consecutive Whitehead stages into one hosted stage (any grouping, rho = 1) | deficiency dim ker(W + I) = m - 1 for every grouping (proved: (I + 2 Lo) W = I + 2 Up, so W + I has rank 1; checked on 729 groupings); a hosted-form stage needs rank(C + I) >= p, so m - 1 forced crossings against m/2 for separate pairs: strictly worse for m >= 3, tied at m = 2 | rho = 1 family (Gram = sgn); any ring | +| Mixed rho = 1 roots (singles plus W stages) | never raise c\*; at c >= 0.5 every root with a W call loses | built symmetric roots; odd W counts unbuilt | +| Other port subgroups with an F2/Q gap; complex t factorisations; one skip shared across stages | none helps / gauge / impossible in the domain | P104 groups | +| A 13 x 8 block hybrid on P104 | not on P104; fails the caller rank unless the public layer mixes | see section 4 | + +## 6. Open routes (odds are judgement [J], not computed) + +1. **Gamma coupling on the Y registers after the bounce.** Bounce every port on a line with Y pre-content Z-mixed to (alpha/delta) y so the X rows come out exact and Y_t = gamma x is pure x; land the owned runs at small frames; then run a public Y-to-Y Gamma network while the Y registers rise. The landings sit at small frames and the mixing is not triangular, which avoids the two rank obstructions of the triangular hybrid. Unknown: (a) whether a frame-legal Y-to-Y network gives rank(beta I - gamma G Sigma) between 8 and 14 (the dot-1 clique forces >= 8); (b) the read cost of a dense row space (the Gram-based layer pays 56 for its read-high, descend, land layer); (c) peak owned registers across the bounce phase. If (a) and (b) land near 56 owned, the total is 56 to 90 against 145 to 173 allowed. Unbuilt. [J] about 3%. +2. **Shared landings for the beta crossing (the hybrid with the window swap).** One owned run serving many ports' crossings (Lemma M floor 1 per port; a pass needs at most 1.66 per port, so a saving of at least 35 of the 208 owned moves). The obstacle: a shared run carries the sum of the x's and leaves junk in other ports' pre-swap X registers; the check "the shadow is beta I" is necessary, not sufficient. An all-ports rank-9 landing sits at an increment of 0.096 to 0.115 per port-call, on the outer target. [J] about 5% for this route or the Gram-plus-window hybrid reaching 1.66 per port; 1 to 2% for the all-ports landing alone. +3. **Hybrid public layer: Gram coupling for the beta crossing, window swap for d.** The swap needs Y_t's pre-content to be disposable while Gram coupling lives in Y. Pass line: owned <= 172.8 / 175.9 per call. First exact step: W' = beta I - T[Y,X] for the chosen public schedule and its rank, before any owned run; with no mixing expect rank >= 52 and a floor of 137. [J] included in the 5% above. +4. **Non-swap d removal** (y leaving through an X that is not its swap partner, two-hop windows) could break the cycle obstruction of the swap family (windows must strictly grow along the swap permutation, so each m-segment costs about 2m). Untested. [J] under 2%. +5. **Real near-resonant non-flat public layer with the pattern minimum rank 8** (the algebra exists; no frame-legal schedule, price unmeasured). [J] about 2%. +6. **A W-stage native in which the hosted ports drop #6936's hosted R part and run plane 1 only, plus the prefix.** The size is unmeasured and no such word is on the frontier. [J] unknown. + +## 7. Scope ledger + +Replayed in this package: sha256 of all objects; both natives' exact endpoints and owned UP mass; the two roots and their controls; exact kappa and the invoice move; the joint caller replay; the 104-port native end to end (regeneration, two engines, structure, price, floor, budget lines, caller block, 100 mutants); the arithmetic of c\*, the budget lines and the pass lines from the ledger constants. + +Quoted, not recomputed here: the kernel ledger (public 1702.405, owned 111.573, T = 11.426 / 14.513, the table of c\* and the free-native ceilings, the Gram-based layer's price and kappa); the hosted Whitehead word's second-engine, physical, ordinary and outer checks; the closed-route table; every odds figure. + +Not built: a caller for the window native; the rho = 1 word (the root exists, no native). + +Credit: Ali Romman (#5599), CubeJerry (#6912, #6914, #6916), unpaidmoon (#6930), icekylinx (#104). + +Prepared by DreamingOfClouds with Claude Opus 5.5 (Anthropic), via Claude Code. diff --git a/research/p104-whitehead-native-objects/README.md b/research/p104-whitehead-native-objects/README.md new file mode 100644 index 0000000000..9fcc0292a7 --- /dev/null +++ b/research/p104-whitehead-native-objects/README.md @@ -0,0 +1,50 @@ +# P104: Whitehead native objects and price targets + +No kappa claim above #6936. Both words here are priced below it. + +A Whitehead (t = -1) hosted pair has d = 0: the Y register ends with no y in it. That removes part of the hosts' public cost, but each host then needs an owned rank-1 move that the t = -1/2 pairs of #6936 do not. This package records the objects built for that, with exact replays, and the exact price a better native has to meet. + +## What is here + +| object | what it is | result | +|---|---|---| +| the hosted Whitehead word | #6936's mixed word with the outer Whitehead stage on the 8 hosted ports (stages 1 and 18). The native is #6936's plus one owned UP carrier per hosted port; the other 16 stages and the 96 two-chain ports are unchanged. Native, joint caller, invoice. | kappa **.0035927413806393823240**, S = 1504, **-0.9451%** against #6936 (.0036270188296). Not a candidate. | +| window native | A helper-free d = 0 native on all 104 ports: X = x + alpha y, Y = beta x for (alpha, beta) = (-2, 1/2) and (-1, 1). One window swap removes y; the beta crossing is 2 owned rank-1 moves per port. | Exact. Public 1652.63 R0 (1.13 above the floor 1651.50), owned 208. Over the replacement budget by 35.2 (outer) / 32.1 (rho = 1) per W call. | +| rho = 1 root | The connected all-Whitehead root: 38 fields, 18 stages at t = -1, product -I, rank G = n, irreducible. | Passes every requirement. Break-even 0.1395 UP per port-call; free-native ceiling +19.33%. | + +`data/OBJECTS.json` lists the sha256 of every object. PROOF.md has the construction, the targets, the closed and open routes, and what is replayed here and what is quoted. + +## Targets (exact, from the ledger) + +- Break-even per port-call: **0.110** on the outer root, **0.1395** on the rho = 1 root. The the carrier costs 1.00, nine times over. +- A native that replaces #6936's at each W call must satisfy `owned <= 111.573 + T - dpub`, with `dpub` the change in public bill against 1702.405 and `T = 11.426` (outer) or `14.513` (rho = 1) R0 per call. +- Pass line with the helper-free public layer: **1.66 owned per port** (outer), 1.69 (rho = 1). The window native pays 2.0. + +## Checks + +``` +python3.12 -I -B check.py # about 100 s +python3.12 -I -B checks/check_joint_w.py # about 100 s +``` + +`check.py`: sha256 of the objects; exact Fractions replay of both natives; both Whitehead roots with controls; exact kappa and the invoice move; the target arithmetic; the 104-port native (regenerated, two engines, 100 mutants, 97 rejected, the 3 accepted are one true equivalence). `check_joint_w.py`: the joint caller replayed mod p at four characters, and the invoice rebuilt from the roots. Standard library only. + +## Declared assumption: owned ascent + +Both words move owned registers up as well as down (the Whitehead word: 8 carrier UPs on top of #6936's 23; window native: 104 UPs). The verifiers here accept an owned MOVE between nested frames in either direction, paid |change in dimension| as for a descent; public MOVEs still ascend strictly. The strict predecessor rule rejects the hosted Whitehead word at exactly 31 events (the 23 of #6936 and the 8 carriers) and the window native at exactly its 104 UPs. The cost argument and the precedent are those of #6883 and the P112 backward word, where owned registers are accumulated, moved up and read; see PROOF.md section 2. Every number here is conditional on that allowance. + +## Not claimed + +No candidate, no admission, no human review. The the hosted Whitehead word's second engine, physical streams, ordinary-call and outer checks come from its build record and are not rerun here. The window native is not joined to a caller: its 2 x 2 block is checked, the joint replay is not. + +## Credit + +Ali Romman (#5599: the split lemma and helper pricing the invoice rule rests on), CubeJerry (#6912 caller blocks, #6914 owned-rise argument, #6916 split application in #6936's word), unpaidmoon (#6930 width-2 phase test, used by #6936's physical audit, not rerun), icekylinx (#104 odd grid; the certificate S = 1125 in the replay), and the retained work of #6936 and its predecessors. + +## Open next questions + +1. A d = 0 native at t = -1 with at most 1.66 owned per port per W call on P104 and a public layer no dearer than 1652.63. Candidates: Gamma coupling on the Y registers after the bounce; shared landings for the beta crossing; a hybrid of Gram coupling and window swaps. See PROOF.md section 6. +2. Whether a shared owned run can carry many ports' beta crossings without leaving junk in the other ports' registers. +3. Whether a public schedule exists that gives the beta crossing through Gram-type coupling while the window swap still removes y. + +Prepared by DreamingOfClouds with Claude Opus 5.5 (Anthropic), via Claude Code. diff --git a/research/p104-whitehead-native-objects/SOURCES.json b/research/p104-whitehead-native-objects/SOURCES.json new file mode 100644 index 0000000000..92230e318c --- /dev/null +++ b/research/p104-whitehead-native-objects/SOURCES.json @@ -0,0 +1,12 @@ +{ + "schema_version": 1, + "base_commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a", + "files": [ + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "3404fbdd5e7529a0674eef26114b5071e4586cec", + "sha256": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81" + } + ] +} \ No newline at end of file diff --git a/research/p104-whitehead-native-objects/TASK.json b/research/p104-whitehead-native-objects/TASK.json new file mode 100644 index 0000000000..4b6b2aa469 --- /dev/null +++ b/research/p104-whitehead-native-objects/TASK.json @@ -0,0 +1,109 @@ +{ + "schema_version": 1, + "task_id": "supplier-boundary-audit", + "base_commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a", + "original_card": { + "id": "supplier-boundary-audit", + "question": "Does one changed supplier have complete source-bound native, caller, ordinary and outer admission coverage?", + "starting_points": [ + "docs/research/current-priorities.md", + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md" + ], + "methods": [ + "Construct and independently check one source-bound instance of the stated first experiment.", + "Seek an exact counterexample or target-specific complete-budget obstruction to that same proposed change." + ], + "acceptance_gate": "Pin the current sources and one obligation; the historical owner audit is an example, not evidence of a current bug.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_selected_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read revision 8, the selected review and live exact-source handoffs. Then follow this card's bounded first_experiment.", + "scope": "Source-bound orientation only, not a supplier replay or theorem proof." + }, + "first_experiment": "Choose one latest uncovered candidate and build a delta coverage map against the selected review. For P104, #5717 changes owned-lifetime assumptions and #5719 covers exact #5713 causal premises; neither automatically transfers to #5718. For BIT, #5679/#5708 need component admission and compatible outer use. Check controls and exact source identity before reuse; stop with one resolved gap or explicit remaining obligation. A heavy full replay requires a separate serial resource budget.", + "bottleneck_link": "Judge the actual current supplier contract and complete signed target/paid bill; frozen-profile ceilings require an applicability proof.", + "allowed_variations": [ + "One exact source head, helper/cut region or quantified proposition and changed hypothesis; check live handoffs first. Different seeds are not different scopes." + ], + "scope_change_triggers": [ + "Changing source head, helper/cut domain, operation alphabet or caller boundary without recording the new scope.", + "Treating an archived proposal or local numerical pass as complete supplier admission." + ], + "overlap_terms": [ + "supplier admission", + "5717", + "5719", + "5708", + "owned lifetime" + ], + "existing_checks": [ + { + "scope": "PR #4088: author-checked local words, native receipts, owner/phase fill and exact moment.", + "evidence": "research/staged544-mixed-fourth-entry/README.md", + "remaining": "Rebind and validate ordinary/outer admission with all four providers; full mixed release not established.", + "status": "author-checked", + "source_commit": "72d7efc181edb21806a878f174847c96dd410ab0", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #3801: successor scatter-boundary decision package.", + "evidence": "research/scatter-boundary-decision/README.md", + "remaining": "Consult its exact acceptance scope before any new exporter audit; not proof of a selected failure.", + "status": "author-checked", + "source_commit": "911f8800ba7a4b03603ef62c5ffc6240e53cb5fd", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "Selected PR5599: complete helper-subspace construction and independent caller replay; five framework assumptions remain.", + "evidence": "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md", + "remaining": "The next experiment must identify uncovered source-specific work. Successor archive intake does not transfer this admission.", + "status": "reviewed", + "source_commit": "09dd0965711ca7eeb169057a420abab1c9052137", + "selected_record_sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5" + } + ] + }, + "scope_status": "changed", + "actual_scope": "Findings and objects for the Whitehead (t = -1, d = 0) hosted native on P104: (1) one hosted word on the #6936 mixed word with the outer Whitehead stage on the 8 hosted ports, its native, joint caller and invoice, replayed (kappa .0035927413806393823240, -0.9451% against #6936); (2) a helper-free d = 0 native on all 104 ports, replayed by two exact engines and 100 mutants; (3) the connected rho = 1 all-Whitehead root with 18 stages; (4) the exact price targets (break-even per port-call, replacement budget formula, pass line) and the routes closed and open against them. No kappa claim above #6936.", + "scope_change_reason": "The card asks whether one changed supplier has complete native, caller, ordinary and outer coverage. This package covers the native, root and caller of a t = -1 supplier that is priced below the baseline, so it is not a candidate and makes no admission claim. It records the objects, the exact targets a better supplier must meet, and which routes are closed with their scope. Ordinary-call and outer admission of the hosted Whitehead word are quoted from its build record and are not replayed here.", + "bottleneck_link": "Judge the actual current supplier contract and complete signed target/paid bill: the Whitehead stage saves public D on the hosts, and the owned rank-1 carriers it needs are the whole bill; both sides are priced exactly against #6936.", + "stop_rule": "No kappa claim and no candidate. Stop when the objects and targets are recorded with their scope. A route is closed here only with the family, hypotheses and escapes stated; the open routes are listed with the first exact step each needs.", + "evidence": "README.md and PROOF.md (objects, targets, closed and open routes, scope ledger); check.py (about 100 s: sha256 of every object, exact replay of both natives, both Whitehead roots with controls, exact kappa and invoice move, target arithmetic, the 104-port native with 100 mutants) and checks/check_joint_w.py (about 100 s: the single 78-role joint caller replayed mod p at four characters with controls, the invoice rebuilt from the roots); data/ with OBJECTS.json.", + "author": "DreamingOfClouds", + "ai_assistance": "Prepared by DreamingOfClouds with Claude Opus 5.5 (Anthropic), via Claude Code.", + "outcome": "partial", + "open_questions": [ + { + "question": "Is there a d = 0 native at t = -1 whose owned mass is at most 1.66 per port per W call on P104 (1.69 at rho = 1 with 18 calls), with a public layer no dearer than the helper-free one (1652.63 R0)?", + "why_it_matters": "That is the pass line from the replacement budget. The windowed native here is exact and helper-free but pays 2.0 owned per port, over by 35.2 / 32.1 R0 per call; below the line the rho = 1 root's free-native ceiling is +19.33% and the outer root's +1.54% (+11.17% at w = 8).", + "first_step": "Build the Gamma coupling on the Y registers after the bounce on a 16 to 32 port toy, with the owned landings placed before the mixing, and report rank(beta I - gamma G Sigma) against the clique floor of 8.", + "blocked_by": "Not built: no frame-legal Y-to-Y network is known, and the read cost of its dense row space is unpriced." + }, + { + "question": "Can one owned run serve the beta crossings of many ports (Lemma M floor: 1 per port), so that the 208 owned moves of the windowed native drop by at least 35?", + "why_it_matters": "A shared crossing run is the only owned-mass route that keeps the free d = 0 window swap; a pass needs the saving at both outer and rho = 1 prices.", + "first_step": "Write the landing as exact rows for one dot-0 block and check whether the sum it carries leaves junk in the other ports' pre-swap X registers.", + "blocked_by": "A shared run carries the sum of the x's of its ports; whether the junk can be cancelled inside the frame law is open." + }, + { + "question": "Can a hybrid public layer give the beta crossing cheaply through Gram-type coupling (0.54 owned per port in the Gram-based layer) while a window swap still removes y?", + "why_it_matters": "The windowed native pays 2.0 owned per port and the Gram-based layer 1.54 with a mandatory 104 owned UP; a hybrid needs at most 172.8 / 175.9 owned per call to pass.", + "first_step": "Compute exactly W' = beta I - T[Y,X] for the chosen public schedule and its rank before any owned run.", + "blocked_by": "The swap needs the pre-content of Y_t to be disposable while Gram coupling lives in Y; no schedule reconciles both." + } + ], + "research_context": { + "sources": [ + "The #6936 package and the retained work listed in its description", + "PROOF.md section 1: the plane block W = [[1, -2a], [-2b, 1 + 4t]] of the caller is the product of the two unit reflections of a hosted pair" + ], + "credit": "Ali Romman (#5599), CubeJerry (#6912, #6914, #6916), unpaidmoon (#6930), icekylinx (#104), and the retained work of #6936 and its predecessors." + }, + "selected_frontier_changed": false +} \ No newline at end of file diff --git a/research/p104-whitehead-native-objects/VERIFY.json b/research/p104-whitehead-native-objects/VERIFY.json new file mode 100644 index 0000000000..0a3dc0b611 --- /dev/null +++ b/research/p104-whitehead-native-objects/VERIFY.json @@ -0,0 +1,29 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/check.py" + ], + "timeout_seconds": 300, + "checks": "sha256 of the twelve objects against data/OBJECTS.json; exact Fractions replay of the Whitehead native (71,184 events, owned UP mass 64, hosted X = x - 2y, Y = x/2 at t = -1) and of the #6936 native (71,144 events, mass 56) with the odd certificate S = 1125, and a control with the wrong declared alpha (16 bad rows); the outer W root by the hosted-root checker and the root checker with two failing controls; the connected rho = 1 root with 18 stages at t = -1 by the root checker (product -I, symbolic whole-job identity, mask credit, rank G = n, strongly connected, span rank 1444) and a control with one wrong entry; exact kappa of the #6936 and Whitehead-word invoices (Decimal, 50 digits), S 1520 and 1504, the invoice move, -0.9451%; the break-even and pass-line arithmetic (0.10987, 0.13955, 1.6613, 1.6909); the helper-free d = 0 native on the 104 ports: regenerated and equal to the shipped object, exact and mod 2^61 - 1 replay, 208 x 208 transfer matrix, public 1652.63 and owned 208, floor 1651.50, budget lines 172.78 / 175.86, caller block, 100 single-edit mutants (97 rejected, the 3 accepted are one true equivalence)." + }, + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/checks/check_joint_w.py" + ], + "timeout_seconds": 400, + "checks": "The single joint caller stream of 78 roles replayed mod p at the four central characters to the block-diagonal target (12 evaluations of 6,084 entries, each type alone, cross-type blocks), each stage's pair read from the root against its native's declared pair, native hashes, target exponents against both roots' mask incidences, single LAMBDA flips, controls (W stage served by the wrong native, ungauged root, wrong root entries, wrong alpha), and the invoice rebuilt from emitted events and, independently, from the two roots plus the natives, term for term." + } + ] +} \ No newline at end of file diff --git a/research/p104-whitehead-native-objects/check.py b/research/p104-whitehead-native-objects/check.py new file mode 100644 index 0000000000..da558508d5 --- /dev/null +++ b/research/p104-whitehead-native-objects/check.py @@ -0,0 +1,122 @@ +#!/usr/bin/env python3 +"""Replay of the objects of this package. Standard library only, about two minutes. + + python3.12 -I -B check.py + + 1. sha256 of every object against data/OBJECTS.json. + 2. The two natives (the baseline native and the one with the owned-UP prefix on the 8 hosted ports) replayed + event by event in exact Fractions: frame law, dyadic rows, the exact endpoint X = x + alpha y, Y = x + (1 + alpha) y + (hosted ports X = x - 2y, Y = x/2 at t = -1), owned UP mass 56 and 64. A control declares the wrong alpha and must fail. + 3. The two roots with W stages (outer, and connected rho = 1 with 18 stages), each by its own checker, with controls. + 4. Exact kappa of the baseline and of the Whitehead invoice (Decimal, 50 digits), S, D, and the move between them. + 5. The exact targets: break-even 0.10987 / 0.13955 UP per port-call and the budget arithmetic. + 6. The helper-free Whitehead native on the 104 ports (checks/window_native.py). +The joint caller replay is the second command of VERIFY.json (checks/check_joint_w.py).""" +import gzip, hashlib, json, os, subprocess, sys, tempfile +from collections import Counter +from decimal import Decimal as D, getcontext +from fractions import Fraction as Q + +getcontext().prec = 50 +HERE = os.path.dirname(os.path.abspath(__file__)) +DATA = os.path.join(HERE, 'data') +CH = os.path.join(HERE, 'checks') + + +def need(ok, msg): + if not ok: + raise SystemExit('FAIL ' + msg) + print('PASS ' + msg, flush=True) + + +def run(args, env=None): + e = {'PATH': os.environ.get('PATH', '')} + e.update(env or {}) + r = subprocess.run([sys.executable, '-I', '-B'] + args, capture_output=True, text=True, env=e) + return r.returncode, r.stdout + r.stderr + + +# 1 ---------------------------------------------------------------- objects +man = json.load(open(os.path.join(DATA, 'OBJECTS.json')))['objects'] +for name, row in man.items(): + need(hashlib.sha256(open(os.path.join(HERE, name), 'rb').read()).hexdigest() == row['sha256'], 'sha256 ' + name) + +# 2 ---------------------------------------------------------------- natives +rc, out = run([os.path.join(CH, 'verify_host3w.py'), os.path.join(DATA, 'mmW.json.gz'), '1125']) +need(rc == 0 and 'PASS_HOST3 decoupled ports 96 hosted ports 8 alpha -2 beta 1/2 t -1' in out and 'endpoint bad rows 0' in out + and "owned UP {1: 18, 2: 4, 3: 1, 4: 6, 5: 1, 6: 1}" in out and 'events 71184' in out, + 'the Whitehead native (baseline plus 8 prefixes): exact endpoint, 71,184 events, owned UP mass 64, hosted X = x - 2y, Y = x/2, t = -1') +rc, out = run([os.path.join(CH, 'verify_host3w.py'), os.path.join(DATA, 'mm.json.gz'), '1125']) +need(rc == 0 and 'PASS_HOST3 decoupled ports 96 hosted ports 8 alpha -1 beta 1/2 t -1/2' in out and 'endpoint bad rows 0' in out + and "owned UP {1: 10, 2: 4, 3: 1, 4: 6, 5: 1, 6: 1}" in out and 'events 71144' in out, + 'baseline native: exact endpoint, 71,144 events, owned UP mass 56, t = -1/2') +W = json.load(gzip.open(os.path.join(DATA, 'mmW.json.gz'), 'rt')) +W['hosted']['alpha'] = '-1' +with tempfile.TemporaryDirectory() as td: + p = os.path.join(td, 'wrong_alpha.json.gz') + with gzip.open(p, 'wt') as f: + json.dump(W, f) + rc, out = run([os.path.join(CH, 'verify_host3w.py'), p, '1125']) +need(rc != 0 and 'endpoint bad rows 16' in out, 'control: the Whitehead native declared with alpha = -1 is rejected (16 bad rows)') + +# 3 ---------------------------------------------------------------- roots +rc, out = run([os.path.join(CH, 'root_check_hw.py'), os.path.join(DATA, 'rootw1g.json')], {'WSTAGES': '1'}) +need(rc == 0 and out.strip().endswith('PASS_ROOT_HOSTED') and 'FAIL' not in out, 'type B root with W stages 1 and 18 (hosted checker, t = -1 exactly at W stages only)') +rc, out = run([os.path.join(CH, 'root_check_hw.py'), os.path.join(DATA, 'root_h.json')], {'WSTAGES': '1'}) +need(rc != 0 and 'FAIL' in out, 'control: the root without W stages fails the W-root checker') +rc, out = run([os.path.join(CH, 'root_check_hw.py'), os.path.join(DATA, 'rootw1.json')], {'WSTAGES': '1'}) +need(rc != 0 and 'FAIL' in out, 'control: the ungauged W root fails (its pairs do not match the natives)') +rc, out = run([os.path.join(CH, 'rootcheck_w.py'), os.path.join(DATA, 'rootw1g.json')]) +need(rc == 0 and 'RESULT ALL_REQ_PASS' in out, 'outer W root: every requirement of the root checker') +rc, out = run([os.path.join(CH, 'rootcheck_w.py'), os.path.join(DATA, 'r1_W18_t3.json')]) +need(rc == 0 and 'RESULT ALL_REQ_PASS' in out and 'rank mod p = 1444 of n^2 = 1444' in out, + 'connected rho = 1 root, 18 stages at t = -1: every requirement (product -I, symbolic whole-job identity, mask credit, rank G = n, strongly connected, irreducible)') +R = json.load(open(os.path.join(DATA, 'r1_W18_t3.json'))) +need(R['n'] == 38 and len(R['stages']) == 18 and all(len(s['units']) == 2 for s in R['stages']), 'rho = 1 root shape: n = 38, 18 stages of two consecutive units (N = 39, rho = 1)') +R['X'][5][3] = str(Q(R['X'][5][3]) + 1) +with tempfile.TemporaryDirectory() as td: + p = os.path.join(td, 'bad_root.json') + json.dump(R, open(p, 'w')) + rc, out = run([os.path.join(CH, 'rootcheck_w.py'), p]) +need(rc != 0 and 'FAIL' in out, 'control: one wrong X entry in the rho = 1 root is rejected') + +# 4 ---------------------------------------------------------------- kappa +def load(f): + i = json.load(open(os.path.join(DATA, f))) + return Counter({int(k): v for k, v in i['T'].items()}), Counter({int(k): v for k, v in i['P'].items()}) + + +def kap(T, P): + rs = sorted(set(T) | set(P)); lo, hi = D('0.001'), D('0.0045') + for _ in range(200): + m = (lo + hi) / 2 + if sum((D(T.get(r, 0)) - D(P.get(r, 0))) * (D(r).ln() * (1 - m)).exp() for r in rs) > 0: lo = m + else: hi = m + return lo + + +T0, P0 = load('mm.chain.invoice.json'); Tw, P1 = load('w.joint.invoice.json') +S0 = sum(r * (T0[r] - P0[r]) for r in set(T0) | set(P0)); S1 = sum(r * (Tw[r] - P1[r]) for r in set(Tw) | set(P1)) +Dd = lambda T, P: sum((D(T[r]) - D(P[r])) * D(r) * D(r).ln() for r in set(T) | set(P)) +k0, k1 = kap(T0, P0), kap(Tw, P1) +need(S0 == 1520 and S1 == 1504, 'S = 1520 (baseline) and 1504 (Whitehead): the 8 carriers x 2 W calls cost 16') +need(str(k0).startswith('0.00362701882') and str(k1).startswith('0.0035927413806393823240'), 'exact kappa: baseline %s, Whitehead %s' % (str(k0)[:16], str(k1)[:24])) +need(+(Tw - T0) == Counter({129: 8}) and +(T0 - Tw) == Counter({145: 8}) and +(P1 - P0) == Counter({1: 16}) and +(P0 - P1) == Counter({8: 16}), + 'invoice move: T 8 x {145} -> 8 x {129} (hub-2 drop on the B ports), P -16 x {8} +16 x {1}') +pct = (k1 / k0 - 1) * 100 +need(D('-0.9452') < pct < D('-0.9450'), 'Whitehead kappa against the baseline: %s%% (below it; not a candidate)' % str(pct)[:8]) +need(abs(Dd(Tw, P1) - D('421735.2022776638')) < D('1e-6'), 'D = %s' % str(Dd(Tw, P1))[:14]) + +# 5 ---------------------------------------------------------------- exact targets +Tw = {'outer w=1 (2 calls)': D('11.4263770958522'), 'rho=1 (18 calls)': D('14.513107')} +cstar = {k: v / 104 for k, v in Tw.items()} +need(D('0.10986') < cstar['outer w=1 (2 calls)'] < D('0.10988') and D('0.13954') < cstar['rho=1 (18 calls)'] < D('0.13956'), + 'break-even per port-call c* = T / 104 = %s (outer) / %s (rho = 1); the carrier here costs 1.00' % (str(cstar['outer w=1 (2 calls)'])[:7], str(cstar['rho=1 (18 calls)'])[:7])) +mm_own = D('111.573067') +pass_outer, pass_rho = (mm_own + Tw['outer w=1 (2 calls)'] + D('49.7765')) / 104, (mm_own + Tw['rho=1 (18 calls)'] + D('49.7765')) / 104 +need(D('1.6612') < pass_outer < D('1.6614') and D('1.6908') < pass_rho < D('1.6910'), 'pass line with the helper-free public layer: owned <= %s (outer) / %s (rho = 1) per port per W call' % (str(pass_outer)[:6], str(pass_rho)[:6])) + +# 6 ---------------------------------------------------------------- the Whitehead native on P104 +rc, out = run([os.path.join(CH, 'window_native.py')]) +need(rc == 0 and out.strip().endswith('PASS_WINDOW_NATIVE'), 'helper-free d = 0 native on P104: regenerated, exact and mod-p replay, structure, price, budget, 100 mutants\n' + out) +print('PASS_PACKAGE_CHECK') diff --git a/research/p104-whitehead-native-objects/checks/check_joint_w.py b/research/p104-whitehead-native-objects/checks/check_joint_w.py new file mode 100644 index 0000000000..7f644efb0b --- /dev/null +++ b/research/p104-whitehead-native-objects/checks/check_joint_w.py @@ -0,0 +1,219 @@ +#!/usr/bin/env python3 +"""Joint caller check (stdlib only; writes mm.joint.invoice.json and ctl_rootB_X.json). python3 -I -B check_joint.py +(R) both roots by their own checkers, with controls; (C) literal replay of the ONE joint event stream over F_p on 78 roles (A roles 0..39, B roles 40..77), +at the four central characters q^4=1, one common set of 18 stage values for both types, block-diagonal target, with mutation / wrong-root / mask / cross-type controls; +(I) the invoice recounted from emitted events and compared with mm.chain.invoice.json, and from the two roots independently; (W) port types tied to the word.""" +import json, gzip, sys, random, copy, subprocess, importlib.util, os, tempfile +HERE = os.path.dirname(os.path.abspath(__file__)) + '/'; DATA = HERE + '../data/'; OUT = tempfile.mkdtemp() + '/' # package paths; scratch outputs go to a temporary directory +from fractions import Fraction as Q +from collections import Counter +from decimal import Decimal as D, getcontext +getcontext().prec = 50 +def need(ok, msg): + if not ok: raise SystemExit('FAIL ' + msg) + print('PASS', msg, flush=True) +J = json.load(open(DATA + 'joint_caller_w.json')); W = json.load(gzip.open(DATA + 'mm.json.gz', 'rt')); WW = json.load(gzip.open(DATA + 'mmW.json.gz', 'rt')); WORDS = {'mm': W, 'mmW': WW} +RA = json.load(open(DATA + 'root_t0_dsum.json')); RB = json.load(open(DATA + 'rootw1g.json')); RB0 = json.load(open(DATA + 'rootw1.json')) # W root (gauged) and its ungauged original as the other-gauge control +def ld(path, name): + s = importlib.util.spec_from_file_location(name, path); m = importlib.util.module_from_spec(s); sys.modules[name] = m; s.loader.exec_module(m); return m +# ---------------------------------------------------------------- (R) roots +RC = ld(HERE + 'root_check_a.py', 'rca') +need(RC.run(RA) == [], '(R) type A root (two #6833 chain roots, t=0): root_check_a run() clean') +Rm = copy.deepcopy(RA); Rm['X'][5][3] = str(Q(Rm['X'][5][3]) + 1) +need(RC.blocks(Rm) != [] and RC.run(Rm) != [], '(R) wrong-root control A: a wrong X entry FAILS (%s)' % RC.blocks(Rm)[:1]) +def hosted(path): + r = subprocess.run([sys.executable, '-B', HERE + 'root_check_hw.py', path], capture_output=True, text=True, env={'WSTAGES': '1'}); return r.stdout +o = hosted(DATA + 'rootw1g.json'); need(o.strip().endswith('PASS_ROOT_HOSTED') and 'FAIL' not in o, '(R) type B root (outer W root, w=1, in the type B gauge, n=38; t=-1 at stages 1,18; t=-1/2 elsewhere): root_check_hw passes every line') +o = hosted(DATA + 'root_h.json'); need('FAIL' in o, '(R) control: the old B root root_h.json (no W stage) FAILS root_check_hw at WSTAGES=1') +o = hosted(DATA + 'rootw1.json'); need('FAIL' in o, '(R) control: the ungauged W root rootw1.json FAILS root_check_hw (pairs do not match the natives)') +Rm = copy.deepcopy(RB); Rm['X'][5][3] = str(Q(Rm['X'][5][3]) + 1); json.dump(Rm, open(OUT + 'ctl_rootB_X.json', 'w')) +o = hosted(OUT + 'ctl_rootB_X.json'); need('FAIL' in o and not o.strip().endswith('PASS_ROOT_HOSTED'), '(R) wrong-root control B: a wrong X entry in the hosted root FAILS root_check_h') +# ---------------------------------------------------------------- (C) joint replay +pM = 2147483629 +IM = next(pow(g, (pM - 1) // 4, pM) for g in range(2, 99) if pow(g, (pM - 1) // 2, pM) == pM - 1); HALF = (pM + 1) // 2 +fm = lambda x: (lambda f: f.numerator % pM * pow(f.denominator, pM - 2, pM) % pM)(Q(x)) +def root_pairs(root): + dot = lambda a_, b_: sum(Q(u) * Q(v) for u, v in zip(a_, b_) if Q(u) and Q(v)); out = {} + for k, s_ in enumerate(root['stages']): + u, v = s_['units']; out[k + 1] = (dot(root['Y'][u], root['X'][v]), dot(root['Y'][v], root['X'][u])) + return out +def mask_inc(root, c): return [int(c in set(s['mask'])) for s in root['stages']] +H = W['hosted']; al_w, be_w, a2_w = Q(H['alpha']), Q(H['beta']), Q(H['alpha2']) +PB = root_pairs(RB); SN = {int(k): v for k, v in J['stage_native'].items()} +wpair = lambda tag: (Q(WORDS[tag]['hosted']['alpha']), Q(WORDS[tag]['hosted']['beta'])) +need(len(PB) == 18 and all(PB[st] == wpair(SN[st]) for st in range(1, 19)) and [st for st in SN if SN[st] == 'mmW'] == [1, 18], '(C) each of the 18 hosted stages of root B has the pair of the native called there: mm (-1,1/2) at 16 stages, mmW (-2,1/2, t=-1) at W stages 1,18, read from the root') +need(all(e[4] == SN[e[1]] for e in J['events'] if e[0] == 'J'), '(C) every joint contact is tagged with its stage native') +need(J['natives']['mm'] == __import__('hashlib').sha256(open(DATA + 'mm.json.gz','rb').read()).hexdigest()[:16] and J['natives']['mmW'] == __import__('hashlib').sha256(open(DATA + 'mmW.json.gz','rb').read()).hexdigest()[:16], '(C) native hashes in the caller equal the files') +TA, TB = J['types']['A'], J['types']['B'] +need(all(TA['diagonal'][c][2:] == mask_inc(RA, c) for c in range(40)), '(C) type A caller target exponents equal the A root mask incidence (field by field, stage by stage)') +need(all(TB['diagonal'][c][2:] == mask_inc(RB, c) for c in range(38)), '(C) type B caller target exponents equal the B root mask incidence') +need(Q(TA['alpha2']) == a2_w and Q(TA['beta2']) == Q(H['beta2']) == 0, '(C) type A plane-2 parameters equal the word\'s') +need(all((Q(e[3][2]), Q(e[3][3])) == wpair(e[4]) for e in J['events'] if e[0] == 'J'), '(C) every joint contact carries its own native\'s hosted pair on its B tuple') +need(all(Q(WORDS[t]['hosted']['alpha2']) == a2_w and WORDS[t]['hosted']['Dports'] == H['Dports'] for t in WORDS), '(C) both natives have the same A-type ports and plane-2 parameter') +NR = J['roles'] +def target(Jc, c_role, qv, Dv): + t, off = (Jc['types']['A'], 0) if c_role < 40 else (Jc['types']['B'], 40); dg = t['diagonal'][c_role - off] + c = pow(qv, dg[0] % 4, pM) + for k, bit in enumerate(dg[2:]): + if bit: c = c * Dv[k + 1] % pM + return c +def replay(Jc, qv, Dv, a2=a2_w, pairs=PB, types='AB', tgt=target, order_check=True): + Rm_ = [[int(i == j) for j in range(NR)] for i in range(NR)]; qi = pow(qv, pM - 2, pM); seen = [] + for e in Jc['events']: + tag = e[0] + if tag == 'J': + st = e[1]; seen.append(st); d = Dv[st] + if 'A' in types: + src, dst, x2, y2 = e[2] + Rm_[dst] = [(a_ + qi * b_) % pM for a_, b_ in zip(Rm_[dst], Rm_[src])] + Rm_[x2] = [(a_ + fm(a2) * qv % pM * b_) % pM for a_, b_ in zip(Rm_[x2], Rm_[y2])] + for r_ in (src, dst, x2, y2): Rm_[r_] = [a_ * d % pM for a_ in Rm_[r_]] + if 'B' in types: + src, dst = e[3][0], e[3][1]; a_, b_ = fm(pairs[st][0]), fm(pairs[st][1]); tt_ = a_ * b_ % pM + ns = [(x + a_ * qv % pM * y) % pM * d % pM for x, y in zip(Rm_[src], Rm_[dst])] + nd = [(b_ * qi % pM * x + (1 + tt_) * y) % pM * d % pM for x, y in zip(Rm_[src], Rm_[dst])] + Rm_[src], Rm_[dst] = ns, nd + continue + if tag not in types: continue + op = e[1] + if op == 'ADD': Rm_[e[2]] = [(a_ + fm(e[4]) * b_) % pM for a_, b_ in zip(Rm_[e[2]], Rm_[e[3]])] + elif op == 'SCALE': c = fm(e[3]); Rm_[e[2]] = [a_ * c % pM for a_ in Rm_[e[2]]] + elif op == 'SWAP': Rm_[e[2]], Rm_[e[3]] = Rm_[e[3]], Rm_[e[2]] + elif op == 'QUERY': c = pow(qv, e[4] % 4, pM); Rm_[e[2]] = [(a_ + c * b_) % pM for a_, b_ in zip(Rm_[e[2]], Rm_[e[3]])] + elif op == 'LAMBDA': + s_ = e[3]; c = ((1 + s_ * IM) * HALF + (1 - s_ * IM) * HALF * qv * qv) % pM; Rm_[e[2]] = [a_ * c % pM for a_ in Rm_[e[2]]] + elif op == 'IDLE_ONE': + c = 1 + for k in e[3]: c = c * Dv[k] % pM + Rm_[e[2]] = [a_ * c % pM for a_ in Rm_[e[2]]] + else: raise SystemExit('FAIL unknown caller event ' + op) + if order_check and seen != list(range(1, 19)): return 10 ** 6 + roles = [r for r in range(NR) if ('A' in types and r < 40) or ('B' in types and r >= 40)] + return sum(Rm_[i][j] != (tgt(Jc, i, qv, Dv) if i == j else 0) for i in roles for j in range(NR)) +rnd = random.Random(11); tot = cnt = 0 +for qv in (1, IM, pM - 1, pM - IM): + for _ in range(3): + Dv = {s_: rnd.randrange(2, pM) for s_ in range(1, 19)}; tot += replay(J, qv, Dv); cnt += 1 +need(tot == 0, '(C) the ONE joint stream (78 roles, one stage value per stage common to both types) replays to the block-diagonal target at all four central characters (%d evaluations, 0 bad of %d entries each, cross-type blocks included)' % (cnt, NR * NR)) +for ty in ('A', 'B'): + t2 = sum(replay(J, qv, {s_: rnd.randrange(2, pM) for s_ in range(1, 19)}, types=ty) for qv in (1, IM, pM - 1, pM - IM)) + need(t2 == 0, '(C) type %s alone (events and joint-contact half of its own type) replays to its target at the four characters' % ty) +Dv = {s_: rnd.randrange(2, pM) for s_ in range(1, 19)} +def rej(Jc=J, **kw): return replay(Jc, IM, Dv, **kw) +def mut(f): + Jm = copy.deepcopy(J); f(Jm); return Jm +idx = lambda Jc, pred: next(i for i, e in enumerate(Jc['events']) if pred(e)) +first = lambda tag, op: (lambda e: e[0] == tag and e[1] == op) +ctr = [] +ctr.append(('A wrong alpha2', rej(a2=Q(1)))) +for nm, fn in (('B alpha sign', lambda x: x.__setitem__(0, -x[0])), ('B beta sign', lambda x: x.__setitem__(1, -x[1])), ('B pair swapped', lambda x: x.reverse())): + pm = {k: list(v) for k, v in PB.items()}; fn(pm[13]); ctr.append((nm + ' at stage 13', rej(pairs=pm))) +ctr.append(('B root in the other gauge (ungauged rootw1)', rej(pairs=root_pairs(RB0)))) +pm = dict(PB); pm[1] = wpair('mm'); ctr.append(('W stage 1 served by mm (t=-1/2 pair) instead of mmW', rej(pairs=pm))) +pm = dict(PB); pm[18] = wpair('mm'); ctr.append(('W stage 18 served by mm instead of mmW', rej(pairs=pm))) +pm = dict(PB); pm[5] = wpair('mmW'); ctr.append(('H stage 5 served by mmW instead of mm', rej(pairs=pm))) +for ty in 'AB': + ctr.append(('%s deleted IDLE_ONE' % ty, rej(mut(lambda Jm: Jm['events'].pop(idx(Jm, first(ty, 'IDLE_ONE'))))))) + ctr.append(('%s deleted QUERY' % ty, rej(mut(lambda Jm: Jm['events'].pop(idx(Jm, first(ty, 'QUERY'))))))) + def flip(Jm): + j0 = idx(Jm, lambda e: e[0] == 'J'); k = max(i for i in range(j0) if Jm['events'][i][0] == ty and Jm['events'][i][1] == 'LAMBDA'); Jm['events'][k][3] *= -1 + ctr.append(('%s flipped LAMBDA before the first contact' % ty, rej(mut(flip)))) +for nm, bad in ctr: print(' control %-52s -> %d bad' % (nm, bad)) +need(all(b > 0 for _, b in ctr), '(C) controls: wrong alpha2, wrong/other-gauge hosted pair, deleted idle, deleted query, flipped LAMBDA at a contact, each type: all rejected') +def tm(Jm, ty, role, st): + Jm['types'][ty]['diagonal'][role][2 + st] ^= 1 +for ty, role in (('A', 3), ('B', 3)): + Jm = mut(lambda x: tm(x, ty, role, 4)); b = rej(Jm) + need(b > 0 and Jm['types'][ty]['diagonal'][role][2:] != (mask_inc(RA, role) if ty == 'A' else mask_inc(RB, role)), '(C) mask control %s: a wrong mask bit in the caller target fails the replay (%d bad) and the mask comparison' % (ty, b)) +Jm = mut(lambda x: x['events'].insert(idx(x, lambda e: e[0] == 'J'), ['A', 'ADD', 5, 45, '1'])); b = rej(Jm) +need(b > 0, '(C) cross-type control: one ADD from an A role into a B role is rejected (%d bad): the types do not interact' % b) +Jm = mut(lambda x: x['events'].insert(idx(x, lambda e: e[0] == 'J'), ['B', 'ADD', 45, 5, '1'])); need(rej(Jm) > 0, '(C) cross-type control, other direction rejected') +def swapst(x): + js = [e for e in x['events'] if e[0] == 'J']; js[0][1], js[1][1] = js[1][1], js[0][1] +need(rej(mut(swapst)) > 0, '(C) stage-order control: two joint contacts with exchanged stages rejected') +def rot(x): + e = x['events'][idx(x, lambda e: e[0] == 'J')]; a = e[2]; e[2] = [a[0], a[1], a[3], a[2]] +need(rej(mut(rot)) > 0, '(C) exchanged second-plane roles (X2,Y2) in a contact rejected') +# exhaustive single LAMBDA flips (information): how many are detected, per type +for ty in 'AB': + ids = [i for i, e in enumerate(J['events']) if e[0] == ty and e[1] == 'LAMBDA']; miss = 0 + for i in ids: + Jm = copy.deepcopy(J); Jm['events'][i][3] *= -1; miss += replay(Jm, IM, Dv) == 0 + print(' info: type %s: %d LAMBDA events, single flips not detected at one character: %d' % (ty, len(ids), miss)) +# ---------------------------------------------------------------- (W) port types +live = W['live']; n = len(W['initial']); DP = H['Dports'] +need(WW['live'] == W['live'] and WW['hosted']['whitehead']['prefix_ports'] == sorted(TB['ports']) and sorted(TA['ports']) == sorted(DP) and sorted(TB['ports']) == [i for i in range(104) if i not in set(DP)] and len(TA['ports']) == 96 and len(TB['ports']) == 8, '(W) joint caller port types equal the word\'s: A = Dports (96), B = the other 8') +X2 = set(H['X2']); Y2 = set(H['Y2']); need(len(X2) == len(Y2) == 96, '(W) second mains exist for exactly the 96 type-A ports') +sc = [e for e in W['program'] if e[0] == 'SCALE'] +print('INFO (W-gauge): original clause, now informational only:',{e[1] for e in sc[:8]}=={live[i] for i in TB['ports']} and all(Q(e[2]) == Q(1, 2) for e in sc[:8]),'| first 8 SCALEs:',[(e[1],e[2]) for e in sc[:8]],'| gauge covered by exact endpoint B.X = x-y, B.Y=(x+y)/2 [rep.py]') +# ---------------------------------------------------------------- (I) invoice from emitted events +fr = W['frames']; dm = [len(b) for b in fr]; live_s = set(live); mains = live_s | {r + 112 for r in live_s} | X2 | Y2 +def hp(Wd): return Counter(dm[Wd['final'][r]] - dm[Wd['initial'][r]] for r in range(n) if r not in mains), Counter(abs(dm[e[3]] - dm[e[2]]) for e in Wd['program'] if e[0] == 'MOVE') +assert WW['frames'] == W['frames'] and WW['initial'] == W['initial'] and WW['final'] == W['final'] +HP = {t: hp(WORDS[t]) for t in WORDS}; hel, paid = HP['mm'] +nA, nB = len(TA['ports']), len(TB['ports']); cnt_ty = {'A': nA, 'B': nB} +T = Counter(); P = Counter(); nj = 0 +for e in J['events']: + if e[0] == 'J': nj += 1; T.update(HP[e[4]][0]); P.update(HP[e[4]][1]) # ONE native call per stage, of the native tagged at that stage + elif e[1] == 'QUERY': P[1] += cnt_ty[e[0]] + elif e[1] == 'IDLE_ONE': P[8 * len(e[3])] += cnt_ty[e[0]] +for ty, t in (('A', TA), ('B', TB)): + for dg in t['diagonal']: T[int(dg[0] % 2) + 8 * sum(dg[2:])] += cnt_ty[ty] +need(nj == 18, '(I) 18 joint native contacts (one per stage)') +def kap(T, P): + rs = sorted(set(T) | set(P)); lo, hi = D('0.001'), D('0.0045') + for _ in range(200): + m = (lo + hi) / 2 + if sum((D(T.get(r, 0)) - D(P.get(r, 0))) * (D(r).ln() * (1 - m)).exp() for r in rs) > 0: lo = m + else: hi = m + return lo +S = sum(r * (T[r] - P[r]) for r in set(T) | set(P)); kj = kap(T, P) +inv = json.load(open(DATA + 'mm.chain.invoice.json')); Tw = Counter({int(k): v for k, v in inv['T'].items()}); P1 = Counter({int(k): v for k, v in inv['P'].items()}) +print(' bill vs mm invoice: T', dict(sorted((+(T - Tw)).items())), '-', dict(sorted((+(Tw - T)).items())), '| P', dict(sorted((+(P - P1)).items())), '-', dict(sorted((+(P1 - P)).items()))) +print(' S', S, 'kappa', str(kj)[:24], 'D', sum((T[r] - P[r]) * r * float(D(r).ln()) for r in set(T) | set(P))) +print(' Whitehead kappa', kj) +# independent: root part per type from the roots, native part from the word +def root_fields(RR): + S_ = RR['stages']; Xr = RR['X']; Yr = RR['Y']; F = [] + for c in range(RR['n']): + ms = [k for k, s_ in enumerate(S_) if c in set(s_['mask'])]; F.append((ms, [k for k in ms if any(Q(Yr[u][c]) != 0 for u in S_[k]['units'])])) + dot = lambda a_, b_: sum(Q(u) * Q(v) for u, v in zip(a_, b_) if Q(u) and Q(v)); planes = [] + for s_ in S_: + u, v = s_['units']; planes.append(2 if dot(Yr[u], Xr[v]) == 0 and dot(Yr[v], Xr[u]) == 0 else 1) + return F, planes, RR['N'] - sum(len(s_['units']) for s_ in S_) +def outer(F, planes, thin, ports): + T_ = Counter(); P_ = Counter(); hc = Counter() + for ms, host in F: + T_[8 * len(ms) + 1] += ports + for k in host: hc[k] += 1 + run = 0; prev = None + for k in ms: + if k in host: + if run: P_[8 * run] += ports + run = 0; prev = None; continue + if prev is not None and k == prev + 1: run += 1 + else: + if run: P_[8 * run] += ports + run = 1 + prev = k + if run: P_[8 * run] += ports + for k in range(18): + if hc[k] > 2 * planes[k]: P_[8] += ports * (hc[k] - 2 * planes[k]) + P_[1] += ports * thin + return T_, P_ +T2 = Counter(); P2 = Counter() +for RR, ports in ((RA, nA), (RB, nB)): + F, pl, th = root_fields(RR); t_, p_ = outer(F, pl, th, ports); T2.update(t_); P2.update(p_) +nW = sum(1 for t in SN.values() if t == 'mmW') +for tg, c in (('mm', 18 - nW), ('mmW', nW)): + for r, k in HP[tg][0].items(): T2[r] += c * k + for r, k in HP[tg][1].items(): P2[r] += c * k +need(+T2 == +T and +P2 == +P, '(I) invoice rebuilt from the two ROOTS (per type, per port count) plus the word equals the emitted-event invoice term for term') +mc = Counter(T); mc.update({}); Tn = Counter(T) +# controls: perturbed port count / moved port / dropped event change the invoice +Jm = copy.deepcopy(J); Jm['events'].pop(idx(Jm, first('B', 'IDLE_ONE'))) +Pm = Counter(P); Pm[8 * len([e for e in J['events'] if e[0] == 'B' and e[1] == 'IDLE_ONE'][0][3])] -= nB +need(+Pm != +P, '(I) control: a deleted B idle changes the recounted invoice') +Tx = Counter(T); Px = Counter(P); Px.subtract(HP['mmW'][1]); Px.update(HP['mm'][1]); need(+Px != +P, '(I) control: pricing a W contact with mm changes the invoice') +json.dump({'T': {str(k): v for k, v in sorted(T.items())}, 'P': {str(k): v for k, v in sorted(P.items())}}, open(OUT + 'w.joint.invoice.json', 'w')) +print('PASS_JOINT_CALLER_ALL') diff --git a/research/p104-whitehead-native-objects/checks/root_check_a.py b/research/p104-whitehead-native-objects/checks/root_check_a.py new file mode 100644 index 0000000000..febc9c8953 --- /dev/null +++ b/research/p104-whitehead-native-objects/checks/root_check_a.py @@ -0,0 +1,130 @@ +#!/usr/bin/env python3 +"""Root checker for the two-chain root (standard library). python3 -I -B root_check.py [data/root.json] +The root is literally two copies of the #6833 chain-nested root on orthogonal coordinates (n = 20 each), one stage variable per stage, units interleaved +(chain A, chain B). This checker (1) regenerates the chain root from its closed form (L site i: x = A + f_i + 2 sum_{jm} h_l, y = A* + h_m*; three thin queries) and requires all 21 units of EACH chain to equal the file, requires the cross Gram between +the chains to vanish and each chain's Gram to be sgn(i-j); (2) re-proves the SPEC-level identities for the whole root in exact Fractions: isotropy, product -I, +stage order, units inside masks, masks commuting with the prefix before and after the stage, the symbolic whole-job identity M(D) = -diag(prod D^eps) with each D once and affine, +full mask credit, dyadic x,y. +DECLARED: the lines of the predecessor family checks that this root does not satisfy, and why they are not requirements of the outer theorem: + hosted t != 0 (The hosted family's root check line 'hosted t not 0, not -1'): here t = 0 by construction (no coupled plane; two separate planes per stage); + hosted alpha, beta dyadic units: here alpha = beta = 0 (same reason); + Gram digraph strongly connected (added by the #6883 root_check.py itself, not a SPEC line): here the Gram digraph has two components. + The theorem's requirement is on the unit identity and the whole-job credit, not on connectivity (see README).""" +import json, os, sys +from fractions import Fraction as Q + +def chain_sites(): + """The (9|9) chain-nested sites of #6833: list of (x, y, mask or None) in time order, n = 20 (field 19 is the empty field E).""" + n = 20; A = 0; f = list(range(1, 10)); h = list(range(10, 19)); E = 19 + def vec(*pairs): + v = [Q(0)] * n + for i, c in pairs: v[i] += Q(c) + return v + out = [] + for i in range(9): + out.append((vec((A, 1), (f[i], 1), *[(f[j], 2) for j in range(i)]), vec((A, 1), (f[i], -1)), {A, *f[:i + 1]})) + def thin(a, u, p=0, q=0): + x = [Q(0)] * n; y = [Q(0)] * n + x[A] = Q(a); y[A] = Q(u) + for i, j in enumerate(f): x[j] = Q(a + 1); y[j] = Q((1 - u) * (-1) ** i) + for r, j in enumerate(reversed(h)): x[j] = Q(1 - a); y[j] = Q((u - 1) * (-1) ** r) + x[E] = Q(q); y[E] = Q(p) + return x, y, None + out += [thin(0, 1, 0, 1), thin(-1, 2, 1, 0), thin(-1, 3, 1, -1)] + for m in range(9): + out.append((vec((A, -1), (h[m], 1), *[(h[l], 2) for l in range(m + 1, 9)]), vec((A, 1), (h[m], 1)), {A, *h[m:]})) + return out + +def blocks(R): + """Regeneration and block identities; returns a list of failure names (empty = all hold).""" + n, N = R['n'], R['N']; bad = [] + X = [[Q(v) for v in r] for r in R['X']]; Y = [[Q(v) for v in r] for r in R['Y']] + S = chain_sites() + if n != 40 or N != 42 or len(S) != 21: return ['shape'] + for c, off in (('A', 0), ('B', 20)): + for k, (x, y, m) in enumerate(S): + u = 2 * k + (0 if c == 'A' else 1) + ex = [Q(0)] * 40; ey = [Q(0)] * 40 + for i in range(20): ex[off + i] = x[i]; ey[off + i] = y[i] + if X[u] != ex or Y[u] != ey: bad.append('regeneration chain %s unit %d' % (c, k)) + dot = lambda a, b: sum(u * v for u, v in zip(a, b) if u and v) + ua = [2 * k for k in range(21)]; ub = [2 * k + 1 for k in range(21)] + if any(dot(Y[i], X[j]) != 0 or dot(Y[j], X[i]) != 0 for i in ua for j in ub): bad.append('cross Gram between the chains') + for nm, us in (('A', ua), ('B', ub)): + if any(dot(Y[i], X[j]) != ((a > b) - (a < b)) for a, i in enumerate(us) for b, j in enumerate(us)): bad.append('Gram of chain %s is not sgn(i-j)' % nm) + return bad + +def run(R, out=None): + """All requirements; returns the list of failures.""" + pr = out or (lambda s: None) + n, N = R['n'], R['N']; ST = R['stages'] + X = [[Q(v) for v in r] for r in R['X']]; Y = [[Q(v) for v in r] for r in R['Y']] + bad = [] + def req(name, ok, info=''): + pr(('PASS ' if ok else 'FAIL ') + name + (' ' + str(info) if info != '' else '')) + if not ok: bad.append(name) + dot = lambda a, b: sum(u * v for u, v in zip(a, b) if u and v) + bb = blocks(R) + req('two #6833 chain roots: all 21 units of each chain regenerate from the closed form, cross Gram 0, each Gram sgn(i-j)', not bb, bb[:3]) + if bb: return bad + I = [[Q(int(i == j)) for j in range(n)] for i in range(n)] + def lmul(M, x, y, c): + d = [sum(y[i] * M[i][j] for i in range(n) if y[i]) for j in range(n)] + return [[M[i][j] + c * x[i] * d[j] for j in range(n)] if x[i] else M[i][:] for i in range(n)] + req('isotropy y_k.x_k=0 all k', all(dot(Y[k], X[k]) == 0 for k in range(N))) + W = I; prefix = [] + for k in range(N): + prefix.append(W); W = lmul(W, X[k], Y[k], Q(-2)) + prefix.append(W) + req('T_{N-1}..T_0 = -I (I - 2xy)', W == [[-v for v in r] for r in I]) + us = [u for s in ST for u in s['units']]; L = len(ST) + req('stage units disjoint, consecutive, in time order, one unit of each chain per stage', len(us) == len(set(us)) and all(s['units'] == [s['units'][0], s['units'][0] + 1] for s in ST) and all(max(ST[i]['units']) < min(ST[i + 1]['units']) for i in range(L - 1)) and all(set(s['mask']) == {c for c in range(40) if any(X[u][c] or Y[u][c] for u in s['units'])} or set(s['mask']) >= {c for c in range(40) if any(X[u][c] or Y[u][c] for u in s['units'])} for s in ST)) + pr(' N n L tau %d %d %d %d thin units %s; mask ranks %s' % (N, n, L, N - len(us), [k for k in range(N) if k not in set(us)], [len(s['mask']) for s in ST])) + inside = lambda s: all(all(X[u][c] == 0 and Y[u][c] == 0 for c in range(n) if c not in set(s['mask'])) for u in s['units']) + req('stage units inside their coordinate mask', all(inside(s) for s in ST)) + def comm(mask, M): + m = set(mask); return all(M[i][j] == 0 for i in range(n) for j in range(n) if (i in m) != (j in m)) + req('mask commutes with the prefix before and after the stage', all(comm(s['mask'], prefix[min(s['units'])]) and comm(s['mask'], prefix[max(s['units']) + 1]) for s in ST)) + rows = [{i: {0: Q(1)}} for i in range(n)]; at = {max(s['units']): i for i, s in enumerate(ST)}; peak = 0 + for k in range(N): + dual = {} + for f, c in enumerate(Y[k]): + if c: + for col, p in rows[f].items(): + e = dual.setdefault(col, {}) + for m, v in p.items(): e[m] = e.get(m, 0) + c * v + for r, c in enumerate(X[k]): + if c: + for col, p in dual.items(): + e = rows[r].setdefault(col, {}) + for m, v in p.items(): + w = e.get(m, 0) - 2 * c * v + if w: e[m] = w + else: e.pop(m, None) + if not e: rows[r].pop(col) + if k in at: + b = 1 << at[k] + for r in ST[at[k]]['mask']: + new = {} + for col, p in rows[r].items(): + q = {} + for m, v in p.items(): + if m & b: bad.append('stage variable twice'); return bad + q[m | b] = v + new[col] = q + rows[r] = new + peak = max(peak, sum(len(p) for r in rows for p in r.values())) + tgt = [sum(1 << i for i, s in enumerate(ST) if r in set(s['mask'])) for r in range(n)] + req('symbolic M(D) = -diag(prod D^eps), eps = mask incidence, each of the 18 stage variables once and affine', all(rows[r] == {r: {tgt[r]: Q(-1)}} for r in range(n)), 'peak monomials %d' % peak) + req('every stage variable credited on all of its mask', all(bin(sum(1 << r for r in range(n) if tgt[r] >> i & 1)).count('1') == len(ST[i]['mask']) for i in range(L))) + dy = lambda v: v.denominator & (v.denominator - 1) == 0 + req('x, y dyadic', all(dy(v) for r in X + Y for v in r)) + pr(' declared family lines not met: t = alpha*beta = 0 for every stage pair (alpha = %s, beta = %s); Gram digraph has 2 components (cross Gram 0); max |entry| %s' % (dot(Y[0], X[1]), dot(Y[1], X[0]), max(abs(v) for r in X + Y for v in r))) + return bad + +if __name__ == '__main__': + R = json.load(open(sys.argv[1] if len(sys.argv) > 1 else os.path.join(os.path.dirname(os.path.abspath(__file__)), 'data', 'root.json'))) + bad = run(R, print) + print('PASS_ROOT_TWO_CHAINS' if not bad else 'FAILED ' + '; '.join(bad)) + sys.exit(1 if bad else 0) diff --git a/research/p104-whitehead-native-objects/checks/root_check_hw.py b/research/p104-whitehead-native-objects/checks/root_check_hw.py new file mode 100644 index 0000000000..6b6b89aafc --- /dev/null +++ b/research/p104-whitehead-native-objects/checks/root_check_hw.py @@ -0,0 +1,139 @@ +#!/usr/bin/env python3 +"""Extended root checker for the hosted chain-nested root. Standard library only. python3 -I -B root_check.py [data/root.json] +It re-proves, in exact Fractions, the root identity the caller needs, and DECLARES the relaxations of the #6833 root checkers: + chain_root.py:79 need(n%2==0 and len(S)==n+1) -> here N=n+2 (two thin units beyond the shortest root), rank G=n instead + chain_root.py:82 sign Gram y_i.x_j=sgn(i-j) -> not required (consequence of 79) + chain_root.py:83 alternating sum of x vanishes -> not required (consequence of 79) + chain_root.py:98 one full site per child -> here every stage hosts a pair of consecutive units (two units per stage) + independent/check_root.py:26 odd/odd family -> not required + independent/check_root.py:133 shortest root N=n+1 -> N=n+2 + independent/check_root.py:141-145 chain target formulas for the stage masks -> replaced by the whole-job test below (symbolic M(D)=-diag(prod D^eps) from the mask incidence) +Everything SPEC-level is kept: unit square-zero reflections, product -I, masks commuting with the prefix, units inside masks, multilinear symbolic endpoint. +Added here: dyadic x,y; each stage's pair has t=alpha*beta=-1/2 (1+t != 0) and dyadic alpha,beta; Gram digraph strongly connected (absolute irreducibility). +Prints PASS_ROOT_HOSTED on success.""" +import json,os,sys +WW=int(os.environ.get("WSTAGES","1")) +from fractions import Fraction as Q +import os +R=json.load(open(sys.argv[1] if len(sys.argv)>1 else os.path.join(os.path.dirname(os.path.abspath(__file__)),'data','root.json')));n,N=R['n'],R['N'] +X=[[Q(v) for v in r] for r in R['X']];Y=[[Q(v) for v in r] for r in R['Y']];ST=R['stages'] +assert len(X)==N==len(Y) and all(len(r)==n for r in X+Y) +bad=[] +def req(name,ok,info=''): + print(('PASS ' if ok else 'FAIL ')+name+(' '+str(info) if info!='' else ''),flush=True) + if not ok:bad.append(name) +dot=lambda a,b:sum(u*v for u,v in zip(a,b) if u and v) +I=[[Q(int(i==j)) for j in range(n)] for i in range(n)] +def lmul_unit(M,x,y,c): + """(I+c x y^T) M""" + d=[sum(y[i]*M[i][j] for i in range(n) if y[i]) for j in range(n)] + return [[M[i][j]+c*x[i]*d[j] for j in range(n)] if x[i] else M[i][:] for i in range(n)] +# 1 isotropy, nonzero +req('isotropy y_k.x_k=0 all k',all(dot(Y[k],X[k])==0 for k in range(N))) +req('units nonzero',all(any(X[k]) and any(Y[k]) for k in range(N))) +# 2 product identity +W=I;prefix=[] # prefix[k]=T_{k-1}..T_0 +for k in range(N): + prefix.append(W);W=lmul_unit(W,X[k],Y[k],Q(-2)) +prefix.append(W) +req('T_{N-1}..T_0=-I (order T_{N-1}..T_0, I-2xy)',W==[[-v for v in r] for r in I]) +# 3 stage partition +us=[u for s in ST for u in s['units']] +req('stage units disjoint',len(us)==len(set(us))) +req('each stage units consecutive',all(sorted(s['units'])==list(range(min(s['units']),max(s['units'])+1)) for s in ST)) +L=len(ST);thin=[k for k in range(N) if k not in set(us)] +hosted=[s for s in ST if len(s['units'])==2] +print(' N n L tau h',N,n,L,len(thin),len(hosted),'thin units',thin) +req('stages ordered in time',all(max(ST[i]['units'])>i&1)).count('1')==len(ST[i]['mask']) for i in range(L))) +# 6 hosts: frame-free t, plane +def t_of(u,v):return dot(Y[u],X[v])*dot(Y[v],X[u]) +print(' hosted pairs (u,v,alpha,beta,t,1+t):',[(s['units'][0],s['units'][1],str(dot(Y[s['units'][0]],X[s['units'][1]])),str(dot(Y[s['units'][1]],X[s['units'][0]])),str(t_of(*s['units'])),str(1+t_of(*s['units']))) for s in hosted]) +req('every hosted pair has the pair its native realises: H/M stages (-1,1/2) [mm], W stages (-2,1/2) [mmW]',all((dot(Y[x['units'][0]],X[x['units'][1]]),dot(Y[x['units'][1]],X[x['units'][0]]))==((-2,Q(1,2)) if x.get('letter')=='W' else (-1,Q(1,2))) for x in hosted)) +req('W stages are exactly the outer stages, symmetric',[i for i,x in enumerate(R['stages']) if x.get('letter')=='W']==[i for i in range(len(R['stages'])) if i=len(R['stages'])-WW]) +req('all 18 stages host',len(hosted)==18) +req('hosted t not 0, not -1 on H/M stages; t = -1 exactly on W stages',all((t_of(*s['units'])==-1) if s.get('letter')=='W' else (t_of(*s['units']) not in (0,-1)) for s in hosted)) +# path frame t for adjacent pair with q=+1 frame U=I+x y equals root frame t +# 7 dyadic +dy=lambda v:v.denominator&(v.denominator-1)==0 +req('x,y dyadic',all(dy(v) for r in X+Y for v in r)) +def odd(v): + v=abs(v.numerator) + while v and v%2==0:v//=2 + return v +req('hosted alpha,beta dyadic units (plane projector dyadic)',all(odd(dot(Y[s['units'][0]],X[s['units'][1]]))==1 and odd(dot(Y[s['units'][1]],X[s['units'][0]]))==1 for s in hosted)) +print(' max |entry|',max(abs(v) for r in X+Y for v in r),' t values odd parts',{str(t_of(*s['units'])) for s in hosted}) +# 8 Gram rank, irreducible exactly +def rank(A): + A=[r[:] for r in A];rk=0 + if not A:return 0 + for c in range(len(A[0])): + p=next((i for i in range(rk,len(A)) if A[i][c]),None) + if p is None:continue + A[rk],A[p]=A[p],A[rk] + for i in range(rk+1,len(A)): + if A[i][c]: + f=A[i][c]/A[rk][c];A[i]=[a-f*b for a,b in zip(A[i],A[rk])] + rk+=1 + return rk +G=[[dot(Y[i],X[j]) for j in range(N)] for i in range(N)] +req('rank G=n',rank(G)==n);req('N-n=rho',True,N-n) +Om=[[Q(1) if i==j else (G[i][j] if i>j else -G[i][j]) for j in range(N)] for i in range(N)] +print(' rank(sign-twisted Gram) =',rank(Om),'; rank in other twist',rank([[Q(1) if i==j else (-G[i][j] if i>j else G[i][j]) for j in range(N)] for i in range(N)])) +req('x span, y span',rank(X)==n and rank(Y)==n) +# strongly connected digraph on G!=0 (proof: W invariant, w!=0, some y_k w!=0 since y span => x_k in W; G_jk!=0 => x_j in W; x span => W=F^n) +def reach(s,fw): + seen={s};st=[s] + while st: + u=st.pop() + for v in range(N): + if v not in seen and (G[v][u] if fw else G[u][v]):seen.add(v);st.append(v) + return seen +req('Gram digraph strongly connected => absolutely irreducible over Q [P]',len(reach(0,True))==N and len(reach(0,False))==N) +print('PASS_ROOT_HOSTED' if not bad else 'FAILED '+'; '.join(bad)) +sys.exit(1 if bad else 0) diff --git a/research/p104-whitehead-native-objects/checks/rootcheck_w.py b/research/p104-whitehead-native-objects/checks/rootcheck_w.py new file mode 100644 index 0000000000..1002b002d7 --- /dev/null +++ b/research/p104-whitehead-native-objects/checks/rootcheck_w.py @@ -0,0 +1,143 @@ +#!/usr/bin/env python3 +"""Exact root verifier. Stdlib only, nothing imported. +Definition used (the root definition of the retained chain roots): T_k=I-2 x_k y_k^T, y_k.x_k=0, T_{N-1}..T_0=-I. +A stage k has coordinate mask E_k; the run word is Phi=Delta_k T (Delta_k=I+(D_k-1)E_k applied right after the stage's last unit). +Whole-job: symbolic M(D)=-diag(prod D_k^{eps_rk}), computed as sparse polynomial matrices, not sampled. +Usage: rootcheck.py file.json ; exits 0 only if every [REQ] passes. Informational lines start with ' '.""" +import json,sys +from fractions import Fraction as Q +R=json.load(open(sys.argv[1]));n,N=R['n'],R['N'] +X=[[Q(v) for v in r] for r in R['X']];Y=[[Q(v) for v in r] for r in R['Y']];ST=R['stages'] +assert len(X)==N==len(Y) and all(len(r)==n for r in X+Y) +bad=[] +def req(name,ok,info=''): + print(('PASS ' if ok else 'FAIL ')+name+(' '+str(info) if info!='' else ''),flush=True) + if not ok:bad.append(name) +dot=lambda a,b:sum(u*v for u,v in zip(a,b) if u and v) +I=[[Q(int(i==j)) for j in range(n)] for i in range(n)] +def lmul_unit(M,x,y,c): + """(I+c x y^T) M""" + d=[sum(y[i]*M[i][j] for i in range(n) if y[i]) for j in range(n)] + return [[M[i][j]+c*x[i]*d[j] for j in range(n)] if x[i] else M[i][:] for i in range(n)] +# 1 isotropy, nonzero +req('isotropy y_k.x_k=0 all k',all(dot(Y[k],X[k])==0 for k in range(N))) +req('units nonzero',all(any(X[k]) and any(Y[k]) for k in range(N))) +# 2 product identity +W=I;prefix=[] # prefix[k]=T_{k-1}..T_0 +for k in range(N): + prefix.append(W);W=lmul_unit(W,X[k],Y[k],Q(-2)) +prefix.append(W) +req('T_{N-1}..T_0=-I (order T_{N-1}..T_0, I-2xy)',W==[[-v for v in r] for r in I]) +# 3 stage partition +us=[u for s in ST for u in s['units']] +req('stage units disjoint',len(us)==len(set(us))) +req('each stage units consecutive',all(sorted(s['units'])==list(range(min(s['units']),max(s['units'])+1)) for s in ST)) +L=len(ST);thin=[k for k in range(N) if k not in set(us)] +hosted=[s for s in ST if len(s['units'])==2] +print(' N n L tau h',N,n,L,len(thin),len(hosted),'thin units',thin) +req('stages ordered in time',all(max(ST[i]['units'])>i&1)).count('1')==len(ST[i]['mask']) for i in range(L))) +# 6 hosts: frame-free t, plane +def t_of(u,v):return dot(Y[u],X[v])*dot(Y[v],X[u]) +print(' hosted pairs (u,v,alpha,beta,t,1+t):',[(s['units'][0],s['units'][1],str(dot(Y[s['units'][0]],X[s['units'][1]])),str(dot(Y[s['units'][1]],X[s['units'][0]])),str(t_of(*s['units'])),str(1+t_of(*s['units']))) for s in hosted]) +req('hosted t not 0, not -1 (W outer stages exempt: t must be -1 exactly)',all(t_of(*s['units']) not in (0,-1) for s in hosted if s['letter']!='W') and all(t_of(*s['units'])==-1 for s in hosted if s['letter']=='W')) +# path frame t for adjacent pair with q=+1 frame U=I+x y equals root frame t +# 7 dyadic +dy=lambda v:v.denominator&(v.denominator-1)==0 +req('x,y dyadic',all(dy(v) for r in X+Y for v in r)) +def odd(v): + v=abs(v.numerator) + while v and v%2==0:v//=2 + return v +req('hosted alpha,beta dyadic units (plane projector dyadic)',all(s['letter']=='W' or (odd(dot(Y[s['units'][0]],X[s['units'][1]]))==1 and odd(dot(Y[s['units'][1]],X[s['units'][0]]))==1) for s in hosted)) +print(' max |entry|',max(abs(v) for r in X+Y for v in r),' t values odd parts',{str(t_of(*s['units'])) for s in hosted}) +# 8 Gram rank, irreducible exactly +def rank(A): + A=[r[:] for r in A];rk=0 + if not A:return 0 + for c in range(len(A[0])): + p=next((i for i in range(rk,len(A)) if A[i][c]),None) + if p is None:continue + A[rk],A[p]=A[p],A[rk] + for i in range(rk+1,len(A)): + if A[i][c]: + f=A[i][c]/A[rk][c];A[i]=[a-f*b for a,b in zip(A[i],A[rk])] + rk+=1 + return rk +G=[[dot(Y[i],X[j]) for j in range(N)] for i in range(N)] +req('rank G=n',rank(G)==n);req('N-n=rho',True,N-n) +Om=[[Q(1) if i==j else (G[i][j] if i>j else -G[i][j]) for j in range(N)] for i in range(N)] +print(' rank(sign-twisted Gram) =',rank(Om),'; rank in other twist',rank([[Q(1) if i==j else (-G[i][j] if i>j else G[i][j]) for j in range(N)] for i in range(N)])) +req('x span, y span',rank(X)==n and rank(Y)==n) +# strongly connected digraph on G!=0 (proof: W invariant, w!=0, some y_k w!=0 since y span => x_k in W; G_jk!=0 => x_j in W; x span => W=F^n) +def reach(s,fw): + seen={s};st=[s] + while st: + u=st.pop() + for v in range(N): + if v not in seen and (G[v][u] if fw else G[u][v]):seen.add(v);st.append(v) + return seen +req('Gram digraph strongly connected => absolutely irreducible over Q [P]',len(reach(0,True))==N and len(reach(0,False))==N) +# independent: exact algebra dimension through {x_i y_j}: R_iR_j=G_ij x_i y_j, closure of pattern +vecs=[[X[i][a]*Y[j][b] for a in range(n) for b in range(n)] for i in range(N) for j in range(N)] +P=2147483629 +def rank_modp(V): + A=[[ (v.numerator*pow(v.denominator,-1,P))%P for v in r] for r in V];rk=0;w=len(A[0]) + for c in range(w): + p=next((i for i in range(rk,len(A)) if A[i][c]),None) + if p is None:continue + A[rk],A[p]=A[p],A[rk];inv=pow(A[rk][c],-1,P);rowr=[x*inv%P for x in A[rk]];A[rk]=rowr + for i in range(rk+1,len(A)): + if A[i][c]: + f=A[i][c];A[i]=[(a-f*b)%P for a,b in zip(A[i],rowr)] + rk+=1 + if rk==w:break + return rk +print(' span{x_i y_j} rank mod p =',rank_modp(vecs),'of n^2 =',n*n) +print('RESULT','ALL_REQ_PASS' if not bad else 'FAILED '+'; '.join(bad)) +sys.exit(1 if bad else 0) diff --git a/research/p104-whitehead-native-objects/checks/verify_host3w.py b/research/p104-whitehead-native-objects/checks/verify_host3w.py new file mode 100644 index 0000000000..07038eab4e --- /dev/null +++ b/research/p104-whitehead-native-objects/checks/verify_host3w.py @@ -0,0 +1,76 @@ +#!/usr/bin/env python3 +"""Two main planes per port. Stdlib-only, no shared code. python3 -I -B verify_host.py WORD.json.gz +Exact Fractions replay of every event. Checks: frame law for each event, public moves up and nested, owned moves nested either way (OWNED UP counted and printed), +ADD at common frame, dyadic coefficients, |q|+1<2^16, finals, helper rank>0, 104 literal ports, main endpoint frames, exact endpoint X=x+a y, Y=x+(1+a) y, helpers identity, owned zero after CLEAR. +Prints histogram paid/helpers and PASS_HOST.""" +import gzip,json,sys +from fractions import Fraction as Q +from collections import Counter +W=json.load(gzip.open(sys.argv[1]));fr=W['frames'];n=len(W['initial']);NO=W['owned_fields'];NR=n+NO +alpha=Q(W['hosted']['alpha']);beta=Q(W['hosted']['beta']);H=W['hosted'];assert H['mode']=='mix-t0' and alpha in (-1,-2) and beta==Q(1,2) # alpha=-2 (t=-1) allowed for the W-stage word +X2=H['X2'];Y2=H['Y2'];a2=Q(H['alpha2']);DP=H['Dports'];assert a2==-1 and len(set(X2)|set(Y2))==2*len(DP)==2*len(X2) +sp=[] +for b in fr: + s={0} + for v in b: + assert 02 else 1 +def smooth(m,ps): + m=abs(m) + for p in ps: + while m%p==0:m//=p + return m==1 +def inA(q):return smooth(q.denominator,(2,3,5)) +def unitA(q):return smooth(q.denominator,(2,3,5)) and smooth(q.numerator,(2,3,5)) +def dy(v):return v.denominator&(v.denominator-1)==0 +def rowdy(row):return all(dy(S*v) for v in row.values()) +assert S>=1 and smooth(S,(3,5)) +def add(a,b,c): + for k,v in b.items(): + t=a.get(k,0)+c*v + if t:a[k]=t + else:a.pop(k,None) +for i,e in enumerate(W['program']): + op=e[0];r=e[1] + if op=='MOVE': + _,r,a,b,pv=e;assert cur[r]==a and (r>=n)==bool(pv),i + if pv: + assert sp[a]=n and r not in own,i;own.add(r);cur[r]=e[2];val[r]={} + elif op=='CLEAR':assert r in own and cur[r]==e[2],i;own.discard(r);cur[r]=None;val[r]={} + elif op=='SCALE': + q=Q(e[2]);assert cur[r]==e[3] and q!=0 and unitA(q),i + val[r]={k:v*q for k,v in val[r].items()};assert rowdy(val[r]),i + elif op in('ADD','COPY'): + s=e[2];q=Q(e[3]);f=e[4];assert cur[r]==f==cur[s] and s!=r and q!=0 and inA(q) and abs(q)+1<2**16,i + assert all(dy(S*q*v) for v in val[s].values()),i + if op=='COPY':assert r in own and not val[r],i + add(val[r],val[s],q);assert rowdy(val[r]),i + else:raise SystemExit('bad op') +assert not own and all(cur[r]==W['final'][r] for r in range(n)) +live=W['live'];X=set(live);Y={r+112 for r in live};assert len(live)==104 +X2s=dict(zip(X2,Y2));Y2s=set(Y2);assert not (X2s.keys()|Y2s)&(X|Y);dX={live[i] for i in DP} +bad=0;hel=Counter() +for r in range(n): + if r in X:ex={r:Q(1)} if r in dX else {r:Q(1),r+112:alpha} + elif r in Y:ex={r-112:Q(1),r:Q(1)} if r-112 in dX else {k:v for k,v in {r-112:beta,r:1+alpha*beta}.items() if v} + elif r in X2s:ex={r:Q(1),X2s[r]:a2} + elif r in Y2s:ex={r:Q(1)} + else: + ex={r:Q(1)};d=len(fr[W['final'][r]])-len(fr[W['initial'][r]]);assert d>0,r;assert sp[W['initial'][r]]<=sp[W['final'][r]];hel[d]+=1 + if val[r]!=ex:bad+=1 +for r,q in zip(live,W['ports']): + assert fr[W['initial'][r]]==[q] and len(fr[W['final'][r]])==9 and len(fr[W['initial'][r+112]])==0 + assert sp[W['final'][r+112]]==frozenset(x for x in range(512) if not (x&q).bit_count()%2) +for x2,y2,r,q in zip(X2,Y2,[live[i] for i in DP],[W['ports'][i] for i in DP]): + assert W['initial'][x2]==W['initial'][r] and fr[W['initial'][x2]]==[q] and W['final'][x2]==W['final'][r] and len(fr[W['final'][x2]])==9 + assert W['initial'][y2]==W['initial'][r+112] and W['final'][y2]==W['final'][r+112] +print('events',len(W['program']),'public',n,'owned roles',NO,'paid',dict(sorted(paid.items())),'owned UP',dict(sorted(up.items())),'helpers',dict(sorted(hel.items()))) +print('endpoint bad rows',bad,'odd certificate S',S) +assert all(dy(v) for r in range(n) for v in val[r].values()),'non-dyadic public row' +assert bad==0;print('PASS_HOST3 decoupled ports',len(DP),'hosted ports',104-len(DP),'alpha',alpha,'beta',beta,'t',alpha*beta) diff --git a/research/p104-whitehead-native-objects/checks/window_native.py b/research/p104-whitehead-native-objects/checks/window_native.py new file mode 100644 index 0000000000..7f855be5fb --- /dev/null +++ b/research/p104-whitehead-native-objects/checks/window_native.py @@ -0,0 +1,386 @@ +#!/usr/bin/env python3 +"""Exact checks of the helper-free Whitehead (t = -1, d = 0) native on the 104 ports of P104. Standard library only. + + python3.12 -I -B window_native.py check the shipped object, regenerate it, run the mutants + python3.12 -I -B window_native.py --emit F (re)write the object file F from the generator + +What it does + * regenerates the word from the generator below and requires it to equal data/window_native.json.gz exactly; + * replays the object event by event in exact Fractions (engine A: frame law, dyadic coefficients, paid ranks, + owned lifetimes, final frames, exact endpoint X = x + alpha y, Y = beta x, helpers none); + * replays it a second time mod 2^61 - 1 on random inputs (engine B); + * checks the 208 x 208 transfer matrix exactly (T[Y,Y] = 0 so d = 0, T[Y,X] = beta I, T[X,Y] = alpha I, det = 1); + * prices the layer (public and owned) with the invoice rule at the kappa of the baseline, and the floor 208 * 8^(1-k); + * recomputes the budget lines owned <= 111.573067 + T - dpub from the quoted ledger constants; + * checks the 2 x 2 caller block (a dyadic conjugator exists for the -1 sector); + * runs 100 single-edit mutants (pairs 0, 25, 51) and four wrong-target judgements; each non-null mutant must be rejected. +Owned moves go UP as well as down: the word is valid only under the owned-ascent allowance (declared in README.md).""" +import gzip, itertools, json, os, random, sys, decimal, hashlib +from fractions import Fraction as Q +from collections import Counter + +HERE = os.path.dirname(os.path.abspath(__file__)) +DATA = os.path.join(HERE, '..', 'data') +KAPPA = decimal.Decimal('0.0036270188296') # the baseline's kappa, used as the pricing exponent +PR = (1 << 61) - 1 +decimal.getcontext().prec = 50 + + +def span(b): + s = {0} + for v in b: + if v not in s: + s |= {x ^ v for x in s} + return frozenset(s) + + +def basis(F): + b = []; s = {0} + for x in sorted(F): + if x not in s: + b.append(x); s |= {y ^ x for y in s} + return b + + +def dim(F): return len(F).bit_length() - 1 +def dot(a, b): return bin(a & b).count('1') & 1 +def perp(v, k): return frozenset(x for x in range(2 ** k) if not dot(x, v)) +def isdy(c): return c != 0 and (c.denominator & (c.denominator - 1)) == 0 +def isunit(c): return isdy(c) and (abs(c.numerator) & (abs(c.numerator) - 1)) == 0 + + +def matching(ports, seed=0): + v = len(ports); adj = {i: [j for j in range(v) if j != i and not dot(ports[i], ports[j])] for i in range(v)} + rng = random.Random(seed) + for _ in range(20000): + order = list(range(v)); rng.shuffle(order); used = set(); M = [] + for i in order: + if i in used: continue + c = [j for j in adj[i] if j not in used] + if not c: break + j = rng.choice(c); used |= {i, j}; M.append((i, j)) + if len(M) * 2 == v: return M + return None + + +def build(ports, k, alpha, beta): + """Windowed native: per dot-0 pair (a, b) two owned rank-1 registers exchange x_a, x_b through + (UP then DOWN each), then Y_b is moved into the window (inside q_b-perp) where the swap + X_a += delta Y_b, Y_b += gamma X_a removes y and creates beta x.""" + v = len(ports); X = list(range(v)); Y = list(range(v, 2 * v)); C1, C2 = 2 * v, 2 * v + 1 + full = span([1 << i for i in range(k)]); Z = span([]) + init = [span([q]) for q in ports] + [Z] * v + [None, None] + final = [full] * v + [perp(q, k) for q in ports] + [None, None] + owned = [False] * (2 * v) + [True, True] + gam = Q(beta); dl = -1 / gam; s = Q(alpha) / dl + assert isunit(s) and isdy(dl) and isdy(gam) and Q(alpha) * Q(beta) == -1 + M = matching(ports); assert M + W = [] + for a, b in M: + La, Lb, Lab = span([ports[a]]), span([ports[b]]), span([ports[a], ports[b]]) + W += [('INIT', C1, La), ('ADD', C1, X[a], Q(1)), ('INIT', C2, Lb), ('ADD', C2, X[b], Q(1)), + ('MOVE', C1, Lab), ('MOVE', C1, Lb), ('MOVE', C2, Lab), ('MOVE', C2, La), + ('ADD', C1, X[b], Q(-1)), ('ADD', X[b], C1, Q(1)), ('CLEAR', C1), + ('ADD', C2, X[a], Q(-1)), ('ADD', X[a], C2, Q(1)), ('CLEAR', C2)] + for (p, t) in ((a, b), (b, a)): + W += [('MOVE', Y[t], span([ports[p]]))] + if s != 1: W += [('SCALE', Y[t], s)] + W += [('ADD', X[p], Y[t], dl), ('ADD', Y[t], X[p], gam)] + for r in X + Y: W.append(('MOVE', r, final[r])) + for a, b in M: + W += [('ADD', X[a], X[b], Q(1)), ('ADD', X[b], X[a], Q(-1)), ('ADD', X[a], X[b], Q(1)), ('SCALE', X[b], Q(-1))] + return dict(init=init, final=final, owned=owned, prog=W, v=v, k=k, alpha=Q(alpha), beta=Q(beta)) + + +# ----------------------------------------------------------------------------------- object (de)serialisation +def to_obj(w, ports): + fr = lambda F: None if F is None else basis(F) + ev = [] + for e in w['prog']: + if e[0] in ('INIT', 'MOVE'): ev.append([e[0], e[1], basis(e[2])]) + elif e[0] == 'CLEAR': ev.append(['CLEAR', e[1]]) + elif e[0] == 'SCALE': ev.append(['SCALE', e[1], str(e[2])]) + else: ev.append(['ADD', e[1], e[2], str(e[3])]) + return dict(format='p104-whitehead-window-native-1', ports=ports, k=w['k'], alpha=str(w['alpha']), beta=str(w['beta']), + init=[fr(F) for F in w['init']], final=[fr(F) for F in w['final']], owned=w['owned'], events=ev) + + +def from_obj(o): + assert o['format'] == 'p104-whitehead-window-native-1' + fr = lambda b: None if b is None else span(b) + prog = [] + for e in o['events']: + if e[0] in ('INIT', 'MOVE'): prog.append((e[0], e[1], span(e[2]))) + elif e[0] == 'CLEAR': prog.append(('CLEAR', e[1])) + elif e[0] == 'SCALE': prog.append(('SCALE', e[1], Q(e[2]))) + else: prog.append(('ADD', e[1], e[2], Q(e[3]))) + return dict(init=[fr(b) for b in o['init']], final=[fr(b) for b in o['final']], owned=o['owned'], prog=prog, + v=len(o['ports']), k=o['k'], alpha=Q(o['alpha']), beta=Q(o['beta'])), o['ports'] + + +# ----------------------------------------------------------------------------------- engine A: exact +def engineA(w, prog, alpha, beta): + v = w['v']; n = len(w['init']); V = [] + def bad(i, why): V.append((i, why)) + cur = list(w['init']); live = [False] * n + rows = [({r: Q(1)} if r < 2 * v else {}) for r in range(n)] + owned = w['owned']; pub = Counter(); own = Counter(); peak = 0; life = 0; dirty = 0 + ups = Counter(); downs = Counter(); ok_sub = {} + def sub(F): + if F not in ok_sub: ok_sub[F] = (span(basis(F)) == F) + return ok_sub[F] + for i, e in enumerate(prog): + op = e[0] + if op == 'INIT': + r, F = e[1], e[2] + if not owned[r] or live[r]: bad(i, 'init'); continue + if not sub(F): bad(i, 'frame not subspace') + live[r] = True; cur[r] = F; rows[r] = {}; life += 1; peak = max(peak, sum(live)) + elif op == 'CLEAR': + r = e[1] + if not (owned[r] and live[r]): bad(i, 'clear'); continue + if rows[r]: dirty += 1 + live[r] = False; cur[r] = None; rows[r] = {} + elif op == 'MOVE': + r, F = e[1], e[2]; A = cur[r] + if A is None: bad(i, 'move dead'); continue + if not sub(F): bad(i, 'frame not subspace') + if owned[r]: + if not live[r] or not (A < F or F < A): bad(i, 'owned nest') + d = dim(F) - dim(A); own[abs(d)] += 1; (ups if d > 0 else downs)[abs(d)] += 1 + else: + if not (A < F): bad(i, 'public up') + pub[dim(F) - dim(A)] += 1 + cur[r] = F + elif op == 'SCALE': + r, c = e[1], Q(e[2]) + if cur[r] is None or (owned[r] and not live[r]): bad(i, 'scale dead'); continue + if not isunit(c): bad(i, 'scale unit') + rows[r] = {k: x * c for k, x in rows[r].items()} + elif op == 'ADD': + d, a, c = e[1], e[2], Q(e[3]) + if d == a: bad(i, 'self add'); continue + if cur[d] is None or cur[a] is None or cur[d] != cur[a]: bad(i, 'chart'); continue + if (owned[d] and not live[d]) or (owned[a] and not live[a]): bad(i, 'dead owned'); continue + if not isdy(c): bad(i, 'dyadic') + if not (abs(c) + 1 < 2 ** 16): bad(i, 'growth') + rd = rows[d] + for k, x in rows[a].items(): + y = rd.get(k, 0) + c * x + if y: rd[k] = y + else: rd.pop(k, None) + else: bad(i, 'unknown op ' + str(op)) + if any(live): bad(-1, 'owned live at end') + for r in range(2 * v): + if cur[r] != w['final'][r]: bad(-1, 'final frame r=%d' % r) + badrows = 0 + for p in range(v): + if rows[p] != {p: Q(1), v + p: Q(alpha)}: badrows += 1 + if rows[v + p] != {p: Q(beta)}: badrows += 1 + for r in range(2 * v, n): + if rows[r]: badrows += 1 + return dict(viol=V, bad=badrows, pub=pub, own=own, peak=peak, life=life, dirty=dirty, rows=rows, ups=ups, downs=downs) + + +# ----------------------------------------------------------------------------------- engine B: mod 2^61 - 1 +def engineB(w, prog, alpha, beta, K=4, seed=7): + v = w['v']; n = len(w['init']); rnd = random.Random(seed); bad = 0 + m = lambda c: (Q(c).numerator % PR) * pow(Q(c).denominator, PR - 2, PR) % PR + for _ in range(K): + x0 = [rnd.randrange(PR) for _ in range(2 * v)] + val = x0 + [0] * (n - 2 * v) + for e in prog: + op = e[0] + if op in ('INIT', 'CLEAR'): val[e[1]] = 0 + elif op == 'SCALE': val[e[1]] = val[e[1]] * m(e[2]) % PR + elif op == 'ADD': val[e[1]] = (val[e[1]] + m(e[3]) * val[e[2]]) % PR + for p in range(v): + if val[p] != (x0[p] + m(alpha) * x0[v + p]) % PR: bad += 1 + if val[v + p] != m(beta) * x0[p] % PR: bad += 1 + bad += sum(1 for r in range(2 * v, n) if val[r]) + return bad + + +def rank_inv(M): + n = len(M); A = [r[:] + [Q(int(i == j)) for j in range(n)] for i, r in enumerate(M)] + for c in range(n): + p = next((i for i in range(c, n) if A[i][c] != 0), None) + if p is None: return None + A[c], A[p] = A[p], A[c]; f = 1 / A[c][c]; A[c] = [x * f for x in A[c]] + for i in range(n): + if i != c and A[i][c] != 0: + g = A[i][c]; A[i] = [x - g * y for x, y in zip(A[i], A[c])] + return [r[n:] for r in A] + + +def structure(w, rows, alpha, beta): + v = w['v']; out = {} + T = [[rows[r].get(c, Q(0)) for c in range(2 * v)] for r in range(2 * v)] + out['T[Y,Y] == 0 on all %d entries (d = 0, raw)' % (v * v)] = all(T[v + p][v + q] == 0 for p in range(v) for q in range(v)) + out['T[Y,X] == beta I'] = all(T[v + p][q] == (Q(beta) if p == q else 0) for p in range(v) for q in range(v)) + out['T[X,X] == I'] = all(T[p][q] == (1 if p == q else 0) for p in range(v) for q in range(v)) + out['T[X,Y] == alpha I'] = all(T[p][v + q] == (Q(alpha) if p == q else 0) for p in range(v) for q in range(v)) + out['every row supported on its own (x_p, y_p)'] = all(set(rows[r]) <= {r % v, v + r % v} for r in range(2 * v)) + inv = rank_inv(T) + out['T invertible (exact, %d x %d)' % (2 * v, 2 * v)] = inv is not None + if inv is not None: + out['Tinv[X,Y] == -alpha I'] = all(inv[p][v + q] == (-Q(alpha) if p == q else 0) for p in range(v) for q in range(v)) + out['Tinv[Y,Y] == I'] = all(inv[v + p][v + q] == (1 if p == q else 0) for p in range(v) for q in range(v)) + out['det per port = -alpha beta = 1'] = (-Q(alpha) * Q(beta) == 1) + return out + + +def wgt(r): return (decimal.Decimal(r).ln() * (1 - KAPPA)).exp() +def bill(c): return sum(decimal.Decimal(n) * wgt(r) for r, n in c.items()) + + +# ----------------------------------------------------------------------------------- caller block +def mmul(A, B): return [[sum(A[i][k] * B[k][j] for k in range(2)) for j in range(2)] for i in range(2)] +def minv(A): + d = A[0][0] * A[1][1] - A[0][1] * A[1][0]; return [[A[1][1] / d, -A[0][1] / d], [-A[1][0] / d, A[0][0] / d]] + + +def caller(al, be): + al, be = Q(al), Q(be); t = al * be + W2 = [[Q(1), -2 * al], [-2 * be, 1 + 4 * t]] + gp = [[1 + t, be], [al, Q(1)]]; gm = [[1 + t, -be], [-al, Q(1)]] + A = mmul(gm, minv(gp)); res = dict(t=t, A=A, W=W2) + vals = [Q(s * 2 ** e) if e >= 0 else Q(s, 2 ** -e) for e in range(-6, 7) for s in (1, -1, 3, -3)] + [Q(0)] + sol = None + for p, q in itertools.product(vals, vals): + r = (p * A[0][0] + q * A[1][0] - W2[0][0] * p) / W2[0][1]; s = (p * A[0][1] + q * A[1][1] - W2[0][0] * q) / W2[0][1] + d = p * s - q * r + if d == 0 or not isunit(d) or not all(isdy(x) or x == 0 for x in (p, q, r, s)): continue + O = [[p, q], [r, s]] + if mmul(O, A) == mmul(W2, O): sol = O; break + res['O'] = sol + if sol: + OR = minv(mmul(sol, gp)) + res['plus1'] = mmul(mmul(sol, gp), OR) == [[1, 0], [0, 1]] + res['minus1'] = mmul(mmul(sol, gm), OR) == W2 + res['dyadic'] = all(isdy(x) or x == 0 for r in sol + OR for x in r) + return res + + +# ----------------------------------------------------------------------------------- mutants +def mutants(w, prog, ports, m, starts): + v = w['v']; s0 = starts[m]; xa, xb = prog[s0 + 1][2], prog[s0 + 3][2]; ya, yb = xa + v, xb + v + sub = lambda i, ev: (lambda p: (p.__setitem__(i, ev), p)[1])(list(prog)) + E = lambda k: prog[s0 + k] + qa, qb = ports[xa], ports[xb] + Lab = span([qa, qb]); Lb = span([qb]); gi = [i for i, e in enumerate(prog) if e[0] == 'ADD' and e[1] == xa and e[2] == xb][0] + yield 'coef: C1 -= Xb sign flipped', sub(s0 + 8, ('ADD', E(8)[1], E(8)[2], Q(1))) + yield 'coef: Xb += C1 coefficient 2', sub(s0 + 9, ('ADD', E(9)[1], E(9)[2], Q(2))) + yield 'coef: Xa += dl Yb with dl halved', sub(s0 + 15, ('ADD', E(15)[1], E(15)[2], E(15)[3] / 2)) + yield 'coef: Yb += gam Xa with gam negated', sub(s0 + 16, ('ADD', E(16)[1], E(16)[2], -E(16)[3])) + yield 'coef: Yb += gam Xa with gam times 3', sub(s0 + 16, ('ADD', E(16)[1], E(16)[2], 3 * E(16)[3])) + yield 'coef: Yb += gam Xa with gam / 3 (non-dyadic)', sub(s0 + 16, ('ADD', E(16)[1], E(16)[2], E(16)[3] / 3)) + yield 'coef: Xb += dl Ya coefficient zero', sub(s0 + 18, ('ADD', E(18)[1], E(18)[2], Q(0))) + yield 'coef: C2 -= Xa sign flipped', sub(s0 + 11, ('ADD', E(11)[1], E(11)[2], Q(1))) + yield 'frame: Yb window moved to ', sub(s0 + 14, ('MOVE', yb, Lb)) + yield 'frame: C1 skips UP', [e for i, e in enumerate(prog) if i != s0 + 4] + yield 'frame: C2 DOWN target Lb instead of La', sub(s0 + 7, ('MOVE', E(7)[1], Lb)) + yield 'frame: C1 UP to for foreign c', sub(s0 + 4, ('MOVE', E(4)[1], span([qa, ports[(xa + 7) % v]]))) + yield 'frame: C1 INIT at Z instead of ', sub(s0, ('INIT', E(0)[1], frozenset({0}))) + yield 'frame: Ya window at a dot-1 line', sub(s0 + 17, ('MOVE', ya, span([next(q for q in ports if dot(q, qa) and q != qa)]))) + ff = [i for i, e in enumerate(prog) if e[0] == 'MOVE' and e[1] == xa and len(e[2]) == 512][0] + yield 'frame: final X_a stops at ', sub(ff, ('MOVE', xa, Lab)) + p = list(prog); p[s0 + 8], p[s0 + 9] = p[s0 + 9], p[s0 + 8]; yield 'order: swap C1 -= Xb and Xb += C1', p + p = list(prog); p[s0 + 15], p[s0 + 16] = p[s0 + 16], p[s0 + 15]; yield 'order: swap the two bounce ADDs', p + p = list(prog); p[s0 + 10], p[s0 + 9] = p[s0 + 9], p[s0 + 10]; yield 'order: CLEAR C1 before Xb += C1', p + p = list(prog); blk = p[s0 + 14:s0 + 20]; del p[s0 + 14:s0 + 20]; p[s0:s0] = blk; yield 'order: bounce block before the exchange', p + p = list(prog); blk = p[s0 + 11:s0 + 14]; del p[s0 + 11:s0 + 14]; p[s0 + 8:s0 + 8] = blk; yield 'order: C2 exchange before C1 exchange (equivalent)', p + p = list(prog); ev = p.pop(gi); p.insert(s0 + 14, ev); yield 'order: V-gate ADD hoisted before bounce', p + p = list(prog); del p[gi + 3]; yield 'drop: V-gate SCALE(-1)', p + p = list(prog); p[gi + 3] = ('SCALE', xb, Q(2)); yield 'coef: V-gate SCALE -1 -> 2', p + p = list(prog); p[gi + 3] = ('SCALE', xb, Q(1)); yield 'coef: V-gate SCALE -1 -> 1', p + p = list(prog); p[gi] = ('ADD', xa, xb, Q(-1)); yield 'coef: V-gate first ADD sign flipped', p + yield 'drop: CLEAR C1', [e for i, e in enumerate(prog) if i != s0 + 10] + yield 'drop: INIT C2', [e for i, e in enumerate(prog) if i != s0 + 2] + yield 'drop: owned DOWN of C1', [e for i, e in enumerate(prog) if i != s0 + 5] + p = list(prog); p.insert(s0 + 16, prog[s0 + 15]); yield 'dup: repeat Xa += dl Yb', p + yield 'drop: Xa += dl Yb', [e for i, e in enumerate(prog) if i != s0 + 15] + yield 'drop: last event', list(prog[:-1]) + xc = (xa + 13) % v + if xc not in (xa, xb): yield 'partner: C1 -= X_c (foreign register)', sub(s0 + 8, ('ADD', E(8)[1], xc, Q(-1))) + + +def main(): + ports = [int(l) for l in open(os.path.join(DATA, 'ports104.txt')).read().split()] + assert len(ports) == 104 == len(set(ports)) and all(0 < q < 512 for q in ports) + path = os.path.join(DATA, 'window_native.json.gz') + raw = open(path, 'rb').read() + obj = json.loads(gzip.decompress(raw)) + w, oports = from_obj(obj); assert oports == ports + alpha, beta, prog = w['alpha'], w['beta'], w['prog'] + print('object', hashlib.sha256(raw).hexdigest()[:16], 'events', len(prog), 'ports', len(ports), 'alpha', alpha, 'beta', beta) + # regenerate + g = build(ports, 9, alpha, beta) + assert to_obj(g, ports) == obj, 'the shipped object differs from the generator output' + print('PASS regenerated word equals the shipped object') + # SPEC mains + full = frozenset(range(512)); v = 104 + assert all(w['init'][p] == span([ports[p]]) and w['final'][p] == full for p in range(v)) + assert all(w['init'][v + p] == frozenset({0}) and w['final'][v + p] == perp(ports[p], 9) and dim(w['final'][v + p]) == 8 for p in range(v)) + print('PASS mains: X from to the 9-dim space, Y from {0} to q-perp (dim 8)') + A = engineA(w, prog, alpha, beta) + assert not A['viol'] and A['bad'] == 0, (A['viol'][:3], A['bad']) + assert dict(A['pub']) == {1: 104, 7: 104, 8: 104} and dict(A['own']) == {1: 208} and dict(A['ups']) == {1: 104} and dict(A['downs']) == {1: 104} + assert A['peak'] == 2 and A['life'] == 104 + print('PASS A exact Fractions: 0 violations, 0 bad rows; public paid', dict(sorted(A['pub'].items())), 'owned UP', dict(A['ups']), 'DOWN', dict(A['downs']), + 'peak owned', A['peak'], 'lifetimes', A['life'], 'dirty clears', A['dirty']) + assert engineB(w, prog, alpha, beta) == 0 + print('PASS B mod 2^61-1, 4 random inputs: 0 bad entries') + S = structure(w, A['rows'], alpha, beta) + assert all(S.values()), S + for k in S: print('PASS structure:', k) + # price and budget (ledger constants quoted) + pb, ob = bill(A['pub']), bill(A['own']) + fl = 208 * wgt(8) + assert abs(pb - decimal.Decimal('1652.6284887')) < decimal.Decimal('1e-6') and ob == 208 and abs(fl - decimal.Decimal('1651.4970321')) < decimal.Decimal('1e-6') + print('PASS price: public %s owned %s floor %s gap %s' % (str(pb)[:10], ob, str(fl)[:10], str(pb - fl)[:7])) + pub_mm, own_mm = decimal.Decimal('1702.405'), decimal.Decimal('111.573067') + dpub = pb - pub_mm + for nm, T in (('outer w=1', decimal.Decimal('11.4263770958522')), ('rho=1', decimal.Decimal('14.513107'))): + mx = own_mm + T - dpub + print('budget %s: dpub %s, owned max %s (%s per port), owned 208 over by %s' % (nm, str(dpub)[:8], str(mx)[:8], str(mx / 104)[:6], str(ob - mx)[:6])) + assert ob > mx + assert abs((own_mm + decimal.Decimal('11.4263770958522') - dpub) - decimal.Decimal('172.776')) < decimal.Decimal('0.001') + assert abs((own_mm + decimal.Decimal('14.513107') - dpub) - decimal.Decimal('175.863')) < decimal.Decimal('0.001') + print('PASS budget lines 172.776 / 175.863; the word is over by 35.224 / 32.137') + # caller block + for ab in ((-2, Q(1, 2)), (-1, 1)): + c = caller(*ab); assert c['O'] and c['plus1'] and c['minus1'] and c['dyadic'] and c['t'] == -1 + print('PASS caller block: a dyadic conjugator exists for (alpha, beta) = (-2, 1/2) and (-1, 1)') + # the other (alpha, beta): same events, other coefficients, same checks + w2 = build(ports, 9, Q(-1), Q(1)); A2 = engineA(w2, w2['prog'], Q(-1), Q(1)) + assert not A2['viol'] and A2['bad'] == 0 and dict(A2['own']) == {1: 208} and engineB(w2, w2['prog'], Q(-1), Q(1)) == 0 + print('PASS (alpha, beta) = (-1, 1) word: same checks, 0 bad rows') + # mutants + starts = [i for i, e in enumerate(prog) if e[0] == 'INIT' and e[1] == 2 * v] + assert len(starts) == 52 and starts[1] - starts[0] == 20 + total = rej = 0; acc = [] + for m in (0, 25, 51): + for name, pg in mutants(w, prog, ports, m, starts): + a = engineA(w, pg, alpha, beta); b = engineB(w, pg, alpha, beta) + r = bool(a['viol']) or a['bad'] > 0 or b > 0 + total += 1; rej += r + if not r: acc.append((m, name)) + for ab in ((Q(-1), Q(1)), (Q(-2), Q(1)), (Q(2), Q(1, 2)), (Q(-2), Q(1, 4))): + a = engineA(w, prog, *ab); b = engineB(w, prog, *ab) + total += 1; rej += bool(a['viol']) or a['bad'] > 0 or b > 0 + print('mutants %d, rejected %d, accepted %d' % (total, rej, total - rej), sorted({n for _, n in acc})) + assert total == 100 and rej == 97 and sorted({n for _, n in acc}) == ['order: C2 exchange before C1 exchange (equivalent)'] + print('PASS the only mutant accepted is the true equivalence (independent owned registers), at each of three pairs') + print('PASS_WINDOW_NATIVE') + + +if __name__ == '__main__': + if len(sys.argv) == 3 and sys.argv[1] == '--emit': + ports = [int(l) for l in open(os.path.join(DATA, 'ports104.txt')).read().split()] + g = build(ports, 9, Q(-2), Q(1, 2)) + with gzip.GzipFile(sys.argv[2], 'wb', mtime=0) as f: + f.write(json.dumps(to_obj(g, ports), sort_keys=True, separators=(',', ':')).encode()) + print('wrote', sys.argv[2]) + else: + main() diff --git a/research/p104-whitehead-native-objects/data/OBJECTS.json b/research/p104-whitehead-native-objects/data/OBJECTS.json new file mode 100644 index 0000000000..6fb9b3c582 --- /dev/null +++ b/research/p104-whitehead-native-objects/data/OBJECTS.json @@ -0,0 +1,65 @@ +{ + "schema_version": 1, + "objects": { + "data/mmW.json.gz": { + "sha256": "13019ac4b8a2f051b83df615677ce1455c50d354a770a565d3be53f4e629f3f1", + "bytes": 358073, + "what": "the Whitehead native: the baseline native plus the owned-UP prefix on the 8 hosted ports; serves the two W stages" + }, + "data/mm.json.gz": { + "sha256": "273e81f176f001684b1fa3eb857992bf58b54748004fcfe806b83adb48d2cc00", + "bytes": 349022, + "what": "baseline native (serves the other 16 stages); replayed as control" + }, + "data/joint_caller_w.json": { + "sha256": "148356dca93357e5055a645237f03361ffaba5dd9b0a4742b702417a552b5353", + "bytes": 106877, + "what": "joint caller: one event stream, 78 roles, each contact names its native" + }, + "data/rootw1g.json": { + "sha256": "0e6622d7d27b0e308426b5dc47f2f6139d5013191e4fb95615bd04fa6aea7509", + "bytes": 18676, + "what": "type B root with the outer W stages (stages 1 and 18 at t = -1), in the baseline root gauge" + }, + "data/root_h.json": { + "sha256": "b0ca675d79e847bdc31964bcd2772a80c6ef693b58ba6fd5793a9fc2e4813dcb", + "bytes": 18682, + "what": "type B root without W stages (control, must fail the W-root checker)" + }, + "data/root_t0_dsum.json": { + "sha256": "b9400ca6087c8fd9d527c3203afa43caaddaa46cb73996cc05a0ac5cbb240e3c", + "bytes": 18515, + "what": "type A root (96 ports, t = 0)" + }, + "data/rootw1.json": { + "sha256": "2f00a0655b34d46c291ca69cc49e6b2016b600f7a7385149f5e88639787f96cd", + "bytes": 18648, + "what": "ungauged W root (control, must fail)" + }, + "data/mm.chain.invoice.json": { + "sha256": "2cef5b86ac7d1a7e3a47e2c02ea58e7de2e582b6b3ebc339eacc5deae3e8f215", + "bytes": 374, + "what": "baseline invoice (T and P histograms)" + }, + "data/w.joint.invoice.json": { + "sha256": "a538d4ea1825fbde09a7e4f97cb7293df1ea622def254176c88e46382c8b6240", + "bytes": 384, + "what": "invoice of the hosted Whitehead word" + }, + "data/r1_W18_t3.json": { + "sha256": "e2bd8b71f9e6670a9d0a3d1cd6503f2b0a5cacf17faf7fcc5ae52d2b7c67ccbf", + "bytes": 17321, + "what": "connected rho = 1 all-Whitehead root, 18 stages at t = -1" + }, + "data/window_native.json.gz": { + "sha256": "56c803aaf5383342c98f7f4f0196711f0c13ea3f73720caf03d17ac01b499458", + "bytes": 6065, + "what": "helper-free d = 0 Whitehead native on P104 (1456 events, alpha = -2, beta = 1/2)" + }, + "data/ports104.txt": { + "sha256": "d2358b31b0bca9e3a46269116aefe0d10626331132c592f93710a10c1fccb0fb", + "bytes": 391, + "what": "the 104 port vectors (9-bit)" + } + } +} diff --git a/research/p104-whitehead-native-objects/data/joint_caller_w.json b/research/p104-whitehead-native-objects/data/joint_caller_w.json new file mode 100644 index 0000000000..2c03ca2a27 --- /dev/null +++ b/research/p104-whitehead-native-objects/data/joint_caller_w.json @@ -0,0 +1 @@ +{"schema": "mixed-root-caller/1", "stages": 18, "ambient_rank": 153, "roles": 78, "types": {"A": {"form": "two-chain-HOST2", "roles": 40, "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], [-1, 0, 1, 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, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0], [-1, 0, 0, 0, 1, 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, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0], [-1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0], [-1, 0, 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, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0], [-1, 0, 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, 0, 0, 0, 0, 0, 0, 0, 0, 0], [-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0], [-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0], [-1, 0, 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, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0], [-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0], [-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0], [-1, 0, 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, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0], [-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1], [-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [-1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [-1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0], [-1, 0, 0, 1, 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, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0], [-1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0], [-1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0], [-1, 0, 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, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0], [-1, 0, 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, 0, 0, 0, 0, 0, 0, 0, 0, 0], [-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0], [-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0], [-1, 0, 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, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0], [-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0], [-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0], [-1, 0, 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, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0], [-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1], [-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]}, "B": {"form": "hosted-HOST", "roles": 38, "offset": 40, "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], [-1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0], [-1, 0, 1, 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, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0], [-1, 0, 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, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0], [-1, 0, 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, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0], [-1, 0, 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, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0], [-1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0], [-1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0], [-1, 0, 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, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0], [-1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0], [-1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0], [-1, 0, 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, 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, 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, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0], [-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0], [-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0], [-1, 0, 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, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0], [-1, 0, 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, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0], [-1, 0, 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, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0], [-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0], [-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0], [-1, 0, 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, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0], [-1, 0, 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, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0], [-1, 0, 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, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1], [-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1]], "pairs": [[0, 1, "-2", "1/2", "-1"], [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, "-2", "1/2", "-1"]]}}, "events": [["A", "ADD", 0, 1, "-1"], ["A", "SWAP", 0, 1], ["A", "LAMBDA", 0, -1], ["A", "ADD", 20, 21, "-1"], ["A", "SWAP", 20, 21], ["A", "SCALE", 21, "-1"], ["A", "LAMBDA", 20, 1], ["B", "ADD", 42, 43, "1"], ["B", "ADD", 40, 43, "-2"], ["B", "SCALE", 43, "128"], ["B", "ADD", 40, 42, "3/2"], ["B", "SCALE", 42, "1/2"], ["B", "ADD", 43, 42, "-128"], ["B", "SWAP", 41, 43], ["B", "SCALE", 40, "-32"], ["B", "ADD", 42, 40, "1/32"], ["B", "LAMBDA", 40, -1], ["J", 1, [1, 0, 20, 21], [41, 40, "-2", "1/2"], "mmW"], ["A", "LAMBDA", 20, -1], ["A", "SCALE", 21, "-1"], ["A", "LAMBDA", 0, 1], ["A", "ADD", 1, 2, "1"], ["A", "ADD", 0, 2, "-1"], ["A", "SCALE", 1, "-1"], ["A", "SWAP", 1, 2], ["A", "ADD", 2, 0, "-1"], ["A", "SWAP", 0, 1], ["A", "LAMBDA", 0, -1], ["A", "ADD", 21, 22, "1"], ["A", "ADD", 20, 22, "-1"], ["A", "SCALE", 21, "-1"], ["A", "SWAP", 21, 22], ["A", "SCALE", 20, "-1"], ["A", "ADD", 22, 20, "1"], ["A", "SWAP", 20, 21], ["A", "LAMBDA", 20, 1], ["B", "LAMBDA", 40, 1], ["B", "IDLE_ONE", 42, [1]], ["B", "ADD", 44, 45, "-2"], ["B", "ADD", 43, 45, "1"], ["B", "ADD", 42, 45, "-2"], ["B", "ADD", 41, 45, "-128"], ["B", "ADD", 43, 44, "1"], ["B", "ADD", 42, 44, "-1"], ["B", "ADD", 41, 44, "-64"], ["B", "ADD", 42, 43, "2"], ["B", "ADD", 41, 43, "128"], ["B", "SCALE", 43, "256"], ["B", "ADD", 45, 43, "-1/128"], ["B", "ADD", 44, 43, "1/128"], ["B", "ADD", 41, 42, "-32"], ["B", "ADD", 40, 42, "-32"], ["B", "SWAP", 42, 43], ["B", "SCALE", 41, "1/64"], ["B", "ADD", 43, 41, "1"], ["B", "SWAP", 41, 42], ["B", "SCALE", 40, "4"], ["B", "ADD", 45, 40, "-1/128"], ["B", "ADD", 44, 40, "1/64"], ["B", "ADD", 43, 40, "3/256"], ["B", "ADD", 42, 40, "1/256"], ["B", "ADD", 41, 40, "1"], ["B", "LAMBDA", 40, -1], ["J", 2, [1, 0, 20, 21], [41, 40, "-1", "1/2"], "mm"], ["A", "LAMBDA", 20, -1], ["A", "SCALE", 21, "-1"], ["A", "LAMBDA", 0, 1], ["A", "ADD", 0, 1, "-1"], ["A", "IDLE_ONE", 2, [2, 3, 4, 5, 6, 7, 8, 9]], ["A", "ADD", 1, 3, "1"], ["A", "ADD", 0, 3, "-2"], ["A", "ADD", 0, 1, "2"], ["A", "SCALE", 1, "-1"], ["A", "SCALE", 0, "-1"], ["A", "ADD", 1, 0, "-1"], ["A", "SWAP", 0, 3], ["A", "LAMBDA", 0, -1], ["A", "ADD", 20, 21, "-1"], ["A", "IDLE_ONE", 22, [2, 3, 4, 5, 6, 7, 8, 9]], ["A", "ADD", 21, 23, "1"], ["A", "ADD", 20, 23, "-2"], ["A", "ADD", 20, 21, "2"], ["A", "SCALE", 20, "-1"], ["A", "ADD", 21, 20, "1"], ["A", "SWAP", 20, 23], ["A", "LAMBDA", 20, 1], ["B", "LAMBDA", 40, 1], ["B", "IDLE_ONE", 42, [2, 3, 4, 5, 6, 7, 8, 9]], ["B", "IDLE_ONE", 43, [2, 3, 4, 5, 6, 7, 8, 9]], ["B", "IDLE_ONE", 44, [2]], ["B", "IDLE_ONE", 45, [2]], ["B", "ADD", 46, 47, "-2"], ["B", "ADD", 44, 47, "-2"], ["B", "ADD", 41, 47, "-256"], ["B", "ADD", 40, 47, "-128"], ["B", "ADD", 45, 46, "1"], ["B", "ADD", 44, 46, "-2"], ["B", "ADD", 41, 46, "-256"], ["B", "ADD", 41, 45, "256"], ["B", "ADD", 40, 45, "-128"], ["B", "ADD", 40, 44, "-128"], ["B", "ADD", 45, 44, "1"], ["B", "ADD", 40, 41, "1/2"], ["B", "SCALE", 41, "-1"], ["B", "ADD", 47, 41, "-1/128"], ["B", "ADD", 46, 41, "1/128"], ["B", "ADD", 45, 41, "1/128"], ["B", "ADD", 44, 41, "1/128"], ["B", "SCALE", 40, "-1"], ["B", "ADD", 47, 40, "1/128"], ["B", "ADD", 45, 40, "-1/128"], ["B", "ADD", 44, 40, "-1/64"], ["B", "ADD", 41, 40, "-1"], ["B", "LAMBDA", 40, -1], ["J", 3, [1, 0, 20, 21], [41, 40, "-1", "1/2"], "mm"], ["A", "LAMBDA", 20, -1], ["A", "SCALE", 21, "-1"], ["A", "LAMBDA", 0, 1], ["A", "ADD", 0, 1, "-1"], ["A", "IDLE_ONE", 3, [3, 4, 5, 6, 7, 8, 9]], ["A", "ADD", 1, 4, "1"], ["A", "ADD", 0, 4, "-2"], ["A", "ADD", 0, 1, "2"], ["A", "SCALE", 1, "-1"], ["A", "SCALE", 0, "-1"], ["A", "ADD", 1, 0, "-1"], ["A", "SWAP", 0, 4], ["A", "LAMBDA", 0, -1], ["A", "ADD", 20, 21, "-1"], ["A", "IDLE_ONE", 23, [3, 4, 5, 6, 7, 8, 9]], ["A", "ADD", 21, 24, "1"], ["A", "ADD", 20, 24, "-2"], ["A", "ADD", 20, 21, "2"], ["A", "SCALE", 20, "-1"], ["A", "ADD", 21, 20, "1"], ["A", "SWAP", 20, 24], ["A", "LAMBDA", 20, 1], ["B", "LAMBDA", 40, 1], ["B", "IDLE_ONE", 44, [3, 4, 5, 6, 7, 8, 9]], ["B", "IDLE_ONE", 45, [3, 4, 5, 6, 7, 8, 9]], ["B", "IDLE_ONE", 46, [3]], ["B", "IDLE_ONE", 47, [3]], ["B", "ADD", 48, 49, "-2"], ["B", "ADD", 46, 49, "-2"], ["B", "ADD", 41, 49, "-256"], ["B", "ADD", 40, 49, "-128"], ["B", "ADD", 47, 48, "1"], ["B", "ADD", 46, 48, "-2"], ["B", "ADD", 41, 48, "-256"], ["B", "ADD", 41, 47, "256"], ["B", "ADD", 40, 47, "-128"], ["B", "ADD", 40, 46, "-128"], ["B", "ADD", 47, 46, "1"], ["B", "ADD", 40, 41, "1/2"], ["B", "SCALE", 41, "-1"], ["B", "ADD", 49, 41, "-1/128"], ["B", "ADD", 48, 41, "1/128"], ["B", "ADD", 47, 41, "1/128"], ["B", "ADD", 46, 41, "1/128"], ["B", "SCALE", 40, "-1"], ["B", "ADD", 49, 40, "1/128"], ["B", "ADD", 47, 40, "-1/128"], ["B", "ADD", 46, 40, "-1/64"], ["B", "ADD", 41, 40, "-1"], ["B", "LAMBDA", 40, -1], ["J", 4, [1, 0, 20, 21], [41, 40, "-1", "1/2"], "mm"], ["A", "LAMBDA", 20, -1], ["A", "SCALE", 21, "-1"], ["A", "LAMBDA", 0, 1], ["A", "ADD", 0, 1, "-1"], ["A", "IDLE_ONE", 4, [4, 5, 6, 7, 8, 9]], ["A", "ADD", 1, 5, "1"], ["A", "ADD", 0, 5, "-2"], ["A", "ADD", 0, 1, "2"], ["A", "SCALE", 1, "-1"], ["A", "SCALE", 0, "-1"], ["A", "ADD", 1, 0, "-1"], ["A", "SWAP", 0, 5], ["A", "LAMBDA", 0, -1], ["A", "ADD", 20, 21, "-1"], ["A", "IDLE_ONE", 24, [4, 5, 6, 7, 8, 9]], ["A", "ADD", 21, 25, "1"], ["A", "ADD", 20, 25, "-2"], ["A", "ADD", 20, 21, "2"], ["A", "SCALE", 20, "-1"], ["A", "ADD", 21, 20, "1"], ["A", "SWAP", 20, 25], ["A", "LAMBDA", 20, 1], ["B", "LAMBDA", 40, 1], ["B", "IDLE_ONE", 46, [4, 5, 6, 7, 8, 9]], ["B", "IDLE_ONE", 47, [4, 5, 6, 7, 8, 9]], ["B", "IDLE_ONE", 48, [4]], ["B", "IDLE_ONE", 49, [4]], ["B", "ADD", 50, 51, "-2"], ["B", "ADD", 48, 51, "-2"], ["B", "ADD", 41, 51, "-256"], ["B", "ADD", 40, 51, "-128"], ["B", "ADD", 49, 50, "1"], ["B", "ADD", 48, 50, "-2"], ["B", "ADD", 41, 50, "-256"], ["B", "ADD", 41, 49, "256"], ["B", "ADD", 40, 49, "-128"], ["B", "ADD", 40, 48, "-128"], ["B", "ADD", 49, 48, "1"], ["B", "ADD", 40, 41, "1/2"], ["B", "SCALE", 41, "-1"], ["B", "ADD", 51, 41, "-1/128"], ["B", "ADD", 50, 41, "1/128"], ["B", "ADD", 49, 41, "1/128"], ["B", "ADD", 48, 41, "1/128"], ["B", "SCALE", 40, "-1"], ["B", "ADD", 51, 40, "1/128"], ["B", "ADD", 49, 40, "-1/128"], ["B", "ADD", 48, 40, "-1/64"], ["B", "ADD", 41, 40, "-1"], ["B", "LAMBDA", 40, -1], ["J", 5, [1, 0, 20, 21], [41, 40, "-1", "1/2"], "mm"], ["A", "LAMBDA", 20, -1], ["A", "SCALE", 21, "-1"], ["A", "LAMBDA", 0, 1], ["A", "ADD", 0, 1, "-1"], ["A", "IDLE_ONE", 5, [5, 6, 7, 8, 9]], ["A", "ADD", 1, 6, "1"], ["A", "ADD", 0, 6, "-2"], ["A", "ADD", 0, 1, "2"], ["A", "SCALE", 1, "-1"], ["A", "SCALE", 0, "-1"], ["A", "ADD", 1, 0, "-1"], ["A", "SWAP", 0, 6], ["A", "LAMBDA", 0, -1], ["A", "ADD", 20, 21, "-1"], ["A", "IDLE_ONE", 25, [5, 6, 7, 8, 9]], ["A", "ADD", 21, 26, "1"], ["A", "ADD", 20, 26, "-2"], ["A", "ADD", 20, 21, "2"], ["A", "SCALE", 20, "-1"], ["A", "ADD", 21, 20, "1"], ["A", "SWAP", 20, 26], ["A", "LAMBDA", 20, 1], ["B", "LAMBDA", 40, 1], ["B", "IDLE_ONE", 48, [5, 6, 7, 8, 9]], ["B", "IDLE_ONE", 49, [5, 6, 7, 8, 9]], ["B", "IDLE_ONE", 50, [5]], ["B", "IDLE_ONE", 51, [5]], ["B", "ADD", 52, 53, "-2"], ["B", "ADD", 50, 53, "-2"], ["B", "ADD", 41, 53, "-256"], ["B", "ADD", 40, 53, "-128"], ["B", "ADD", 51, 52, "1"], ["B", "ADD", 50, 52, "-2"], ["B", "ADD", 41, 52, "-256"], ["B", "ADD", 41, 51, "256"], ["B", "ADD", 40, 51, "-128"], ["B", "ADD", 40, 50, "-128"], ["B", "ADD", 51, 50, "1"], ["B", "ADD", 40, 41, "1/2"], ["B", "SCALE", 41, "-1"], ["B", "ADD", 53, 41, "-1/128"], ["B", "ADD", 52, 41, "1/128"], ["B", "ADD", 51, 41, "1/128"], ["B", "ADD", 50, 41, "1/128"], ["B", "SCALE", 40, "-1"], ["B", "ADD", 53, 40, "1/128"], ["B", "ADD", 51, 40, "-1/128"], ["B", "ADD", 50, 40, "-1/64"], ["B", "ADD", 41, 40, "-1"], ["B", "LAMBDA", 40, -1], ["J", 6, [1, 0, 20, 21], [41, 40, "-1", "1/2"], "mm"], ["A", "LAMBDA", 20, -1], ["A", "SCALE", 21, "-1"], ["A", "LAMBDA", 0, 1], ["A", "ADD", 0, 1, "-1"], ["A", "IDLE_ONE", 6, [6, 7, 8, 9]], ["A", "ADD", 1, 7, "1"], ["A", "ADD", 0, 7, "-2"], ["A", "ADD", 0, 1, "2"], ["A", "SCALE", 1, "-1"], ["A", "SCALE", 0, "-1"], ["A", "ADD", 1, 0, "-1"], ["A", "SWAP", 0, 7], ["A", "LAMBDA", 0, -1], ["A", "ADD", 20, 21, "-1"], ["A", "IDLE_ONE", 26, [6, 7, 8, 9]], ["A", "ADD", 21, 27, "1"], ["A", "ADD", 20, 27, "-2"], ["A", "ADD", 20, 21, "2"], ["A", "SCALE", 20, "-1"], ["A", "ADD", 21, 20, "1"], ["A", "SWAP", 20, 27], ["A", "LAMBDA", 20, 1], ["B", "LAMBDA", 40, 1], ["B", "IDLE_ONE", 50, [6, 7, 8, 9]], ["B", "IDLE_ONE", 51, [6, 7, 8, 9]], ["B", "IDLE_ONE", 52, [6]], ["B", "IDLE_ONE", 53, [6]], ["B", "ADD", 54, 55, "-2"], ["B", "ADD", 52, 55, "-2"], ["B", "ADD", 41, 55, "-256"], ["B", "ADD", 40, 55, "-128"], ["B", "ADD", 53, 54, "1"], ["B", "ADD", 52, 54, "-2"], ["B", "ADD", 41, 54, "-256"], ["B", "ADD", 41, 53, "256"], ["B", "ADD", 40, 53, "-128"], ["B", "ADD", 40, 52, "-128"], ["B", "ADD", 53, 52, "1"], ["B", "ADD", 40, 41, "1/2"], ["B", "SCALE", 41, "-1"], ["B", "ADD", 55, 41, "-1/128"], ["B", "ADD", 54, 41, "1/128"], ["B", "ADD", 53, 41, "1/128"], ["B", "ADD", 52, 41, "1/128"], ["B", "SCALE", 40, "-1"], ["B", "ADD", 55, 40, "1/128"], ["B", "ADD", 53, 40, "-1/128"], ["B", "ADD", 52, 40, "-1/64"], ["B", "ADD", 41, 40, "-1"], ["B", "LAMBDA", 40, -1], ["J", 7, [1, 0, 20, 21], [41, 40, "-1", "1/2"], "mm"], ["A", "LAMBDA", 20, -1], ["A", "SCALE", 21, "-1"], ["A", "LAMBDA", 0, 1], ["A", "ADD", 0, 1, "-1"], ["A", "IDLE_ONE", 7, [7, 8, 9]], ["A", "ADD", 1, 8, "1"], ["A", "ADD", 0, 8, "-2"], ["A", "ADD", 0, 1, "2"], ["A", "SCALE", 1, "-1"], ["A", "SCALE", 0, "-1"], ["A", "ADD", 1, 0, "-1"], ["A", "SWAP", 0, 8], ["A", "LAMBDA", 0, -1], ["A", "ADD", 20, 21, "-1"], ["A", "IDLE_ONE", 27, [7, 8, 9]], ["A", "ADD", 21, 28, "1"], ["A", "ADD", 20, 28, "-2"], ["A", "ADD", 20, 21, "2"], ["A", "SCALE", 20, "-1"], ["A", "ADD", 21, 20, "1"], ["A", "SWAP", 20, 28], ["A", "LAMBDA", 20, 1], ["B", "LAMBDA", 40, 1], ["B", "IDLE_ONE", 52, [7, 8, 9]], ["B", "IDLE_ONE", 53, [7, 8, 9]], ["B", "IDLE_ONE", 54, [7]], ["B", "IDLE_ONE", 55, [7]], ["B", "ADD", 56, 57, "-2"], ["B", "ADD", 54, 57, "-2"], ["B", "ADD", 41, 57, "-256"], ["B", "ADD", 40, 57, "-128"], ["B", "ADD", 55, 56, "1"], ["B", "ADD", 54, 56, "-2"], ["B", "ADD", 41, 56, "-256"], ["B", "ADD", 41, 55, "256"], ["B", "ADD", 40, 55, "-128"], ["B", "ADD", 40, 54, "-128"], ["B", "ADD", 55, 54, "1"], ["B", "ADD", 40, 41, "1/2"], ["B", "SCALE", 41, "-1"], ["B", "ADD", 57, 41, "-1/128"], ["B", "ADD", 56, 41, "1/128"], ["B", "ADD", 55, 41, "1/128"], ["B", "ADD", 54, 41, "1/128"], ["B", "SCALE", 40, "-1"], ["B", "ADD", 57, 40, "1/128"], ["B", "ADD", 55, 40, "-1/128"], ["B", "ADD", 54, 40, "-1/64"], ["B", "ADD", 41, 40, "-1"], ["B", "LAMBDA", 40, -1], ["J", 8, [1, 0, 20, 21], [41, 40, "-1", "1/2"], "mm"], ["A", "LAMBDA", 20, -1], ["A", "SCALE", 21, "-1"], ["A", "LAMBDA", 0, 1], ["A", "ADD", 0, 1, "-1"], ["A", "IDLE_ONE", 8, [8, 9]], ["A", "ADD", 1, 9, "1"], ["A", "ADD", 0, 9, "-2"], ["A", "ADD", 0, 1, "2"], ["A", "SCALE", 1, "-1"], ["A", "SCALE", 0, "-1"], ["A", "ADD", 1, 0, "-1"], ["A", "SWAP", 0, 9], ["A", "LAMBDA", 0, -1], ["A", "ADD", 20, 21, "-1"], ["A", "IDLE_ONE", 28, [8, 9]], ["A", "ADD", 21, 29, "1"], ["A", "ADD", 20, 29, "-2"], ["A", "ADD", 20, 21, "2"], ["A", "SCALE", 20, "-1"], ["A", "ADD", 21, 20, "1"], ["A", "SWAP", 20, 29], ["A", "LAMBDA", 20, 1], ["B", "LAMBDA", 40, 1], ["B", "IDLE_ONE", 54, [8, 9]], ["B", "IDLE_ONE", 55, [8, 9]], ["B", "IDLE_ONE", 56, [8]], ["B", "IDLE_ONE", 57, [8]], ["B", "ADD", 58, 59, "-2"], ["B", "ADD", 56, 59, "-2"], ["B", "ADD", 41, 59, "-256"], ["B", "ADD", 40, 59, "-128"], ["B", "ADD", 57, 58, "1"], ["B", "ADD", 56, 58, "-2"], ["B", "ADD", 41, 58, "-256"], ["B", "ADD", 41, 57, "256"], ["B", "ADD", 40, 57, "-128"], ["B", "ADD", 40, 56, "-128"], ["B", "ADD", 57, 56, "1"], ["B", "ADD", 40, 41, "1/2"], ["B", "SCALE", 41, "-1"], ["B", "ADD", 59, 41, "-1/128"], ["B", "ADD", 58, 41, "1/128"], ["B", "ADD", 57, 41, "1/128"], ["B", "ADD", 56, 41, "1/128"], ["B", "SCALE", 40, "-1"], ["B", "ADD", 59, 40, "1/128"], ["B", "ADD", 57, 40, "-1/128"], ["B", "ADD", 56, 40, "-1/64"], ["B", "ADD", 41, 40, "-1"], ["B", "LAMBDA", 40, -1], ["J", 9, [1, 0, 20, 21], [41, 40, "-1", "1/2"], "mm"], ["A", "LAMBDA", 20, -1], ["A", "SCALE", 21, "-1"], ["A", "LAMBDA", 0, 1], ["A", "ADD", 0, 1, "-1"], ["A", "IDLE_ONE", 9, [9]], ["A", "SWAP", 8, 9], ["A", "SWAP", 7, 9], ["A", "SWAP", 6, 9], ["A", "SWAP", 5, 9], ["A", "SWAP", 4, 9], ["A", "SWAP", 3, 9], ["A", "SWAP", 2, 9], ["A", "ADD", 0, 1, "1"], ["A", "SCALE", 1, "-1"], ["A", "SWAP", 1, 9], ["A", "ADD", 9, 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", "ADD", 19, 1, "-1"], ["A", "ADD", 18, 1, "-1"], ["A", "ADD", 17, 1, "-1"], ["A", "ADD", 16, 1, "-1"], ["A", "ADD", 15, 1, "-1"], ["A", "ADD", 14, 1, "-1"], ["A", "ADD", 13, 1, "-1"], ["A", "ADD", 12, 1, "-1"], ["A", "ADD", 11, 1, "-1"], ["A", "ADD", 10, 1, "-1"], ["A", "ADD", 9, 1, "-1"], ["A", "ADD", 8, 1, "-1"], ["A", "ADD", 7, 1, "-1"], ["A", "ADD", 6, 1, "-1"], ["A", "ADD", 5, 1, "-1"], ["A", "ADD", 4, 1, "-1"], ["A", "ADD", 3, 1, "-1"], ["A", "ADD", 2, 1, "-1"], ["A", "SWAP", 0, 1], ["A", "LAMBDA", 0, -1], ["A", "QUERY", 0, 1, -1], ["A", "LAMBDA", 0, 1], ["A", "ADD", 0, 1, "-1"], ["A", "ADD", 19, 0, "1"], ["A", "ADD", 18, 0, "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", 1, 19, "-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", "SCALE", 1, "-1"], ["A", "SCALE", 0, "-1"], ["A", "ADD", 18, 0, "-2"], ["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", 1, 0, "-2"], ["A", "LAMBDA", 0, -1], ["A", "QUERY", 0, 1, -1], ["A", "LAMBDA", 0, 1], ["A", "ADD", 1, 19, "-1"], ["A", "ADD", 0, 19, "-1"], ["A", "ADD", 1, 18, "-1"], ["A", "ADD", 0, 18, "-1"], ["A", "ADD", 19, 18, "2"], ["A", "SWAP", 18, 19], ["A", "ADD", 1, 17, "1"], ["A", "ADD", 0, 17, "1"], ["A", "ADD", 18, 17, "-2"], ["A", "SWAP", 17, 18], ["A", "ADD", 1, 16, "-1"], ["A", "ADD", 0, 16, "-1"], ["A", "ADD", 17, 16, "2"], ["A", "SWAP", 16, 17], ["A", "ADD", 1, 15, "1"], ["A", "ADD", 0, 15, "1"], ["A", "ADD", 16, 15, "-2"], ["A", "SWAP", 15, 16], ["A", "ADD", 1, 14, "-1"], ["A", "ADD", 0, 14, "-1"], ["A", "ADD", 15, 14, "2"], ["A", "SWAP", 14, 15], ["A", "ADD", 1, 13, "1"], ["A", "ADD", 0, 13, "1"], ["A", "ADD", 14, 13, "-2"], ["A", "SWAP", 13, 14], ["A", "ADD", 1, 12, "-1"], ["A", "ADD", 0, 12, "-1"], ["A", "ADD", 13, 12, "2"], ["A", "SWAP", 12, 13], ["A", "ADD", 1, 11, "1"], ["A", "ADD", 0, 11, "1"], ["A", "ADD", 12, 11, "-2"], ["A", "SWAP", 11, 12], ["A", "ADD", 1, 10, "-1"], ["A", "ADD", 0, 10, "-1"], ["A", "ADD", 11, 10, "2"], ["A", "SWAP", 10, 11], ["A", "ADD", 1, 9, "1"], ["A", "ADD", 0, 9, "1"], ["A", "ADD", 10, 9, "-2"], ["A", "SWAP", 9, 10], ["A", "ADD", 1, 8, "-1"], ["A", "ADD", 0, 8, "-1"], ["A", "ADD", 9, 8, "2"], ["A", "SWAP", 8, 9], ["A", "ADD", 1, 7, "1"], ["A", "ADD", 0, 7, "1"], ["A", "ADD", 8, 7, "-2"], ["A", "SWAP", 7, 8], ["A", "ADD", 1, 6, "-1"], ["A", "ADD", 0, 6, "-1"], ["A", "ADD", 7, 6, "2"], ["A", "SWAP", 6, 7], ["A", "ADD", 1, 5, "1"], ["A", "ADD", 0, 5, "1"], ["A", "ADD", 6, 5, "-2"], ["A", "SWAP", 5, 6], ["A", "ADD", 1, 4, "-1"], ["A", "ADD", 0, 4, "-1"], ["A", "ADD", 5, 4, "2"], ["A", "SWAP", 4, 5], ["A", "ADD", 1, 3, "1"], ["A", "ADD", 0, 3, "1"], ["A", "ADD", 4, 3, "-2"], ["A", "SWAP", 3, 4], ["A", "ADD", 1, 2, "-1"], ["A", "ADD", 0, 2, "-1"], ["A", "ADD", 3, 2, "2"], ["A", "SWAP", 2, 3], ["A", "ADD", 0, 1, "-1"], ["A", "SCALE", 1, "-1"], ["A", "ADD", 2, 1, "-2"], ["A", "SWAP", 1, 2], ["A", "ADD", 1, 0, "1"], ["A", "LAMBDA", 0, -1], ["A", "QUERY", 0, 1, -1], ["A", "LAMBDA", 0, 1], ["A", "ADD", 1, 19, "-2"], ["A", "ADD", 0, 19, "-2"], ["A", "ADD", 1, 18, "2"], ["A", "ADD", 0, 18, "2"], ["A", "ADD", 1, 17, "-2"], ["A", "ADD", 0, 17, "-2"], ["A", "SWAP", 17, 19], ["A", "ADD", 1, 16, "2"], ["A", "ADD", 0, 16, "2"], ["A", "SWAP", 16, 18], ["A", "ADD", 1, 15, "-2"], ["A", "ADD", 0, 15, "-2"], ["A", "SWAP", 15, 19], ["A", "ADD", 1, 14, "2"], ["A", "ADD", 0, 14, "2"], ["A", "SWAP", 14, 18], ["A", "ADD", 1, 13, "-2"], ["A", "ADD", 0, 13, "-2"], ["A", "SWAP", 13, 19], ["A", "ADD", 1, 12, "2"], ["A", "ADD", 0, 12, "2"], ["A", "SWAP", 12, 18], ["A", "ADD", 1, 11, "-1"], ["A", "SCALE", 11, "-1"], ["A", "SWAP", 11, 19], ["A", "ADD", 1, 10, "2"], ["A", "ADD", 0, 10, "2"], ["A", "SWAP", 10, 18], ["A", "ADD", 1, 9, "-2"], ["A", "ADD", 0, 9, "-2"], ["A", "SWAP", 9, 17], ["A", "ADD", 1, 8, "2"], ["A", "ADD", 0, 8, "2"], ["A", "SWAP", 8, 16], ["A", "ADD", 1, 7, "-2"], ["A", "ADD", 0, 7, "-2"], ["A", "SWAP", 7, 15], ["A", "ADD", 1, 6, "2"], ["A", "ADD", 0, 6, "2"], ["A", "SWAP", 6, 14], ["A", "ADD", 1, 5, "-2"], ["A", "ADD", 0, 5, "-2"], ["A", "SWAP", 5, 13], ["A", "ADD", 1, 4, "2"], ["A", "ADD", 0, 4, "2"], ["A", "SWAP", 4, 12], ["A", "ADD", 1, 3, "-2"], ["A", "ADD", 0, 3, "-2"], ["A", "SWAP", 3, 11], ["A", "ADD", 1, 2, "2"], ["A", "ADD", 0, 2, "2"], ["A", "SWAP", 2, 10], ["A", "ADD", 0, 1, "-1"], ["A", "SWAP", 1, 19], ["A", "ADD", 19, 0, "-1"], ["A", "ADD", 1, 0, "2"], ["A", "SWAP", 0, 1], ["A", "LAMBDA", 0, -1], ["A", "ADD", 20, 21, "-1"], ["A", "IDLE_ONE", 29, [9]], ["A", "SWAP", 28, 29], ["A", "SWAP", 27, 29], ["A", "SWAP", 26, 29], ["A", "SWAP", 25, 29], ["A", "SWAP", 24, 29], ["A", "SWAP", 23, 29], ["A", "SWAP", 22, 29], ["A", "ADD", 20, 21, "1"], ["A", "SCALE", 21, "-1"], ["A", "SWAP", 21, 29], ["A", "ADD", 29, 20, "1"], ["A", "ADD", 28, 20, "2"], ["A", "ADD", 27, 20, "2"], ["A", "ADD", 26, 20, "2"], ["A", "ADD", 25, 20, "2"], ["A", "ADD", 24, 20, "2"], ["A", "ADD", 23, 20, "2"], ["A", "ADD", 22, 20, "2"], ["A", "ADD", 21, 20, "2"], ["A", "ADD", 39, 21, "-1"], ["A", "ADD", 38, 21, "-1"], ["A", "ADD", 37, 21, "-1"], ["A", "ADD", 36, 21, "-1"], ["A", "ADD", 35, 21, "-1"], ["A", "ADD", 34, 21, "-1"], ["A", "ADD", 33, 21, "-1"], ["A", "ADD", 32, 21, "-1"], ["A", "ADD", 31, 21, "-1"], ["A", "ADD", 30, 21, "-1"], ["A", "ADD", 29, 21, "-1"], ["A", "ADD", 28, 21, "-1"], ["A", "ADD", 27, 21, "-1"], ["A", "ADD", 26, 21, "-1"], ["A", "ADD", 25, 21, "-1"], ["A", "ADD", 24, 21, "-1"], ["A", "ADD", 23, 21, "-1"], ["A", "ADD", 22, 21, "-1"], ["A", "SWAP", 20, 21], ["A", "LAMBDA", 20, -1], ["A", "QUERY", 20, 21, -1], ["A", "LAMBDA", 20, 1], ["A", "ADD", 20, 21, "-1"], ["A", "ADD", 39, 20, "1"], ["A", "ADD", 38, 20, "1"], ["A", "ADD", 37, 20, "1"], ["A", "ADD", 36, 20, "1"], ["A", "ADD", 35, 20, "1"], ["A", "ADD", 34, 20, "1"], ["A", "ADD", 33, 20, "1"], ["A", "ADD", 32, 20, "1"], ["A", "ADD", 31, 20, "1"], ["A", "ADD", 30, 20, "1"], ["A", "ADD", 29, 20, "1"], ["A", "ADD", 28, 20, "1"], ["A", "ADD", 27, 20, "1"], ["A", "ADD", 26, 20, "1"], ["A", "ADD", 25, 20, "1"], ["A", "ADD", 24, 20, "1"], ["A", "ADD", 23, 20, "1"], ["A", "ADD", 22, 20, "1"], ["A", "SWAP", 20, 21], ["A", "ADD", 21, 39, "-1"], ["A", "ADD", 21, 38, "-1"], ["A", "ADD", 21, 37, "1"], ["A", "ADD", 21, 36, "-1"], ["A", "ADD", 21, 35, "1"], ["A", "ADD", 21, 34, "-1"], ["A", "ADD", 21, 33, "1"], ["A", "ADD", 21, 32, "-1"], ["A", "ADD", 21, 31, "1"], ["A", "ADD", 21, 30, "-1"], ["A", "ADD", 21, 29, "1"], ["A", "ADD", 21, 28, "-1"], ["A", "ADD", 21, 27, "1"], ["A", "ADD", 21, 26, "-1"], ["A", "ADD", 21, 25, "1"], ["A", "ADD", 21, 24, "-1"], ["A", "ADD", 21, 23, "1"], ["A", "ADD", 21, 22, "-1"], ["A", "SCALE", 21, "-1"], ["A", "SCALE", 20, "-1"], ["A", "ADD", 38, 20, "-2"], ["A", "ADD", 37, 20, "-2"], ["A", "ADD", 36, 20, "-2"], ["A", "ADD", 35, 20, "-2"], ["A", "ADD", 34, 20, "-2"], ["A", "ADD", 33, 20, "-2"], ["A", "ADD", 32, 20, "-2"], ["A", "ADD", 31, 20, "-2"], ["A", "ADD", 30, 20, "-2"], ["A", "ADD", 21, 20, "-2"], ["A", "LAMBDA", 20, -1], ["A", "QUERY", 20, 21, -1], ["A", "LAMBDA", 20, 1], ["A", "ADD", 21, 39, "-1"], ["A", "ADD", 20, 39, "-1"], ["A", "ADD", 21, 38, "-1"], ["A", "ADD", 20, 38, "-1"], ["A", "ADD", 39, 38, "2"], ["A", "SWAP", 38, 39], ["A", "ADD", 21, 37, "1"], ["A", "ADD", 20, 37, "1"], ["A", "ADD", 38, 37, "-2"], ["A", "SWAP", 37, 38], ["A", "ADD", 21, 36, "-1"], ["A", "ADD", 20, 36, "-1"], ["A", "ADD", 37, 36, "2"], ["A", "SWAP", 36, 37], ["A", "ADD", 21, 35, "1"], ["A", "ADD", 20, 35, "1"], ["A", "ADD", 36, 35, "-2"], ["A", "SWAP", 35, 36], ["A", "ADD", 21, 34, "-1"], ["A", "ADD", 20, 34, "-1"], ["A", "ADD", 35, 34, "2"], ["A", "SWAP", 34, 35], ["A", "ADD", 21, 33, "1"], ["A", "ADD", 20, 33, "1"], ["A", "ADD", 34, 33, "-2"], ["A", "SWAP", 33, 34], ["A", "ADD", 21, 32, "-1"], ["A", "ADD", 20, 32, "-1"], ["A", "ADD", 33, 32, "2"], ["A", "SWAP", 32, 33], ["A", "ADD", 21, 31, "1"], ["A", "ADD", 20, 31, "1"], ["A", "ADD", 32, 31, "-2"], ["A", "SWAP", 31, 32], ["A", "ADD", 21, 30, "-1"], ["A", "ADD", 20, 30, "-1"], ["A", "ADD", 31, 30, "2"], ["A", "SWAP", 30, 31], ["A", "ADD", 21, 29, "1"], ["A", "ADD", 20, 29, "1"], ["A", "ADD", 30, 29, "-2"], ["A", "SWAP", 29, 30], ["A", "ADD", 21, 28, "-1"], ["A", "ADD", 20, 28, "-1"], ["A", "ADD", 29, 28, "2"], ["A", "SWAP", 28, 29], ["A", "ADD", 21, 27, "1"], ["A", "ADD", 20, 27, "1"], ["A", "ADD", 28, 27, "-2"], ["A", "SWAP", 27, 28], ["A", "ADD", 21, 26, "-1"], ["A", "ADD", 20, 26, "-1"], ["A", "ADD", 27, 26, "2"], ["A", "SWAP", 26, 27], ["A", "ADD", 21, 25, "1"], ["A", "ADD", 20, 25, "1"], ["A", "ADD", 26, 25, "-2"], ["A", "SWAP", 25, 26], ["A", "ADD", 21, 24, "-1"], ["A", "ADD", 20, 24, "-1"], ["A", "ADD", 25, 24, "2"], ["A", "SWAP", 24, 25], ["A", "ADD", 21, 23, "1"], ["A", "ADD", 20, 23, "1"], ["A", "ADD", 24, 23, "-2"], ["A", "SWAP", 23, 24], ["A", "ADD", 21, 22, "-1"], ["A", "ADD", 20, 22, "-1"], ["A", "ADD", 23, 22, "2"], ["A", "SWAP", 22, 23], ["A", "ADD", 20, 21, "-1"], ["A", "SCALE", 21, "-1"], ["A", "ADD", 22, 21, "-2"], ["A", "SWAP", 21, 22], ["A", "ADD", 21, 20, "1"], ["A", "LAMBDA", 20, -1], ["A", "QUERY", 20, 21, -1], ["A", "LAMBDA", 20, 1], ["A", "ADD", 21, 39, "-2"], ["A", "ADD", 20, 39, "-2"], ["A", "ADD", 21, 38, "2"], ["A", "ADD", 20, 38, "2"], ["A", "ADD", 21, 37, "-2"], ["A", "ADD", 20, 37, "-2"], ["A", "SWAP", 37, 39], ["A", "ADD", 21, 36, "2"], ["A", "ADD", 20, 36, "2"], ["A", "SWAP", 36, 38], ["A", "ADD", 21, 35, "-2"], ["A", "ADD", 20, 35, "-2"], ["A", "SWAP", 35, 39], ["A", "ADD", 21, 34, "2"], ["A", "ADD", 20, 34, "2"], ["A", "SWAP", 34, 38], ["A", "ADD", 21, 33, "-2"], ["A", "ADD", 20, 33, "-2"], ["A", "SWAP", 33, 39], ["A", "ADD", 21, 32, "2"], ["A", "ADD", 20, 32, "2"], ["A", "SWAP", 32, 38], ["A", "ADD", 21, 31, "-1"], ["A", "SCALE", 31, "-1"], ["A", "SWAP", 31, 39], ["A", "ADD", 21, 30, "2"], ["A", "ADD", 20, 30, "2"], ["A", "SWAP", 30, 38], ["A", "ADD", 21, 29, "-2"], ["A", "ADD", 20, 29, "-2"], ["A", "SWAP", 29, 37], ["A", "ADD", 21, 28, "2"], ["A", "ADD", 20, 28, "2"], ["A", "SWAP", 28, 36], ["A", "ADD", 21, 27, "-2"], ["A", "ADD", 20, 27, "-2"], ["A", "SWAP", 27, 35], ["A", "ADD", 21, 26, "2"], ["A", "ADD", 20, 26, "2"], ["A", "SWAP", 26, 34], ["A", "ADD", 21, 25, "-2"], ["A", "ADD", 20, 25, "-2"], ["A", "SWAP", 25, 33], ["A", "ADD", 21, 24, "2"], ["A", "ADD", 20, 24, "2"], ["A", "SWAP", 24, 32], ["A", "ADD", 21, 23, "-2"], ["A", "ADD", 20, 23, "-2"], ["A", "SWAP", 23, 31], ["A", "ADD", 21, 22, "2"], ["A", "ADD", 20, 22, "2"], ["A", "SWAP", 22, 30], ["A", "ADD", 20, 21, "-1"], ["A", "SWAP", 21, 39], ["A", "SCALE", 20, "-1"], ["A", "ADD", 39, 20, "1"], ["A", "ADD", 21, 20, "-2"], ["A", "SWAP", 20, 21], ["A", "LAMBDA", 20, 1], ["B", "LAMBDA", 40, 1], ["B", "IDLE_ONE", 56, [9]], ["B", "IDLE_ONE", 57, [9]], ["B", "IDLE_ONE", 58, [9]], ["B", "IDLE_ONE", 59, [9]], ["B", "ADD", 41, 59, "256"], ["B", "ADD", 40, 59, "-128"], ["B", "ADD", 40, 58, "-128"], ["B", "ADD", 59, 58, "1"], ["B", "SCALE", 41, "-1/256"], ["B", "ADD", 59, 41, "-1"], ["B", "ADD", 58, 41, "-2"], ["B", "ADD", 57, 41, "-2"], ["B", "ADD", 56, 41, "-2"], ["B", "ADD", 55, 41, "-2"], ["B", "ADD", 54, 41, "-2"], ["B", "ADD", 53, 41, "-2"], ["B", "ADD", 52, 41, "-2"], ["B", "ADD", 51, 41, "-2"], ["B", "ADD", 50, 41, "-2"], ["B", "ADD", 49, 41, "-2"], ["B", "ADD", 48, 41, "-2"], ["B", "ADD", 47, 41, "-2"], ["B", "ADD", 46, 41, "-2"], ["B", "ADD", 45, 41, "-2"], ["B", "ADD", 44, 41, "-2"], ["B", "ADD", 43, 41, "-2"], ["B", "ADD", 42, 41, "-2"], ["B", "SCALE", 40, "1/64"], ["B", "ADD", 77, 40, "-1"], ["B", "ADD", 76, 40, "-1"], ["B", "ADD", 75, 40, "-1"], ["B", "ADD", 74, 40, "-1"], ["B", "ADD", 73, 40, "-1"], ["B", "ADD", 72, 40, "-1"], ["B", "ADD", 71, 40, "-1"], ["B", "ADD", 70, 40, "-1"], ["B", "ADD", 69, 40, "-1"], ["B", "ADD", 68, 40, "-1"], ["B", "ADD", 67, 40, "-1"], ["B", "ADD", 66, 40, "-1"], ["B", "ADD", 65, 40, "-1"], ["B", "ADD", 64, 40, "-1"], ["B", "ADD", 63, 40, "-1"], ["B", "ADD", 62, 40, "-1"], ["B", "ADD", 61, 40, "-1"], ["B", "ADD", 60, 40, "-1"], ["B", "ADD", 59, 40, "1/2"], ["B", "ADD", 58, 40, "1"], ["B", "ADD", 41, 40, "1/2"], ["B", "LAMBDA", 40, -1], ["B", "QUERY", 40, 41, -1], ["B", "LAMBDA", 40, 1], ["B", "ADD", 40, 41, "-1"], ["B", "ADD", 76, 77, "-2"], ["B", "ADD", 75, 77, "-2"], ["B", "ADD", 74, 77, "-2"], ["B", "ADD", 73, 77, "-2"], ["B", "ADD", 72, 77, "-2"], ["B", "ADD", 71, 77, "-2"], ["B", "ADD", 70, 77, "-2"], ["B", "ADD", 69, 77, "-2"], ["B", "ADD", 68, 77, "-2"], ["B", "ADD", 67, 77, "-2"], ["B", "ADD", 66, 77, "-2"], ["B", "ADD", 65, 77, "-2"], ["B", "ADD", 64, 77, "-2"], ["B", "ADD", 63, 77, "-2"], ["B", "ADD", 62, 77, "-2"], ["B", "ADD", 61, 77, "-2"], ["B", "ADD", 60, 77, "-2"], ["B", "ADD", 58, 77, "2"], ["B", "ADD", 56, 77, "2"], ["B", "ADD", 54, 77, "2"], ["B", "ADD", 52, 77, "2"], ["B", "ADD", 50, 77, "2"], ["B", "ADD", 48, 77, "2"], ["B", "ADD", 46, 77, "2"], ["B", "ADD", 44, 77, "2"], ["B", "ADD", 43, 77, "2"], ["B", "ADD", 42, 77, "2"], ["B", "ADD", 40, 77, "2"], ["B", "SCALE", 77, "-1"], ["B", "ADD", 75, 76, "-2"], ["B", "ADD", 74, 76, "-2"], ["B", "ADD", 73, 76, "-2"], ["B", "ADD", 72, 76, "-2"], ["B", "ADD", 71, 76, "-2"], ["B", "ADD", 70, 76, "-2"], ["B", "ADD", 69, 76, "-2"], ["B", "ADD", 68, 76, "-2"], ["B", "ADD", 67, 76, "-2"], ["B", "ADD", 66, 76, "-2"], ["B", "ADD", 65, 76, "-2"], ["B", "ADD", 64, 76, "-2"], ["B", "ADD", 63, 76, "-2"], ["B", "ADD", 62, 76, "-2"], ["B", "ADD", 61, 76, "-2"], ["B", "ADD", 60, 76, "-2"], ["B", "ADD", 58, 76, "2"], ["B", "ADD", 56, 76, "2"], ["B", "ADD", 54, 76, "2"], ["B", "ADD", 52, 76, "2"], ["B", "ADD", 50, 76, "2"], ["B", "ADD", 48, 76, "2"], ["B", "ADD", 46, 76, "2"], ["B", "ADD", 44, 76, "2"], ["B", "ADD", 43, 76, "2"], ["B", "ADD", 42, 76, "2"], ["B", "ADD", 40, 76, "2"], ["B", "SCALE", 76, "-1"], ["B", "ADD", 77, 76, "2"], ["B", "ADD", 73, 74, "-2"], ["B", "ADD", 72, 74, "-2"], ["B", "ADD", 71, 74, "-2"], ["B", "ADD", 70, 74, "-2"], ["B", "ADD", 69, 74, "-2"], ["B", "ADD", 68, 74, "-2"], ["B", "ADD", 67, 74, "-2"], ["B", "ADD", 66, 74, "-2"], ["B", "ADD", 65, 74, "-2"], ["B", "ADD", 64, 74, "-2"], ["B", "ADD", 63, 74, "-2"], ["B", "ADD", 62, 74, "-2"], ["B", "ADD", 61, 74, "-2"], ["B", "ADD", 60, 74, "-2"], ["B", "ADD", 58, 74, "2"], ["B", "ADD", 56, 74, "2"], ["B", "ADD", 54, 74, "2"], ["B", "ADD", 52, 74, "2"], ["B", "ADD", 50, 74, "2"], ["B", "ADD", 48, 74, "2"], ["B", "ADD", 46, 74, "2"], ["B", "ADD", 44, 74, "2"], ["B", "ADD", 43, 74, "2"], ["B", "ADD", 42, 74, "2"], ["B", "ADD", 40, 74, "2"], ["B", "SCALE", 74, "-1"], ["B", "ADD", 77, 74, "2"], ["B", "ADD", 76, 74, "2"], ["B", "ADD", 75, 74, "2"], ["B", "ADD", 72, 73, "-2"], ["B", "ADD", 71, 73, "-2"], ["B", "ADD", 70, 73, "-2"], ["B", "ADD", 69, 73, "-2"], ["B", "ADD", 68, 73, "-2"], ["B", "ADD", 67, 73, "-2"], ["B", "ADD", 66, 73, "-2"], ["B", "ADD", 65, 73, "-2"], ["B", "ADD", 64, 73, "-2"], ["B", "ADD", 63, 73, "-2"], ["B", "ADD", 62, 73, "-2"], ["B", "ADD", 61, 73, "-2"], ["B", "ADD", 60, 73, "-2"], ["B", "ADD", 58, 73, "2"], ["B", "ADD", 56, 73, "2"], ["B", "ADD", 54, 73, "2"], ["B", "ADD", 52, 73, "2"], ["B", "ADD", 50, 73, "2"], ["B", "ADD", 48, 73, "2"], ["B", "ADD", 46, 73, "2"], ["B", "ADD", 44, 73, "2"], ["B", "ADD", 43, 73, "2"], ["B", "ADD", 42, 73, "2"], ["B", "ADD", 40, 73, "2"], ["B", "SCALE", 73, "-1"], ["B", "ADD", 77, 73, "2"], ["B", "ADD", 76, 73, "2"], ["B", "ADD", 75, 73, "2"], ["B", "ADD", 74, 73, "2"], ["B", "ADD", 71, 72, "-2"], ["B", "ADD", 70, 72, "-2"], ["B", "ADD", 69, 72, "-2"], ["B", "ADD", 68, 72, "-2"], ["B", "ADD", 67, 72, "-2"], ["B", "ADD", 66, 72, "-2"], ["B", "ADD", 65, 72, "-2"], ["B", "ADD", 64, 72, "-2"], ["B", "ADD", 63, 72, "-2"], ["B", "ADD", 62, 72, "-2"], ["B", "ADD", 61, 72, "-2"], ["B", "ADD", 60, 72, "-2"], ["B", "ADD", 58, 72, "2"], ["B", "ADD", 56, 72, "2"], ["B", "ADD", 54, 72, "2"], ["B", "ADD", 52, 72, "2"], ["B", "ADD", 50, 72, "2"], ["B", "ADD", 48, 72, "2"], ["B", "ADD", 46, 72, "2"], ["B", "ADD", 44, 72, "2"], ["B", "ADD", 43, 72, "2"], ["B", "ADD", 42, 72, "2"], ["B", "ADD", 40, 72, "2"], ["B", "SCALE", 72, "-1"], ["B", "ADD", 77, 72, "2"], ["B", "ADD", 76, 72, "2"], ["B", "ADD", 75, 72, "2"], ["B", "ADD", 74, 72, "2"], ["B", "ADD", 73, 72, "2"], ["B", "ADD", 69, 70, "-2"], ["B", "ADD", 68, 70, "-2"], ["B", "ADD", 67, 70, "-2"], ["B", "ADD", 66, 70, "-2"], ["B", "ADD", 65, 70, "-2"], ["B", "ADD", 64, 70, "-2"], ["B", "ADD", 63, 70, "-2"], ["B", "ADD", 62, 70, "-2"], ["B", "ADD", 61, 70, "-2"], ["B", "ADD", 60, 70, "-2"], ["B", "ADD", 58, 70, "2"], ["B", "ADD", 56, 70, "2"], ["B", "ADD", 54, 70, "2"], ["B", "ADD", 52, 70, "2"], ["B", "ADD", 50, 70, "2"], ["B", "ADD", 48, 70, "2"], ["B", "ADD", 46, 70, "2"], ["B", "ADD", 44, 70, "2"], ["B", "ADD", 43, 70, "2"], ["B", "ADD", 42, 70, "2"], ["B", "ADD", 40, 70, "2"], ["B", "SCALE", 70, "-1"], ["B", "ADD", 77, 70, "2"], ["B", "ADD", 76, 70, "2"], ["B", "ADD", 75, 70, "2"], ["B", "ADD", 74, 70, "2"], ["B", "ADD", 73, 70, "2"], ["B", "ADD", 72, 70, "2"], ["B", "ADD", 71, 70, "2"], ["B", "ADD", 68, 69, "-2"], ["B", "ADD", 67, 69, "-2"], ["B", "ADD", 66, 69, "-2"], ["B", "ADD", 65, 69, "-2"], ["B", "ADD", 64, 69, "-2"], ["B", "ADD", 63, 69, "-2"], ["B", "ADD", 62, 69, "-2"], ["B", "ADD", 61, 69, "-2"], ["B", "ADD", 60, 69, "-2"], ["B", "ADD", 58, 69, "2"], ["B", "ADD", 56, 69, "2"], ["B", "ADD", 54, 69, "2"], ["B", "ADD", 52, 69, "2"], ["B", "ADD", 50, 69, "2"], ["B", "ADD", 48, 69, "2"], ["B", "ADD", 46, 69, "2"], ["B", "ADD", 44, 69, "2"], ["B", "ADD", 43, 69, "2"], ["B", "ADD", 42, 69, "2"], ["B", "ADD", 40, 69, "2"], ["B", "SCALE", 69, "-1"], ["B", "ADD", 77, 69, "2"], ["B", "ADD", 76, 69, "2"], ["B", "ADD", 75, 69, "2"], ["B", "ADD", 74, 69, "2"], ["B", "ADD", 73, 69, "2"], ["B", "ADD", 72, 69, "2"], ["B", "ADD", 71, 69, "2"], ["B", "ADD", 70, 69, "2"], ["B", "ADD", 67, 68, "-2"], ["B", "ADD", 66, 68, "-2"], ["B", "ADD", 65, 68, "-2"], ["B", "ADD", 64, 68, "-2"], ["B", "ADD", 63, 68, "-2"], ["B", "ADD", 62, 68, "-2"], ["B", "ADD", 61, 68, "-2"], ["B", "ADD", 60, 68, "-2"], ["B", "ADD", 58, 68, "2"], ["B", "ADD", 56, 68, "2"], ["B", "ADD", 54, 68, "2"], ["B", "ADD", 52, 68, "2"], ["B", "ADD", 50, 68, "2"], ["B", "ADD", 48, 68, "2"], ["B", "ADD", 46, 68, "2"], ["B", "ADD", 44, 68, "2"], ["B", "ADD", 43, 68, "2"], ["B", "ADD", 42, 68, "2"], ["B", "ADD", 40, 68, "2"], ["B", "SCALE", 68, "-1"], ["B", "ADD", 77, 68, "2"], ["B", "ADD", 76, 68, "2"], ["B", "ADD", 75, 68, "2"], ["B", "ADD", 74, 68, "2"], ["B", "ADD", 73, 68, "2"], ["B", "ADD", 72, 68, "2"], ["B", "ADD", 71, 68, "2"], ["B", "ADD", 70, 68, "2"], ["B", "ADD", 69, 68, "2"], ["B", "ADD", 65, 66, "-2"], ["B", "ADD", 64, 66, "-2"], ["B", "ADD", 63, 66, "-2"], ["B", "ADD", 62, 66, "-2"], ["B", "ADD", 61, 66, "-2"], ["B", "ADD", 60, 66, "-2"], ["B", "ADD", 58, 66, "2"], ["B", "ADD", 56, 66, "2"], ["B", "ADD", 54, 66, "2"], ["B", "ADD", 52, 66, "2"], ["B", "ADD", 50, 66, "2"], ["B", "ADD", 48, 66, "2"], ["B", "ADD", 46, 66, "2"], ["B", "ADD", 44, 66, "2"], ["B", "ADD", 43, 66, "2"], ["B", "ADD", 42, 66, "2"], ["B", "ADD", 40, 66, "2"], ["B", "SCALE", 66, "-1"], ["B", "ADD", 77, 66, "2"], ["B", "ADD", 76, 66, "2"], ["B", "ADD", 75, 66, "2"], ["B", "ADD", 74, 66, "2"], ["B", "ADD", 73, 66, "2"], ["B", "ADD", 72, 66, "2"], ["B", "ADD", 71, 66, "2"], ["B", "ADD", 70, 66, "2"], ["B", "ADD", 69, 66, "2"], ["B", "ADD", 68, 66, "2"], ["B", "ADD", 67, 66, "2"], ["B", "ADD", 64, 65, "-2"], ["B", "ADD", 63, 65, "-2"], ["B", "ADD", 62, 65, "-2"], ["B", "ADD", 61, 65, "-2"], ["B", "ADD", 60, 65, "-2"], ["B", "ADD", 58, 65, "2"], ["B", "ADD", 56, 65, "2"], ["B", "ADD", 54, 65, "2"], ["B", "ADD", 52, 65, "2"], ["B", "ADD", 50, 65, "2"], ["B", "ADD", 48, 65, "2"], ["B", "ADD", 46, 65, "2"], ["B", "ADD", 44, 65, "2"], ["B", "ADD", 43, 65, "2"], ["B", "ADD", 42, 65, "2"], ["B", "ADD", 40, 65, "2"], ["B", "SCALE", 65, "-1"], ["B", "ADD", 77, 65, "2"], ["B", "ADD", 76, 65, "2"], ["B", "ADD", 75, 65, "2"], ["B", "ADD", 74, 65, "2"], ["B", "ADD", 73, 65, "2"], ["B", "ADD", 72, 65, "2"], ["B", "ADD", 71, 65, "2"], ["B", "ADD", 70, 65, "2"], ["B", "ADD", 69, 65, "2"], ["B", "ADD", 68, 65, "2"], ["B", "ADD", 67, 65, "2"], ["B", "ADD", 66, 65, "2"], ["B", "ADD", 63, 64, "-2"], ["B", "ADD", 62, 64, "-2"], ["B", "ADD", 61, 64, "-2"], ["B", "ADD", 60, 64, "-2"], ["B", "ADD", 58, 64, "2"], ["B", "ADD", 56, 64, "2"], ["B", "ADD", 54, 64, "2"], ["B", "ADD", 52, 64, "2"], ["B", "ADD", 50, 64, "2"], ["B", "ADD", 48, 64, "2"], ["B", "ADD", 46, 64, "2"], ["B", "ADD", 44, 64, "2"], ["B", "ADD", 43, 64, "2"], ["B", "ADD", 42, 64, "2"], ["B", "ADD", 40, 64, "2"], ["B", "SCALE", 64, "-1"], ["B", "ADD", 77, 64, "2"], ["B", "ADD", 76, 64, "2"], ["B", "ADD", 75, 64, "2"], ["B", "ADD", 74, 64, "2"], ["B", "ADD", 73, 64, "2"], ["B", "ADD", 72, 64, "2"], ["B", "ADD", 71, 64, "2"], ["B", "ADD", 70, 64, "2"], ["B", "ADD", 69, 64, "2"], ["B", "ADD", 68, 64, "2"], ["B", "ADD", 67, 64, "2"], ["B", "ADD", 66, 64, "2"], ["B", "ADD", 65, 64, "2"], ["B", "ADD", 61, 62, "-2"], ["B", "ADD", 60, 62, "-2"], ["B", "ADD", 58, 62, "2"], ["B", "ADD", 56, 62, "2"], ["B", "ADD", 54, 62, "2"], ["B", "ADD", 52, 62, "2"], ["B", "ADD", 50, 62, "2"], ["B", "ADD", 48, 62, "2"], ["B", "ADD", 46, 62, "2"], ["B", "ADD", 44, 62, "2"], ["B", "ADD", 43, 62, "2"], ["B", "ADD", 42, 62, "2"], ["B", "ADD", 40, 62, "2"], ["B", "SCALE", 62, "-1"], ["B", "ADD", 77, 62, "2"], ["B", "ADD", 76, 62, "2"], ["B", "ADD", 75, 62, "2"], ["B", "ADD", 74, 62, "2"], ["B", "ADD", 73, 62, "2"], ["B", "ADD", 72, 62, "2"], ["B", "ADD", 71, 62, "2"], ["B", "ADD", 70, 62, "2"], ["B", "ADD", 69, 62, "2"], ["B", "ADD", 68, 62, "2"], ["B", "ADD", 67, 62, "2"], ["B", "ADD", 66, 62, "2"], ["B", "ADD", 65, 62, "2"], ["B", "ADD", 64, 62, "2"], ["B", "ADD", 63, 62, "2"], ["B", "ADD", 60, 61, "-2"], ["B", "ADD", 58, 61, "2"], ["B", "ADD", 56, 61, "2"], ["B", "ADD", 54, 61, "2"], ["B", "ADD", 52, 61, "2"], ["B", "ADD", 50, 61, "2"], ["B", "ADD", 48, 61, "2"], ["B", "ADD", 46, 61, "2"], ["B", "ADD", 44, 61, "2"], ["B", "ADD", 43, 61, "2"], ["B", "ADD", 42, 61, "2"], ["B", "ADD", 40, 61, "2"], ["B", "SCALE", 61, "-1"], ["B", "ADD", 77, 61, "2"], ["B", "ADD", 76, 61, "2"], ["B", "ADD", 75, 61, "2"], ["B", "ADD", 74, 61, "2"], ["B", "ADD", 73, 61, "2"], ["B", "ADD", 72, 61, "2"], ["B", "ADD", 71, 61, "2"], ["B", "ADD", 70, 61, "2"], ["B", "ADD", 69, 61, "2"], ["B", "ADD", 68, 61, "2"], ["B", "ADD", 67, 61, "2"], ["B", "ADD", 66, 61, "2"], ["B", "ADD", 65, 61, "2"], ["B", "ADD", 64, 61, "2"], ["B", "ADD", 63, 61, "2"], ["B", "ADD", 62, 61, "2"], ["B", "ADD", 58, 60, "2"], ["B", "ADD", 56, 60, "2"], ["B", "ADD", 54, 60, "2"], ["B", "ADD", 52, 60, "2"], ["B", "ADD", 50, 60, "2"], ["B", "ADD", 48, 60, "2"], ["B", "ADD", 46, 60, "2"], ["B", "ADD", 44, 60, "2"], ["B", "ADD", 43, 60, "2"], ["B", "ADD", 42, 60, "2"], ["B", "ADD", 40, 60, "2"], ["B", "SCALE", 60, "-1"], ["B", "ADD", 77, 60, "2"], ["B", "ADD", 76, 60, "2"], ["B", "ADD", 75, 60, "2"], ["B", "ADD", 74, 60, "2"], ["B", "ADD", 73, 60, "2"], ["B", "ADD", 72, 60, "2"], ["B", "ADD", 71, 60, "2"], ["B", "ADD", 70, 60, "2"], ["B", "ADD", 69, 60, "2"], ["B", "ADD", 68, 60, "2"], ["B", "ADD", 67, 60, "2"], ["B", "ADD", 66, 60, "2"], ["B", "ADD", 65, 60, "2"], ["B", "ADD", 64, 60, "2"], ["B", "ADD", 63, 60, "2"], ["B", "ADD", 62, 60, "2"], ["B", "ADD", 61, 60, "2"], ["B", "ADD", 58, 59, "2"], ["B", "ADD", 56, 59, "2"], ["B", "ADD", 54, 59, "2"], ["B", "ADD", 52, 59, "2"], ["B", "ADD", 50, 59, "2"], ["B", "ADD", 48, 59, "2"], ["B", "ADD", 46, 59, "2"], ["B", "ADD", 44, 59, "2"], ["B", "ADD", 43, 59, "2"], ["B", "ADD", 42, 59, "2"], ["B", "ADD", 40, 59, "2"], ["B", "ADD", 77, 59, "-2"], ["B", "ADD", 76, 59, "-2"], ["B", "ADD", 75, 59, "-2"], ["B", "ADD", 74, 59, "-2"], ["B", "ADD", 73, 59, "-2"], ["B", "ADD", 72, 59, "-2"], ["B", "ADD", 71, 59, "-2"], ["B", "ADD", 70, 59, "-2"], ["B", "ADD", 69, 59, "-2"], ["B", "ADD", 68, 59, "-2"], ["B", "ADD", 67, 59, "-2"], ["B", "ADD", 66, 59, "-2"], ["B", "ADD", 65, 59, "-2"], ["B", "ADD", 64, 59, "-2"], ["B", "ADD", 63, 59, "-2"], ["B", "ADD", 62, 59, "-2"], ["B", "ADD", 61, 59, "-2"], ["B", "ADD", 60, 59, "-2"], ["B", "ADD", 56, 58, "-1"], ["B", "ADD", 54, 58, "-1/2"], ["B", "ADD", 52, 58, "-1"], ["B", "ADD", 50, 58, "-1"], ["B", "ADD", 48, 58, "-1"], ["B", "ADD", 46, 58, "-1"], ["B", "ADD", 44, 58, "-1"], ["B", "ADD", 43, 58, "-1"], ["B", "ADD", 42, 58, "-1"], ["B", "ADD", 40, 58, "-1"], ["B", "SCALE", 58, "-1/2"], ["B", "ADD", 77, 58, "-2"], ["B", "ADD", 76, 58, "-2"], ["B", "ADD", 75, 58, "-2"], ["B", "ADD", 74, 58, "-2"], ["B", "ADD", 73, 58, "-2"], ["B", "ADD", 72, 58, "-2"], ["B", "ADD", 71, 58, "-2"], ["B", "ADD", 70, 58, "-2"], ["B", "ADD", 69, 58, "-2"], ["B", "ADD", 68, 58, "-2"], ["B", "ADD", 67, 58, "-2"], ["B", "ADD", 66, 58, "-2"], ["B", "ADD", 65, 58, "-2"], ["B", "ADD", 64, 58, "-2"], ["B", "ADD", 63, 58, "-2"], ["B", "ADD", 62, 58, "-2"], ["B", "ADD", 61, 58, "-2"], ["B", "ADD", 60, 58, "-2"], ["B", "ADD", 54, 57, "1"], ["B", "ADD", 58, 57, "-1"], ["B", "ADD", 54, 56, "1/2"], ["B", "ADD", 52, 56, "-1"], ["B", "ADD", 50, 56, "-1"], ["B", "ADD", 48, 56, "-1"], ["B", "ADD", 46, 56, "-1"], ["B", "ADD", 44, 56, "-1"], ["B", "ADD", 43, 56, "-1"], ["B", "ADD", 42, 56, "-1"], ["B", "ADD", 40, 56, "-1"], ["B", "SCALE", 56, "-1"], ["B", "ADD", 77, 56, "-1"], ["B", "ADD", 76, 56, "-1"], ["B", "ADD", 75, 56, "-1"], ["B", "ADD", 74, 56, "-1"], ["B", "ADD", 73, 56, "-1"], ["B", "ADD", 72, 56, "-1"], ["B", "ADD", 71, 56, "-1"], ["B", "ADD", 70, 56, "-1"], ["B", "ADD", 69, 56, "-1"], ["B", "ADD", 68, 56, "-1"], ["B", "ADD", 67, 56, "-1"], ["B", "ADD", 66, 56, "-1"], ["B", "ADD", 65, 56, "-1"], ["B", "ADD", 64, 56, "-1"], ["B", "ADD", 63, 56, "-1"], ["B", "ADD", 62, 56, "-1"], ["B", "ADD", 61, 56, "-1"], ["B", "ADD", 60, 56, "-1"], ["B", "ADD", 58, 56, "3/2"], ["B", "SWAP", 56, 58], ["B", "ADD", 54, 55, "-1"], ["B", "ADD", 56, 55, "1"], ["B", "ADD", 52, 54, "2"], ["B", "ADD", 50, 54, "2"], ["B", "ADD", 48, 54, "2"], ["B", "ADD", 46, 54, "2"], ["B", "ADD", 44, 54, "2"], ["B", "ADD", 43, 54, "2"], ["B", "ADD", 42, 54, "2"], ["B", "ADD", 40, 54, "2"], ["B", "SCALE", 54, "2"], ["B", "ADD", 77, 54, "-1"], ["B", "ADD", 76, 54, "-1"], ["B", "ADD", 75, 54, "-1"], ["B", "ADD", 74, 54, "-1"], ["B", "ADD", 73, 54, "-1"], ["B", "ADD", 72, 54, "-1"], ["B", "ADD", 71, 54, "-1"], ["B", "ADD", 70, 54, "-1"], ["B", "ADD", 69, 54, "-1"], ["B", "ADD", 68, 54, "-1"], ["B", "ADD", 67, 54, "-1"], ["B", "ADD", 66, 54, "-1"], ["B", "ADD", 65, 54, "-1"], ["B", "ADD", 64, 54, "-1"], ["B", "ADD", 63, 54, "-1"], ["B", "ADD", 62, 54, "-1"], ["B", "ADD", 61, 54, "-1"], ["B", "ADD", 60, 54, "-1"], ["B", "ADD", 58, 54, "1"], ["B", "ADD", 56, 54, "3/2"], ["B", "SWAP", 54, 56], ["B", "ADD", 52, 53, "-2"], ["B", "ADD", 50, 53, "-2"], ["B", "ADD", 48, 53, "-2"], ["B", "ADD", 46, 53, "-2"], ["B", "ADD", 44, 53, "-2"], ["B", "ADD", 43, 53, "-2"], ["B", "ADD", 42, 53, "-2"], ["B", "ADD", 40, 53, "-2"], ["B", "ADD", 77, 53, "2"], ["B", "ADD", 76, 53, "2"], ["B", "ADD", 75, 53, "2"], ["B", "ADD", 74, 53, "2"], ["B", "ADD", 73, 53, "2"], ["B", "ADD", 72, 53, "2"], ["B", "ADD", 71, 53, "2"], ["B", "ADD", 70, 53, "2"], ["B", "ADD", 69, 53, "2"], ["B", "ADD", 68, 53, "2"], ["B", "ADD", 67, 53, "2"], ["B", "ADD", 66, 53, "2"], ["B", "ADD", 65, 53, "2"], ["B", "ADD", 64, 53, "2"], ["B", "ADD", 63, 53, "2"], ["B", "ADD", 62, 53, "2"], ["B", "ADD", 61, 53, "2"], ["B", "ADD", 60, 53, "2"], ["B", "ADD", 58, 53, "-2"], ["B", "ADD", 56, 53, "-2"], ["B", "ADD", 54, 53, "-2"], ["B", "ADD", 50, 51, "2"], ["B", "ADD", 48, 51, "2"], ["B", "ADD", 46, 51, "2"], ["B", "ADD", 44, 51, "2"], ["B", "ADD", 43, 51, "2"], ["B", "ADD", 42, 51, "2"], ["B", "ADD", 40, 51, "2"], ["B", "ADD", 77, 51, "-2"], ["B", "ADD", 76, 51, "-2"], ["B", "ADD", 75, 51, "-2"], ["B", "ADD", 74, 51, "-2"], ["B", "ADD", 73, 51, "-2"], ["B", "ADD", 72, 51, "-2"], ["B", "ADD", 71, 51, "-2"], ["B", "ADD", 70, 51, "-2"], ["B", "ADD", 69, 51, "-2"], ["B", "ADD", 68, 51, "-2"], ["B", "ADD", 67, 51, "-2"], ["B", "ADD", 66, 51, "-2"], ["B", "ADD", 65, 51, "-2"], ["B", "ADD", 64, 51, "-2"], ["B", "ADD", 63, 51, "-2"], ["B", "ADD", 62, 51, "-2"], ["B", "ADD", 61, 51, "-2"], ["B", "ADD", 60, 51, "-2"], ["B", "ADD", 58, 51, "2"], ["B", "ADD", 56, 51, "2"], ["B", "ADD", 54, 51, "2"], ["B", "ADD", 52, 51, "2"], ["B", "ADD", 48, 50, "-1"], ["B", "ADD", 46, 50, "-1/2"], ["B", "ADD", 44, 50, "-1"], ["B", "ADD", 43, 50, "-1"], ["B", "ADD", 42, 50, "-1"], ["B", "ADD", 40, 50, "-1"], ["B", "SCALE", 50, "-1/2"], ["B", "ADD", 77, 50, "-2"], ["B", "ADD", 76, 50, "-2"], ["B", "ADD", 75, 50, "-2"], ["B", "ADD", 74, 50, "-2"], ["B", "ADD", 73, 50, "-2"], ["B", "ADD", 72, 50, "-2"], ["B", "ADD", 71, 50, "-2"], ["B", "ADD", 70, 50, "-2"], ["B", "ADD", 69, 50, "-2"], ["B", "ADD", 68, 50, "-2"], ["B", "ADD", 67, 50, "-2"], ["B", "ADD", 66, 50, "-2"], ["B", "ADD", 65, 50, "-2"], ["B", "ADD", 64, 50, "-2"], ["B", "ADD", 63, 50, "-2"], ["B", "ADD", 62, 50, "-2"], ["B", "ADD", 61, 50, "-2"], ["B", "ADD", 60, 50, "-2"], ["B", "ADD", 58, 50, "2"], ["B", "ADD", 56, 50, "2"], ["B", "ADD", 54, 50, "2"], ["B", "ADD", 52, 50, "2"], ["B", "ADD", 46, 49, "1"], ["B", "ADD", 50, 49, "-1"], ["B", "ADD", 46, 48, "1/2"], ["B", "ADD", 44, 48, "-1"], ["B", "ADD", 43, 48, "-1"], ["B", "ADD", 42, 48, "-1"], ["B", "ADD", 40, 48, "-1"], ["B", "SCALE", 48, "-1"], ["B", "ADD", 77, 48, "-1"], ["B", "ADD", 76, 48, "-1"], ["B", "ADD", 75, 48, "-1"], ["B", "ADD", 74, 48, "-1"], ["B", "ADD", 73, 48, "-1"], ["B", "ADD", 72, 48, "-1"], ["B", "ADD", 71, 48, "-1"], ["B", "ADD", 70, 48, "-1"], ["B", "ADD", 69, 48, "-1"], ["B", "ADD", 68, 48, "-1"], ["B", "ADD", 67, 48, "-1"], ["B", "ADD", 66, 48, "-1"], ["B", "ADD", 65, 48, "-1"], ["B", "ADD", 64, 48, "-1"], ["B", "ADD", 63, 48, "-1"], ["B", "ADD", 62, 48, "-1"], ["B", "ADD", 61, 48, "-1"], ["B", "ADD", 60, 48, "-1"], ["B", "ADD", 58, 48, "1"], ["B", "ADD", 56, 48, "1"], ["B", "ADD", 54, 48, "1"], ["B", "ADD", 52, 48, "1"], ["B", "ADD", 50, 48, "3/2"], ["B", "SWAP", 48, 50], ["B", "ADD", 46, 47, "-1"], ["B", "ADD", 48, 47, "1"], ["B", "ADD", 44, 46, "2"], ["B", "ADD", 43, 46, "2"], ["B", "ADD", 42, 46, "2"], ["B", "ADD", 40, 46, "2"], ["B", "SCALE", 46, "2"], ["B", "ADD", 77, 46, "-1"], ["B", "ADD", 76, 46, "-1"], ["B", "ADD", 75, 46, "-1"], ["B", "ADD", 74, 46, "-1"], ["B", "ADD", 73, 46, "-1"], ["B", "ADD", 72, 46, "-1"], ["B", "ADD", 71, 46, "-1"], ["B", "ADD", 70, 46, "-1"], ["B", "ADD", 69, 46, "-1"], ["B", "ADD", 68, 46, "-1"], ["B", "ADD", 67, 46, "-1"], ["B", "ADD", 66, 46, "-1"], ["B", "ADD", 65, 46, "-1"], ["B", "ADD", 64, 46, "-1"], ["B", "ADD", 63, 46, "-1"], ["B", "ADD", 62, 46, "-1"], ["B", "ADD", 61, 46, "-1"], ["B", "ADD", 60, 46, "-1"], ["B", "ADD", 58, 46, "1"], ["B", "ADD", 56, 46, "1"], ["B", "ADD", 54, 46, "1"], ["B", "ADD", 52, 46, "1"], ["B", "ADD", 50, 46, "1"], ["B", "ADD", 48, 46, "3/2"], ["B", "SWAP", 46, 48], ["B", "ADD", 44, 45, "-2"], ["B", "ADD", 43, 45, "-2"], ["B", "ADD", 42, 45, "-2"], ["B", "ADD", 40, 45, "-2"], ["B", "ADD", 77, 45, "2"], ["B", "ADD", 76, 45, "2"], ["B", "ADD", 75, 45, "2"], ["B", "ADD", 74, 45, "2"], ["B", "ADD", 73, 45, "2"], ["B", "ADD", 72, 45, "2"], ["B", "ADD", 71, 45, "2"], ["B", "ADD", 70, 45, "2"], ["B", "ADD", 69, 45, "2"], ["B", "ADD", 68, 45, "2"], ["B", "ADD", 67, 45, "2"], ["B", "ADD", 66, 45, "2"], ["B", "ADD", 65, 45, "2"], ["B", "ADD", 64, 45, "2"], ["B", "ADD", 63, 45, "2"], ["B", "ADD", 62, 45, "2"], ["B", "ADD", 61, 45, "2"], ["B", "ADD", 60, 45, "2"], ["B", "ADD", 58, 45, "-2"], ["B", "ADD", 56, 45, "-2"], ["B", "ADD", 54, 45, "-2"], ["B", "ADD", 52, 45, "-2"], ["B", "ADD", 50, 45, "-2"], ["B", "ADD", 48, 45, "-2"], ["B", "ADD", 46, 45, "-2"], ["B", "ADD", 42, 43, "-2"], ["B", "ADD", 40, 43, "-2"], ["B", "SCALE", 43, "-1"], ["B", "ADD", 77, 43, "-2"], ["B", "ADD", 76, 43, "-2"], ["B", "ADD", 75, 43, "-2"], ["B", "ADD", 74, 43, "-2"], ["B", "ADD", 73, 43, "-2"], ["B", "ADD", 72, 43, "-2"], ["B", "ADD", 71, 43, "-2"], ["B", "ADD", 70, 43, "-2"], ["B", "ADD", 69, 43, "-2"], ["B", "ADD", 68, 43, "-2"], ["B", "ADD", 67, 43, "-2"], ["B", "ADD", 66, 43, "-2"], ["B", "ADD", 65, 43, "-2"], ["B", "ADD", 64, 43, "-2"], ["B", "ADD", 63, 43, "-2"], ["B", "ADD", 62, 43, "-2"], ["B", "ADD", 61, 43, "-2"], ["B", "ADD", 60, 43, "-2"], ["B", "ADD", 58, 43, "2"], ["B", "ADD", 56, 43, "2"], ["B", "ADD", 54, 43, "2"], ["B", "ADD", 52, 43, "2"], ["B", "ADD", 50, 43, "2"], ["B", "ADD", 48, 43, "2"], ["B", "ADD", 46, 43, "2"], ["B", "ADD", 44, 43, "2"], ["B", "ADD", 40, 42, "-2"], ["B", "SCALE", 42, "-1"], ["B", "ADD", 77, 42, "-2"], ["B", "ADD", 76, 42, "-2"], ["B", "ADD", 75, 42, "-2"], ["B", "ADD", 74, 42, "-2"], ["B", "ADD", 73, 42, "-2"], ["B", "ADD", 72, 42, "-2"], ["B", "ADD", 71, 42, "-2"], ["B", "ADD", 70, 42, "-2"], ["B", "ADD", 69, 42, "-2"], ["B", "ADD", 68, 42, "-2"], ["B", "ADD", 67, 42, "-2"], ["B", "ADD", 66, 42, "-2"], ["B", "ADD", 65, 42, "-2"], ["B", "ADD", 64, 42, "-2"], ["B", "ADD", 63, 42, "-2"], ["B", "ADD", 62, 42, "-2"], ["B", "ADD", 61, 42, "-2"], ["B", "ADD", 60, 42, "-2"], ["B", "ADD", 58, 42, "2"], ["B", "ADD", 56, 42, "2"], ["B", "ADD", 54, 42, "2"], ["B", "ADD", 52, 42, "2"], ["B", "ADD", 50, 42, "2"], ["B", "ADD", 48, 42, "2"], ["B", "ADD", 46, 42, "2"], ["B", "ADD", 44, 42, "2"], ["B", "ADD", 43, 42, "2"], ["B", "SCALE", 41, "-1"], ["B", "ADD", 77, 41, "-2"], ["B", "ADD", 76, 41, "-2"], ["B", "ADD", 75, 41, "-2"], ["B", "ADD", 74, 41, "-2"], ["B", "ADD", 73, 41, "-2"], ["B", "ADD", 72, 41, "-2"], ["B", "ADD", 71, 41, "-2"], ["B", "ADD", 70, 41, "-2"], ["B", "ADD", 69, 41, "-2"], ["B", "ADD", 68, 41, "-2"], ["B", "ADD", 67, 41, "-2"], ["B", "ADD", 66, 41, "-2"], ["B", "ADD", 65, 41, "-2"], ["B", "ADD", 64, 41, "-2"], ["B", "ADD", 63, 41, "-2"], ["B", "ADD", 62, 41, "-2"], ["B", "ADD", 61, 41, "-2"], ["B", "ADD", 60, 41, "-2"], ["B", "SCALE", 40, "1/2"], ["B", "ADD", 77, 40, "2"], ["B", "ADD", 76, 40, "2"], ["B", "ADD", 75, 40, "2"], ["B", "ADD", 74, 40, "2"], ["B", "ADD", 73, 40, "2"], ["B", "ADD", 72, 40, "2"], ["B", "ADD", 71, 40, "2"], ["B", "ADD", 70, 40, "2"], ["B", "ADD", 69, 40, "2"], ["B", "ADD", 68, 40, "2"], ["B", "ADD", 67, 40, "2"], ["B", "ADD", 66, 40, "2"], ["B", "ADD", 65, 40, "2"], ["B", "ADD", 64, 40, "2"], ["B", "ADD", 63, 40, "2"], ["B", "ADD", 62, 40, "2"], ["B", "ADD", 61, 40, "2"], ["B", "ADD", 60, 40, "2"], ["B", "ADD", 58, 40, "-2"], ["B", "ADD", 56, 40, "-2"], ["B", "ADD", 54, 40, "-2"], ["B", "ADD", 52, 40, "-2"], ["B", "ADD", 50, 40, "-2"], ["B", "ADD", 48, 40, "-2"], ["B", "ADD", 46, 40, "-2"], ["B", "ADD", 44, 40, "-2"], ["B", "ADD", 43, 40, "-2"], ["B", "ADD", 42, 40, "-2"], ["B", "SWAP", 40, 41], ["B", "LAMBDA", 40, -1], ["B", "QUERY", 40, 41, -1], ["B", "LAMBDA", 40, 1], ["B", "ADD", 40, 41, "-1"], ["B", "ADD", 76, 77, "-5/4"], ["B", "ADD", 75, 77, "-1"], ["B", "ADD", 74, 77, "-1"], ["B", "ADD", 73, 77, "-1"], ["B", "ADD", 72, 77, "-1"], ["B", "ADD", 71, 77, "-1"], ["B", "ADD", 70, 77, "-1"], ["B", "ADD", 69, 77, "-1"], ["B", "ADD", 68, 77, "-1"], ["B", "ADD", 67, 77, "-1"], ["B", "ADD", 66, 77, "-1"], ["B", "ADD", 65, 77, "-1"], ["B", "ADD", 64, 77, "-1"], ["B", "ADD", 63, 77, "-1"], ["B", "ADD", 62, 77, "-1"], ["B", "ADD", 61, 77, "-1"], ["B", "ADD", 60, 77, "-1"], ["B", "ADD", 41, 77, "-1/4"], ["B", "ADD", 40, 77, "1/2"], ["B", "SCALE", 77, "1/4"], ["B", "ADD", 75, 76, "-4"], ["B", "ADD", 74, 76, "-4"], ["B", "ADD", 73, 76, "-4"], ["B", "ADD", 72, 76, "-4"], ["B", "ADD", 71, 76, "-4"], ["B", "ADD", 70, 76, "-4"], ["B", "ADD", 69, 76, "-4"], ["B", "ADD", 68, 76, "-4"], ["B", "ADD", 67, 76, "-4"], ["B", "ADD", 66, 76, "-4"], ["B", "ADD", 65, 76, "-4"], ["B", "ADD", 64, 76, "-4"], ["B", "ADD", 63, 76, "-4"], ["B", "ADD", 62, 76, "-4"], ["B", "ADD", 61, 76, "-4"], ["B", "ADD", 60, 76, "-4"], ["B", "ADD", 41, 76, "-1"], ["B", "ADD", 40, 76, "2"], ["B", "SCALE", 76, "-4"], ["B", "ADD", 77, 76, "3/4"], ["B", "SWAP", 76, 77], ["B", "ADD", 74, 75, "-2"], ["B", "ADD", 73, 75, "-2"], ["B", "ADD", 72, 75, "-2"], ["B", "ADD", 71, 75, "-2"], ["B", "ADD", 70, 75, "-2"], ["B", "ADD", 69, 75, "-2"], ["B", "ADD", 68, 75, "-2"], ["B", "ADD", 67, 75, "-2"], ["B", "ADD", 66, 75, "-2"], ["B", "ADD", 65, 75, "-2"], ["B", "ADD", 64, 75, "-2"], ["B", "ADD", 63, 75, "-2"], ["B", "ADD", 62, 75, "-2"], ["B", "ADD", 61, 75, "-2"], ["B", "ADD", 60, 75, "-2"], ["B", "ADD", 40, 75, "1"], ["B", "SCALE", 75, "-1"], ["B", "ADD", 77, 75, "2"], ["B", "ADD", 76, 75, "2"], ["B", "ADD", 41, 74, "1"], ["B", "ADD", 72, 73, "-2"], ["B", "ADD", 71, 73, "-2"], ["B", "ADD", 70, 73, "-2"], ["B", "ADD", 69, 73, "-2"], ["B", "ADD", 68, 73, "-2"], ["B", "ADD", 67, 73, "-2"], ["B", "ADD", 66, 73, "-2"], ["B", "ADD", 65, 73, "-2"], ["B", "ADD", 64, 73, "-2"], ["B", "ADD", 63, 73, "-2"], ["B", "ADD", 62, 73, "-2"], ["B", "ADD", 61, 73, "-2"], ["B", "ADD", 60, 73, "-2"], ["B", "ADD", 41, 73, "-1"], ["B", "ADD", 40, 73, "1"], ["B", "SCALE", 73, "-1"], ["B", "ADD", 77, 73, "2"], ["B", "ADD", 76, 73, "2"], ["B", "ADD", 75, 73, "2"], ["B", "ADD", 74, 73, "2"], ["B", "ADD", 71, 72, "-3/2"], ["B", "ADD", 70, 72, "-1"], ["B", "ADD", 69, 72, "-1"], ["B", "ADD", 68, 72, "-1"], ["B", "ADD", 67, 72, "-1"], ["B", "ADD", 66, 72, "-1"], ["B", "ADD", 65, 72, "-1"], ["B", "ADD", 64, 72, "-1"], ["B", "ADD", 63, 72, "-1"], ["B", "ADD", 62, 72, "-1"], ["B", "ADD", 61, 72, "-1"], ["B", "ADD", 60, 72, "-1"], ["B", "ADD", 40, 72, "1/2"], ["B", "SCALE", 72, "1/2"], ["B", "ADD", 77, 72, "-2"], ["B", "ADD", 76, 72, "-2"], ["B", "ADD", 75, 72, "-2"], ["B", "ADD", 74, 72, "-2"], ["B", "ADD", 73, 72, "-2"], ["B", "ADD", 70, 71, "2"], ["B", "ADD", 69, 71, "2"], ["B", "ADD", 68, 71, "2"], ["B", "ADD", 67, 71, "2"], ["B", "ADD", 66, 71, "2"], ["B", "ADD", 65, 71, "2"], ["B", "ADD", 64, 71, "2"], ["B", "ADD", 63, 71, "2"], ["B", "ADD", 62, 71, "2"], ["B", "ADD", 61, 71, "2"], ["B", "ADD", 60, 71, "2"], ["B", "ADD", 41, 71, "2"], ["B", "ADD", 40, 71, "-1"], ["B", "SCALE", 71, "2"], ["B", "ADD", 77, 71, "1"], ["B", "ADD", 76, 71, "1"], ["B", "ADD", 75, 71, "1"], ["B", "ADD", 74, 71, "1"], ["B", "ADD", 73, 71, "1"], ["B", "ADD", 72, 71, "3/2"], ["B", "SWAP", 71, 72], ["B", "ADD", 41, 70, "-1"], ["B", "ADD", 68, 69, "-3/4"], ["B", "ADD", 67, 69, "-1"], ["B", "ADD", 66, 69, "-1"], ["B", "ADD", 65, 69, "-1"], ["B", "ADD", 64, 69, "-1"], ["B", "ADD", 63, 69, "-1"], ["B", "ADD", 62, 69, "-1"], ["B", "ADD", 61, 69, "-1"], ["B", "ADD", 60, 69, "-1"], ["B", "ADD", 41, 69, "1/4"], ["B", "ADD", 40, 69, "1/2"], ["B", "SCALE", 69, "-1/4"], ["B", "ADD", 77, 69, "4"], ["B", "ADD", 76, 69, "4"], ["B", "ADD", 75, 69, "4"], ["B", "ADD", 74, 69, "4"], ["B", "ADD", 73, 69, "4"], ["B", "ADD", 72, 69, "4"], ["B", "ADD", 71, 69, "4"], ["B", "ADD", 70, 69, "4"], ["B", "ADD", 67, 68, "-4"], ["B", "ADD", 66, 68, "-4"], ["B", "ADD", 65, 68, "-4"], ["B", "ADD", 64, 68, "-4"], ["B", "ADD", 63, 68, "-4"], ["B", "ADD", 62, 68, "-4"], ["B", "ADD", 61, 68, "-4"], ["B", "ADD", 60, 68, "-4"], ["B", "ADD", 41, 68, "-1"], ["B", "ADD", 40, 68, "2"], ["B", "SCALE", 68, "-4"], ["B", "ADD", 77, 68, "1"], ["B", "ADD", 76, 68, "1"], ["B", "ADD", 75, 68, "1"], ["B", "ADD", 74, 68, "1"], ["B", "ADD", 73, 68, "1"], ["B", "ADD", 72, 68, "1"], ["B", "ADD", 71, 68, "1"], ["B", "ADD", 70, 68, "1"], ["B", "ADD", 69, 68, "3/4"], ["B", "SWAP", 68, 69], ["B", "ADD", 66, 67, "-2"], ["B", "ADD", 65, 67, "-2"], ["B", "ADD", 64, 67, "-2"], ["B", "ADD", 63, 67, "-2"], ["B", "ADD", 62, 67, "-2"], ["B", "ADD", 61, 67, "-2"], ["B", "ADD", 60, 67, "-2"], ["B", "ADD", 40, 67, "1"], ["B", "SCALE", 67, "-1"], ["B", "ADD", 77, 67, "2"], ["B", "ADD", 76, 67, "2"], ["B", "ADD", 75, 67, "2"], ["B", "ADD", 74, 67, "2"], ["B", "ADD", 73, 67, "2"], ["B", "ADD", 72, 67, "2"], ["B", "ADD", 71, 67, "2"], ["B", "ADD", 70, 67, "2"], ["B", "ADD", 69, 67, "2"], ["B", "ADD", 68, 67, "2"], ["B", "ADD", 41, 66, "1"], ["B", "ADD", 64, 65, "-2"], ["B", "ADD", 63, 65, "-2"], ["B", "ADD", 62, 65, "-2"], ["B", "ADD", 61, 65, "-2"], ["B", "ADD", 60, 65, "-2"], ["B", "ADD", 41, 65, "-1"], ["B", "ADD", 40, 65, "1"], ["B", "SCALE", 65, "-1"], ["B", "ADD", 77, 65, "2"], ["B", "ADD", 76, 65, "2"], ["B", "ADD", 75, 65, "2"], ["B", "ADD", 74, 65, "2"], ["B", "ADD", 73, 65, "2"], ["B", "ADD", 72, 65, "2"], ["B", "ADD", 71, 65, "2"], ["B", "ADD", 70, 65, "2"], ["B", "ADD", 69, 65, "2"], ["B", "ADD", 68, 65, "2"], ["B", "ADD", 67, 65, "2"], ["B", "ADD", 66, 65, "2"], ["B", "ADD", 63, 64, "-3/2"], ["B", "ADD", 62, 64, "-1"], ["B", "ADD", 61, 64, "-1"], ["B", "ADD", 60, 64, "-1"], ["B", "ADD", 40, 64, "1/2"], ["B", "SCALE", 64, "1/2"], ["B", "ADD", 77, 64, "-2"], ["B", "ADD", 76, 64, "-2"], ["B", "ADD", 75, 64, "-2"], ["B", "ADD", 74, 64, "-2"], ["B", "ADD", 73, 64, "-2"], ["B", "ADD", 72, 64, "-2"], ["B", "ADD", 71, 64, "-2"], ["B", "ADD", 70, 64, "-2"], ["B", "ADD", 69, 64, "-2"], ["B", "ADD", 68, 64, "-2"], ["B", "ADD", 67, 64, "-2"], ["B", "ADD", 66, 64, "-2"], ["B", "ADD", 65, 64, "-2"], ["B", "ADD", 62, 63, "2"], ["B", "ADD", 61, 63, "2"], ["B", "ADD", 60, 63, "2"], ["B", "ADD", 41, 63, "2"], ["B", "ADD", 40, 63, "-1"], ["B", "SCALE", 63, "2"], ["B", "ADD", 77, 63, "1"], ["B", "ADD", 76, 63, "1"], ["B", "ADD", 75, 63, "1"], ["B", "ADD", 74, 63, "1"], ["B", "ADD", 73, 63, "1"], ["B", "ADD", 72, 63, "1"], ["B", "ADD", 71, 63, "1"], ["B", "ADD", 70, 63, "1"], ["B", "ADD", 69, 63, "1"], ["B", "ADD", 68, 63, "1"], ["B", "ADD", 67, 63, "1"], ["B", "ADD", 66, 63, "1"], ["B", "ADD", 65, 63, "1"], ["B", "ADD", 64, 63, "3/2"], ["B", "SWAP", 63, 64], ["B", "ADD", 41, 62, "-1"], ["B", "ADD", 60, 61, "-3/4"], ["B", "ADD", 41, 61, "1/4"], ["B", "ADD", 40, 61, "1/2"], ["B", "SCALE", 61, "-1/4"], ["B", "ADD", 77, 61, "4"], ["B", "ADD", 76, 61, "4"], ["B", "ADD", 75, 61, "4"], ["B", "ADD", 74, 61, "4"], ["B", "ADD", 73, 61, "4"], ["B", "ADD", 72, 61, "4"], ["B", "ADD", 71, 61, "4"], ["B", "ADD", 70, 61, "4"], ["B", "ADD", 69, 61, "4"], ["B", "ADD", 68, 61, "4"], ["B", "ADD", 67, 61, "4"], ["B", "ADD", 66, 61, "4"], ["B", "ADD", 65, 61, "4"], ["B", "ADD", 64, 61, "4"], ["B", "ADD", 63, 61, "4"], ["B", "ADD", 62, 61, "4"], ["B", "ADD", 41, 60, "-1"], ["B", "ADD", 40, 60, "2"], ["B", "SCALE", 60, "-4"], ["B", "ADD", 77, 60, "1"], ["B", "ADD", 76, 60, "1"], ["B", "ADD", 75, 60, "1"], ["B", "ADD", 74, 60, "1"], ["B", "ADD", 73, 60, "1"], ["B", "ADD", 72, 60, "1"], ["B", "ADD", 71, 60, "1"], ["B", "ADD", 70, 60, "1"], ["B", "ADD", 69, 60, "1"], ["B", "ADD", 68, 60, "1"], ["B", "ADD", 67, 60, "1"], ["B", "ADD", 66, 60, "1"], ["B", "ADD", 65, 60, "1"], ["B", "ADD", 64, 60, "1"], ["B", "ADD", 63, 60, "1"], ["B", "ADD", 62, 60, "1"], ["B", "ADD", 61, 60, "3/4"], ["B", "SWAP", 60, 61], ["B", "ADD", 41, 59, "-1"], ["B", "ADD", 40, 59, "2"], ["B", "ADD", 77, 59, "-4"], ["B", "ADD", 76, 59, "-4"], ["B", "ADD", 75, 59, "-4"], ["B", "ADD", 74, 59, "-4"], ["B", "ADD", 73, 59, "-4"], ["B", "ADD", 72, 59, "-4"], ["B", "ADD", 71, 59, "-4"], ["B", "ADD", 70, 59, "-4"], ["B", "ADD", 69, 59, "-4"], ["B", "ADD", 68, 59, "-4"], ["B", "ADD", 67, 59, "-4"], ["B", "ADD", 66, 59, "-4"], ["B", "ADD", 65, 59, "-4"], ["B", "ADD", 64, 59, "-4"], ["B", "ADD", 63, 59, "-4"], ["B", "ADD", 62, 59, "-4"], ["B", "ADD", 61, 59, "-4"], ["B", "ADD", 60, 59, "-4"], ["B", "ADD", 41, 58, "1"], ["B", "ADD", 40, 58, "-1"], ["B", "ADD", 77, 58, "2"], ["B", "ADD", 76, 58, "2"], ["B", "ADD", 75, 58, "2"], ["B", "ADD", 74, 58, "2"], ["B", "ADD", 73, 58, "2"], ["B", "ADD", 72, 58, "2"], ["B", "ADD", 71, 58, "2"], ["B", "ADD", 70, 58, "2"], ["B", "ADD", 69, 58, "2"], ["B", "ADD", 68, 58, "2"], ["B", "ADD", 67, 58, "2"], ["B", "ADD", 66, 58, "2"], ["B", "ADD", 65, 58, "2"], ["B", "ADD", 64, 58, "2"], ["B", "ADD", 63, 58, "2"], ["B", "ADD", 62, 58, "2"], ["B", "ADD", 61, 58, "2"], ["B", "ADD", 60, 58, "2"], ["B", "ADD", 41, 57, "-1"], ["B", "ADD", 40, 56, "1"], ["B", "ADD", 77, 56, "-2"], ["B", "ADD", 76, 56, "-2"], ["B", "ADD", 75, 56, "-2"], ["B", "ADD", 74, 56, "-2"], ["B", "ADD", 73, 56, "-2"], ["B", "ADD", 72, 56, "-2"], ["B", "ADD", 71, 56, "-2"], ["B", "ADD", 70, 56, "-2"], ["B", "ADD", 69, 56, "-2"], ["B", "ADD", 68, 56, "-2"], ["B", "ADD", 67, 56, "-2"], ["B", "ADD", 66, 56, "-2"], ["B", "ADD", 65, 56, "-2"], ["B", "ADD", 64, 56, "-2"], ["B", "ADD", 63, 56, "-2"], ["B", "ADD", 62, 56, "-2"], ["B", "ADD", 61, 56, "-2"], ["B", "ADD", 60, 56, "-2"], ["B", "ADD", 41, 55, "1"], ["B", "ADD", 40, 55, "-2"], ["B", "ADD", 77, 55, "4"], ["B", "ADD", 76, 55, "4"], ["B", "ADD", 75, 55, "4"], ["B", "ADD", 74, 55, "4"], ["B", "ADD", 73, 55, "4"], ["B", "ADD", 72, 55, "4"], ["B", "ADD", 71, 55, "4"], ["B", "ADD", 70, 55, "4"], ["B", "ADD", 69, 55, "4"], ["B", "ADD", 68, 55, "4"], ["B", "ADD", 67, 55, "4"], ["B", "ADD", 66, 55, "4"], ["B", "ADD", 65, 55, "4"], ["B", "ADD", 64, 55, "4"], ["B", "ADD", 63, 55, "4"], ["B", "ADD", 62, 55, "4"], ["B", "ADD", 61, 55, "4"], ["B", "ADD", 60, 55, "4"], ["B", "ADD", 41, 54, "-1"], ["B", "ADD", 40, 54, "1"], ["B", "ADD", 77, 54, "-2"], ["B", "ADD", 76, 54, "-2"], ["B", "ADD", 75, 54, "-2"], ["B", "ADD", 74, 54, "-2"], ["B", "ADD", 73, 54, "-2"], ["B", "ADD", 72, 54, "-2"], ["B", "ADD", 71, 54, "-2"], ["B", "ADD", 70, 54, "-2"], ["B", "ADD", 69, 54, "-2"], ["B", "ADD", 68, 54, "-2"], ["B", "ADD", 67, 54, "-2"], ["B", "ADD", 66, 54, "-2"], ["B", "ADD", 65, 54, "-2"], ["B", "ADD", 64, 54, "-2"], ["B", "ADD", 63, 54, "-2"], ["B", "ADD", 62, 54, "-2"], ["B", "ADD", 61, 54, "-2"], ["B", "ADD", 60, 54, "-2"], ["B", "ADD", 41, 53, "1"], ["B", "ADD", 40, 52, "-1"], ["B", "ADD", 77, 52, "2"], ["B", "ADD", 76, 52, "2"], ["B", "ADD", 75, 52, "2"], ["B", "ADD", 74, 52, "2"], ["B", "ADD", 73, 52, "2"], ["B", "ADD", 72, 52, "2"], ["B", "ADD", 71, 52, "2"], ["B", "ADD", 70, 52, "2"], ["B", "ADD", 69, 52, "2"], ["B", "ADD", 68, 52, "2"], ["B", "ADD", 67, 52, "2"], ["B", "ADD", 66, 52, "2"], ["B", "ADD", 65, 52, "2"], ["B", "ADD", 64, 52, "2"], ["B", "ADD", 63, 52, "2"], ["B", "ADD", 62, 52, "2"], ["B", "ADD", 61, 52, "2"], ["B", "ADD", 60, 52, "2"], ["B", "ADD", 41, 51, "-1"], ["B", "ADD", 40, 51, "2"], ["B", "ADD", 77, 51, "-4"], ["B", "ADD", 76, 51, "-4"], ["B", "ADD", 75, 51, "-4"], ["B", "ADD", 74, 51, "-4"], ["B", "ADD", 73, 51, "-4"], ["B", "ADD", 72, 51, "-4"], ["B", "ADD", 71, 51, "-4"], ["B", "ADD", 70, 51, "-4"], ["B", "ADD", 69, 51, "-4"], ["B", "ADD", 68, 51, "-4"], ["B", "ADD", 67, 51, "-4"], ["B", "ADD", 66, 51, "-4"], ["B", "ADD", 65, 51, "-4"], ["B", "ADD", 64, 51, "-4"], ["B", "ADD", 63, 51, "-4"], ["B", "ADD", 62, 51, "-4"], ["B", "ADD", 61, 51, "-4"], ["B", "ADD", 60, 51, "-4"], ["B", "ADD", 41, 50, "1"], ["B", "ADD", 40, 50, "-1"], ["B", "ADD", 77, 50, "2"], ["B", "ADD", 76, 50, "2"], ["B", "ADD", 75, 50, "2"], ["B", "ADD", 74, 50, "2"], ["B", "ADD", 73, 50, "2"], ["B", "ADD", 72, 50, "2"], ["B", "ADD", 71, 50, "2"], ["B", "ADD", 70, 50, "2"], ["B", "ADD", 69, 50, "2"], ["B", "ADD", 68, 50, "2"], ["B", "ADD", 67, 50, "2"], ["B", "ADD", 66, 50, "2"], ["B", "ADD", 65, 50, "2"], ["B", "ADD", 64, 50, "2"], ["B", "ADD", 63, 50, "2"], ["B", "ADD", 62, 50, "2"], ["B", "ADD", 61, 50, "2"], ["B", "ADD", 60, 50, "2"], ["B", "ADD", 41, 49, "-1"], ["B", "ADD", 40, 48, "1"], ["B", "ADD", 77, 48, "-2"], ["B", "ADD", 76, 48, "-2"], ["B", "ADD", 75, 48, "-2"], ["B", "ADD", 74, 48, "-2"], ["B", "ADD", 73, 48, "-2"], ["B", "ADD", 72, 48, "-2"], ["B", "ADD", 71, 48, "-2"], ["B", "ADD", 70, 48, "-2"], ["B", "ADD", 69, 48, "-2"], ["B", "ADD", 68, 48, "-2"], ["B", "ADD", 67, 48, "-2"], ["B", "ADD", 66, 48, "-2"], ["B", "ADD", 65, 48, "-2"], ["B", "ADD", 64, 48, "-2"], ["B", "ADD", 63, 48, "-2"], ["B", "ADD", 62, 48, "-2"], ["B", "ADD", 61, 48, "-2"], ["B", "ADD", 60, 48, "-2"], ["B", "ADD", 41, 47, "1"], ["B", "ADD", 40, 47, "-2"], ["B", "ADD", 77, 47, "4"], ["B", "ADD", 76, 47, "4"], ["B", "ADD", 75, 47, "4"], ["B", "ADD", 74, 47, "4"], ["B", "ADD", 73, 47, "4"], ["B", "ADD", 72, 47, "4"], ["B", "ADD", 71, 47, "4"], ["B", "ADD", 70, 47, "4"], ["B", "ADD", 69, 47, "4"], ["B", "ADD", 68, 47, "4"], ["B", "ADD", 67, 47, "4"], ["B", "ADD", 66, 47, "4"], ["B", "ADD", 65, 47, "4"], ["B", "ADD", 64, 47, "4"], ["B", "ADD", 63, 47, "4"], ["B", "ADD", 62, 47, "4"], ["B", "ADD", 61, 47, "4"], ["B", "ADD", 60, 47, "4"], ["B", "ADD", 41, 46, "-1"], ["B", "ADD", 40, 46, "1"], ["B", "ADD", 77, 46, "-2"], ["B", "ADD", 76, 46, "-2"], ["B", "ADD", 75, 46, "-2"], ["B", "ADD", 74, 46, "-2"], ["B", "ADD", 73, 46, "-2"], ["B", "ADD", 72, 46, "-2"], ["B", "ADD", 71, 46, "-2"], ["B", "ADD", 70, 46, "-2"], ["B", "ADD", 69, 46, "-2"], ["B", "ADD", 68, 46, "-2"], ["B", "ADD", 67, 46, "-2"], ["B", "ADD", 66, 46, "-2"], ["B", "ADD", 65, 46, "-2"], ["B", "ADD", 64, 46, "-2"], ["B", "ADD", 63, 46, "-2"], ["B", "ADD", 62, 46, "-2"], ["B", "ADD", 61, 46, "-2"], ["B", "ADD", 60, 46, "-2"], ["B", "ADD", 41, 45, "1"], ["B", "ADD", 40, 44, "-1"], ["B", "ADD", 77, 44, "2"], ["B", "ADD", 76, 44, "2"], ["B", "ADD", 75, 44, "2"], ["B", "ADD", 74, 44, "2"], ["B", "ADD", 73, 44, "2"], ["B", "ADD", 72, 44, "2"], ["B", "ADD", 71, 44, "2"], ["B", "ADD", 70, 44, "2"], ["B", "ADD", 69, 44, "2"], ["B", "ADD", 68, 44, "2"], ["B", "ADD", 67, 44, "2"], ["B", "ADD", 66, 44, "2"], ["B", "ADD", 65, 44, "2"], ["B", "ADD", 64, 44, "2"], ["B", "ADD", 63, 44, "2"], ["B", "ADD", 62, 44, "2"], ["B", "ADD", 61, 44, "2"], ["B", "ADD", 60, 44, "2"], ["B", "ADD", 41, 43, "-1"], ["B", "ADD", 40, 43, "2"], ["B", "ADD", 77, 43, "-4"], ["B", "ADD", 76, 43, "-4"], ["B", "ADD", 75, 43, "-4"], ["B", "ADD", 74, 43, "-4"], ["B", "ADD", 73, 43, "-4"], ["B", "ADD", 72, 43, "-4"], ["B", "ADD", 71, 43, "-4"], ["B", "ADD", 70, 43, "-4"], ["B", "ADD", 69, 43, "-4"], ["B", "ADD", 68, 43, "-4"], ["B", "ADD", 67, 43, "-4"], ["B", "ADD", 66, 43, "-4"], ["B", "ADD", 65, 43, "-4"], ["B", "ADD", 64, 43, "-4"], ["B", "ADD", 63, 43, "-4"], ["B", "ADD", 62, 43, "-4"], ["B", "ADD", 61, 43, "-4"], ["B", "ADD", 60, 43, "-4"], ["B", "ADD", 41, 42, "1"], ["B", "ADD", 40, 42, "-2"], ["B", "ADD", 77, 42, "4"], ["B", "ADD", 76, 42, "4"], ["B", "ADD", 75, 42, "4"], ["B", "ADD", 74, 42, "4"], ["B", "ADD", 73, 42, "4"], ["B", "ADD", 72, 42, "4"], ["B", "ADD", 71, 42, "4"], ["B", "ADD", 70, 42, "4"], ["B", "ADD", 69, 42, "4"], ["B", "ADD", 68, 42, "4"], ["B", "ADD", 67, 42, "4"], ["B", "ADD", 66, 42, "4"], ["B", "ADD", 65, 42, "4"], ["B", "ADD", 64, 42, "4"], ["B", "ADD", 63, 42, "4"], ["B", "ADD", 62, 42, "4"], ["B", "ADD", 61, 42, "4"], ["B", "ADD", 60, 42, "4"], ["B", "ADD", 40, 41, "2"], ["B", "SCALE", 41, "-2"], ["B", "ADD", 74, 41, "1"], ["B", "ADD", 72, 41, "1"], ["B", "ADD", 70, 41, "1"], ["B", "ADD", 68, 41, "1"], ["B", "ADD", 66, 41, "1"], ["B", "ADD", 64, 41, "1"], ["B", "ADD", 62, 41, "1"], ["B", "ADD", 60, 41, "1"], ["B", "ADD", 77, 40, "2"], ["B", "ADD", 76, 40, "2"], ["B", "ADD", 75, 40, "2"], ["B", "ADD", 74, 40, "2"], ["B", "ADD", 73, 40, "2"], ["B", "ADD", 72, 40, "2"], ["B", "ADD", 71, 40, "2"], ["B", "ADD", 70, 40, "2"], ["B", "ADD", 69, 40, "2"], ["B", "ADD", 68, 40, "2"], ["B", "ADD", 67, 40, "2"], ["B", "ADD", 66, 40, "2"], ["B", "ADD", 65, 40, "2"], ["B", "ADD", 64, 40, "2"], ["B", "ADD", 63, 40, "2"], ["B", "ADD", 62, 40, "2"], ["B", "ADD", 61, 40, "2"], ["B", "ADD", 60, 40, "2"], ["B", "SWAP", 40, 41], ["B", "LAMBDA", 40, -1], ["B", "QUERY", 40, 41, -1], ["B", "LAMBDA", 40, 1], ["B", "ADD", 40, 41, "-1"], ["B", "SCALE", 40, "1/2"], ["B", "ADD", 77, 40, "2"], ["B", "ADD", 76, 40, "2"], ["B", "ADD", 75, 40, "2"], ["B", "ADD", 74, 40, "1"], ["B", "ADD", 73, 40, "2"], ["B", "ADD", 72, 40, "1"], ["B", "ADD", 71, 40, "2"], ["B", "ADD", 70, 40, "1"], ["B", "ADD", 69, 40, "2"], ["B", "ADD", 68, 40, "1"], ["B", "ADD", 67, 40, "2"], ["B", "ADD", 66, 40, "1"], ["B", "ADD", 65, 40, "2"], ["B", "ADD", 64, 40, "1"], ["B", "ADD", 63, 40, "2"], ["B", "ADD", 62, 40, "1"], ["B", "ADD", 61, 40, "2"], ["B", "ADD", 60, 40, "1"], ["B", "ADD", 59, 40, "1"], ["B", "ADD", 57, 40, "1"], ["B", "ADD", 55, 40, "1"], ["B", "ADD", 53, 40, "1"], ["B", "ADD", 51, 40, "1"], ["B", "ADD", 49, 40, "1"], ["B", "ADD", 47, 40, "1"], ["B", "ADD", 45, 40, "1"], ["B", "ADD", 41, 40, "1"], ["B", "LAMBDA", 40, -1], ["B", "QUERY", 40, 41, -1], ["B", "LAMBDA", 40, 1], ["B", "ADD", 40, 41, "-1"], ["B", "ADD", 76, 77, "-1"], ["B", "ADD", 75, 77, "-1"], ["B", "ADD", 74, 77, "-1"], ["B", "ADD", 73, 77, "-1"], ["B", "ADD", 72, 77, "-1"], ["B", "ADD", 71, 77, "-1"], ["B", "ADD", 70, 77, "-1"], ["B", "ADD", 69, 77, "-1"], ["B", "ADD", 68, 77, "-1"], ["B", "ADD", 67, 77, "-1"], ["B", "ADD", 66, 77, "-1"], ["B", "ADD", 65, 77, "-1"], ["B", "ADD", 64, 77, "-1"], ["B", "ADD", 61, 77, "-1/2"], ["B", "ADD", 60, 77, "-1/2"], ["B", "ADD", 41, 77, "1"], ["B", "ADD", 75, 76, "-1"], ["B", "ADD", 74, 76, "-1"], ["B", "ADD", 73, 76, "-1"], ["B", "ADD", 72, 76, "-1"], ["B", "ADD", 71, 76, "-1"], ["B", "ADD", 70, 76, "-1"], ["B", "ADD", 69, 76, "-1"], ["B", "ADD", 68, 76, "-1"], ["B", "ADD", 67, 76, "-1"], ["B", "ADD", 66, 76, "-1"], ["B", "ADD", 65, 76, "-1"], ["B", "ADD", 64, 76, "-1"], ["B", "ADD", 61, 76, "-1/2"], ["B", "ADD", 60, 76, "-1/2"], ["B", "ADD", 41, 76, "-1"], ["B", "SCALE", 76, "-1"], ["B", "ADD", 77, 76, "-1"], ["B", "ADD", 41, 75, "1"], ["B", "SWAP", 75, 77], ["B", "ADD", 72, 74, "-1"], ["B", "ADD", 70, 74, "-1"], ["B", "ADD", 68, 74, "-1"], ["B", "ADD", 66, 74, "-1"], ["B", "ADD", 64, 74, "-1"], ["B", "ADD", 63, 74, "-2"], ["B", "ADD", 62, 74, "-1"], ["B", "ADD", 61, 74, "-1"], ["B", "ADD", 60, 74, "-1"], ["B", "ADD", 59, 74, "1"], ["B", "ADD", 57, 74, "1"], ["B", "ADD", 55, 74, "1"], ["B", "ADD", 53, 74, "1"], ["B", "ADD", 51, 74, "1"], ["B", "ADD", 49, 74, "1"], ["B", "ADD", 47, 74, "1"], ["B", "ADD", 45, 74, "1"], ["B", "ADD", 41, 74, "-1"], ["B", "ADD", 40, 74, "1"], ["B", "SCALE", 74, "2"], ["B", "ADD", 75, 74, "-1"], ["B", "ADD", 41, 73, "-1"], ["B", "ADD", 41, 72, "2"], ["B", "ADD", 41, 71, "-1"], ["B", "ADD", 41, 69, "1"], ["B", "ADD", 41, 68, "-2"], ["B", "ADD", 41, 67, "1"], ["B", "SWAP", 67, 71], ["B", "SWAP", 66, 70], ["B", "ADD", 41, 65, "-1"], ["B", "SWAP", 65, 73], ["B", "ADD", 41, 64, "2"], ["B", "SWAP", 64, 72], ["B", "ADD", 41, 63, "-1"], ["B", "SWAP", 63, 77], ["B", "SWAP", 62, 76], ["B", "ADD", 60, 61, "-1"], ["B", "ADD", 59, 61, "1"], ["B", "ADD", 57, 61, "1"], ["B", "ADD", 55, 61, "1"], ["B", "ADD", 53, 61, "1"], ["B", "ADD", 51, 61, "1"], ["B", "ADD", 49, 61, "1"], ["B", "ADD", 47, 61, "1"], ["B", "ADD", 45, 61, "1"], ["B", "ADD", 41, 61, "-1"], ["B", "ADD", 40, 61, "1"], ["B", "SCALE", 61, "-1"], ["B", "ADD", 77, 61, "2"], ["B", "ADD", 76, 61, "1"], ["B", "ADD", 75, 61, "2"], ["B", "ADD", 74, 61, "-2"], ["B", "ADD", 72, 61, "1"], ["B", "ADD", 70, 61, "1"], ["B", "ADD", 68, 61, "1"], ["B", "ADD", 66, 61, "1"], ["B", "ADD", 64, 61, "1"], ["B", "SWAP", 61, 62], ["B", "ADD", 59, 60, "1"], ["B", "ADD", 57, 60, "1"], ["B", "ADD", 55, 60, "1"], ["B", "ADD", 53, 60, "1"], ["B", "ADD", 51, 60, "1"], ["B", "ADD", 49, 60, "1"], ["B", "ADD", 47, 60, "1"], ["B", "ADD", 45, 60, "1"], ["B", "ADD", 41, 60, "-2"], ["B", "ADD", 40, 60, "1"], ["B", "SCALE", 60, "-128"], ["B", "ADD", 76, 60, "-1/128"], ["B", "ADD", 74, 60, "-1/64"], ["B", "ADD", 72, 60, "1/128"], ["B", "ADD", 70, 60, "1/128"], ["B", "ADD", 68, 60, "1/128"], ["B", "ADD", 66, 60, "1/128"], ["B", "ADD", 64, 60, "1/128"], ["B", "ADD", 62, 60, "1/128"], ["B", "ADD", 57, 59, "-1"], ["B", "ADD", 55, 59, "-1"], ["B", "ADD", 53, 59, "-1"], ["B", "ADD", 51, 59, "-1"], ["B", "ADD", 49, 59, "-1"], ["B", "ADD", 47, 59, "-1"], ["B", "ADD", 45, 59, "-1"], ["B", "ADD", 41, 59, "-1"], ["B", "ADD", 40, 59, "-1"], ["B", "SCALE", 59, "-2"], ["B", "ADD", 77, 59, "-1"], ["B", "ADD", 76, 59, "-1/2"], ["B", "ADD", 75, 59, "-2"], ["B", "ADD", 74, 59, "1"], ["B", "ADD", 73, 59, "1"], ["B", "ADD", 72, 59, "1/2"], ["B", "ADD", 71, 59, "1"], ["B", "ADD", 70, 59, "1/2"], ["B", "ADD", 69, 59, "1"], ["B", "ADD", 68, 59, "1/2"], ["B", "ADD", 67, 59, "1"], ["B", "ADD", 66, 59, "1/2"], ["B", "ADD", 65, 59, "1"], ["B", "ADD", 64, 59, "1/2"], ["B", "ADD", 63, 59, "1"], ["B", "ADD", 62, 59, "1/2"], ["B", "ADD", 61, 59, "1"], ["B", "SWAP", 59, 60], ["B", "ADD", 41, 58, "1"], ["B", "ADD", 55, 57, "-1"], ["B", "ADD", 53, 57, "-1"], ["B", "ADD", 51, 57, "-1"], ["B", "ADD", 49, 57, "-1"], ["B", "ADD", 47, 57, "-1"], ["B", "ADD", 45, 57, "-1"], ["B", "ADD", 41, 57, "1"], ["B", "ADD", 40, 57, "-1"], ["B", "SCALE", 57, "-1"], ["B", "ADD", 77, 57, "-2"], ["B", "ADD", 76, 57, "-1"], ["B", "ADD", 75, 57, "-4"], ["B", "ADD", 74, 57, "2"], ["B", "ADD", 73, 57, "2"], ["B", "ADD", 72, 57, "1"], ["B", "ADD", 71, 57, "2"], ["B", "ADD", 70, 57, "1"], ["B", "ADD", 69, 57, "2"], ["B", "ADD", 68, 57, "1"], ["B", "ADD", 67, 57, "2"], ["B", "ADD", 66, 57, "1"], ["B", "ADD", 65, 57, "2"], ["B", "ADD", 64, 57, "1"], ["B", "ADD", 63, 57, "2"], ["B", "ADD", 62, 57, "1"], ["B", "ADD", 61, 57, "2"], ["B", "ADD", 60, 57, "2"], ["B", "SWAP", 57, 59], ["B", "ADD", 41, 56, "-1"], ["B", "ADD", 53, 55, "-1"], ["B", "ADD", 51, 55, "-1"], ["B", "ADD", 49, 55, "-1"], ["B", "ADD", 47, 55, "-1"], ["B", "ADD", 45, 55, "-1"], ["B", "ADD", 41, 55, "1"], ["B", "ADD", 40, 55, "-1"], ["B", "SCALE", 55, "-1"], ["B", "ADD", 77, 55, "-2"], ["B", "ADD", 76, 55, "-1"], ["B", "ADD", 75, 55, "-4"], ["B", "ADD", 74, 55, "2"], ["B", "ADD", 73, 55, "2"], ["B", "ADD", 72, 55, "1"], ["B", "ADD", 71, 55, "2"], ["B", "ADD", 70, 55, "1"], ["B", "ADD", 69, 55, "2"], ["B", "ADD", 68, 55, "1"], ["B", "ADD", 67, 55, "2"], ["B", "ADD", 66, 55, "1"], ["B", "ADD", 65, 55, "2"], ["B", "ADD", 64, 55, "1"], ["B", "ADD", 63, 55, "2"], ["B", "ADD", 62, 55, "1"], ["B", "ADD", 61, 55, "2"], ["B", "ADD", 60, 55, "2"], ["B", "ADD", 59, 55, "1"], ["B", "SWAP", 55, 57], ["B", "ADD", 41, 54, "-1"], ["B", "ADD", 51, 53, "-1"], ["B", "ADD", 49, 53, "-1"], ["B", "ADD", 47, 53, "-1"], ["B", "ADD", 45, 53, "-1"], ["B", "ADD", 41, 53, "-1"], ["B", "ADD", 40, 53, "-1"], ["B", "SCALE", 53, "-1"], ["B", "ADD", 77, 53, "-2"], ["B", "ADD", 76, 53, "-1"], ["B", "ADD", 75, 53, "-4"], ["B", "ADD", 74, 53, "2"], ["B", "ADD", 73, 53, "2"], ["B", "ADD", 72, 53, "1"], ["B", "ADD", 71, 53, "2"], ["B", "ADD", 70, 53, "1"], ["B", "ADD", 69, 53, "2"], ["B", "ADD", 68, 53, "1"], ["B", "ADD", 67, 53, "2"], ["B", "ADD", 66, 53, "1"], ["B", "ADD", 65, 53, "2"], ["B", "ADD", 64, 53, "1"], ["B", "ADD", 63, 53, "2"], ["B", "ADD", 62, 53, "1"], ["B", "ADD", 61, 53, "2"], ["B", "ADD", 60, 53, "2"], ["B", "ADD", 59, 53, "1"], ["B", "ADD", 57, 53, "1"], ["B", "SWAP", 53, 55], ["B", "ADD", 41, 52, "1"], ["B", "ADD", 49, 51, "-1"], ["B", "ADD", 47, 51, "-1"], ["B", "ADD", 45, 51, "-1"], ["B", "ADD", 41, 51, "-1"], ["B", "ADD", 40, 51, "-1"], ["B", "SCALE", 51, "-1"], ["B", "ADD", 77, 51, "-2"], ["B", "ADD", 76, 51, "-1"], ["B", "ADD", 75, 51, "-4"], ["B", "ADD", 74, 51, "2"], ["B", "ADD", 73, 51, "2"], ["B", "ADD", 72, 51, "1"], ["B", "ADD", 71, 51, "2"], ["B", "ADD", 70, 51, "1"], ["B", "ADD", 69, 51, "2"], ["B", "ADD", 68, 51, "1"], ["B", "ADD", 67, 51, "2"], ["B", "ADD", 66, 51, "1"], ["B", "ADD", 65, 51, "2"], ["B", "ADD", 64, 51, "1"], ["B", "ADD", 63, 51, "2"], ["B", "ADD", 62, 51, "1"], ["B", "ADD", 61, 51, "2"], ["B", "ADD", 60, 51, "2"], ["B", "ADD", 59, 51, "1"], ["B", "ADD", 57, 51, "1"], ["B", "ADD", 55, 51, "1"], ["B", "SWAP", 51, 53], ["B", "ADD", 41, 50, "1"], ["B", "ADD", 47, 49, "-1"], ["B", "ADD", 45, 49, "-1"], ["B", "ADD", 41, 49, "1"], ["B", "ADD", 40, 49, "-1"], ["B", "SCALE", 49, "-1"], ["B", "ADD", 77, 49, "-2"], ["B", "ADD", 76, 49, "-1"], ["B", "ADD", 75, 49, "-4"], ["B", "ADD", 74, 49, "2"], ["B", "ADD", 73, 49, "2"], ["B", "ADD", 72, 49, "1"], ["B", "ADD", 71, 49, "2"], ["B", "ADD", 70, 49, "1"], ["B", "ADD", 69, 49, "2"], ["B", "ADD", 68, 49, "1"], ["B", "ADD", 67, 49, "2"], ["B", "ADD", 66, 49, "1"], ["B", "ADD", 65, 49, "2"], ["B", "ADD", 64, 49, "1"], ["B", "ADD", 63, 49, "2"], ["B", "ADD", 62, 49, "1"], ["B", "ADD", 61, 49, "2"], ["B", "ADD", 60, 49, "2"], ["B", "ADD", 59, 49, "1"], ["B", "ADD", 57, 49, "1"], ["B", "ADD", 55, 49, "1"], ["B", "ADD", 53, 49, "1"], ["B", "SWAP", 49, 51], ["B", "ADD", 41, 48, "-1"], ["B", "ADD", 45, 47, "-1"], ["B", "ADD", 41, 47, "1"], ["B", "ADD", 40, 47, "-1"], ["B", "SCALE", 47, "-1"], ["B", "ADD", 77, 47, "-2"], ["B", "ADD", 76, 47, "-1"], ["B", "ADD", 75, 47, "-4"], ["B", "ADD", 74, 47, "2"], ["B", "ADD", 73, 47, "2"], ["B", "ADD", 72, 47, "1"], ["B", "ADD", 71, 47, "2"], ["B", "ADD", 70, 47, "1"], ["B", "ADD", 69, 47, "2"], ["B", "ADD", 68, 47, "1"], ["B", "ADD", 67, 47, "2"], ["B", "ADD", 66, 47, "1"], ["B", "ADD", 65, 47, "2"], ["B", "ADD", 64, 47, "1"], ["B", "ADD", 63, 47, "2"], ["B", "ADD", 62, 47, "1"], ["B", "ADD", 61, 47, "2"], ["B", "ADD", 60, 47, "2"], ["B", "ADD", 59, 47, "1"], ["B", "ADD", 57, 47, "1"], ["B", "ADD", 55, 47, "1"], ["B", "ADD", 53, 47, "1"], ["B", "ADD", 51, 47, "1"], ["B", "SWAP", 47, 49], ["B", "ADD", 41, 46, "-1"], ["B", "ADD", 41, 45, "-1"], ["B", "ADD", 40, 45, "-1"], ["B", "SCALE", 45, "-1"], ["B", "ADD", 77, 45, "-2"], ["B", "ADD", 76, 45, "-1"], ["B", "ADD", 75, 45, "-4"], ["B", "ADD", 74, 45, "2"], ["B", "ADD", 73, 45, "2"], ["B", "ADD", 72, 45, "1"], ["B", "ADD", 71, 45, "2"], ["B", "ADD", 70, 45, "1"], ["B", "ADD", 69, 45, "2"], ["B", "ADD", 68, 45, "1"], ["B", "ADD", 67, 45, "2"], ["B", "ADD", 66, 45, "1"], ["B", "ADD", 65, 45, "2"], ["B", "ADD", 64, 45, "1"], ["B", "ADD", 63, 45, "2"], ["B", "ADD", 62, 45, "1"], ["B", "ADD", 61, 45, "2"], ["B", "ADD", 60, 45, "2"], ["B", "ADD", 59, 45, "1"], ["B", "ADD", 57, 45, "1"], ["B", "ADD", 55, 45, "1"], ["B", "ADD", 53, 45, "1"], ["B", "ADD", 51, 45, "1"], ["B", "ADD", 49, 45, "1"], ["B", "SWAP", 45, 47], ["B", "ADD", 41, 44, "1"], ["B", "ADD", 41, 43, "-2"], ["B", "ADD", 41, 42, "2"], ["B", "ADD", 40, 41, "-1"], ["B", "SCALE", 41, "-1"], ["B", "ADD", 77, 41, "-2"], ["B", "ADD", 76, 41, "-1"], ["B", "ADD", 75, 41, "-4"], ["B", "ADD", 74, 41, "2"], ["B", "ADD", 73, 41, "2"], ["B", "ADD", 72, 41, "1"], ["B", "ADD", 71, 41, "2"], ["B", "ADD", 70, 41, "1"], ["B", "ADD", 69, 41, "2"], ["B", "ADD", 68, 41, "1"], ["B", "ADD", 67, 41, "2"], ["B", "ADD", 66, 41, "1"], ["B", "ADD", 65, 41, "2"], ["B", "ADD", 64, 41, "1"], ["B", "ADD", 63, 41, "2"], ["B", "ADD", 62, 41, "1"], ["B", "ADD", 61, 41, "2"], ["B", "ADD", 60, 41, "2"], ["B", "ADD", 59, 41, "1"], ["B", "ADD", 57, 41, "1"], ["B", "ADD", 55, 41, "1"], ["B", "ADD", 53, 41, "1"], ["B", "ADD", 51, 41, "1"], ["B", "ADD", 49, 41, "1"], ["B", "ADD", 47, 41, "1"], ["B", "SWAP", 41, 45], ["B", "SCALE", 40, "128"], ["B", "ADD", 77, 40, "1/32"], ["B", "ADD", 76, 40, "1/128"], ["B", "ADD", 75, 40, "1/32"], ["B", "ADD", 74, 40, "-1/32"], ["B", "ADD", 72, 40, "1/128"], ["B", "ADD", 70, 40, "1/128"], ["B", "ADD", 68, 40, "1/128"], ["B", "ADD", 66, 40, "1/128"], ["B", "ADD", 64, 40, "1/128"], ["B", "ADD", 62, 40, "1/128"], ["B", "ADD", 59, 40, "-1/128"], ["B", "ADD", 57, 40, "-1/128"], ["B", "ADD", 55, 40, "-1/128"], ["B", "ADD", 53, 40, "-1/128"], ["B", "ADD", 51, 40, "-1/128"], ["B", "ADD", 49, 40, "-1/128"], ["B", "ADD", 47, 40, "-1/128"], ["B", "ADD", 45, 40, "-1/128"], ["B", "SWAP", 40, 41], ["B", "LAMBDA", 40, -1], ["J", 10, [1, 0, 20, 21], [41, 40, "-1", "1/2"], "mm"], ["A", "LAMBDA", 20, -1], ["A", "SCALE", 21, "-1"], ["A", "LAMBDA", 0, 1], ["A", "ADD", 0, 1, "-1"], ["A", "IDLE_ONE", 2, [10]], ["A", "IDLE_ONE", 3, [10, 11]], ["A", "IDLE_ONE", 4, [10, 11, 12]], ["A", "IDLE_ONE", 5, [10, 11, 12, 13]], ["A", "IDLE_ONE", 6, [10, 11, 12, 13, 14]], ["A", "IDLE_ONE", 7, [10, 11, 12, 13, 14, 15]], ["A", "IDLE_ONE", 8, [10, 11, 12, 13, 14, 15, 16]], ["A", "IDLE_ONE", 9, [10, 11, 12, 13, 14, 15, 16, 17]], ["A", "SWAP", 17, 18], ["A", "SWAP", 16, 18], ["A", "SWAP", 15, 18], ["A", "SWAP", 14, 18], ["A", "SWAP", 13, 18], ["A", "SWAP", 12, 18], ["A", "SWAP", 11, 18], ["A", "SWAP", 10, 18], ["A", "SWAP", 9, 18], ["A", "SWAP", 8, 18], ["A", "SWAP", 7, 18], ["A", "SWAP", 6, 18], ["A", "SWAP", 5, 18], ["A", "SWAP", 4, 18], ["A", "SWAP", 3, 18], ["A", "ADD", 1, 2, "-1"], ["A", "SCALE", 2, "-1"], ["A", "SWAP", 2, 18], ["A", "SCALE", 1, "-1"], ["A", "ADD", 18, 1, "2"], ["A", "ADD", 18, 0, "2"], ["A", "ADD", 1, 0, "1"], ["A", "SWAP", 0, 18], ["A", "LAMBDA", 0, -1], ["A", "ADD", 20, 21, "-1"], ["A", "IDLE_ONE", 22, [10]], ["A", "IDLE_ONE", 23, [10, 11]], ["A", "IDLE_ONE", 24, [10, 11, 12]], ["A", "IDLE_ONE", 25, [10, 11, 12, 13]], ["A", "IDLE_ONE", 26, [10, 11, 12, 13, 14]], ["A", "IDLE_ONE", 27, [10, 11, 12, 13, 14, 15]], ["A", "IDLE_ONE", 28, [10, 11, 12, 13, 14, 15, 16]], ["A", "IDLE_ONE", 29, [10, 11, 12, 13, 14, 15, 16, 17]], ["A", "SWAP", 37, 38], ["A", "SWAP", 36, 38], ["A", "SWAP", 35, 38], ["A", "SWAP", 34, 38], ["A", "SWAP", 33, 38], ["A", "SWAP", 32, 38], ["A", "SWAP", 31, 38], ["A", "SWAP", 30, 38], ["A", "SWAP", 29, 38], ["A", "SWAP", 28, 38], ["A", "SWAP", 27, 38], ["A", "SWAP", 26, 38], ["A", "SWAP", 25, 38], ["A", "SWAP", 24, 38], ["A", "SWAP", 23, 38], ["A", "ADD", 21, 22, "-1"], ["A", "SCALE", 22, "-1"], ["A", "SWAP", 22, 38], ["A", "ADD", 38, 21, "-2"], ["A", "ADD", 38, 20, "2"], ["A", "ADD", 21, 20, "-1"], ["A", "SWAP", 20, 38], ["A", "LAMBDA", 20, 1], ["B", "LAMBDA", 40, 1], ["B", "IDLE_ONE", 60, [10, 11, 12, 13, 14, 15, 16, 17]], ["B", "IDLE_ONE", 61, [10, 11, 12, 13, 14, 15, 16, 17]], ["B", "IDLE_ONE", 62, [10, 11, 12, 13, 14, 15, 16]], ["B", "IDLE_ONE", 63, [10, 11, 12, 13, 14, 15, 16]], ["B", "IDLE_ONE", 64, [10, 11, 12, 13, 14, 15]], ["B", "IDLE_ONE", 65, [10, 11, 12, 13, 14, 15]], ["B", "IDLE_ONE", 66, [10, 11, 12, 13, 14]], ["B", "IDLE_ONE", 67, [10, 11, 12, 13, 14]], ["B", "IDLE_ONE", 68, [10, 11, 12, 13]], ["B", "IDLE_ONE", 69, [10, 11, 12, 13]], ["B", "IDLE_ONE", 70, [10, 11, 12]], ["B", "IDLE_ONE", 71, [10, 11, 12]], ["B", "IDLE_ONE", 72, [10, 11]], ["B", "IDLE_ONE", 73, [10, 11]], ["B", "IDLE_ONE", 74, [10]], ["B", "IDLE_ONE", 75, [10]], ["B", "IDLE_ONE", 76, [10]], ["B", "IDLE_ONE", 77, [10]], ["B", "ADD", 76, 77, "-1/2"], ["B", "ADD", 75, 77, "-1"], ["B", "ADD", 74, 77, "1/2"], ["B", "ADD", 41, 77, "-64"], ["B", "SCALE", 77, "1/4"], ["B", "ADD", 74, 76, "-2"], ["B", "SCALE", 76, "2"], ["B", "ADD", 77, 76, "1/2"], ["B", "ADD", 74, 75, "3/2"], ["B", "ADD", 41, 75, "64"], ["B", "ADD", 40, 75, "64"], ["B", "SCALE", 75, "2"], ["B", "ADD", 77, 75, "-5/8"], ["B", "ADD", 76, 75, "-3/2"], ["B", "SWAP", 75, 77], ["B", "ADD", 40, 74, "-64"], ["B", "ADD", 76, 74, "2"], ["B", "ADD", 75, 74, "3/2"], ["B", "SWAP", 74, 75], ["B", "SWAP", 73, 75], ["B", "SWAP", 72, 74], ["B", "SWAP", 71, 73], ["B", "SWAP", 70, 72], ["B", "SWAP", 69, 71], ["B", "SWAP", 68, 70], ["B", "SWAP", 67, 69], ["B", "SWAP", 66, 68], ["B", "SWAP", 65, 67], ["B", "SWAP", 64, 66], ["B", "SWAP", 63, 65], ["B", "SWAP", 62, 64], ["B", "SWAP", 61, 63], ["B", "SWAP", 60, 62], ["B", "ADD", 40, 41, "1/2"], ["B", "SCALE", 41, "-1"], ["B", "ADD", 77, 41, "1/32"], ["B", "ADD", 76, 41, "-1/64"], ["B", "ADD", 61, 41, "1/64"], ["B", "ADD", 60, 41, "1/128"], ["B", "SCALE", 40, "-1"], ["B", "ADD", 77, 40, "-1/32"], ["B", "ADD", 61, 40, "-1/64"], ["B", "ADD", 60, 40, "-1/64"], ["B", "ADD", 41, 40, "-1"], ["B", "LAMBDA", 40, -1], ["J", 11, [1, 0, 20, 21], [41, 40, "-1", "1/2"], "mm"], ["A", "LAMBDA", 20, -1], ["A", "SCALE", 21, "-1"], ["A", "LAMBDA", 0, 1], ["A", "SWAP", 17, 18], ["A", "SWAP", 16, 18], ["A", "SWAP", 15, 18], ["A", "SWAP", 14, 18], ["A", "SWAP", 13, 18], ["A", "SWAP", 12, 18], ["A", "SWAP", 11, 18], ["A", "SWAP", 10, 18], ["A", "SWAP", 9, 18], ["A", "SWAP", 8, 18], ["A", "SWAP", 7, 18], ["A", "SWAP", 6, 18], ["A", "SWAP", 5, 18], ["A", "SWAP", 4, 18], ["A", "SWAP", 3, 18], ["A", "ADD", 1, 2, "-1"], ["A", "ADD", 0, 2, "-1"], ["A", "SCALE", 2, "-1"], ["A", "SWAP", 2, 18], ["A", "ADD", 0, 1, "-1"], ["A", "SCALE", 1, "-1"], ["A", "ADD", 18, 1, "2"], ["A", "ADD", 18, 0, "2"], ["A", "ADD", 1, 0, "1"], ["A", "SWAP", 0, 18], ["A", "LAMBDA", 0, -1], ["A", "SWAP", 37, 38], ["A", "SWAP", 36, 38], ["A", "SWAP", 35, 38], ["A", "SWAP", 34, 38], ["A", "SWAP", 33, 38], ["A", "SWAP", 32, 38], ["A", "SWAP", 31, 38], ["A", "SWAP", 30, 38], ["A", "SWAP", 29, 38], ["A", "SWAP", 28, 38], ["A", "SWAP", 27, 38], ["A", "SWAP", 26, 38], ["A", "SWAP", 25, 38], ["A", "SWAP", 24, 38], ["A", "SWAP", 23, 38], ["A", "ADD", 21, 22, "-1"], ["A", "ADD", 20, 22, "-1"], ["A", "SCALE", 22, "-1"], ["A", "SWAP", 22, 38], ["A", "ADD", 20, 21, "-1"], ["A", "ADD", 38, 21, "-2"], ["A", "ADD", 38, 20, "2"], ["A", "ADD", 21, 20, "-1"], ["A", "SWAP", 20, 38], ["A", "LAMBDA", 20, 1], ["B", "LAMBDA", 40, 1], ["B", "IDLE_ONE", 76, [11]], ["B", "IDLE_ONE", 77, [11]], ["B", "ADD", 76, 77, "1"], ["B", "ADD", 74, 77, "-1/4"], ["B", "ADD", 41, 77, "-64"], ["B", "SCALE", 77, "-1/2"], ["B", "ADD", 75, 76, "1/2"], ["B", "ADD", 74, 76, "1/2"], ["B", "ADD", 41, 76, "64"], ["B", "ADD", 40, 76, "32"], ["B", "SWAP", 76, 77], ["B", "ADD", 74, 75, "-1/2"], ["B", "ADD", 41, 75, "-128"], ["B", "SCALE", 75, "-1"], ["B", "ADD", 77, 75, "2"], ["B", "ADD", 76, 75, "-1"], ["B", "ADD", 40, 74, "128"], ["B", "SCALE", 74, "-2"], ["B", "ADD", 76, 74, "1"], ["B", "ADD", 75, 74, "1"], ["B", "SWAP", 73, 75], ["B", "SWAP", 72, 74], ["B", "SWAP", 71, 73], ["B", "SWAP", 70, 72], ["B", "SWAP", 69, 71], ["B", "SWAP", 68, 70], ["B", "SWAP", 67, 69], ["B", "SWAP", 66, 68], ["B", "SWAP", 65, 67], ["B", "SWAP", 64, 66], ["B", "SWAP", 63, 65], ["B", "SWAP", 62, 64], ["B", "ADD", 40, 41, "1/2"], ["B", "SCALE", 41, "-1"], ["B", "ADD", 77, 41, "1/32"], ["B", "ADD", 76, 41, "-1/64"], ["B", "ADD", 63, 41, "1/64"], ["B", "ADD", 62, 41, "1/128"], ["B", "SCALE", 40, "-1"], ["B", "ADD", 77, 40, "-1/32"], ["B", "ADD", 63, 40, "-1/64"], ["B", "ADD", 62, 40, "-1/64"], ["B", "ADD", 41, 40, "-1"], ["B", "LAMBDA", 40, -1], ["J", 12, [1, 0, 20, 21], [41, 40, "-1", "1/2"], "mm"], ["A", "LAMBDA", 20, -1], ["A", "SCALE", 21, "-1"], ["A", "LAMBDA", 0, 1], ["A", "SWAP", 17, 18], ["A", "SWAP", 16, 18], ["A", "SWAP", 15, 18], ["A", "SWAP", 14, 18], ["A", "SWAP", 13, 18], ["A", "SWAP", 12, 18], ["A", "SWAP", 11, 18], ["A", "SWAP", 10, 18], ["A", "SWAP", 9, 18], ["A", "SWAP", 8, 18], ["A", "SWAP", 7, 18], ["A", "SWAP", 6, 18], ["A", "SWAP", 5, 18], ["A", "SWAP", 4, 18], ["A", "SWAP", 3, 18], ["A", "ADD", 1, 2, "-1"], ["A", "ADD", 0, 2, "-1"], ["A", "SCALE", 2, "-1"], ["A", "SWAP", 2, 18], ["A", "ADD", 0, 1, "-1"], ["A", "SCALE", 1, "-1"], ["A", "ADD", 18, 1, "2"], ["A", "ADD", 18, 0, "2"], ["A", "ADD", 1, 0, "1"], ["A", "SWAP", 0, 18], ["A", "LAMBDA", 0, -1], ["A", "SWAP", 37, 38], ["A", "SWAP", 36, 38], ["A", "SWAP", 35, 38], ["A", "SWAP", 34, 38], ["A", "SWAP", 33, 38], ["A", "SWAP", 32, 38], ["A", "SWAP", 31, 38], ["A", "SWAP", 30, 38], ["A", "SWAP", 29, 38], ["A", "SWAP", 28, 38], ["A", "SWAP", 27, 38], ["A", "SWAP", 26, 38], ["A", "SWAP", 25, 38], ["A", "SWAP", 24, 38], ["A", "SWAP", 23, 38], ["A", "ADD", 21, 22, "-1"], ["A", "ADD", 20, 22, "-1"], ["A", "SCALE", 22, "-1"], ["A", "SWAP", 22, 38], ["A", "ADD", 20, 21, "-1"], ["A", "ADD", 38, 21, "-2"], ["A", "ADD", 38, 20, "2"], ["A", "ADD", 21, 20, "-1"], ["A", "SWAP", 20, 38], ["A", "LAMBDA", 20, 1], ["B", "LAMBDA", 40, 1], ["B", "IDLE_ONE", 76, [12]], ["B", "IDLE_ONE", 77, [12]], ["B", "ADD", 76, 77, "1"], ["B", "ADD", 74, 77, "-1/4"], ["B", "ADD", 41, 77, "-64"], ["B", "SCALE", 77, "-1/2"], ["B", "ADD", 75, 76, "1/2"], ["B", "ADD", 74, 76, "1/2"], ["B", "ADD", 41, 76, "64"], ["B", "ADD", 40, 76, "32"], ["B", "SWAP", 76, 77], ["B", "ADD", 74, 75, "-1/2"], ["B", "ADD", 41, 75, "-128"], ["B", "SCALE", 75, "-1"], ["B", "ADD", 77, 75, "2"], ["B", "ADD", 76, 75, "-1"], ["B", "ADD", 40, 74, "128"], ["B", "SCALE", 74, "-2"], ["B", "ADD", 76, 74, "1"], ["B", "ADD", 75, 74, "1"], ["B", "SWAP", 73, 75], ["B", "SWAP", 72, 74], ["B", "SWAP", 71, 73], ["B", "SWAP", 70, 72], ["B", "SWAP", 69, 71], ["B", "SWAP", 68, 70], ["B", "SWAP", 67, 69], ["B", "SWAP", 66, 68], ["B", "SWAP", 65, 67], ["B", "SWAP", 64, 66], ["B", "ADD", 40, 41, "1/2"], ["B", "SCALE", 41, "-1"], ["B", "ADD", 77, 41, "1/32"], ["B", "ADD", 76, 41, "-1/64"], ["B", "ADD", 65, 41, "1/64"], ["B", "ADD", 64, 41, "1/128"], ["B", "SCALE", 40, "-1"], ["B", "ADD", 77, 40, "-1/32"], ["B", "ADD", 65, 40, "-1/64"], ["B", "ADD", 64, 40, "-1/64"], ["B", "ADD", 41, 40, "-1"], ["B", "LAMBDA", 40, -1], ["J", 13, [1, 0, 20, 21], [41, 40, "-1", "1/2"], "mm"], ["A", "LAMBDA", 20, -1], ["A", "SCALE", 21, "-1"], ["A", "LAMBDA", 0, 1], ["A", "SWAP", 17, 18], ["A", "SWAP", 16, 18], ["A", "SWAP", 15, 18], ["A", "SWAP", 14, 18], ["A", "SWAP", 13, 18], ["A", "SWAP", 12, 18], ["A", "SWAP", 11, 18], ["A", "SWAP", 10, 18], ["A", "SWAP", 9, 18], ["A", "SWAP", 8, 18], ["A", "SWAP", 7, 18], ["A", "SWAP", 6, 18], ["A", "SWAP", 5, 18], ["A", "SWAP", 4, 18], ["A", "SWAP", 3, 18], ["A", "ADD", 1, 2, "-1"], ["A", "ADD", 0, 2, "-1"], ["A", "SCALE", 2, "-1"], ["A", "SWAP", 2, 18], ["A", "ADD", 0, 1, "-1"], ["A", "SCALE", 1, "-1"], ["A", "ADD", 18, 1, "2"], ["A", "ADD", 18, 0, "2"], ["A", "ADD", 1, 0, "1"], ["A", "SWAP", 0, 18], ["A", "LAMBDA", 0, -1], ["A", "SWAP", 37, 38], ["A", "SWAP", 36, 38], ["A", "SWAP", 35, 38], ["A", "SWAP", 34, 38], ["A", "SWAP", 33, 38], ["A", "SWAP", 32, 38], ["A", "SWAP", 31, 38], ["A", "SWAP", 30, 38], ["A", "SWAP", 29, 38], ["A", "SWAP", 28, 38], ["A", "SWAP", 27, 38], ["A", "SWAP", 26, 38], ["A", "SWAP", 25, 38], ["A", "SWAP", 24, 38], ["A", "SWAP", 23, 38], ["A", "ADD", 21, 22, "-1"], ["A", "ADD", 20, 22, "-1"], ["A", "SCALE", 22, "-1"], ["A", "SWAP", 22, 38], ["A", "ADD", 20, 21, "-1"], ["A", "ADD", 38, 21, "-2"], ["A", "ADD", 38, 20, "2"], ["A", "ADD", 21, 20, "-1"], ["A", "SWAP", 20, 38], ["A", "LAMBDA", 20, 1], ["B", "LAMBDA", 40, 1], ["B", "IDLE_ONE", 76, [13]], ["B", "IDLE_ONE", 77, [13]], ["B", "ADD", 76, 77, "1"], ["B", "ADD", 74, 77, "-1/4"], ["B", "ADD", 41, 77, "-64"], ["B", "SCALE", 77, "-1/2"], ["B", "ADD", 75, 76, "1/2"], ["B", "ADD", 74, 76, "1/2"], ["B", "ADD", 41, 76, "64"], ["B", "ADD", 40, 76, "32"], ["B", "SWAP", 76, 77], ["B", "ADD", 74, 75, "-1/2"], ["B", "ADD", 41, 75, "-128"], ["B", "SCALE", 75, "-1"], ["B", "ADD", 77, 75, "2"], ["B", "ADD", 76, 75, "-1"], ["B", "ADD", 40, 74, "128"], ["B", "SCALE", 74, "-2"], ["B", "ADD", 76, 74, "1"], ["B", "ADD", 75, 74, "1"], ["B", "SWAP", 73, 75], ["B", "SWAP", 72, 74], ["B", "SWAP", 71, 73], ["B", "SWAP", 70, 72], ["B", "SWAP", 69, 71], ["B", "SWAP", 68, 70], ["B", "SWAP", 67, 69], ["B", "SWAP", 66, 68], ["B", "ADD", 40, 41, "1/2"], ["B", "SCALE", 41, "-1"], ["B", "ADD", 77, 41, "1/32"], ["B", "ADD", 76, 41, "-1/64"], ["B", "ADD", 67, 41, "1/64"], ["B", "ADD", 66, 41, "1/128"], ["B", "SCALE", 40, "-1"], ["B", "ADD", 77, 40, "-1/32"], ["B", "ADD", 67, 40, "-1/64"], ["B", "ADD", 66, 40, "-1/64"], ["B", "ADD", 41, 40, "-1"], ["B", "LAMBDA", 40, -1], ["J", 14, [1, 0, 20, 21], [41, 40, "-1", "1/2"], "mm"], ["A", "LAMBDA", 20, -1], ["A", "SCALE", 21, "-1"], ["A", "LAMBDA", 0, 1], ["A", "SWAP", 17, 18], ["A", "SWAP", 16, 18], ["A", "SWAP", 15, 18], ["A", "SWAP", 14, 18], ["A", "SWAP", 13, 18], ["A", "SWAP", 12, 18], ["A", "SWAP", 11, 18], ["A", "SWAP", 10, 18], ["A", "SWAP", 9, 18], ["A", "SWAP", 8, 18], ["A", "SWAP", 7, 18], ["A", "SWAP", 6, 18], ["A", "SWAP", 5, 18], ["A", "SWAP", 4, 18], ["A", "SWAP", 3, 18], ["A", "ADD", 1, 2, "-1"], ["A", "ADD", 0, 2, "-1"], ["A", "SCALE", 2, "-1"], ["A", "SWAP", 2, 18], ["A", "ADD", 0, 1, "-1"], ["A", "SCALE", 1, "-1"], ["A", "ADD", 18, 1, "2"], ["A", "ADD", 18, 0, "2"], ["A", "ADD", 1, 0, "1"], ["A", "SWAP", 0, 18], ["A", "LAMBDA", 0, -1], ["A", "SWAP", 37, 38], ["A", "SWAP", 36, 38], ["A", "SWAP", 35, 38], ["A", "SWAP", 34, 38], ["A", "SWAP", 33, 38], ["A", "SWAP", 32, 38], ["A", "SWAP", 31, 38], ["A", "SWAP", 30, 38], ["A", "SWAP", 29, 38], ["A", "SWAP", 28, 38], ["A", "SWAP", 27, 38], ["A", "SWAP", 26, 38], ["A", "SWAP", 25, 38], ["A", "SWAP", 24, 38], ["A", "SWAP", 23, 38], ["A", "ADD", 21, 22, "-1"], ["A", "ADD", 20, 22, "-1"], ["A", "SCALE", 22, "-1"], ["A", "SWAP", 22, 38], ["A", "ADD", 20, 21, "-1"], ["A", "ADD", 38, 21, "-2"], ["A", "ADD", 38, 20, "2"], ["A", "ADD", 21, 20, "-1"], ["A", "SWAP", 20, 38], ["A", "LAMBDA", 20, 1], ["B", "LAMBDA", 40, 1], ["B", "IDLE_ONE", 76, [14]], ["B", "IDLE_ONE", 77, [14]], ["B", "ADD", 76, 77, "1"], ["B", "ADD", 74, 77, "-1/4"], ["B", "ADD", 41, 77, "-64"], ["B", "SCALE", 77, "-1/2"], ["B", "ADD", 75, 76, "1/2"], ["B", "ADD", 74, 76, "1/2"], ["B", "ADD", 41, 76, "64"], ["B", "ADD", 40, 76, "32"], ["B", "SWAP", 76, 77], ["B", "ADD", 74, 75, "-1/2"], ["B", "ADD", 41, 75, "-128"], ["B", "SCALE", 75, "-1"], ["B", "ADD", 77, 75, "2"], ["B", "ADD", 76, 75, "-1"], ["B", "ADD", 40, 74, "128"], ["B", "SCALE", 74, "-2"], ["B", "ADD", 76, 74, "1"], ["B", "ADD", 75, 74, "1"], ["B", "SWAP", 73, 75], ["B", "SWAP", 72, 74], ["B", "SWAP", 71, 73], ["B", "SWAP", 70, 72], ["B", "SWAP", 69, 71], ["B", "SWAP", 68, 70], ["B", "ADD", 40, 41, "1/2"], ["B", "SCALE", 41, "-1"], ["B", "ADD", 77, 41, "1/32"], ["B", "ADD", 76, 41, "-1/64"], ["B", "ADD", 69, 41, "1/64"], ["B", "ADD", 68, 41, "1/128"], ["B", "SCALE", 40, "-1"], ["B", "ADD", 77, 40, "-1/32"], ["B", "ADD", 69, 40, "-1/64"], ["B", "ADD", 68, 40, "-1/64"], ["B", "ADD", 41, 40, "-1"], ["B", "LAMBDA", 40, -1], ["J", 15, [1, 0, 20, 21], [41, 40, "-1", "1/2"], "mm"], ["A", "LAMBDA", 20, -1], ["A", "SCALE", 21, "-1"], ["A", "LAMBDA", 0, 1], ["A", "SWAP", 17, 18], ["A", "SWAP", 16, 18], ["A", "SWAP", 15, 18], ["A", "SWAP", 14, 18], ["A", "SWAP", 13, 18], ["A", "SWAP", 12, 18], ["A", "SWAP", 11, 18], ["A", "SWAP", 10, 18], ["A", "SWAP", 9, 18], ["A", "SWAP", 8, 18], ["A", "SWAP", 7, 18], ["A", "SWAP", 6, 18], ["A", "SWAP", 5, 18], ["A", "SWAP", 4, 18], ["A", "SWAP", 3, 18], ["A", "ADD", 1, 2, "-1"], ["A", "ADD", 0, 2, "-1"], ["A", "SCALE", 2, "-1"], ["A", "SWAP", 2, 18], ["A", "ADD", 0, 1, "-1"], ["A", "SCALE", 1, "-1"], ["A", "ADD", 18, 1, "2"], ["A", "ADD", 18, 0, "2"], ["A", "ADD", 1, 0, "1"], ["A", "SWAP", 0, 18], ["A", "LAMBDA", 0, -1], ["A", "SWAP", 37, 38], ["A", "SWAP", 36, 38], ["A", "SWAP", 35, 38], ["A", "SWAP", 34, 38], ["A", "SWAP", 33, 38], ["A", "SWAP", 32, 38], ["A", "SWAP", 31, 38], ["A", "SWAP", 30, 38], ["A", "SWAP", 29, 38], ["A", "SWAP", 28, 38], ["A", "SWAP", 27, 38], ["A", "SWAP", 26, 38], ["A", "SWAP", 25, 38], ["A", "SWAP", 24, 38], ["A", "SWAP", 23, 38], ["A", "ADD", 21, 22, "-1"], ["A", "ADD", 20, 22, "-1"], ["A", "SCALE", 22, "-1"], ["A", "SWAP", 22, 38], ["A", "ADD", 20, 21, "-1"], ["A", "ADD", 38, 21, "-2"], ["A", "ADD", 38, 20, "2"], ["A", "ADD", 21, 20, "-1"], ["A", "SWAP", 20, 38], ["A", "LAMBDA", 20, 1], ["B", "LAMBDA", 40, 1], ["B", "IDLE_ONE", 76, [15]], ["B", "IDLE_ONE", 77, [15]], ["B", "ADD", 76, 77, "1"], ["B", "ADD", 74, 77, "-1/4"], ["B", "ADD", 41, 77, "-64"], ["B", "SCALE", 77, "-1/2"], ["B", "ADD", 75, 76, "1/2"], ["B", "ADD", 74, 76, "1/2"], ["B", "ADD", 41, 76, "64"], ["B", "ADD", 40, 76, "32"], ["B", "SWAP", 76, 77], ["B", "ADD", 74, 75, "-1/2"], ["B", "ADD", 41, 75, "-128"], ["B", "SCALE", 75, "-1"], ["B", "ADD", 77, 75, "2"], ["B", "ADD", 76, 75, "-1"], ["B", "ADD", 40, 74, "128"], ["B", "SCALE", 74, "-2"], ["B", "ADD", 76, 74, "1"], ["B", "ADD", 75, 74, "1"], ["B", "SWAP", 73, 75], ["B", "SWAP", 72, 74], ["B", "SWAP", 71, 73], ["B", "SWAP", 70, 72], ["B", "ADD", 40, 41, "1/2"], ["B", "SCALE", 41, "-1"], ["B", "ADD", 77, 41, "1/32"], ["B", "ADD", 76, 41, "-1/64"], ["B", "ADD", 71, 41, "1/64"], ["B", "ADD", 70, 41, "1/128"], ["B", "SCALE", 40, "-1"], ["B", "ADD", 77, 40, "-1/32"], ["B", "ADD", 71, 40, "-1/64"], ["B", "ADD", 70, 40, "-1/64"], ["B", "ADD", 41, 40, "-1"], ["B", "LAMBDA", 40, -1], ["J", 16, [1, 0, 20, 21], [41, 40, "-1", "1/2"], "mm"], ["A", "LAMBDA", 20, -1], ["A", "SCALE", 21, "-1"], ["A", "LAMBDA", 0, 1], ["A", "SWAP", 17, 18], ["A", "SWAP", 16, 18], ["A", "SWAP", 15, 18], ["A", "SWAP", 14, 18], ["A", "SWAP", 13, 18], ["A", "SWAP", 12, 18], ["A", "SWAP", 11, 18], ["A", "SWAP", 10, 18], ["A", "SWAP", 9, 18], ["A", "SWAP", 8, 18], ["A", "SWAP", 7, 18], ["A", "SWAP", 6, 18], ["A", "SWAP", 5, 18], ["A", "SWAP", 4, 18], ["A", "SWAP", 3, 18], ["A", "ADD", 1, 2, "-1"], ["A", "ADD", 0, 2, "-1"], ["A", "SCALE", 2, "-1"], ["A", "SWAP", 2, 18], ["A", "ADD", 0, 1, "-1"], ["A", "SCALE", 1, "-1"], ["A", "ADD", 18, 1, "2"], ["A", "ADD", 18, 0, "2"], ["A", "ADD", 1, 0, "1"], ["A", "SWAP", 0, 18], ["A", "LAMBDA", 0, -1], ["A", "SWAP", 37, 38], ["A", "SWAP", 36, 38], ["A", "SWAP", 35, 38], ["A", "SWAP", 34, 38], ["A", "SWAP", 33, 38], ["A", "SWAP", 32, 38], ["A", "SWAP", 31, 38], ["A", "SWAP", 30, 38], ["A", "SWAP", 29, 38], ["A", "SWAP", 28, 38], ["A", "SWAP", 27, 38], ["A", "SWAP", 26, 38], ["A", "SWAP", 25, 38], ["A", "SWAP", 24, 38], ["A", "SWAP", 23, 38], ["A", "ADD", 21, 22, "-1"], ["A", "ADD", 20, 22, "-1"], ["A", "SCALE", 22, "-1"], ["A", "SWAP", 22, 38], ["A", "ADD", 20, 21, "-1"], ["A", "ADD", 38, 21, "-2"], ["A", "ADD", 38, 20, "2"], ["A", "ADD", 21, 20, "-1"], ["A", "SWAP", 20, 38], ["A", "LAMBDA", 20, 1], ["B", "LAMBDA", 40, 1], ["B", "IDLE_ONE", 76, [16]], ["B", "IDLE_ONE", 77, [16]], ["B", "ADD", 76, 77, "1"], ["B", "ADD", 74, 77, "-1/4"], ["B", "ADD", 41, 77, "-64"], ["B", "SCALE", 77, "-1/4"], ["B", "ADD", 75, 76, "1/2"], ["B", "ADD", 74, 76, "1/2"], ["B", "ADD", 41, 76, "64"], ["B", "ADD", 40, 76, "32"], ["B", "SWAP", 76, 77], ["B", "ADD", 74, 75, "-1/2"], ["B", "ADD", 41, 75, "-128"], ["B", "SCALE", 75, "-1"], ["B", "ADD", 77, 75, "2"], ["B", "ADD", 76, 75, "-1/2"], ["B", "ADD", 40, 74, "128"], ["B", "SCALE", 74, "-2"], ["B", "ADD", 76, 74, "1/2"], ["B", "ADD", 75, 74, "1"], ["B", "SWAP", 73, 75], ["B", "SWAP", 72, 74], ["B", "ADD", 40, 41, "1/2"], ["B", "SCALE", 41, "-1"], ["B", "ADD", 77, 41, "1/32"], ["B", "ADD", 76, 41, "-1/128"], ["B", "ADD", 73, 41, "1/64"], ["B", "ADD", 72, 41, "1/128"], ["B", "SCALE", 40, "-1"], ["B", "ADD", 77, 40, "-1/32"], ["B", "ADD", 73, 40, "-1/64"], ["B", "ADD", 72, 40, "-1/64"], ["B", "ADD", 41, 40, "-1"], ["B", "LAMBDA", 40, -1], ["J", 17, [1, 0, 20, 21], [41, 40, "-1", "1/2"], "mm"], ["A", "LAMBDA", 20, -1], ["A", "SCALE", 21, "-1"], ["A", "LAMBDA", 0, 1], ["A", "SWAP", 17, 18], ["A", "SWAP", 16, 18], ["A", "SWAP", 15, 18], ["A", "SWAP", 14, 18], ["A", "SWAP", 13, 18], ["A", "SWAP", 12, 18], ["A", "SWAP", 11, 18], ["A", "SWAP", 10, 18], ["A", "SWAP", 9, 18], ["A", "SWAP", 8, 18], ["A", "SWAP", 7, 18], ["A", "SWAP", 6, 18], ["A", "SWAP", 5, 18], ["A", "SWAP", 4, 18], ["A", "SWAP", 3, 18], ["A", "ADD", 1, 2, "-1"], ["A", "ADD", 0, 2, "-1"], ["A", "SCALE", 2, "-1"], ["A", "SWAP", 2, 18], ["A", "ADD", 0, 1, "-1"], ["A", "SCALE", 1, "-1"], ["A", "ADD", 18, 1, "2"], ["A", "ADD", 18, 0, "2"], ["A", "ADD", 1, 0, "1"], ["A", "SWAP", 0, 18], ["A", "LAMBDA", 0, -1], ["A", "SWAP", 37, 38], ["A", "SWAP", 36, 38], ["A", "SWAP", 35, 38], ["A", "SWAP", 34, 38], ["A", "SWAP", 33, 38], ["A", "SWAP", 32, 38], ["A", "SWAP", 31, 38], ["A", "SWAP", 30, 38], ["A", "SWAP", 29, 38], ["A", "SWAP", 28, 38], ["A", "SWAP", 27, 38], ["A", "SWAP", 26, 38], ["A", "SWAP", 25, 38], ["A", "SWAP", 24, 38], ["A", "SWAP", 23, 38], ["A", "ADD", 21, 22, "-1"], ["A", "ADD", 20, 22, "-1"], ["A", "SCALE", 22, "-1"], ["A", "SWAP", 22, 38], ["A", "ADD", 20, 21, "-1"], ["A", "ADD", 38, 21, "-2"], ["A", "ADD", 38, 20, "2"], ["A", "ADD", 21, 20, "-1"], ["A", "SWAP", 20, 38], ["A", "LAMBDA", 20, 1], ["B", "LAMBDA", 40, 1], ["B", "IDLE_ONE", 76, [17]], ["B", "IDLE_ONE", 77, [17]], ["B", "ADD", 76, 77, "1/2"], ["B", "ADD", 41, 77, "-64"], ["B", "SCALE", 77, "-1/4"], ["B", "ADD", 75, 76, "1"], ["B", "ADD", 74, 76, "1"], ["B", "ADD", 41, 76, "128"], ["B", "ADD", 40, 76, "64"], ["B", "ADD", 74, 75, "-1"], ["B", "ADD", 41, 75, "-128"], ["B", "SCALE", 75, "-1"], ["B", "ADD", 77, 75, "-1/2"], ["B", "ADD", 76, 75, "1"], ["B", "ADD", 41, 74, "-192"], ["B", "SCALE", 74, "-64"], ["B", "ADD", 77, 74, "-3/256"], ["B", "ADD", 76, 74, "1/128"], ["B", "ADD", 75, 74, "3/128"], ["B", "SCALE", 41, "1/4"], ["B", "ADD", 77, 41, "1/64"], ["B", "ADD", 76, 41, "-1/32"], ["B", "ADD", 75, 41, "-1/32"], ["B", "SWAP", 41, 74], ["B", "SCALE", 40, "1/64"], ["B", "ADD", 77, 40, "1/2"], ["B", "ADD", 75, 40, "1"], ["B", "SWAP", 40, 74], ["B", "LAMBDA", 40, -1], ["J", 18, [1, 0, 20, 21], [41, 40, "-2", "1/2"], "mmW"], ["A", "LAMBDA", 20, -1], ["A", "SCALE", 21, "-1"], ["A", "LAMBDA", 0, 1], ["A", "SWAP", 17, 18], ["A", "SWAP", 16, 18], ["A", "SWAP", 15, 18], ["A", "SWAP", 14, 18], ["A", "SWAP", 13, 18], ["A", "SWAP", 12, 18], ["A", "SWAP", 11, 18], ["A", "SWAP", 10, 18], ["A", "SWAP", 9, 18], ["A", "SWAP", 8, 18], ["A", "SWAP", 7, 18], ["A", "SWAP", 6, 18], ["A", "SWAP", 5, 18], ["A", "SWAP", 4, 18], ["A", "SWAP", 3, 18], ["A", "SWAP", 2, 18], ["A", "ADD", 0, 1, "-2"], ["A", "SWAP", 1, 18], ["A", "SCALE", 0, "-1"], ["A", "ADD", 18, 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", "SWAP", 37, 38], ["A", "SWAP", 36, 38], ["A", "SWAP", 35, 38], ["A", "SWAP", 34, 38], ["A", "SWAP", 33, 38], ["A", "SWAP", 32, 38], ["A", "SWAP", 31, 38], ["A", "SWAP", 30, 38], ["A", "SWAP", 29, 38], ["A", "SWAP", 28, 38], ["A", "SWAP", 27, 38], ["A", "SWAP", 26, 38], ["A", "SWAP", 25, 38], ["A", "SWAP", 24, 38], ["A", "SWAP", 23, 38], ["A", "SWAP", 22, 38], ["A", "ADD", 20, 21, "-2"], ["A", "SWAP", 21, 38], ["A", "SCALE", 20, "-1"], ["A", "ADD", 38, 20, "-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], ["A", "LAMBDA", 36, -1], ["A", "LAMBDA", 37, -1], ["A", "LAMBDA", 38, -1], ["A", "LAMBDA", 39, -1], ["B", "LAMBDA", 40, 1], ["B", "IDLE_ONE", 76, [18]], ["B", "ADD", 41, 76, "32"], ["B", "ADD", 40, 76, "32"], ["B", "SCALE", 76, "-1"], ["B", "SWAP", 76, 77], ["B", "SCALE", 41, "1/64"], ["B", "ADD", 77, 41, "1"], ["B", "SWAP", 41, 76], ["B", "SCALE", 40, "-1/32"], ["B", "ADD", 77, 40, "-3/2"], ["B", "ADD", 76, 40, "-1/2"], ["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], ["B", "LAMBDA", 68, -1], ["B", "LAMBDA", 69, -1], ["B", "LAMBDA", 70, -1], ["B", "LAMBDA", 71, -1], ["B", "LAMBDA", 72, -1], ["B", "LAMBDA", 73, -1], ["B", "LAMBDA", 74, -1], ["B", "LAMBDA", 75, -1], ["B", "LAMBDA", 76, -1], ["B", "LAMBDA", 77, -1]], "natives": {"mm": "273e81f176f00168", "mmW": "13019ac4b8a2f051"}, "stage_native": {"1": "mmW", "2": "mm", "3": "mm", "4": "mm", "5": "mm", "6": "mm", "7": "mm", "8": "mm", "9": "mm", "10": "mm", "11": "mm", "12": "mm", "13": "mm", "14": "mm", "15": "mm", "16": "mm", "17": "mm", "18": "mmW"}, "root_B": "rootw1g.json 0e6622d7d27b0e30"} \ No newline at end of file diff --git a/research/p104-whitehead-native-objects/data/mm.chain.invoice.json b/research/p104-whitehead-native-objects/data/mm.chain.invoice.json new file mode 100644 index 0000000000..aacb22079a --- /dev/null +++ b/research/p104-whitehead-native-objects/data/mm.chain.invoice.json @@ -0,0 +1 @@ +{"T": {"1": 408, "2": 306, "3": 792, "4": 3870, "5": 1224, "6": 738, "7": 252, "8": 1116, "9": 11000, "17": 416, "25": 416, "33": 416, "41": 416, "49": 416, "57": 416, "65": 416, "73": 416, "145": 208}, "P": {"1": 74570, "2": 15804, "3": 14058, "4": 3924, "5": 5472, "6": 270, "7": 216, "8": 812, "16": 416, "24": 416, "32": 416, "40": 416, "48": 416, "56": 416, "64": 416}} \ No newline at end of file diff --git a/research/p104-whitehead-native-objects/data/mm.json.gz b/research/p104-whitehead-native-objects/data/mm.json.gz new file mode 100644 index 0000000000..d93e67ca76 Binary files /dev/null and b/research/p104-whitehead-native-objects/data/mm.json.gz differ diff --git a/research/p104-whitehead-native-objects/data/mmW.json.gz b/research/p104-whitehead-native-objects/data/mmW.json.gz new file mode 100644 index 0000000000..529f516fe1 Binary files /dev/null and b/research/p104-whitehead-native-objects/data/mmW.json.gz differ diff --git a/research/p104-whitehead-native-objects/data/ports104.txt b/research/p104-whitehead-native-objects/data/ports104.txt new file mode 100644 index 0000000000..fbdc73df31 --- /dev/null +++ b/research/p104-whitehead-native-objects/data/ports104.txt @@ -0,0 +1,104 @@ +11 +19 +35 +131 +259 +13 +21 +37 +69 +133 +261 +41 +73 +265 +49 +81 +145 +273 +161 +193 +321 +385 +14 +22 +38 +70 +134 +262 +26 +74 +138 +50 +146 +274 +98 +290 +194 +322 +386 +28 +44 +140 +268 +84 +148 +276 +100 +164 +292 +196 +324 +388 +56 +88 +152 +280 +168 +296 +200 +328 +392 +112 +176 +304 +208 +336 +400 +224 +352 +416 +508 +506 +502 +494 +478 +446 +382 +254 +505 +501 +493 +477 +445 +381 +253 +499 +475 +443 +379 +251 +487 +471 +439 +375 +247 +463 +431 +367 +239 +415 +351 +223 +319 +191 \ No newline at end of file diff --git a/research/p104-whitehead-native-objects/data/r1_W18_t3.json b/research/p104-whitehead-native-objects/data/r1_W18_t3.json new file mode 100644 index 0000000000..1fbe76878b --- /dev/null +++ b/research/p104-whitehead-native-objects/data/r1_W18_t3.json @@ -0,0 +1 @@ +{"n": 38, "N": 39, "Y": [["1", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["-1", "-2", "2", "-2", "2", "-2", "2", "-2", "2", "-2", "2", "-2", "2", "-2", "2", "-2", "2", "-2", "2", "2", "-2", "2", "-2", "2", "-2", "2", "-2", "2", "-2", "2", "-2", "2", "-2", "2", "-2", "2", "-2", "0"], ["0", "-1", "1", "-1", "1", "-1", "1", "-1", "1", "-1", "1", "-1", "1", "-1", "1", "-1", "1", "-1", "1", "1", "-1", "1", "-1", "1", "-1", "1", "-1", "1", "-1", "1", "-1", "1", "-1", "1", "-1", "1", "-1", "1"], ["1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1"], ["1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0"], ["1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0"], ["1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0"], ["1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0"], ["1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0"], ["1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0"]], "X": [["1", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "-2", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "-2", "-2", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "-2", "-2", "-2", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "-2", "-2", "-2", "-2", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "-2", "-2", "-2", "-2", "-2", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "-2", "-2", "-2", "-2", "-2", "-2", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "-1", "-1", "-1", "-1", "-1", "-1", "-1", "-1", "-1", "-1", "-1", "-1", "-1", "-1", "-1", "-1", "-1", "-1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1"], ["1", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "-1"], ["-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "0"], ["-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "0"], ["-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "0"], ["-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "0"], ["-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "0"], ["-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "0"], ["-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "0"], ["-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "0"], ["-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "2", "2", "2", "2", "2", "2", "2", "2", "2", "0"], ["-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "2", "2", "2", "2", "2", "2", "2", "2", "0"], ["-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "2", "2", "2", "2", "2", "2", "2", "0"], ["-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "2", "2", "2", "2", "2", "2", "0"], ["-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "2", "2", "2", "2", "2", "0"], ["-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "2", "2", "2", "2", "0"], ["-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "2", "2", "2", "0"], ["-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "2", "2", "0"], ["-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "2", "0"], ["-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0"]], "stages": [{"units": [0, 1], "mask": [0, 1, 2], "letter": "W", "side": "l"}, {"units": [2, 3], "mask": [0, 1, 2, 3, 4], "letter": "W", "side": "l"}, {"units": [4, 5], "mask": [0, 1, 2, 3, 4, 5, 6], "letter": "W", "side": "l"}, {"units": [6, 7], "mask": [0, 1, 2, 3, 4, 5, 6, 7, 8], "letter": "W", "side": "l"}, {"units": [8, 9], "mask": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10], "letter": "W", "side": "l"}, {"units": [10, 11], "mask": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12], "letter": "W", "side": "l"}, {"units": [12, 13], "mask": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14], "letter": "W", "side": "l"}, {"units": [14, 15], "mask": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16], "letter": "W", "side": "l"}, {"units": [16, 17], "mask": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18], "letter": "W", "side": "l"}, {"units": [21, 22], "mask": [0, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36], "letter": "W", "side": "r"}, {"units": [23, 24], "mask": [0, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36], "letter": "W", "side": "r"}, {"units": [25, 26], "mask": [0, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36], "letter": "W", "side": "r"}, {"units": [27, 28], "mask": [0, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36], "letter": "W", "side": "r"}, {"units": [29, 30], "mask": [0, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36], "letter": "W", "side": "r"}, {"units": [31, 32], "mask": [0, 29, 30, 31, 32, 33, 34, 35, 36], "letter": "W", "side": "r"}, {"units": [33, 34], "mask": [0, 31, 32, 33, 34, 35, 36], "letter": "W", "side": "r"}, {"units": [35, 36], "mask": [0, 33, 34, 35, 36], "letter": "W", "side": "r"}, {"units": [37, 38], "mask": [0, 35, 36], "letter": "W", "side": "r"}], "family": {"rho": 1, "tau": 3, "sites": [["W", "l"], ["W", "l"], ["W", "l"], ["W", "l"], ["W", "l"], ["W", "l"], ["W", "l"], ["W", "l"], ["W", "l"], ["W", "r"], ["W", "r"], ["W", "r"], ["W", "r"], ["W", "r"], ["W", "r"], ["W", "r"], ["W", "r"], ["W", "r"]]}} \ No newline at end of file diff --git a/research/p104-whitehead-native-objects/data/root_h.json b/research/p104-whitehead-native-objects/data/root_h.json new file mode 100644 index 0000000000..0ac7a01199 --- /dev/null +++ b/research/p104-whitehead-native-objects/data/root_h.json @@ -0,0 +1 @@ +{"n": 38, "N": 40, "Y": [["1", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "-1", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "-1", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "-1", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "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", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "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", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["3", "-2", "1", "0", "-1", "2", "-1", "0", "1", "-2", "1", "0", "-1", "2", "-1", "0", "1", "-2", "1", "0", "0", "1", "-2", "1", "0", "-1", "2", "-1", "0", "1", "-2", "1", "0", "-1", "2", "-1", "0", "1"], ["1", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "-1", "-1", "1", "0", "-1", "1", "-1", "0", "1", "-1", "1", "0", "-1", "1", "-1", "0", "1", "-1", "1", "1", "-1", "1", "0", "-1", "1", "-1", "0", "1", "-1", "1", "0", "-1", "1", "-1", "0", "1", "-1"], ["1", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1/2", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0"], ["1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1/2", "0", "0", "0", "0", "0", "0"], ["1", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0"], ["1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1/2", "0", "0", "0", "0"], ["1", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0"], ["1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1/2", "0", "0"], ["1", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0"], ["1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1/2"]], "X": [["1", "1/2", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "-2", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "1/2", "-2", "-1", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "-2", "-2", "-2", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "1/2", "-2", "-1", "-2", "-1", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "-2", "-2", "-2", "-2", "-2", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "1/2", "-2", "-1", "-2", "-1", "-2", "-1", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "1/2", "-2", "-1", "-2", "-1", "-2", "-1", "-2", "-1", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "1/2", "-2", "-1", "-2", "-1", "-2", "-1", "-2", "-1", "-2", "-1", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "1/2", "-2", "-1", "-2", "-1", "-2", "-1", "-2", "-1", "-2", "-1", "-2", "-1", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "1/2", "-2", "-1", "-2", "-1", "-2", "-1", "-2", "-1", "-2", "-1", "-2", "-1", "-2", "-1", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "1/2", "-2", "-1", "-2", "-1", "-2", "-1", "-2", "-1", "-2", "-1", "-2", "-1", "-2", "-1", "-2", "-1", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "1/2", "-2", "-1", "-2", "-1", "-2", "-1", "-2", "-1", "-2", "-1", "-2", "-1", "-2", "-1", "-2", "-1", "-2", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "1", "-2", "-1", "-2", "-1", "-2", "-1", "-2", "-1", "-2", "-1", "-2", "-1", "-2", "-1", "-2", "-1", "-2", "-1", "1", "0", "1", "0", "1", "0", "1", "0", "1", "0", "1", "0", "1", "0", "1", "0", "1", "0"], ["0", "1/2", "-1", "0", "-1", "0", "-1", "0", "-1", "0", "-1", "0", "-1", "0", "-1", "0", "-1", "0", "-1", "0", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1"], ["-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2"], ["-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2"], ["-2", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "2", "2", "4", "2", "4", "2", "4", "2", "4", "2", "4", "2", "4", "2", "4", "2", "4"], ["-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2"], ["-2", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "2", "2", "4", "2", "4", "2", "4", "2", "4", "2", "4", "2", "4", "2", "4"], ["-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2"], ["-2", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "2", "2", "4", "2", "4", "2", "4", "2", "4", "2", "4", "2", "4"], ["-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2"], ["-2", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "2", "2", "4", "2", "4", "2", "4", "2", "4", "2", "4"], ["-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "2", "2", "2", "2", "2", "2", "2", "2", "2"], ["-2", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "2", "2", "4", "2", "4", "2", "4", "2", "4"], ["-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "2", "2", "2", "2", "2", "2", "2"], ["-2", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "2", "2", "4", "2", "4", "2", "4"], ["-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "2", "2", "2", "2", "2"], ["-2", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "2", "2", "4", "2", "4"], ["-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "2", "2", "2"], ["-2", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "2", "2", "4"], ["-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "2"], ["-2", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "2"]], "stages": [{"units": [0, 1], "mask": [0, 1, 2, 3], "letter": "H", "side": "l"}, {"units": [2, 3], "mask": [0, 1, 2, 3, 4, 5], "letter": "H", "side": "l"}, {"units": [4, 5], "mask": [0, 1, 2, 3, 4, 5, 6, 7], "letter": "H", "side": "l"}, {"units": [6, 7], "mask": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9], "letter": "H", "side": "l"}, {"units": [8, 9], "mask": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11], "letter": "H", "side": "l"}, {"units": [10, 11], "mask": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13], "letter": "H", "side": "l"}, {"units": [12, 13], "mask": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15], "letter": "H", "side": "l"}, {"units": [14, 15], "mask": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17], "letter": "H", "side": "l"}, {"units": [16, 17], "mask": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19], "letter": "H", "side": "l"}, {"units": [22, 23], "mask": [0, 1, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37], "letter": "M", "side": "r"}, {"units": [24, 25], "mask": [0, 1, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37], "letter": "M", "side": "r"}, {"units": [26, 27], "mask": [0, 1, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37], "letter": "M", "side": "r"}, {"units": [28, 29], "mask": [0, 1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37], "letter": "M", "side": "r"}, {"units": [30, 31], "mask": [0, 1, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37], "letter": "M", "side": "r"}, {"units": [32, 33], "mask": [0, 1, 30, 31, 32, 33, 34, 35, 36, 37], "letter": "M", "side": "r"}, {"units": [34, 35], "mask": [0, 1, 32, 33, 34, 35, 36, 37], "letter": "M", "side": "r"}, {"units": [36, 37], "mask": [0, 1, 34, 35, 36, 37], "letter": "M", "side": "r"}, {"units": [38, 39], "mask": [0, 1, 36, 37], "letter": "M", "side": "r"}], "xi": [["1", "0"], ["1", "-1"], ["1", "0"], ["1", "-1"], ["1", "0"], ["1", "-1"], ["1", "0"], ["1", "-1"], ["1", "0"], ["1", "-1"], ["1", "0"], ["1", "-1"], ["1", "0"], ["1", "-1"], ["1", "0"], ["1", "-1"], ["1", "0"], ["1", "-1"], ["1", "0"], ["1", "-1"], ["1", "0"], ["1", "-1"], ["1", "-1"], ["1/2", "0"], ["1", "-1"], ["1/2", "0"], ["1", "-1"], ["1/2", "0"], ["1", "-1"], ["1/2", "0"], ["1", "-1"], ["1/2", "0"], ["1", "-1"], ["1/2", "0"], ["1", "-1"], ["1/2", "0"], ["1", "-1"], ["1/2", "0"], ["1", "-1"], ["1/2", "0"]], "eta": [["1", "1/2"], ["1", "0"], ["1", "1/2"], ["1", "0"], ["1", "1/2"], ["1", "0"], ["1", "1/2"], ["1", "0"], ["1", "1/2"], ["1", "0"], ["1", "1/2"], ["1", "0"], ["1", "1/2"], ["1", "0"], ["1", "1/2"], ["1", "0"], ["1", "1/2"], ["1", "0"], ["1", "1/2"], ["1", "0"], ["1", "1/2"], ["1", "0"], ["1", "0"], ["2", "1"], ["1", "0"], ["2", "1"], ["1", "0"], ["2", "1"], ["1", "0"], ["2", "1"], ["1", "0"], ["2", "1"], ["1", "0"], ["2", "1"], ["1", "0"], ["2", "1"], ["1", "0"], ["2", "1"], ["1", "0"], ["2", "1"]], "family": {"r": 0, "s": 0, "a": "1/2", "b": "-1", "k": 9, "t": "-1/2"}} \ No newline at end of file diff --git a/research/p104-whitehead-native-objects/data/root_t0_dsum.json b/research/p104-whitehead-native-objects/data/root_t0_dsum.json new file mode 100644 index 0000000000..1f8c2e3152 --- /dev/null +++ b/research/p104-whitehead-native-objects/data/root_t0_dsum.json @@ -0,0 +1 @@ +{"n": 40, "N": 42, "X": [["1", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "2", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "2", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "2", "2", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "2", "2", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "2", "2", "2", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "2", "2", "2", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "2", "2", "2", "2", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "2", "2", "2", "2", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "2", "2", "2", "2", "2", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "2", "2", "2", "2", "2", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "2", "2", "2", "2", "2", "2", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "2", "2", "2", "2", "2", "2", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "2", "2", "2", "2", "2", "2", "2", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "2", "2", "2", "2", "2", "2", "2", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "2", "2", "2", "2", "2", "2", "2", "2", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "2", "2", "2", "2", "2", "2", "2", "2", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1"], ["-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "2", "2", "2", "2", "2", "2", "2", "2", "2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "2", "2", "2", "2", "2", "2", "2", "2", "2", "0"], ["-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "2", "2", "2", "2", "2", "2", "2", "2", "2", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "2", "2", "2", "2", "2", "2", "2", "2", "2", "-1"], ["-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "2", "2", "2", "2", "2", "2", "2", "2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "2", "2", "2", "2", "2", "2", "2", "2", "0"], ["-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "2", "2", "2", "2", "2", "2", "2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "2", "2", "2", "2", "2", "2", "2", "0"], ["-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "2", "2", "2", "2", "2", "2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "2", "2", "2", "2", "2", "2", "0"], ["-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "2", "2", "2", "2", "2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "2", "2", "2", "2", "2", "0"], ["-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "2", "2", "2", "2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "2", "2", "2", "2", "0"], ["-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "2", "2", "2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "2", "2", "2", "0"], ["-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "2", "2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "2", "2", "0"], ["-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "2", "0"], ["-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0"]], "Y": [["1", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "0", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "0", "0", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "0", "0", "0", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "0", "0", "0", "0", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "0", "0", "0", "0", "0", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "0", "0", "0", "0", "0", "0", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "0", "0", "0", "0", "0", "0", "0", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["2", "-1", "1", "-1", "1", "-1", "1", "-1", "1", "-1", "1", "-1", "1", "-1", "1", "-1", "1", "-1", "1", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "2", "-1", "1", "-1", "1", "-1", "1", "-1", "1", "-1", "1", "-1", "1", "-1", "1", "-1", "1", "-1", "1", "1"], ["3", "-2", "2", "-2", "2", "-2", "2", "-2", "2", "-2", "2", "-2", "2", "-2", "2", "-2", "2", "-2", "2", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "3", "-2", "2", "-2", "2", "-2", "2", "-2", "2", "-2", "2", "-2", "2", "-2", "2", "-2", "2", "-2", "2", "1"], ["1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0"], ["1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0"], ["1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0"], ["1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0"], ["1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0"], ["1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0"]], "stages": [{"units": [0, 1], "mask": [0, 1, 20, 21]}, {"units": [2, 3], "mask": [0, 1, 2, 20, 21, 22]}, {"units": [4, 5], "mask": [0, 1, 2, 3, 20, 21, 22, 23]}, {"units": [6, 7], "mask": [0, 1, 2, 3, 4, 20, 21, 22, 23, 24]}, {"units": [8, 9], "mask": [0, 1, 2, 3, 4, 5, 20, 21, 22, 23, 24, 25]}, {"units": [10, 11], "mask": [0, 1, 2, 3, 4, 5, 6, 20, 21, 22, 23, 24, 25, 26]}, {"units": [12, 13], "mask": [0, 1, 2, 3, 4, 5, 6, 7, 20, 21, 22, 23, 24, 25, 26, 27]}, {"units": [14, 15], "mask": [0, 1, 2, 3, 4, 5, 6, 7, 8, 20, 21, 22, 23, 24, 25, 26, 27, 28]}, {"units": [16, 17], "mask": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29]}, {"units": [24, 25], "mask": [0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 20, 30, 31, 32, 33, 34, 35, 36, 37, 38]}, {"units": [26, 27], "mask": [0, 11, 12, 13, 14, 15, 16, 17, 18, 20, 31, 32, 33, 34, 35, 36, 37, 38]}, {"units": [28, 29], "mask": [0, 12, 13, 14, 15, 16, 17, 18, 20, 32, 33, 34, 35, 36, 37, 38]}, {"units": [30, 31], "mask": [0, 13, 14, 15, 16, 17, 18, 20, 33, 34, 35, 36, 37, 38]}, {"units": [32, 33], "mask": [0, 14, 15, 16, 17, 18, 20, 34, 35, 36, 37, 38]}, {"units": [34, 35], "mask": [0, 15, 16, 17, 18, 20, 35, 36, 37, 38]}, {"units": [36, 37], "mask": [0, 16, 17, 18, 20, 36, 37, 38]}, {"units": [38, 39], "mask": [0, 17, 18, 20, 37, 38]}, {"units": [40, 41], "mask": [0, 18, 20, 38]}], "note": "t=0 direct sum of two chain roots, one stage variable each stage"} \ No newline at end of file diff --git a/research/p104-whitehead-native-objects/data/rootw1.json b/research/p104-whitehead-native-objects/data/rootw1.json new file mode 100644 index 0000000000..39d7ed2ab0 --- /dev/null +++ b/research/p104-whitehead-native-objects/data/rootw1.json @@ -0,0 +1 @@ +{"n": 38, "N": 40, "Y": [["1", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "-1", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "-1", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "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", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "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", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "1", "-1", "1", "0", "-1", "1", "-1", "0", "1", "-1", "1", "0", "-1", "1", "-1", "0", "1", "-1", "1", "1", "-1", "1", "0", "-1", "1", "-1", "0", "1", "-1", "1", "0", "-1", "1", "-1", "0", "1", "-1"], ["-1", "2", "-2", "2", "-1", "0", "1", "-2", "1", "0", "-1", "2", "-1", "0", "1", "-2", "1", "0", "-1", "2", "2", "-1", "0", "1", "-2", "1", "0", "-1", "2", "-1", "0", "1", "-2", "1", "0", "-1", "2", "-2"], ["-1", "1", "-2", "2", "-1", "0", "1", "-2", "1", "0", "-1", "2", "-1", "0", "1", "-2", "1", "0", "-1", "2", "2", "-1", "0", "1", "-2", "1", "0", "-1", "2", "-1", "0", "1", "-2", "1", "0", "-1", "2", "-2"], ["1", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0"], ["1", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0"], ["1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0"], ["1", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0"], ["1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0"], ["1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0"], ["1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1"]], "X": [["1", "0", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "-2", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "1/2", "-2", "-2", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "-2", "-2", "-2", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "1/2", "-2", "-2", "-2", "-1", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "-2", "-2", "-2", "-2", "-2", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "1/2", "-2", "-2", "-2", "-1", "-2", "-1", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "1/2", "-2", "-2", "-2", "-1", "-2", "-1", "-2", "-1", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "1/2", "-2", "-2", "-2", "-1", "-2", "-1", "-2", "-1", "-2", "-1", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "1/2", "-2", "-2", "-2", "-1", "-2", "-1", "-2", "-1", "-2", "-1", "-2", "-1", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "1/2", "-2", "-2", "-2", "-1", "-2", "-1", "-2", "-1", "-2", "-1", "-2", "-1", "-2", "-1", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "1/2", "-2", "-2", "-2", "-1", "-2", "-1", "-2", "-1", "-2", "-1", "-2", "-1", "-2", "-1", "-2", "-1", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "1/2", "-1", "-1", "-1", "0", "-1", "0", "-1", "0", "-1", "0", "-1", "0", "-1", "0", "-1", "0", "-1", "0", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1"], ["-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2"], ["-1", "-1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "2", "1", "2", "1", "2", "1", "2", "1", "2", "1", "2", "1", "2", "1", "2", "2", "2"], ["-1", "-1", "0", "0", "0", "-1", "0", "-1", "0", "-1", "0", "-1", "0", "-1", "0", "-1", "0", "-1", "0", "-1", "1", "2", "1", "2", "1", "2", "1", "2", "1", "2", "1", "2", "1", "2", "1", "2", "2", "2"], ["-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2"], ["-1", "-1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "1", "2", "1", "2", "1", "2", "1", "2", "1", "2", "1", "2", "1", "2", "2", "2"], ["-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2"], ["-1", "-1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "1", "2", "1", "2", "1", "2", "1", "2", "1", "2", "1", "2", "2", "2"], ["-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2"], ["-1", "-1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "1", "2", "1", "2", "1", "2", "1", "2", "1", "2", "2", "2"], ["-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2"], ["-1", "-1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "1", "2", "1", "2", "1", "2", "1", "2", "2", "2"], ["-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "2", "2", "2", "2", "2", "2", "2", "2", "2"], ["-1", "-1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "1", "2", "1", "2", "1", "2", "2", "2"], ["-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "2", "2", "2", "2", "2", "2", "2"], ["-1", "-1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "1", "2", "1", "2", "2", "2"], ["-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "2", "2", "2", "2", "2"], ["-1", "-1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "1", "2", "2", "2"], ["-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "2", "2", "2"], ["-1", "-1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "2", "2"], ["-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "2"], ["-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1"]], "stages": [{"units": [0, 1], "mask": [0, 2, 3], "letter": "W", "side": "l"}, {"units": [2, 3], "mask": [0, 1, 2, 3, 4, 5], "letter": "H", "side": "l"}, {"units": [4, 5], "mask": [0, 1, 2, 3, 4, 5, 6, 7], "letter": "H", "side": "l"}, {"units": [6, 7], "mask": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9], "letter": "H", "side": "l"}, {"units": [8, 9], "mask": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11], "letter": "H", "side": "l"}, {"units": [10, 11], "mask": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13], "letter": "H", "side": "l"}, {"units": [12, 13], "mask": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15], "letter": "H", "side": "l"}, {"units": [14, 15], "mask": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17], "letter": "H", "side": "l"}, {"units": [16, 17], "mask": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19], "letter": "H", "side": "l"}, {"units": [22, 23], "mask": [0, 1, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37], "letter": "M", "side": "r"}, {"units": [24, 25], "mask": [0, 1, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37], "letter": "M", "side": "r"}, {"units": [26, 27], "mask": [0, 1, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37], "letter": "M", "side": "r"}, {"units": [28, 29], "mask": [0, 1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37], "letter": "M", "side": "r"}, {"units": [30, 31], "mask": [0, 1, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37], "letter": "M", "side": "r"}, {"units": [32, 33], "mask": [0, 1, 30, 31, 32, 33, 34, 35, 36, 37], "letter": "M", "side": "r"}, {"units": [34, 35], "mask": [0, 1, 32, 33, 34, 35, 36, 37], "letter": "M", "side": "r"}, {"units": [36, 37], "mask": [0, 1, 34, 35, 36, 37], "letter": "M", "side": "r"}, {"units": [38, 39], "mask": [0, 36, 37], "letter": "W", "side": "r"}], "xi": [["1", "0"], ["1", "0"], ["1", "0"], ["1", "-1"], ["1", "0"], ["1", "-1"], ["1", "0"], ["1", "-1"], ["1", "0"], ["1", "-1"], ["1", "0"], ["1", "-1"], ["1", "0"], ["1", "-1"], ["1", "0"], ["1", "-1"], ["1", "0"], ["1", "-1"], ["1", "0"], ["1", "-1"], ["1", "0"], ["1", "-1"], ["1", "-1"], ["1", "0"], ["1", "-1"], ["1", "0"], ["1", "-1"], ["1", "0"], ["1", "-1"], ["1", "0"], ["1", "-1"], ["1", "0"], ["1", "-1"], ["1", "0"], ["1", "-1"], ["1", "0"], ["1", "-1"], ["1", "0"], ["1", "0"], ["1", "0"]], "eta": [["1", "0"], ["1", "0"], ["1", "1/2"], ["1", "0"], ["1", "1/2"], ["1", "0"], ["1", "1/2"], ["1", "0"], ["1", "1/2"], ["1", "0"], ["1", "1/2"], ["1", "0"], ["1", "1/2"], ["1", "0"], ["1", "1/2"], ["1", "0"], ["1", "1/2"], ["1", "0"], ["1", "1/2"], ["1", "0"], ["1", "1/2"], ["1", "0"], ["1", "0"], ["1", "1/2"], ["1", "0"], ["1", "1/2"], ["1", "0"], ["1", "1/2"], ["1", "0"], ["1", "1/2"], ["1", "0"], ["1", "1/2"], ["1", "0"], ["1", "1/2"], ["1", "0"], ["1", "1/2"], ["1", "0"], ["1", "1/2"], ["1", "0"], ["1", "0"]], "family": {"w": 1, "k": 9, "a": "1/2", "b": "-1", "thin": ["1", "-2", "1", "-2"]}} \ No newline at end of file diff --git a/research/p104-whitehead-native-objects/data/rootw1g.json b/research/p104-whitehead-native-objects/data/rootw1g.json new file mode 100644 index 0000000000..df631ad7c6 --- /dev/null +++ b/research/p104-whitehead-native-objects/data/rootw1g.json @@ -0,0 +1 @@ +{"n": 38, "N": 40, "Y": [["1", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1/2", "0", "0", "1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "-1", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "-1", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "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", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "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", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "1", "-1", "1", "0", "-1", "1", "-1", "0", "1", "-1", "1", "0", "-1", "1", "-1", "0", "1", "-1", "1", "1", "-1", "1", "0", "-1", "1", "-1", "0", "1", "-1", "1", "0", "-1", "1", "-1", "0", "1", "-1"], ["-1", "2", "-2", "2", "-1", "0", "1", "-2", "1", "0", "-1", "2", "-1", "0", "1", "-2", "1", "0", "-1", "2", "2", "-1", "0", "1", "-2", "1", "0", "-1", "2", "-1", "0", "1", "-2", "1", "0", "-1", "2", "-2"], ["-1", "1", "-2", "2", "-1", "0", "1", "-2", "1", "0", "-1", "2", "-1", "0", "1", "-2", "1", "0", "-1", "2", "2", "-1", "0", "1", "-2", "1", "0", "-1", "2", "-1", "0", "1", "-2", "1", "0", "-1", "2", "-2"], ["1", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1/2", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0"], ["1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1/2", "0", "0", "0", "0", "0", "0"], ["1", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0"], ["1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1/2", "0", "0", "0", "0"], ["1", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0"], ["1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1/2", "0", "0"], ["1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0"], ["1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1/2"]], "X": [["1", "0", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["2", "0", "-4", "-2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "1/2", "-2", "-2", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "-2", "-2", "-2", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "1/2", "-2", "-2", "-2", "-1", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "-2", "-2", "-2", "-2", "-2", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "1/2", "-2", "-2", "-2", "-1", "-2", "-1", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "1/2", "-2", "-2", "-2", "-1", "-2", "-1", "-2", "-1", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "1/2", "-2", "-2", "-2", "-1", "-2", "-1", "-2", "-1", "-2", "-1", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "1/2", "-2", "-2", "-2", "-1", "-2", "-1", "-2", "-1", "-2", "-1", "-2", "-1", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "1/2", "-2", "-2", "-2", "-1", "-2", "-1", "-2", "-1", "-2", "-1", "-2", "-1", "-2", "-1", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "1/2", "-2", "-2", "-2", "-1", "-2", "-1", "-2", "-1", "-2", "-1", "-2", "-1", "-2", "-1", "-2", "-1", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["1", "0", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-2", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"], ["0", "1/2", "-1", "-1", "-1", "0", "-1", "0", "-1", "0", "-1", "0", "-1", "0", "-1", "0", "-1", "0", "-1", "0", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1"], ["-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2"], ["-1", "-1/2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "2", "1", "2", "1", "2", "1", "2", "1", "2", "1", "2", "1", "2", "1", "2", "2", "2"], ["-1", "-1", "0", "0", "0", "-1", "0", "-1", "0", "-1", "0", "-1", "0", "-1", "0", "-1", "0", "-1", "0", "-1", "1", "2", "1", "2", "1", "2", "1", "2", "1", "2", "1", "2", "1", "2", "1", "2", "2", "2"], ["-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2"], ["-2", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "2", "2", "4", "2", "4", "2", "4", "2", "4", "2", "4", "2", "4", "2", "4", "4", "4"], ["-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2"], ["-2", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "2", "2", "4", "2", "4", "2", "4", "2", "4", "2", "4", "2", "4", "4", "4"], ["-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2"], ["-2", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "2", "2", "4", "2", "4", "2", "4", "2", "4", "2", "4", "4", "4"], ["-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2"], ["-2", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "2", "2", "4", "2", "4", "2", "4", "2", "4", "4", "4"], ["-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "2", "2", "2", "2", "2", "2", "2", "2", "2"], ["-2", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "2", "2", "4", "2", "4", "2", "4", "4", "4"], ["-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "2", "2", "2", "2", "2", "2", "2"], ["-2", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "2", "2", "4", "2", "4", "4", "4"], ["-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "2", "2", "2", "2", "2"], ["-2", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "2", "2", "4", "4", "4"], ["-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "2", "2", "2"], ["-2", "-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "2", "4", "4"], ["-1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "2"], ["-2", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "2"]], "stages": [{"units": [0, 1], "mask": [0, 2, 3], "letter": "W", "side": "l"}, {"units": [2, 3], "mask": [0, 1, 2, 3, 4, 5], "letter": "H", "side": "l"}, {"units": [4, 5], "mask": [0, 1, 2, 3, 4, 5, 6, 7], "letter": "H", "side": "l"}, {"units": [6, 7], "mask": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9], "letter": "H", "side": "l"}, {"units": [8, 9], "mask": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11], "letter": "H", "side": "l"}, {"units": [10, 11], "mask": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13], "letter": "H", "side": "l"}, {"units": [12, 13], "mask": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15], "letter": "H", "side": "l"}, {"units": [14, 15], "mask": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17], "letter": "H", "side": "l"}, {"units": [16, 17], "mask": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19], "letter": "H", "side": "l"}, {"units": [22, 23], "mask": [0, 1, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37], "letter": "M", "side": "r"}, {"units": [24, 25], "mask": [0, 1, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37], "letter": "M", "side": "r"}, {"units": [26, 27], "mask": [0, 1, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37], "letter": "M", "side": "r"}, {"units": [28, 29], "mask": [0, 1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37], "letter": "M", "side": "r"}, {"units": [30, 31], "mask": [0, 1, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37], "letter": "M", "side": "r"}, {"units": [32, 33], "mask": [0, 1, 30, 31, 32, 33, 34, 35, 36, 37], "letter": "M", "side": "r"}, {"units": [34, 35], "mask": [0, 1, 32, 33, 34, 35, 36, 37], "letter": "M", "side": "r"}, {"units": [36, 37], "mask": [0, 1, 34, 35, 36, 37], "letter": "M", "side": "r"}, {"units": [38, 39], "mask": [0, 36, 37], "letter": "W", "side": "r"}], "xi": [["1", "0"], ["1/2", "0"], ["1", "0"], ["1", "-1"], ["1", "0"], ["1", "-1"], ["1", "0"], ["1", "-1"], ["1", "0"], ["1", "-1"], ["1", "0"], ["1", "-1"], ["1", "0"], ["1", "-1"], ["1", "0"], ["1", "-1"], ["1", "0"], ["1", "-1"], ["1", "0"], ["1", "-1"], ["1", "0"], ["1", "-1"], ["1", "-1"], ["1/2", "0"], ["1", "-1"], ["1/2", "0"], ["1", "-1"], ["1/2", "0"], ["1", "-1"], ["1/2", "0"], ["1", "-1"], ["1/2", "0"], ["1", "-1"], ["1/2", "0"], ["1", "-1"], ["1/2", "0"], ["1", "-1"], ["1/2", "0"], ["1", "0"], ["1/2", "0"]], "eta": [["1", "0"], ["2", "0"], ["1", "1/2"], ["1", "0"], ["1", "1/2"], ["1", "0"], ["1", "1/2"], ["1", "0"], ["1", "1/2"], ["1", "0"], ["1", "1/2"], ["1", "0"], ["1", "1/2"], ["1", "0"], ["1", "1/2"], ["1", "0"], ["1", "1/2"], ["1", "0"], ["1", "1/2"], ["1", "0"], ["1", "1/2"], ["1", "0"], ["1", "0"], ["2", "1"], ["1", "0"], ["2", "1"], ["1", "0"], ["2", "1"], ["1", "0"], ["2", "1"], ["1", "0"], ["2", "1"], ["1", "0"], ["2", "1"], ["1", "0"], ["2", "1"], ["1", "0"], ["2", "1"], ["1", "0"], ["2", "0"]], "family": {"w": 1, "k": 9, "a": "1/2", "b": "-1", "thin": ["1", "-2", "1", "-2"]}} \ No newline at end of file diff --git a/research/p104-whitehead-native-objects/data/w.joint.invoice.json b/research/p104-whitehead-native-objects/data/w.joint.invoice.json new file mode 100644 index 0000000000..a36ecdb31e --- /dev/null +++ b/research/p104-whitehead-native-objects/data/w.joint.invoice.json @@ -0,0 +1 @@ +{"T": {"1": 408, "2": 306, "3": 792, "4": 3870, "5": 1224, "6": 738, "7": 252, "8": 1116, "9": 11000, "17": 416, "25": 416, "33": 416, "41": 416, "49": 416, "57": 416, "65": 416, "73": 416, "129": 8, "145": 200}, "P": {"1": 74586, "2": 15804, "3": 14058, "4": 3924, "5": 5472, "6": 270, "7": 216, "8": 796, "16": 416, "24": 416, "32": 416, "40": 416, "48": 416, "56": 416, "64": 416}} \ No newline at end of file diff --git a/research/p104-whitehead-native-objects/data/window_native.json.gz b/research/p104-whitehead-native-objects/data/window_native.json.gz new file mode 100644 index 0000000000..a607242f3e Binary files /dev/null and b/research/p104-whitehead-native-objects/data/window_native.json.gz differ