From 9cc0d4d60819ddd246c9db9549f8ae4a61b68e45 Mon Sep 17 00:00:00 2001 From: ywz65 <154373401+ywz65@users.noreply.github.com> Date: Thu, 15 Oct 2026 05:33:23 -0700 Subject: [PATCH] Research: realize the QQ16 L2 record with paid native frames --- .../PREDECESSORS.json | 29 + .../qq16-l2-native-reconstruction/README.md | 235 + .../qq16-l2-native-reconstruction/RESULT.json | 145 + .../SOURCES.json | 71 + .../qq16-l2-native-reconstruction/TASK.json | 103 + .../qq16-l2-native-reconstruction/VERIFY.json | 40 + .../qq16-l2-native-reconstruction/WORD.json | 8344 +++++++++++++++++ .../evidence/PR2468-PROOF.md | 139 + .../evidence/PR2468-verify.py | 316 + .../evidence/PR2470-README.md | 260 + .../native_support.py | 180 + .../test_verify.py | 111 + .../qq16-l2-native-reconstruction/verify.py | 275 + 13 files changed, 10248 insertions(+) create mode 100644 research/qq16-l2-native-reconstruction/PREDECESSORS.json create mode 100644 research/qq16-l2-native-reconstruction/README.md create mode 100644 research/qq16-l2-native-reconstruction/RESULT.json create mode 100644 research/qq16-l2-native-reconstruction/SOURCES.json create mode 100644 research/qq16-l2-native-reconstruction/TASK.json create mode 100644 research/qq16-l2-native-reconstruction/VERIFY.json create mode 100644 research/qq16-l2-native-reconstruction/WORD.json create mode 100644 research/qq16-l2-native-reconstruction/evidence/PR2468-PROOF.md create mode 100644 research/qq16-l2-native-reconstruction/evidence/PR2468-verify.py create mode 100644 research/qq16-l2-native-reconstruction/evidence/PR2470-README.md create mode 100644 research/qq16-l2-native-reconstruction/native_support.py create mode 100644 research/qq16-l2-native-reconstruction/test_verify.py create mode 100644 research/qq16-l2-native-reconstruction/verify.py diff --git a/research/qq16-l2-native-reconstruction/PREDECESSORS.json b/research/qq16-l2-native-reconstruction/PREDECESSORS.json new file mode 100644 index 0000000000..a2d93a3666 --- /dev/null +++ b/research/qq16-l2-native-reconstruction/PREDECESSORS.json @@ -0,0 +1,29 @@ +[ + { + "path": "research/qq16-l2-native-reconstruction/evidence/PR2470-README.md", + "usage": "input", + "sha256": "796636d4d9824bc4959b00d9d2cbbfafec07c14e6845a1e238fb668a2f3d8adf", + "git_blob": "83d2b42eed128a7a9e2151e47990ac8966b6d4f9", + "source_path": "research/qq16-cut-retention-census/README.md", + "source_commit": "1b2eee3bf1ec67e68c0b0fa7f47c7b2a66febe56", + "author": "thakrarsagar / PR2470" + }, + { + "path": "research/qq16-l2-native-reconstruction/evidence/PR2468-verify.py", + "usage": "input", + "sha256": "c6514274c5ebf2b4d8d5bc62583f08e65b2487d03cc02af048a2f721bb21dee7", + "git_blob": "58c9c9b31555ceeddf9d2a46606a878958cc054f", + "source_path": "research/qq16-future-x-query/verify.py", + "source_commit": "baa90ee8176931e697d91a9024114ee2e9a189ea", + "author": "ywz65 / PR2468" + }, + { + "path": "research/qq16-l2-native-reconstruction/evidence/PR2468-PROOF.md", + "usage": "input", + "sha256": "b6e53153b81d8a6d865d007145b7c7541e72723943b748362415c3c71e7869c7", + "git_blob": "95b98d8b2a4e6ac072c34c9afa5e2e0e9f402b2a", + "source_path": "research/qq16-future-x-query/PROOF.md", + "source_commit": "baa90ee8176931e697d91a9024114ee2e9a189ea", + "author": "ywz65 / PR2468" + } +] diff --git a/research/qq16-l2-native-reconstruction/README.md b/research/qq16-l2-native-reconstruction/README.md new file mode 100644 index 0000000000..f7729d0e6f --- /dev/null +++ b/research/qq16-l2-native-reconstruction/README.md @@ -0,0 +1,235 @@ +# A paid native reconstruction of QQ16's L2 old-cut record + +PR2470's L2 record can be reconstructed by an explicit local native word with +all 200 source arrays unchanged at its boundary. The word produces 96 owned +outputs in the old F0 completed-X frame. It costs 400 rank-one children, +96 rank-eight children, 208 full-cover maps and 6,624 real scalar primitives +under the retained QQ16 allowance. Its native rank mass is 1,168. + +The useful distinction is between the logical L2 identity and a legal native +read across two cuts. Directly applying the current-chart alignment fails: +it also moves the frame accumulated by B1. This construction explicitly removes +that frame on its owned sums before the selected correction. The verifier +rejects the cheap alignment on all 96 ordinary ports. + +This is one paid local reconstruction, not a complete 224-input decoder or a +storage saving. Its 96 output arrays are owned, allocated and charged as a +separate requirement. Delivery of the eight earlier T records is assumed. +Their capture, retention and retirement are not supplied here. The remainder +of the decoder, global hosting, physical movement costs, precision and supplier +invoice remain open. No new supplier or kappa is claimed. + +## Exact source and field contract + +Canonical main is `0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2`, priority revision 4. +The retained joint-query packet and selected-replay archive supply the actual +centre matrix R, port labels, native phases and all current-chart owner maps. +[SOURCES.json](SOURCES.json) pins canonical inputs; [PREDECESSORS.json](PREDECESSORS.json) +binds the retained pending proof/code bytes and their Git blobs. + +PR2470 (`1b2eee3bf1ec67e68c0b0fa7f47c7b2a66febe56`) supplies the L2 lead. +PR2468 (`baa90ee8176931e697d91a9024114ee2e9a189ea`) supplies the source +reconstruction, phase-polynomial and line-kernel methods adapted in +`native_support.py`. That predecessor implements a different query, B2 C, +using future chart 2. This package uses current chart 1 and adds the necessary +cross-cut frame removal. The adaptation is credited, not presented as a +second independent implementation of PR2468. + +Let L be axes 0..8, E1 axes 9..16, and U1=L+E1. At owner d write +`F_V = product_(v in the specified orthonormal axes of V) C_(d v)` and +`C_q = ((1+i)I+(1-i)T_q)/2`. The three input families are: + +| Inputs | Count | Native frame | Meaning | +| --- | ---: | --- | --- | +| X_p, p in U | 96 | F_U1 | live post-B1 X2_U | +| Y_p, p in U | 96 | F_U1 C_qp^-1 | live post-B1 Y2_U | +| T_t, t in T | 8 | F_L | retained post-F0 x1_T | + +All 200 arrays may vary independently in the local operator contract. Their +source content and frame are restored; X is read-only. No arbitrary dirty +helper is cleared. There are 96 exclusively owned output arrays Z_p whose +initial values are discarded, and one exclusively owned local scratch C, +cleared before and after each query at each owner. The scratch is not a +cover-wide bank. Other source/helper fields are untouched. + +The output, in frame F_L, is + +``` +Z_p = X_p + Y_p - sum_(t in T) (R_U^T R_T)[p,t]/4 D_1(p)^-1 D_1(t) T_t. +``` + +The logical route `D_1(p)` changes the owner by the actual involution rho1(p). +It is distinct from its physical translated native alignment. All route +products retain their order. Applied at the specified cuts, this gives x1_U: +the retained backward contract says `X2_U=x1_U-y1_U` and +`Y2_U=y1_U+K_(1,U) ell_(1,T) x1_T`. Their sum minus the correction is x1_U. +This algebraic identity is credited to the QQ16 contract and PR2470; the new +result is its paid native realization with exact restoration and scope. + +## Construction and proof + +For each port use the pinned map + +``` +A_p = M(rho1(p), delta_p), +M(g,a) f(d,z1,...,zlambda) = f(dg,z1+d a,...,zlambda+d a). +``` + +Its inverse is `(g^-1,g^-1 a)`, not merely `(g^-1,a)`. The retained bridge +identity at the old cut is + +``` +A_p [F_L C_qp^-1] = F_E1 D_1(p). +``` + +The bracket denotes the physical representation of logical data, so this +identity includes owner change, payload translation and the resulting native +phase. The verifier reconstructs every relevant actual rho/delta and checks +the entire Z/4 phase polynomial in all 73 character bits. Equality per tensor +layer extends to every number of layers; spectators remain unchanged. + +Execute the following literal sweeps, recorded in [WORD.json](WORD.json): + +1. Apply positive C_qp to each Y_p, so its frame matches X_p. Clear Z_p in + that common frame and add X_p and Y_p. Apply inverse C_qp to restore Y_p. + Now Z represents X+Y in F_U1 and both source families are restored. +2. Apply `F_E1^-1` to each owned Z_p. Since the axis factors commute, + `F_E1^-1 F_U1 = F_L`. The logical content is unchanged. No source is + subjected to this additional rank-eight child. +3. Apply inverse C_q followed by A_p to all Z_U and retained T_T fields. + Both families now have the common frame F_E1. Their logical rows are + `D_1(p)(X_p+Y_p)` and `D_1(t)T_t`. +4. Complete one private sweep. At each owner, for k=0..7, clear C, form + `C=sum_t R[k,t] D_1(t)T_t`, add `-R[k,p] C/4` to each nonzero U row, + and clear C. Every ADD has exactly the same native frame. Complete the + entire body at that owner before reusing C at another owner. +5. Undo each T and Z alignment with its actual inverse, then apply positive + C_q. T returns to its input frame and content; Z has the displayed ordered + operator in frame F_L. The private scratch returns to zero/identity. + +Every cover-map sweep finishes before the next sweep or scalar body begins. +The proof never reads a partially permuted bank. In step 4 only the owned +outputs change; retained T sources stay fixed throughout all eight queries. + +### Why the tempting cheap alignment fails + +Applying A_p directly to `F_U1 C_qp^-1` does not produce the old common +F_E1 frame. The current rho1 swaps the port's eight orthogonal chart vectors +with E1, so the *already accumulated* F_E1 factor moves back to a port-dependent +frame. PR2468's future chart 2 leaves E1 alone; that proof cannot be transferred +by simply changing its chart index. A complete phase comparison rejects the +shortcut for all 96 ports. Omitting stage removal from this word also fails +an actual scalar ADD phase check. This is a boundary of the attempted shortcut, +not a defect attributed to either predecessor. + +## Native lowering and local invoice + +For a nonzero q, an invertible binary wrapper P sending e0 to q gives +`C_q=P C_e0 P^-1`; the negative line uses `C_q^-1=T_q C_q`, with T_q fused +into the left wrapper. These are exactly one inherited positive rank-one child +and two monomial wrappers. The checker verifies both signs on all 512 basis +columns for each of the 104 distinct source/target port lines. + +Let P exchange axes 0..7 with 9..16 and fix every other axis. Then + +``` +F_E1^-1 = T_(e9+...+e16) P F_8 P^-1. +``` + +This uses one positive rank-eight child and two monomial wrappers. At another +owner the complete recipe is conjugated by that owner's coordinate embedding. +The formula holds on arbitrary arrays and spectators, and tensorizes over +layers. The exact Gaussian checker compares all 65,536 coefficients of its +256-by-256 active kernel against the product of eight inverse line kernels; +all have common denominator 256. The full 73-axis wrapper and its inverse are +also checked. This proves the local inherited child identity; it does not +place 96 new children in the global supplier schedule. + +| Operation | Count | +| --- | ---: | +| rank-one children: Y normalization/restoration | 192 | +| rank-one children: Z normalization/restoration | 192 | +| rank-one children: retained T normalization/restoration | 16 | +| rank-eight children: owned Z stage removal | 96 | +| native rank mass | 1,168 | +| native monomial wrapper maps | 992 | +| full-cover maps, both directions | 208 | +| unit ADD macros | 224 | +| quarter-coefficient ADD macros | 384 | +| CLEAR macros | 112 | +| real scalar primitive allowance | 6,624 | +| owned output arrays / local private scratch | 96 / 1 | + +The real scalar allowance is bound to `joint-query/verify_scalar.py`: +224 unit ADDs cost 8 each, 384 quarter ADDs cost 12 each, and 112 CLEARs cost 2 +each. The source function is hash-checked and evaluated in isolation. Counting +quarter ADDs like unit ADDs would understate this allowance by 1,536. +Native wrapper and cover-map counts are operations, not physical tape or +stream time. These counts are a constructive upper invoice, with no optimality +claim. Capture/retention of the earlier eight source records and subsequent +use/retirement of the 96 outputs are additional obligations. + +## Reproduce and validation + +Python 3.12, standard library only, from the repository root: + +``` +python3 -I -B research/qq16-l2-native-reconstruction/verify.py +python3 -I -O -B research/qq16-l2-native-reconstruction/test_verify.py +python3 scripts/research_package.py --package research/qq16-l2-native-reconstruction +``` + +Expected main marker: +`PASS_QQ16_L2_NATIVE_RECONSTRUCTION sources=200 outputs=96 rank_mass=1168 controls=9 no_new_kappa`. + +The default replay is read-only and compares the complete literal word and +receipt, not just a digest or operation counts. It checks 200 independent +source-array symbols with exact noncommuting owner products, all 96 output +rows and source restoration, full 73-bit native phase identities, 106,496 +rank-one basis columns and 65,536 rank-eight coefficients. The written operator +proof supplies the arbitrary-owner/array implication; the finite checks are +reported separately. Nine semantic controls reject missing Y normalization, +missing T restoration, missing or wrongly signed accumulated-stage removal, +missing or wrong inverse payload translation, uncleared output dirt, wrong +correction sign and a payload-only owner map. No proof assistant or selected +supplier cold replay is claimed. + +## Open next questions + +Can the complete immediate-cut decoder consume these outputs without storing +all 96 simultaneously? First specify the decoder's ordered reads, output +lifetimes and reconstruction schedule, then count capture, retention and +retirement. The present owned-output contract does not settle that question. + +Can a lower-cost native representation avoid 96 rank-eight stage removals? +First exhibit an exact common physical frame for the live sums and old T +records, including accumulated E1 and all owner translations. The rejected +direct current alignment cannot be used as that premise. No lower bound on +all possible native reconstructions is claimed. + +Can the full controller and supplier admit the new children and outputs? +Bind each child/output to actual owners, include physical maps, recursive +precision, all four bank repairs and the final retained boundary. Those +global contracts are absent here. + +## Credit and overlap + +Credit thakrarsagar / PR2470 for L2 and the retention census; starship-s / +PR2443 for the original cut decoder; Ali Romman / PR1969 for the complete +QQ16 maps, native word and bridge convention; ywz65 / PR2456 and PR2468 for +the operator audit and native read methods; and the retained selected geometry, +local-core and native interpretation lineage. Source notices remain in the +unchanged retained files. New work is Apache-2.0. + +Ross Richardson's active discussion 2424 claim at 12:06 UTC minimizes a different +part of the contract: 24 retained arrays and an information lower bound with +reads granted. This package neither minimizes the record nor proves that +decoder. Its narrow advance claim is +https://github.com/CrocSwap/integer-mult-bounds/pull/2470#issuecomment-6191762591. +The initial complete overlap refresh covered 677 open PRs and 1194 discussion +records; exact source pins, freshness and the task-card refinement are recorded +in TASK. No text search is a novelty guarantee. + +Prepared for **ywz65** with substantial OpenAI Codex assistance in derivation, +source review, implementation, verification and writing. Agent review is +distinct from independent human or maintainer acceptance. diff --git a/research/qq16-l2-native-reconstruction/RESULT.json b/research/qq16-l2-native-reconstruction/RESULT.json new file mode 100644 index 0000000000..d0a0c861a0 --- /dev/null +++ b/research/qq16-l2-native-reconstruction/RESULT.json @@ -0,0 +1,145 @@ +{ + "cheap_current_alignment_rejected_ports": 96, + "contract": "Z_U = X2_U + Y2_U - D1_U^-1 K_U R_T D1_T retained_x1_T; output frame F_L", + "controls": { + "omit_T_restoration": "borrowed source frame not restored: T21", + "omit_Y_normalization": "native ADD frame mismatch at 98", + "omit_accumulated_E1_removal": "native ADD frame mismatch at 790", + "omit_owned_output_clear": "ordered L2 operator or owned dirt mismatch", + "omit_payload_translation": "native ADD frame mismatch at 844", + "payload_only_owner_map": "native ADD frame mismatch at 844", + "use_positive_E1": "native ADD frame mismatch at 790", + "wrong_correction_sign": "ordered L2 operator or owned dirt mismatch", + "wrong_inverse_translation": "old-cut output frame" + }, + "invoice": { + "ADD_macros": 608, + "CLEAR_macros": 112, + "absolute_ADD_coefficients": { + "1": 224, + "1/4": 384 + }, + "borrowed_source_arrays_unchanged": 200, + "full_cover_maps": 208, + "literal_events": 1426, + "native_rank_mass": 1168, + "native_wrapper_maps": 992, + "owned_private_scratch_arrays_per_owner": 1, + "owned_reconstruction_output_arrays": 96, + "post_B1_X_sources_read_only": 96, + "rank_eight_children": 96, + "rank_one_children": 400, + "retained_F0_T_source_arrays": 8, + "scalar_real_primitive_allowance": 6624 + }, + "member_sha256": { + "slots/local/CANONICAL-WORD.json.gz": "16bc0ebb04b4be6c0ade74badc6a0c0cdba4215eda86e4ff9f13abf8ecebd219", + "slots/local/LOCAL-PROGRAMS.json.gz": "241fde27d4e43f5a9cb6b128f9f76c5131a53d09f0371676163f914d0b0fef3a", + "t16/global/base/work/complex-nine-native/DATA-PHASES.json": "c5916ff312678f12aba403847643fbbc29f643acec60bdf836fa56cd3e8251fa" + }, + "native_kernels": { + "rank_eight_denominator": 256, + "rank_eight_left_translation": 130560, + "rank_eight_matrix_coefficients": 65536, + "rank_eight_wrapper_columns": [ + 512, + 1024, + 2048, + 4096, + 8192, + 16384, + 32768, + 65536, + 256, + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 131072, + 262144, + 524288, + 1048576, + 2097152, + 4194304, + 8388608, + 16777216, + 33554432, + 67108864, + 134217728, + 268435456, + 536870912, + 1073741824, + 2147483648, + 4294967296, + 8589934592, + 17179869184, + 34359738368, + 68719476736, + 137438953472, + 274877906944, + 549755813888, + 1099511627776, + 2199023255552, + 4398046511104, + 8796093022208, + 17592186044416, + 35184372088832, + 70368744177664, + 140737488355328, + 281474976710656, + 562949953421312, + 1125899906842624, + 2251799813685248, + 4503599627370496, + 9007199254740992, + 18014398509481984, + 36028797018963968, + 72057594037927936, + 144115188075855872, + 288230376151711744, + 576460752303423488, + 1152921504606846976, + 2305843009213693952, + 4611686018427387904, + 9223372036854775808, + 18446744073709551616, + 36893488147419103232, + 73786976294838206464, + 147573952589676412928, + 295147905179352825856, + 590295810358705651712, + 1180591620717411303424, + 2361183241434822606848, + 4722366482869645213696 + ], + "rank_one_basis_columns": 106496 + }, + "operator_sha256": "a765ad2bfd4c9daa9aa8189ae930ecb2af7f56f6c77a97be5efde3635eeb2ce4", + "scope": "One local native reconstruction; retained source delivery, full decoder, physical cover cost, hosting and supplier saving remain open", + "source_sha256": { + "research/community-frontier1042-audit/selected-replay.tar.gz": "22c3f4dce4b897a1d423d1388801933e288b6a6b1906cb15e1b16a5eb68db754", + "research/joint-query/certificate.json.gz": "a5ed85fac5ebf3c091482a113ab0d351eb5a7892fe2841a35e16017ec1ff49f7", + "research/joint-query/evidence/BRIDGE-REVIEW.md": "d01b5f4959f7c91f835496d050dfae3eeab9dee2f581571c316a42571eaa1cd3", + "research/joint-query/evidence/CONSERVED-QQ16.md": "60f0de3a7205ba5046b5ae7ffa8bf2b1ea42ea46b498face0a77966b59e7f3fb", + "research/joint-query/evidence/QQ16-COVER-ACTION-ADDENDUM.md": "4bb4a68d8b4811b6d8364150612056bc124d38f1974d6f603dae68a99c4682fb", + "research/joint-query/verify_scalar.py": "33bdbad17a0531fe527aff306eb235d9c38c1629db4fd167b989725930b0327a", + "research/qq16-l2-native-reconstruction/evidence/PR2468-PROOF.md": "b6e53153b81d8a6d865d007145b7c7541e72723943b748362415c3c71e7869c7", + "research/qq16-l2-native-reconstruction/evidence/PR2468-verify.py": "c6514274c5ebf2b4d8d5bc62583f08e65b2487d03cc02af048a2f721bb21dee7", + "research/qq16-l2-native-reconstruction/evidence/PR2470-README.md": "796636d4d9824bc4959b00d9d2cbbfafec07c14e6845a1e238fb668a2f3d8adf" + }, + "source_variables": 200, + "status": "PASS_QQ16_L2_NATIVE_RECONSTRUCTION", + "trace": { + "add": 608, + "clear": 112, + "line": 400, + "map": 208, + "private_sweep_begin": 1, + "private_sweep_end": 1, + "remove_stage": 96 + } +} diff --git a/research/qq16-l2-native-reconstruction/SOURCES.json b/research/qq16-l2-native-reconstruction/SOURCES.json new file mode 100644 index 0000000000..de3f6f0981 --- /dev/null +++ b/research/qq16-l2-native-reconstruction/SOURCES.json @@ -0,0 +1,71 @@ +{ + "schema_version": 1, + "base_commit": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "ae6a99f28aa468649eb66a361e764d769363bf11", + "sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "e8870e5917057d59b730eb14721a778639eca050", + "sha256": "d46eb6d5b3e279428753d770653663fbdf1063e55c255ea073d768f344927ef7" + }, + { + "path": "research/community-frontier1042-audit/selected-replay.tar.gz", + "usage": "input", + "git_blob": "6f4dc6fe7631d8aacf8081fcaecf32197181685b", + "sha256": "22c3f4dce4b897a1d423d1388801933e288b6a6b1906cb15e1b16a5eb68db754" + }, + { + "path": "research/joint-query/certificate.json.gz", + "usage": "input", + "git_blob": "c6e876d8b48d768214deee265ade428f8983b566", + "sha256": "a5ed85fac5ebf3c091482a113ab0d351eb5a7892fe2841a35e16017ec1ff49f7" + }, + { + "path": "research/joint-query/evidence/BRIDGE-REVIEW.md", + "usage": "input", + "git_blob": "86139908c418235588045324f0873de6ac9f9707", + "sha256": "d01b5f4959f7c91f835496d050dfae3eeab9dee2f581571c316a42571eaa1cd3" + }, + { + "path": "research/joint-query/evidence/CONSERVED-QQ16.md", + "usage": "input", + "git_blob": "4639583c1be02c2fb60ed8a8072c9969ef1569ce", + "sha256": "60f0de3a7205ba5046b5ae7ffa8bf2b1ea42ea46b498face0a77966b59e7f3fb" + }, + { + "path": "research/joint-query/evidence/QQ16-COVER-ACTION-ADDENDUM.md", + "usage": "input", + "git_blob": "3dd1a990d7b9d57cfb20cf8e8dd45548f043a944", + "sha256": "4bb4a68d8b4811b6d8364150612056bc124d38f1974d6f603dae68a99c4682fb" + }, + { + "path": "research/joint-query/verify_scalar.py", + "usage": "input", + "git_blob": "7a7051fa8a70f48589fa1fccd5c38fccb5eacbf7", + "sha256": "33bdbad17a0531fe527aff306eb235d9c38c1629db4fd167b989725930b0327a" + } + ], + "pending_sources": [ + { + "path": "research/qq16-l2-native-reconstruction/evidence/PR2470-README.md", + "usage": "input", + "sha256": "796636d4d9824bc4959b00d9d2cbbfafec07c14e6845a1e238fb668a2f3d8adf" + }, + { + "path": "research/qq16-l2-native-reconstruction/evidence/PR2468-verify.py", + "usage": "input", + "sha256": "c6514274c5ebf2b4d8d5bc62583f08e65b2487d03cc02af048a2f721bb21dee7" + }, + { + "path": "research/qq16-l2-native-reconstruction/evidence/PR2468-PROOF.md", + "usage": "input", + "sha256": "b6e53153b81d8a6d865d007145b7c7541e72723943b748362415c3c71e7869c7" + } + ] +} diff --git a/research/qq16-l2-native-reconstruction/TASK.json b/research/qq16-l2-native-reconstruction/TASK.json new file mode 100644 index 0000000000..d29686e5ae --- /dev/null +++ b/research/qq16-l2-native-reconstruction/TASK.json @@ -0,0 +1,103 @@ +{ + "schema_version": 1, + "task_id": "joint-query-controller", + "priority_revision": 4, + "base_commit": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2", + "original_card": { + "id": "joint-query-controller", + "question": "Can one explicitly changed QQ16 interface recover the missing chart query and close a two-call controller within a favorable full budget?", + "starting_points": [ + "research/joint-query/README.md", + "research/joint-query/evidence/QQ16-SELECTED-WITNESS.md", + "research/joint-query/evidence/JOINT-QUERY-TRANSFER.md", + "docs/research/community-efficient1000-review.md" + ], + "methods": [ + "Add one explicitly priced ordinary-to-selected observation and derive the ordered two-call map and inverse.", + "Change the first local pair or retained state, then test the existing lost-observation witness and price all new operations." + ], + "acceptance_gate": "Name the changed premise of the fixed F0/B1 observation obstruction. Show exactly which query is recovered, legal native reads and restoration, and a full favorable budget including cover maps, helpers and endpoints. Local inverse identities alone do not close the global controller.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read the fixed-first-pair QQ16 witness before designing a controller. The checked #1969 local words do not evade that witness or supply global placement.", + "scope": "Source-bound orientation only. Read the named package and review before relying on its local evidence; this command is not its replay or supplier admission." + }, + "first_experiment": "Apply the existing witness to one proposed extra observation or changed first pair. If it still loses the required record, stop. Otherwise derive one ordered two-call identity and charge the added read, chart maps and restoration before extending to more stages.", + "bottleneck_link": "The native local words exist; retained query information and its physical access are the missing link to a composed recursive interface.", + "allowed_variations": [ + "One paid query, one changed first pair, or one precisely specified affine helper state.", + "A counterexample or lower bound for that exact proposed repair." + ], + "scope_change_triggers": [ + "Retaining the fixed first pair and ordinary schedule while allowing only homogeneous selected-only control, already excluded by the witness.", + "Treating cover-map counts as zero-cost physical address operations." + ], + "overlap_terms": [ + "QQ16", + "joint-query", + "changing-chart controller", + "selected observation", + "1969" + ] + }, + "scope_status": "changed", + "actual_scope": "One paid native L2 reconstruction at the immediate post-B1 cut, with exact source restoration and an explicit owned-output contract", + "scope_change_reason": "The third card in the recursive-interface draw led to PR2470's explicit native-read handoff. This closes only that local read/phase/restoration obligation, not the card's complete favorable controller budget. Active retention minimization, R439 routing and selected typed-echo scopes are excluded.", + "bottleneck_link": "The compressed L2 record uses current X/Y and an earlier T record; its logical sum cannot be used as a native scalar ADD until the actual accumulated frame, owner routes, cleanup and added children are paid.", + "budget_minutes": 60, + "stop_rule": "Stop after one exact source-bound local construction or falsification with controls; do not claim full decoder recovery, free storage, global admission or a kappa improvement.", + "outcome": "completed", + "evidence": "Exact ordered arbitrary-array proof, complete1426-event word,200 independent sources restored,96 owned outputs,73-bit phase polynomials,106496 rank-one basis columns,65536 rank-eight coefficients and9 semantic controls. Local invoice:400 rank1+96 rank8 children,208 cover maps,6624 source-priced scalar primitives. Export and source mutation checks are registered. Native CPython3.12.7 registered replay (normal primary, optimized five-test boundary/export suite) and3.14.5 optimized primary pass; baseline source bindings and git diff --check pass.", + "author": "ywz65, with substantial OpenAI Codex assistance", + "ai_assistance": "Substantial OpenAI Codex assistance in derivation, source review, implementation, verification and writing.", + "open_questions": [ + { + "question": "Can the full immediate-cut decoder consume the reconstructed outputs without storing all96?", + "why_it_matters": "The local construction does not establish net storage savings.", + "first_step": "Specify ordered decoder reads and output lifetimes, then count capture, retention and retirement.", + "blocked_by": "The complete native decoder and storage contract are not supplied." + }, + { + "question": "Can another common native frame reduce the96 stage-removal children?", + "why_it_matters": "The constructive rank invoice is large and is not an optimum.", + "first_step": "Exhibit exact phases for live sums and old T, including the accumulated E1 and all translations.", + "blocked_by": "The direct current-chart alignment fails on all96 ports." + }, + { + "question": "Can the new children and outputs be globally admitted?", + "why_it_matters": "Local maps are insufficient for a supplier or recursive cost claim.", + "first_step": "Bind each new child/output to owners, then price physical maps, precision and all four banks.", + "blocked_by": "Global ownership, physical map cost and controller closure remain open." + } + ], + "selection": { + "nonce": "c550078c4eedfec6a4ceb37fe01d08e4", + "track": "recursive-interfaces", + "card_order": [ + "centre-path-sharing", + "coverage-law-change", + "joint-query-controller" + ], + "reason": "Named recent handoff with a distinct native implementation gap" + }, + "freshness": { + "canonical_main": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2", + "priority_revision": 4, + "initial_overlap": "677 open PRs at2026-10-15T12:05:39Z and1194 discussion records at12:08:58Z; complete pagination/no warnings;1536 local records. Literal-term and active-L2 scope screening; not a novelty certificate.", + "final_overlap": "679 open PRs at2026-10-15T12:25:32.757452Z and1197 Discussion/comment/reply records at12:29:05.136311Z; complete pagination/no warnings. Main and both2470/2468 sourceheads rechecked unchanged. Ross Richardson's active record-minimization claim grants native reads and remains distinct.", + "final_main": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2" + }, + "claim_url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2470#issuecomment-6191762591", + "adjacent_active_scope": "Ross Richardson discussion2424#discussioncomment-18948536 minimizes the24 retained arrays with native reads granted; not duplicated here.", + "environment": { + "os": "Windows", + "python312": "3.12.7", + "python314": "3.14.5", + "temp": "writable workspace directory" + } +} diff --git a/research/qq16-l2-native-reconstruction/VERIFY.json b/research/qq16-l2-native-reconstruction/VERIFY.json new file mode 100644 index 0000000000..c2f4901370 --- /dev/null +++ b/research/qq16-l2-native-reconstruction/VERIFY.json @@ -0,0 +1,40 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/community-frontier1042-audit/selected-replay.tar.gz", + "research/joint-query/certificate.json.gz", + "research/joint-query/evidence/BRIDGE-REVIEW.md", + "research/joint-query/evidence/CONSERVED-QQ16.md", + "research/joint-query/evidence/QQ16-COVER-ACTION-ADDENDUM.md", + "research/joint-query/verify_scalar.py", + "research/qq16-l2-native-reconstruction/evidence/PR2470-README.md", + "research/qq16-l2-native-reconstruction/evidence/PR2468-verify.py", + "research/qq16-l2-native-reconstruction/evidence/PR2468-PROOF.md" + ], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Exact source-bound owner/phase word, all independent source rows, output and scratch cleanup, native line/rank8 kernels, source scalar invoice and9 semantic controls" + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/test_verify.py" + ], + "timeout_seconds": 180, + "checks": "Private cleanup and sweep ordering faults; Git-free read-only export, required whole-word/receipt checks, pinned scalar/proof mutations" + } + ] +} diff --git a/research/qq16-l2-native-reconstruction/WORD.json b/research/qq16-l2-native-reconstruction/WORD.json new file mode 100644 index 0000000000..7b329d4380 --- /dev/null +++ b/research/qq16-l2-native-reconstruction/WORD.json @@ -0,0 +1,8344 @@ +[ + { + "field": "Y1", + "op": "line", + "port": 1, + "sign": 1 + }, + { + "field": "Y2", + "op": "line", + "port": 2, + "sign": 1 + }, + { + "field": "Y3", + "op": "line", + "port": 3, + "sign": 1 + }, + { + "field": "Y4", + "op": "line", + "port": 4, + "sign": 1 + }, + { + "field": "Y5", + "op": "line", + "port": 5, + "sign": 1 + }, + { + "field": "Y6", + "op": "line", + "port": 6, + "sign": 1 + }, + { + "field": "Y8", + "op": "line", + "port": 8, + "sign": 1 + }, + { + "field": "Y9", + "op": "line", + "port": 9, + "sign": 1 + }, + { + "field": "Y10", + "op": "line", + "port": 10, + "sign": 1 + }, + { + "field": "Y11", + "op": "line", + "port": 11, + "sign": 1 + }, + { + "field": "Y12", + "op": "line", + "port": 12, + "sign": 1 + }, + { + "field": "Y13", + "op": "line", + "port": 13, + "sign": 1 + }, + { + "field": "Y14", + "op": "line", + "port": 14, + "sign": 1 + }, + { + "field": "Y15", + "op": "line", + "port": 15, + "sign": 1 + }, + { + "field": "Y16", + "op": "line", + "port": 16, + "sign": 1 + }, + { + "field": "Y17", + "op": "line", + "port": 17, + "sign": 1 + }, + { + "field": "Y18", + "op": "line", + "port": 18, + "sign": 1 + }, + { + "field": "Y19", + "op": "line", + "port": 19, + "sign": 1 + }, + { + "field": "Y22", + "op": "line", + "port": 22, + "sign": 1 + }, + { + "field": "Y23", + "op": "line", + "port": 23, + "sign": 1 + }, + { + "field": "Y24", + "op": "line", + "port": 24, + "sign": 1 + }, + { + "field": "Y25", + "op": "line", + "port": 25, + "sign": 1 + }, + { + "field": "Y26", + "op": "line", + "port": 26, + "sign": 1 + }, + { + "field": "Y28", + "op": "line", + "port": 28, + "sign": 1 + }, + { + "field": "Y29", + "op": "line", + "port": 29, + "sign": 1 + }, + { + "field": "Y30", + "op": "line", + "port": 30, + "sign": 1 + }, + { + "field": "Y31", + "op": "line", + "port": 31, + "sign": 1 + }, + { + "field": "Y32", + "op": "line", + "port": 32, + "sign": 1 + }, + { + "field": "Y33", + "op": "line", + "port": 33, + "sign": 1 + }, + { + "field": "Y34", + "op": "line", + "port": 34, + "sign": 1 + }, + { + "field": "Y35", + "op": "line", + "port": 35, + "sign": 1 + }, + { + "field": "Y38", + "op": "line", + "port": 38, + "sign": 1 + }, + { + "field": "Y39", + "op": "line", + "port": 39, + "sign": 1 + }, + { + "field": "Y40", + "op": "line", + "port": 40, + "sign": 1 + }, + { + "field": "Y41", + "op": "line", + "port": 41, + "sign": 1 + }, + { + "field": "Y42", + "op": "line", + "port": 42, + "sign": 1 + }, + { + "field": "Y43", + "op": "line", + "port": 43, + "sign": 1 + }, + { + "field": "Y44", + "op": "line", + "port": 44, + "sign": 1 + }, + { + "field": "Y45", + "op": "line", + "port": 45, + "sign": 1 + }, + { + "field": "Y48", + "op": "line", + "port": 48, + "sign": 1 + }, + { + "field": "Y49", + "op": "line", + "port": 49, + "sign": 1 + }, + { + "field": "Y50", + "op": "line", + "port": 50, + "sign": 1 + }, + { + "field": "Y51", + "op": "line", + "port": 51, + "sign": 1 + }, + { + "field": "Y52", + "op": "line", + "port": 52, + "sign": 1 + }, + { + "field": "Y53", + "op": "line", + "port": 53, + "sign": 1 + }, + { + "field": "Y54", + "op": "line", + "port": 54, + "sign": 1 + }, + { + "field": "Y55", + "op": "line", + "port": 55, + "sign": 1 + }, + { + "field": "Y56", + "op": "line", + "port": 56, + "sign": 1 + }, + { + "field": "Y58", + "op": "line", + "port": 58, + "sign": 1 + }, + { + "field": "Y59", + "op": "line", + "port": 59, + "sign": 1 + }, + { + "field": "Y60", + "op": "line", + "port": 60, + "sign": 1 + }, + { + "field": "Y61", + "op": "line", + "port": 61, + "sign": 1 + }, + { + "field": "Y62", + "op": "line", + "port": 62, + "sign": 1 + }, + { + "field": "Y63", + "op": "line", + "port": 63, + "sign": 1 + }, + { + "field": "Y64", + "op": "line", + "port": 64, + "sign": 1 + }, + { + "field": "Y65", + "op": "line", + "port": 65, + "sign": 1 + }, + { + "field": "Y66", + "op": "line", + "port": 66, + "sign": 1 + }, + { + "field": "Y67", + "op": "line", + "port": 67, + "sign": 1 + }, + { + "field": "Y68", + "op": "line", + "port": 68, + "sign": 1 + }, + { + "field": "Y69", + "op": "line", + "port": 69, + "sign": 1 + }, + { + "field": "Y70", + "op": "line", + "port": 70, + "sign": 1 + }, + { + "field": "Y71", + "op": "line", + "port": 71, + "sign": 1 + }, + { + "field": "Y72", + "op": "line", + "port": 72, + "sign": 1 + }, + { + "field": "Y73", + "op": "line", + "port": 73, + "sign": 1 + }, + { + "field": "Y74", + "op": "line", + "port": 74, + "sign": 1 + }, + { + "field": "Y75", + "op": "line", + "port": 75, + "sign": 1 + }, + { + "field": "Y77", + "op": "line", + "port": 77, + "sign": 1 + }, + { + "field": "Y78", + "op": "line", + "port": 78, + "sign": 1 + }, + { + "field": "Y79", + "op": "line", + "port": 79, + "sign": 1 + }, + { + "field": "Y80", + "op": "line", + "port": 80, + "sign": 1 + }, + { + "field": "Y82", + "op": "line", + "port": 82, + "sign": 1 + }, + { + "field": "Y83", + "op": "line", + "port": 83, + "sign": 1 + }, + { + "field": "Y84", + "op": "line", + "port": 84, + "sign": 1 + }, + { + "field": "Y85", + "op": "line", + "port": 85, + "sign": 1 + }, + { + "field": "Y86", + "op": "line", + "port": 86, + "sign": 1 + }, + { + "field": "Y88", + "op": "line", + "port": 88, + "sign": 1 + }, + { + "field": "Y89", + "op": "line", + "port": 89, + "sign": 1 + }, + { + "field": "Y90", + "op": "line", + "port": 90, + "sign": 1 + }, + { + "field": "Y91", + "op": "line", + "port": 91, + "sign": 1 + }, + { + "field": "Y93", + "op": "line", + "port": 93, + "sign": 1 + }, + { + "field": "Y94", + "op": "line", + "port": 94, + "sign": 1 + }, + { + "field": "Y95", + "op": "line", + "port": 95, + "sign": 1 + }, + { + "field": "Y96", + "op": "line", + "port": 96, + "sign": 1 + }, + { + "field": "Y97", + "op": "line", + "port": 97, + "sign": 1 + }, + { + "field": "Y98", + "op": "line", + "port": 98, + "sign": 1 + }, + { + "field": "Y99", + "op": "line", + "port": 99, + "sign": 1 + }, + { + "field": "Y100", + "op": "line", + "port": 100, + "sign": 1 + }, + { + "field": "Y101", + "op": "line", + "port": 101, + "sign": 1 + }, + { + "field": "Y102", + "op": "line", + "port": 102, + "sign": 1 + }, + { + "field": "Y103", + "op": "line", + "port": 103, + "sign": 1 + }, + { + "field": "Y104", + "op": "line", + "port": 104, + "sign": 1 + }, + { + "field": "Y105", + "op": "line", + "port": 105, + "sign": 1 + }, + { + "field": "Y106", + "op": "line", + "port": 106, + "sign": 1 + }, + { + "field": "Y107", + "op": "line", + "port": 107, + "sign": 1 + }, + { + "field": "Y108", + "op": "line", + "port": 108, + "sign": 1 + }, + { + "field": "Y109", + "op": "line", + "port": 109, + "sign": 1 + }, + { + "field": "Z1", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z1", + "op": "add", + "src": "X1" + }, + { + "coefficient": "1", + "dst": "Z1", + "op": "add", + "src": "Y1" + }, + { + "field": "Z2", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z2", + "op": "add", + "src": "X2" + }, + { + "coefficient": "1", + "dst": "Z2", + "op": "add", + "src": "Y2" + }, + { + "field": "Z3", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z3", + "op": "add", + "src": "X3" + }, + { + "coefficient": "1", + "dst": "Z3", + "op": "add", + "src": "Y3" + }, + { + "field": "Z4", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z4", + "op": "add", + "src": "X4" + }, + { + "coefficient": "1", + "dst": "Z4", + "op": "add", + "src": "Y4" + }, + { + "field": "Z5", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z5", + "op": "add", + "src": "X5" + }, + { + "coefficient": "1", + "dst": "Z5", + "op": "add", + "src": "Y5" + }, + { + "field": "Z6", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z6", + "op": "add", + "src": "X6" + }, + { + "coefficient": "1", + "dst": "Z6", + "op": "add", + "src": "Y6" + }, + { + "field": "Z8", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z8", + "op": "add", + "src": "X8" + }, + { + "coefficient": "1", + "dst": "Z8", + "op": "add", + "src": "Y8" + }, + { + "field": "Z9", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z9", + "op": "add", + "src": "X9" + }, + { + "coefficient": "1", + "dst": "Z9", + "op": "add", + "src": "Y9" + }, + { + "field": "Z10", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z10", + "op": "add", + "src": "X10" + }, + { + "coefficient": "1", + "dst": "Z10", + "op": "add", + "src": "Y10" + }, + { + "field": "Z11", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z11", + "op": "add", + "src": "X11" + }, + { + "coefficient": "1", + "dst": "Z11", + "op": "add", + "src": "Y11" + }, + { + "field": "Z12", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z12", + "op": "add", + "src": "X12" + }, + { + "coefficient": "1", + "dst": "Z12", + "op": "add", + "src": "Y12" + }, + { + "field": "Z13", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z13", + "op": "add", + "src": "X13" + }, + { + "coefficient": "1", + "dst": "Z13", + "op": "add", + "src": "Y13" + }, + { + "field": "Z14", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z14", + "op": "add", + "src": "X14" + }, + { + "coefficient": "1", + "dst": "Z14", + "op": "add", + "src": "Y14" + }, + { + "field": "Z15", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z15", + "op": "add", + "src": "X15" + }, + { + "coefficient": "1", + "dst": "Z15", + "op": "add", + "src": "Y15" + }, + { + "field": "Z16", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z16", + "op": "add", + "src": "X16" + }, + { + "coefficient": "1", + "dst": "Z16", + "op": "add", + "src": "Y16" + }, + { + "field": "Z17", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z17", + "op": "add", + "src": "X17" + }, + { + "coefficient": "1", + "dst": "Z17", + "op": "add", + "src": "Y17" + }, + { + "field": "Z18", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z18", + "op": "add", + "src": "X18" + }, + { + "coefficient": "1", + "dst": "Z18", + "op": "add", + "src": "Y18" + }, + { + "field": "Z19", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z19", + "op": "add", + "src": "X19" + }, + { + "coefficient": "1", + "dst": "Z19", + "op": "add", + "src": "Y19" + }, + { + "field": "Z22", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z22", + "op": "add", + "src": "X22" + }, + { + "coefficient": "1", + "dst": "Z22", + "op": "add", + "src": "Y22" + }, + { + "field": "Z23", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z23", + "op": "add", + "src": "X23" + }, + { + "coefficient": "1", + "dst": "Z23", + "op": "add", + "src": "Y23" + }, + { + "field": "Z24", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z24", + "op": "add", + "src": "X24" + }, + { + "coefficient": "1", + "dst": "Z24", + "op": "add", + "src": "Y24" + }, + { + "field": "Z25", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z25", + "op": "add", + "src": "X25" + }, + { + "coefficient": "1", + "dst": "Z25", + "op": "add", + "src": "Y25" + }, + { + "field": "Z26", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z26", + "op": "add", + "src": "X26" + }, + { + "coefficient": "1", + "dst": "Z26", + "op": "add", + "src": "Y26" + }, + { + "field": "Z28", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z28", + "op": "add", + "src": "X28" + }, + { + "coefficient": "1", + "dst": "Z28", + "op": "add", + "src": "Y28" + }, + { + "field": "Z29", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z29", + "op": "add", + "src": "X29" + }, + { + "coefficient": "1", + "dst": "Z29", + "op": "add", + "src": "Y29" + }, + { + "field": "Z30", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z30", + "op": "add", + "src": "X30" + }, + { + "coefficient": "1", + "dst": "Z30", + "op": "add", + "src": "Y30" + }, + { + "field": "Z31", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z31", + "op": "add", + "src": "X31" + }, + { + "coefficient": "1", + "dst": "Z31", + "op": "add", + "src": "Y31" + }, + { + "field": "Z32", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z32", + "op": "add", + "src": "X32" + }, + { + "coefficient": "1", + "dst": "Z32", + "op": "add", + "src": "Y32" + }, + { + "field": "Z33", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z33", + "op": "add", + "src": "X33" + }, + { + "coefficient": "1", + "dst": "Z33", + "op": "add", + "src": "Y33" + }, + { + "field": "Z34", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z34", + "op": "add", + "src": "X34" + }, + { + "coefficient": "1", + "dst": "Z34", + "op": "add", + "src": "Y34" + }, + { + "field": "Z35", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z35", + "op": "add", + "src": "X35" + }, + { + "coefficient": "1", + "dst": "Z35", + "op": "add", + "src": "Y35" + }, + { + "field": "Z38", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z38", + "op": "add", + "src": "X38" + }, + { + "coefficient": "1", + "dst": "Z38", + "op": "add", + "src": "Y38" + }, + { + "field": "Z39", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z39", + "op": "add", + "src": "X39" + }, + { + "coefficient": "1", + "dst": "Z39", + "op": "add", + "src": "Y39" + }, + { + "field": "Z40", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z40", + "op": "add", + "src": "X40" + }, + { + "coefficient": "1", + "dst": "Z40", + "op": "add", + "src": "Y40" + }, + { + "field": "Z41", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z41", + "op": "add", + "src": "X41" + }, + { + "coefficient": "1", + "dst": "Z41", + "op": "add", + "src": "Y41" + }, + { + "field": "Z42", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z42", + "op": "add", + "src": "X42" + }, + { + "coefficient": "1", + "dst": "Z42", + "op": "add", + "src": "Y42" + }, + { + "field": "Z43", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z43", + "op": "add", + "src": "X43" + }, + { + "coefficient": "1", + "dst": "Z43", + "op": "add", + "src": "Y43" + }, + { + "field": "Z44", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z44", + "op": "add", + "src": "X44" + }, + { + "coefficient": "1", + "dst": "Z44", + "op": "add", + "src": "Y44" + }, + { + "field": "Z45", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z45", + "op": "add", + "src": "X45" + }, + { + "coefficient": "1", + "dst": "Z45", + "op": "add", + "src": "Y45" + }, + { + "field": "Z48", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z48", + "op": "add", + "src": "X48" + }, + { + "coefficient": "1", + "dst": "Z48", + "op": "add", + "src": "Y48" + }, + { + "field": "Z49", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z49", + "op": "add", + "src": "X49" + }, + { + "coefficient": "1", + "dst": "Z49", + "op": "add", + "src": "Y49" + }, + { + "field": "Z50", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z50", + "op": "add", + "src": "X50" + }, + { + "coefficient": "1", + "dst": "Z50", + "op": "add", + "src": "Y50" + }, + { + "field": "Z51", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z51", + "op": "add", + "src": "X51" + }, + { + "coefficient": "1", + "dst": "Z51", + "op": "add", + "src": "Y51" + }, + { + "field": "Z52", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z52", + "op": "add", + "src": "X52" + }, + { + "coefficient": "1", + "dst": "Z52", + "op": "add", + "src": "Y52" + }, + { + "field": "Z53", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z53", + "op": "add", + "src": "X53" + }, + { + "coefficient": "1", + "dst": "Z53", + "op": "add", + "src": "Y53" + }, + { + "field": "Z54", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z54", + "op": "add", + "src": "X54" + }, + { + "coefficient": "1", + "dst": "Z54", + "op": "add", + "src": "Y54" + }, + { + "field": "Z55", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z55", + "op": "add", + "src": "X55" + }, + { + "coefficient": "1", + "dst": "Z55", + "op": "add", + "src": "Y55" + }, + { + "field": "Z56", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z56", + "op": "add", + "src": "X56" + }, + { + "coefficient": "1", + "dst": "Z56", + "op": "add", + "src": "Y56" + }, + { + "field": "Z58", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z58", + "op": "add", + "src": "X58" + }, + { + "coefficient": "1", + "dst": "Z58", + "op": "add", + "src": "Y58" + }, + { + "field": "Z59", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z59", + "op": "add", + "src": "X59" + }, + { + "coefficient": "1", + "dst": "Z59", + "op": "add", + "src": "Y59" + }, + { + "field": "Z60", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z60", + "op": "add", + "src": "X60" + }, + { + "coefficient": "1", + "dst": "Z60", + "op": "add", + "src": "Y60" + }, + { + "field": "Z61", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z61", + "op": "add", + "src": "X61" + }, + { + "coefficient": "1", + "dst": "Z61", + "op": "add", + "src": "Y61" + }, + { + "field": "Z62", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z62", + "op": "add", + "src": "X62" + }, + { + "coefficient": "1", + "dst": "Z62", + "op": "add", + "src": "Y62" + }, + { + "field": "Z63", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z63", + "op": "add", + "src": "X63" + }, + { + "coefficient": "1", + "dst": "Z63", + "op": "add", + "src": "Y63" + }, + { + "field": "Z64", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z64", + "op": "add", + "src": "X64" + }, + { + "coefficient": "1", + "dst": "Z64", + "op": "add", + "src": "Y64" + }, + { + "field": "Z65", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z65", + "op": "add", + "src": "X65" + }, + { + "coefficient": "1", + "dst": "Z65", + "op": "add", + "src": "Y65" + }, + { + "field": "Z66", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z66", + "op": "add", + "src": "X66" + }, + { + "coefficient": "1", + "dst": "Z66", + "op": "add", + "src": "Y66" + }, + { + "field": "Z67", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z67", + "op": "add", + "src": "X67" + }, + { + "coefficient": "1", + "dst": "Z67", + "op": "add", + "src": "Y67" + }, + { + "field": "Z68", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z68", + "op": "add", + "src": "X68" + }, + { + "coefficient": "1", + "dst": "Z68", + "op": "add", + "src": "Y68" + }, + { + "field": "Z69", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z69", + "op": "add", + "src": "X69" + }, + { + "coefficient": "1", + "dst": "Z69", + "op": "add", + "src": "Y69" + }, + { + "field": "Z70", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z70", + "op": "add", + "src": "X70" + }, + { + "coefficient": "1", + "dst": "Z70", + "op": "add", + "src": "Y70" + }, + { + "field": "Z71", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z71", + "op": "add", + "src": "X71" + }, + { + "coefficient": "1", + "dst": "Z71", + "op": "add", + "src": "Y71" + }, + { + "field": "Z72", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z72", + "op": "add", + "src": "X72" + }, + { + "coefficient": "1", + "dst": "Z72", + "op": "add", + "src": "Y72" + }, + { + "field": "Z73", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z73", + "op": "add", + "src": "X73" + }, + { + "coefficient": "1", + "dst": "Z73", + "op": "add", + "src": "Y73" + }, + { + "field": "Z74", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z74", + "op": "add", + "src": "X74" + }, + { + "coefficient": "1", + "dst": "Z74", + "op": "add", + "src": "Y74" + }, + { + "field": "Z75", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z75", + "op": "add", + "src": "X75" + }, + { + "coefficient": "1", + "dst": "Z75", + "op": "add", + "src": "Y75" + }, + { + "field": "Z77", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z77", + "op": "add", + "src": "X77" + }, + { + "coefficient": "1", + "dst": "Z77", + "op": "add", + "src": "Y77" + }, + { + "field": "Z78", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z78", + "op": "add", + "src": "X78" + }, + { + "coefficient": "1", + "dst": "Z78", + "op": "add", + "src": "Y78" + }, + { + "field": "Z79", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z79", + "op": "add", + "src": "X79" + }, + { + "coefficient": "1", + "dst": "Z79", + "op": "add", + "src": "Y79" + }, + { + "field": "Z80", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z80", + "op": "add", + "src": "X80" + }, + { + "coefficient": "1", + "dst": "Z80", + "op": "add", + "src": "Y80" + }, + { + "field": "Z82", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z82", + "op": "add", + "src": "X82" + }, + { + "coefficient": "1", + "dst": "Z82", + "op": "add", + "src": "Y82" + }, + { + "field": "Z83", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z83", + "op": "add", + "src": "X83" + }, + { + "coefficient": "1", + "dst": "Z83", + "op": "add", + "src": "Y83" + }, + { + "field": "Z84", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z84", + "op": "add", + "src": "X84" + }, + { + "coefficient": "1", + "dst": "Z84", + "op": "add", + "src": "Y84" + }, + { + "field": "Z85", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z85", + "op": "add", + "src": "X85" + }, + { + "coefficient": "1", + "dst": "Z85", + "op": "add", + "src": "Y85" + }, + { + "field": "Z86", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z86", + "op": "add", + "src": "X86" + }, + { + "coefficient": "1", + "dst": "Z86", + "op": "add", + "src": "Y86" + }, + { + "field": "Z88", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z88", + "op": "add", + "src": "X88" + }, + { + "coefficient": "1", + "dst": "Z88", + "op": "add", + "src": "Y88" + }, + { + "field": "Z89", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z89", + "op": "add", + "src": "X89" + }, + { + "coefficient": "1", + "dst": "Z89", + "op": "add", + "src": "Y89" + }, + { + "field": "Z90", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z90", + "op": "add", + "src": "X90" + }, + { + "coefficient": "1", + "dst": "Z90", + "op": "add", + "src": "Y90" + }, + { + "field": "Z91", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z91", + "op": "add", + "src": "X91" + }, + { + "coefficient": "1", + "dst": "Z91", + "op": "add", + "src": "Y91" + }, + { + "field": "Z93", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z93", + "op": "add", + "src": "X93" + }, + { + "coefficient": "1", + "dst": "Z93", + "op": "add", + "src": "Y93" + }, + { + "field": "Z94", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z94", + "op": "add", + "src": "X94" + }, + { + "coefficient": "1", + "dst": "Z94", + "op": "add", + "src": "Y94" + }, + { + "field": "Z95", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z95", + "op": "add", + "src": "X95" + }, + { + "coefficient": "1", + "dst": "Z95", + "op": "add", + "src": "Y95" + }, + { + "field": "Z96", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z96", + "op": "add", + "src": "X96" + }, + { + "coefficient": "1", + "dst": "Z96", + "op": "add", + "src": "Y96" + }, + { + "field": "Z97", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z97", + "op": "add", + "src": "X97" + }, + { + "coefficient": "1", + "dst": "Z97", + "op": "add", + "src": "Y97" + }, + { + "field": "Z98", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z98", + "op": "add", + "src": "X98" + }, + { + "coefficient": "1", + "dst": "Z98", + "op": "add", + "src": "Y98" + }, + { + "field": "Z99", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z99", + "op": "add", + "src": "X99" + }, + { + "coefficient": "1", + "dst": "Z99", + "op": "add", + "src": "Y99" + }, + { + "field": "Z100", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z100", + "op": "add", + "src": "X100" + }, + { + "coefficient": "1", + "dst": "Z100", + "op": "add", + "src": "Y100" + }, + { + "field": "Z101", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z101", + "op": "add", + "src": "X101" + }, + { + "coefficient": "1", + "dst": "Z101", + "op": "add", + "src": "Y101" + }, + { + "field": "Z102", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z102", + "op": "add", + "src": "X102" + }, + { + "coefficient": "1", + "dst": "Z102", + "op": "add", + "src": "Y102" + }, + { + "field": "Z103", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z103", + "op": "add", + "src": "X103" + }, + { + "coefficient": "1", + "dst": "Z103", + "op": "add", + "src": "Y103" + }, + { + "field": "Z104", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z104", + "op": "add", + "src": "X104" + }, + { + "coefficient": "1", + "dst": "Z104", + "op": "add", + "src": "Y104" + }, + { + "field": "Z105", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z105", + "op": "add", + "src": "X105" + }, + { + "coefficient": "1", + "dst": "Z105", + "op": "add", + "src": "Y105" + }, + { + "field": "Z106", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z106", + "op": "add", + "src": "X106" + }, + { + "coefficient": "1", + "dst": "Z106", + "op": "add", + "src": "Y106" + }, + { + "field": "Z107", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z107", + "op": "add", + "src": "X107" + }, + { + "coefficient": "1", + "dst": "Z107", + "op": "add", + "src": "Y107" + }, + { + "field": "Z108", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z108", + "op": "add", + "src": "X108" + }, + { + "coefficient": "1", + "dst": "Z108", + "op": "add", + "src": "Y108" + }, + { + "field": "Z109", + "frame": "current", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "Z109", + "op": "add", + "src": "X109" + }, + { + "coefficient": "1", + "dst": "Z109", + "op": "add", + "src": "Y109" + }, + { + "field": "Y1", + "op": "line", + "port": 1, + "sign": -1 + }, + { + "field": "Y2", + "op": "line", + "port": 2, + "sign": -1 + }, + { + "field": "Y3", + "op": "line", + "port": 3, + "sign": -1 + }, + { + "field": "Y4", + "op": "line", + "port": 4, + "sign": -1 + }, + { + "field": "Y5", + "op": "line", + "port": 5, + "sign": -1 + }, + { + "field": "Y6", + "op": "line", + "port": 6, + "sign": -1 + }, + { + "field": "Y8", + "op": "line", + "port": 8, + "sign": -1 + }, + { + "field": "Y9", + "op": "line", + "port": 9, + "sign": -1 + }, + { + "field": "Y10", + "op": "line", + "port": 10, + "sign": -1 + }, + { + "field": "Y11", + "op": "line", + "port": 11, + "sign": -1 + }, + { + "field": "Y12", + "op": "line", + "port": 12, + "sign": -1 + }, + { + "field": "Y13", + "op": "line", + "port": 13, + "sign": -1 + }, + { + "field": "Y14", + "op": "line", + "port": 14, + "sign": -1 + }, + { + "field": "Y15", + "op": "line", + "port": 15, + "sign": -1 + }, + { + "field": "Y16", + "op": "line", + "port": 16, + "sign": -1 + }, + { + "field": "Y17", + "op": "line", + "port": 17, + "sign": -1 + }, + { + "field": "Y18", + "op": "line", + "port": 18, + "sign": -1 + }, + { + "field": "Y19", + "op": "line", + "port": 19, + "sign": -1 + }, + { + "field": "Y22", + "op": "line", + "port": 22, + "sign": -1 + }, + { + "field": "Y23", + "op": "line", + "port": 23, + "sign": -1 + }, + { + "field": "Y24", + "op": "line", + "port": 24, + "sign": -1 + }, + { + "field": "Y25", + "op": "line", + "port": 25, + "sign": -1 + }, + { + "field": "Y26", + "op": "line", + "port": 26, + "sign": -1 + }, + { + "field": "Y28", + "op": "line", + "port": 28, + "sign": -1 + }, + { + "field": "Y29", + "op": "line", + "port": 29, + "sign": -1 + }, + { + "field": "Y30", + "op": "line", + "port": 30, + "sign": -1 + }, + { + "field": "Y31", + "op": "line", + "port": 31, + "sign": -1 + }, + { + "field": "Y32", + "op": "line", + "port": 32, + "sign": -1 + }, + { + "field": "Y33", + "op": "line", + "port": 33, + "sign": -1 + }, + { + "field": "Y34", + "op": "line", + "port": 34, + "sign": -1 + }, + { + "field": "Y35", + "op": "line", + "port": 35, + "sign": -1 + }, + { + "field": "Y38", + "op": "line", + "port": 38, + "sign": -1 + }, + { + "field": "Y39", + "op": "line", + "port": 39, + "sign": -1 + }, + { + "field": "Y40", + "op": "line", + "port": 40, + "sign": -1 + }, + { + "field": "Y41", + "op": "line", + "port": 41, + "sign": -1 + }, + { + "field": "Y42", + "op": "line", + "port": 42, + "sign": -1 + }, + { + "field": "Y43", + "op": "line", + "port": 43, + "sign": -1 + }, + { + "field": "Y44", + "op": "line", + "port": 44, + "sign": -1 + }, + { + "field": "Y45", + "op": "line", + "port": 45, + "sign": -1 + }, + { + "field": "Y48", + "op": "line", + "port": 48, + "sign": -1 + }, + { + "field": "Y49", + "op": "line", + "port": 49, + "sign": -1 + }, + { + "field": "Y50", + "op": "line", + "port": 50, + "sign": -1 + }, + { + "field": "Y51", + "op": "line", + "port": 51, + "sign": -1 + }, + { + "field": "Y52", + "op": "line", + "port": 52, + "sign": -1 + }, + { + "field": "Y53", + "op": "line", + "port": 53, + "sign": -1 + }, + { + "field": "Y54", + "op": "line", + "port": 54, + "sign": -1 + }, + { + "field": "Y55", + "op": "line", + "port": 55, + "sign": -1 + }, + { + "field": "Y56", + "op": "line", + "port": 56, + "sign": -1 + }, + { + "field": "Y58", + "op": "line", + "port": 58, + "sign": -1 + }, + { + "field": "Y59", + "op": "line", + "port": 59, + "sign": -1 + }, + { + "field": "Y60", + "op": "line", + "port": 60, + "sign": -1 + }, + { + "field": "Y61", + "op": "line", + "port": 61, + "sign": -1 + }, + { + "field": "Y62", + "op": "line", + "port": 62, + "sign": -1 + }, + { + "field": "Y63", + "op": "line", + "port": 63, + "sign": -1 + }, + { + "field": "Y64", + "op": "line", + "port": 64, + "sign": -1 + }, + { + "field": "Y65", + "op": "line", + "port": 65, + "sign": -1 + }, + { + "field": "Y66", + "op": "line", + "port": 66, + "sign": -1 + }, + { + "field": "Y67", + "op": "line", + "port": 67, + "sign": -1 + }, + { + "field": "Y68", + "op": "line", + "port": 68, + "sign": -1 + }, + { + "field": "Y69", + "op": "line", + "port": 69, + "sign": -1 + }, + { + "field": "Y70", + "op": "line", + "port": 70, + "sign": -1 + }, + { + "field": "Y71", + "op": "line", + "port": 71, + "sign": -1 + }, + { + "field": "Y72", + "op": "line", + "port": 72, + "sign": -1 + }, + { + "field": "Y73", + "op": "line", + "port": 73, + "sign": -1 + }, + { + "field": "Y74", + "op": "line", + "port": 74, + "sign": -1 + }, + { + "field": "Y75", + "op": "line", + "port": 75, + "sign": -1 + }, + { + "field": "Y77", + "op": "line", + "port": 77, + "sign": -1 + }, + { + "field": "Y78", + "op": "line", + "port": 78, + "sign": -1 + }, + { + "field": "Y79", + "op": "line", + "port": 79, + "sign": -1 + }, + { + "field": "Y80", + "op": "line", + "port": 80, + "sign": -1 + }, + { + "field": "Y82", + "op": "line", + "port": 82, + "sign": -1 + }, + { + "field": "Y83", + "op": "line", + "port": 83, + "sign": -1 + }, + { + "field": "Y84", + "op": "line", + "port": 84, + "sign": -1 + }, + { + "field": "Y85", + "op": "line", + "port": 85, + "sign": -1 + }, + { + "field": "Y86", + "op": "line", + "port": 86, + "sign": -1 + }, + { + "field": "Y88", + "op": "line", + "port": 88, + "sign": -1 + }, + { + "field": "Y89", + "op": "line", + "port": 89, + "sign": -1 + }, + { + "field": "Y90", + "op": "line", + "port": 90, + "sign": -1 + }, + { + "field": "Y91", + "op": "line", + "port": 91, + "sign": -1 + }, + { + "field": "Y93", + "op": "line", + "port": 93, + "sign": -1 + }, + { + "field": "Y94", + "op": "line", + "port": 94, + "sign": -1 + }, + { + "field": "Y95", + "op": "line", + "port": 95, + "sign": -1 + }, + { + "field": "Y96", + "op": "line", + "port": 96, + "sign": -1 + }, + { + "field": "Y97", + "op": "line", + "port": 97, + "sign": -1 + }, + { + "field": "Y98", + "op": "line", + "port": 98, + "sign": -1 + }, + { + "field": "Y99", + "op": "line", + "port": 99, + "sign": -1 + }, + { + "field": "Y100", + "op": "line", + "port": 100, + "sign": -1 + }, + { + "field": "Y101", + "op": "line", + "port": 101, + "sign": -1 + }, + { + "field": "Y102", + "op": "line", + "port": 102, + "sign": -1 + }, + { + "field": "Y103", + "op": "line", + "port": 103, + "sign": -1 + }, + { + "field": "Y104", + "op": "line", + "port": 104, + "sign": -1 + }, + { + "field": "Y105", + "op": "line", + "port": 105, + "sign": -1 + }, + { + "field": "Y106", + "op": "line", + "port": 106, + "sign": -1 + }, + { + "field": "Y107", + "op": "line", + "port": 107, + "sign": -1 + }, + { + "field": "Y108", + "op": "line", + "port": 108, + "sign": -1 + }, + { + "field": "Y109", + "op": "line", + "port": 109, + "sign": -1 + }, + { + "field": "Z1", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z2", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z3", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z4", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z5", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z6", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z8", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z9", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z10", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z11", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z12", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z13", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z14", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z15", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z16", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z17", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z18", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z19", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z22", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z23", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z24", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z25", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z26", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z28", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z29", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z30", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z31", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z32", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z33", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z34", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z35", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z38", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z39", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z40", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z41", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z42", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z43", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z44", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z45", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z48", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z49", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z50", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z51", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z52", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z53", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z54", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z55", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z56", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z58", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z59", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z60", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z61", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z62", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z63", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z64", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z65", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z66", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z67", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z68", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z69", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z70", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z71", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z72", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z73", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z74", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z75", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z77", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z78", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z79", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z80", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z82", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z83", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z84", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z85", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z86", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z88", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z89", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z90", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z91", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z93", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z94", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z95", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z96", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z97", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z98", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z99", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z100", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z101", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z102", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z103", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z104", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z105", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z106", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z107", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z108", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z109", + "op": "remove_stage", + "rank": 8 + }, + { + "field": "Z1", + "op": "line", + "port": 1, + "sign": -1 + }, + { + "field": "Z2", + "op": "line", + "port": 2, + "sign": -1 + }, + { + "field": "Z3", + "op": "line", + "port": 3, + "sign": -1 + }, + { + "field": "Z4", + "op": "line", + "port": 4, + "sign": -1 + }, + { + "field": "Z5", + "op": "line", + "port": 5, + "sign": -1 + }, + { + "field": "Z6", + "op": "line", + "port": 6, + "sign": -1 + }, + { + "field": "Z8", + "op": "line", + "port": 8, + "sign": -1 + }, + { + "field": "Z9", + "op": "line", + "port": 9, + "sign": -1 + }, + { + "field": "Z10", + "op": "line", + "port": 10, + "sign": -1 + }, + { + "field": "Z11", + "op": "line", + "port": 11, + "sign": -1 + }, + { + "field": "Z12", + "op": "line", + "port": 12, + "sign": -1 + }, + { + "field": "Z13", + "op": "line", + "port": 13, + "sign": -1 + }, + { + "field": "Z14", + "op": "line", + "port": 14, + "sign": -1 + }, + { + "field": "Z15", + "op": "line", + "port": 15, + "sign": -1 + }, + { + "field": "Z16", + "op": "line", + "port": 16, + "sign": -1 + }, + { + "field": "Z17", + "op": "line", + "port": 17, + "sign": -1 + }, + { + "field": "Z18", + "op": "line", + "port": 18, + "sign": -1 + }, + { + "field": "Z19", + "op": "line", + "port": 19, + "sign": -1 + }, + { + "field": "Z22", + "op": "line", + "port": 22, + "sign": -1 + }, + { + "field": "Z23", + "op": "line", + "port": 23, + "sign": -1 + }, + { + "field": "Z24", + "op": "line", + "port": 24, + "sign": -1 + }, + { + "field": "Z25", + "op": "line", + "port": 25, + "sign": -1 + }, + { + "field": "Z26", + "op": "line", + "port": 26, + "sign": -1 + }, + { + "field": "Z28", + "op": "line", + "port": 28, + "sign": -1 + }, + { + "field": "Z29", + "op": "line", + "port": 29, + "sign": -1 + }, + { + "field": "Z30", + "op": "line", + "port": 30, + "sign": -1 + }, + { + "field": "Z31", + "op": "line", + "port": 31, + "sign": -1 + }, + { + "field": "Z32", + "op": "line", + "port": 32, + "sign": -1 + }, + { + "field": "Z33", + "op": "line", + "port": 33, + "sign": -1 + }, + { + "field": "Z34", + "op": "line", + "port": 34, + "sign": -1 + }, + { + "field": "Z35", + "op": "line", + "port": 35, + "sign": -1 + }, + { + "field": "Z38", + "op": "line", + "port": 38, + "sign": -1 + }, + { + "field": "Z39", + "op": "line", + "port": 39, + "sign": -1 + }, + { + "field": "Z40", + "op": "line", + "port": 40, + "sign": -1 + }, + { + "field": "Z41", + "op": "line", + "port": 41, + "sign": -1 + }, + { + "field": "Z42", + "op": "line", + "port": 42, + "sign": -1 + }, + { + "field": "Z43", + "op": "line", + "port": 43, + "sign": -1 + }, + { + "field": "Z44", + "op": "line", + "port": 44, + "sign": -1 + }, + { + "field": "Z45", + "op": "line", + "port": 45, + "sign": -1 + }, + { + "field": "Z48", + "op": "line", + "port": 48, + "sign": -1 + }, + { + "field": "Z49", + "op": "line", + "port": 49, + "sign": -1 + }, + { + "field": "Z50", + "op": "line", + "port": 50, + "sign": -1 + }, + { + "field": "Z51", + "op": "line", + "port": 51, + "sign": -1 + }, + { + "field": "Z52", + "op": "line", + "port": 52, + "sign": -1 + }, + { + "field": "Z53", + "op": "line", + "port": 53, + "sign": -1 + }, + { + "field": "Z54", + "op": "line", + "port": 54, + "sign": -1 + }, + { + "field": "Z55", + "op": "line", + "port": 55, + "sign": -1 + }, + { + "field": "Z56", + "op": "line", + "port": 56, + "sign": -1 + }, + { + "field": "Z58", + "op": "line", + "port": 58, + "sign": -1 + }, + { + "field": "Z59", + "op": "line", + "port": 59, + "sign": -1 + }, + { + "field": "Z60", + "op": "line", + "port": 60, + "sign": -1 + }, + { + "field": "Z61", + "op": "line", + "port": 61, + "sign": -1 + }, + { + "field": "Z62", + "op": "line", + "port": 62, + "sign": -1 + }, + { + "field": "Z63", + "op": "line", + "port": 63, + "sign": -1 + }, + { + "field": "Z64", + "op": "line", + "port": 64, + "sign": -1 + }, + { + "field": "Z65", + "op": "line", + "port": 65, + "sign": -1 + }, + { + "field": "Z66", + "op": "line", + "port": 66, + "sign": -1 + }, + { + "field": "Z67", + "op": "line", + "port": 67, + "sign": -1 + }, + { + "field": "Z68", + "op": "line", + "port": 68, + "sign": -1 + }, + { + "field": "Z69", + "op": "line", + "port": 69, + "sign": -1 + }, + { + "field": "Z70", + "op": "line", + "port": 70, + "sign": -1 + }, + { + "field": "Z71", + "op": "line", + "port": 71, + "sign": -1 + }, + { + "field": "Z72", + "op": "line", + "port": 72, + "sign": -1 + }, + { + "field": "Z73", + "op": "line", + "port": 73, + "sign": -1 + }, + { + "field": "Z74", + "op": "line", + "port": 74, + "sign": -1 + }, + { + "field": "Z75", + "op": "line", + "port": 75, + "sign": -1 + }, + { + "field": "Z77", + "op": "line", + "port": 77, + "sign": -1 + }, + { + "field": "Z78", + "op": "line", + "port": 78, + "sign": -1 + }, + { + "field": "Z79", + "op": "line", + "port": 79, + "sign": -1 + }, + { + "field": "Z80", + "op": "line", + "port": 80, + "sign": -1 + }, + { + "field": "Z82", + "op": "line", + "port": 82, + "sign": -1 + }, + { + "field": "Z83", + "op": "line", + "port": 83, + "sign": -1 + }, + { + "field": "Z84", + "op": "line", + "port": 84, + "sign": -1 + }, + { + "field": "Z85", + "op": "line", + "port": 85, + "sign": -1 + }, + { + "field": "Z86", + "op": "line", + "port": 86, + "sign": -1 + }, + { + "field": "Z88", + "op": "line", + "port": 88, + "sign": -1 + }, + { + "field": "Z89", + "op": "line", + "port": 89, + "sign": -1 + }, + { + "field": "Z90", + "op": "line", + "port": 90, + "sign": -1 + }, + { + "field": "Z91", + "op": "line", + "port": 91, + "sign": -1 + }, + { + "field": "Z93", + "op": "line", + "port": 93, + "sign": -1 + }, + { + "field": "Z94", + "op": "line", + "port": 94, + "sign": -1 + }, + { + "field": "Z95", + "op": "line", + "port": 95, + "sign": -1 + }, + { + "field": "Z96", + "op": "line", + "port": 96, + "sign": -1 + }, + { + "field": "Z97", + "op": "line", + "port": 97, + "sign": -1 + }, + { + "field": "Z98", + "op": "line", + "port": 98, + "sign": -1 + }, + { + "field": "Z99", + "op": "line", + "port": 99, + "sign": -1 + }, + { + "field": "Z100", + "op": "line", + "port": 100, + "sign": -1 + }, + { + "field": "Z101", + "op": "line", + "port": 101, + "sign": -1 + }, + { + "field": "Z102", + "op": "line", + "port": 102, + "sign": -1 + }, + { + "field": "Z103", + "op": "line", + "port": 103, + "sign": -1 + }, + { + "field": "Z104", + "op": "line", + "port": 104, + "sign": -1 + }, + { + "field": "Z105", + "op": "line", + "port": 105, + "sign": -1 + }, + { + "field": "Z106", + "op": "line", + "port": 106, + "sign": -1 + }, + { + "field": "Z107", + "op": "line", + "port": 107, + "sign": -1 + }, + { + "field": "Z108", + "op": "line", + "port": 108, + "sign": -1 + }, + { + "field": "Z109", + "op": "line", + "port": 109, + "sign": -1 + }, + { + "field": "Z1", + "inverse": false, + "op": "map", + "port": 1 + }, + { + "field": "Z2", + "inverse": false, + "op": "map", + "port": 2 + }, + { + "field": "Z3", + "inverse": false, + "op": "map", + "port": 3 + }, + { + "field": "Z4", + "inverse": false, + "op": "map", + "port": 4 + }, + { + "field": "Z5", + "inverse": false, + "op": "map", + "port": 5 + }, + { + "field": "Z6", + "inverse": false, + "op": "map", + "port": 6 + }, + { + "field": "Z8", + "inverse": false, + "op": "map", + "port": 8 + }, + { + "field": "Z9", + "inverse": false, + "op": "map", + "port": 9 + }, + { + "field": "Z10", + "inverse": false, + "op": "map", + "port": 10 + }, + { + "field": "Z11", + "inverse": false, + "op": "map", + "port": 11 + }, + { + "field": "Z12", + "inverse": false, + "op": "map", + "port": 12 + }, + { + "field": "Z13", + "inverse": false, + "op": "map", + "port": 13 + }, + { + "field": "Z14", + "inverse": false, + "op": "map", + "port": 14 + }, + { + "field": "Z15", + "inverse": false, + "op": "map", + "port": 15 + }, + { + "field": "Z16", + "inverse": false, + "op": "map", + "port": 16 + }, + { + "field": "Z17", + "inverse": false, + "op": "map", + "port": 17 + }, + { + "field": "Z18", + "inverse": false, + "op": "map", + "port": 18 + }, + { + "field": "Z19", + "inverse": false, + "op": "map", + "port": 19 + }, + { + "field": "Z22", + "inverse": false, + "op": "map", + "port": 22 + }, + { + "field": "Z23", + "inverse": false, + "op": "map", + "port": 23 + }, + { + "field": "Z24", + "inverse": false, + "op": "map", + "port": 24 + }, + { + "field": "Z25", + "inverse": false, + "op": "map", + "port": 25 + }, + { + "field": "Z26", + "inverse": false, + "op": "map", + "port": 26 + }, + { + "field": "Z28", + "inverse": false, + "op": "map", + "port": 28 + }, + { + "field": "Z29", + "inverse": false, + "op": "map", + "port": 29 + }, + { + "field": "Z30", + "inverse": false, + "op": "map", + "port": 30 + }, + { + "field": "Z31", + "inverse": false, + "op": "map", + "port": 31 + }, + { + "field": "Z32", + "inverse": false, + "op": "map", + "port": 32 + }, + { + "field": "Z33", + "inverse": false, + "op": "map", + "port": 33 + }, + { + "field": "Z34", + "inverse": false, + "op": "map", + "port": 34 + }, + { + "field": "Z35", + "inverse": false, + "op": "map", + "port": 35 + }, + { + "field": "Z38", + "inverse": false, + "op": "map", + "port": 38 + }, + { + "field": "Z39", + "inverse": false, + "op": "map", + "port": 39 + }, + { + "field": "Z40", + "inverse": false, + "op": "map", + "port": 40 + }, + { + "field": "Z41", + "inverse": false, + "op": "map", + "port": 41 + }, + { + "field": "Z42", + "inverse": false, + "op": "map", + "port": 42 + }, + { + "field": "Z43", + "inverse": false, + "op": "map", + "port": 43 + }, + { + "field": "Z44", + "inverse": false, + "op": "map", + "port": 44 + }, + { + "field": "Z45", + "inverse": false, + "op": "map", + "port": 45 + }, + { + "field": "Z48", + "inverse": false, + "op": "map", + "port": 48 + }, + { + "field": "Z49", + "inverse": false, + "op": "map", + "port": 49 + }, + { + "field": "Z50", + "inverse": false, + "op": "map", + "port": 50 + }, + { + "field": "Z51", + "inverse": false, + "op": "map", + "port": 51 + }, + { + "field": "Z52", + "inverse": false, + "op": "map", + "port": 52 + }, + { + "field": "Z53", + "inverse": false, + "op": "map", + "port": 53 + }, + { + "field": "Z54", + "inverse": false, + "op": "map", + "port": 54 + }, + { + "field": "Z55", + "inverse": false, + "op": "map", + "port": 55 + }, + { + "field": "Z56", + "inverse": false, + "op": "map", + "port": 56 + }, + { + "field": "Z58", + "inverse": false, + "op": "map", + "port": 58 + }, + { + "field": "Z59", + "inverse": false, + "op": "map", + "port": 59 + }, + { + "field": "Z60", + "inverse": false, + "op": "map", + "port": 60 + }, + { + "field": "Z61", + "inverse": false, + "op": "map", + "port": 61 + }, + { + "field": "Z62", + "inverse": false, + "op": "map", + "port": 62 + }, + { + "field": "Z63", + "inverse": false, + "op": "map", + "port": 63 + }, + { + "field": "Z64", + "inverse": false, + "op": "map", + "port": 64 + }, + { + "field": "Z65", + "inverse": false, + "op": "map", + "port": 65 + }, + { + "field": "Z66", + "inverse": false, + "op": "map", + "port": 66 + }, + { + "field": "Z67", + "inverse": false, + "op": "map", + "port": 67 + }, + { + "field": "Z68", + "inverse": false, + "op": "map", + "port": 68 + }, + { + "field": "Z69", + "inverse": false, + "op": "map", + "port": 69 + }, + { + "field": "Z70", + "inverse": false, + "op": "map", + "port": 70 + }, + { + "field": "Z71", + "inverse": false, + "op": "map", + "port": 71 + }, + { + "field": "Z72", + "inverse": false, + "op": "map", + "port": 72 + }, + { + "field": "Z73", + "inverse": false, + "op": "map", + "port": 73 + }, + { + "field": "Z74", + "inverse": false, + "op": "map", + "port": 74 + }, + { + "field": "Z75", + "inverse": false, + "op": "map", + "port": 75 + }, + { + "field": "Z77", + "inverse": false, + "op": "map", + "port": 77 + }, + { + "field": "Z78", + "inverse": false, + "op": "map", + "port": 78 + }, + { + "field": "Z79", + "inverse": false, + "op": "map", + "port": 79 + }, + { + "field": "Z80", + "inverse": false, + "op": "map", + "port": 80 + }, + { + "field": "Z82", + "inverse": false, + "op": "map", + "port": 82 + }, + { + "field": "Z83", + "inverse": false, + "op": "map", + "port": 83 + }, + { + "field": "Z84", + "inverse": false, + "op": "map", + "port": 84 + }, + { + "field": "Z85", + "inverse": false, + "op": "map", + "port": 85 + }, + { + "field": "Z86", + "inverse": false, + "op": "map", + "port": 86 + }, + { + "field": "Z88", + "inverse": false, + "op": "map", + "port": 88 + }, + { + "field": "Z89", + "inverse": false, + "op": "map", + "port": 89 + }, + { + "field": "Z90", + "inverse": false, + "op": "map", + "port": 90 + }, + { + "field": "Z91", + "inverse": false, + "op": "map", + "port": 91 + }, + { + "field": "Z93", + "inverse": false, + "op": "map", + "port": 93 + }, + { + "field": "Z94", + "inverse": false, + "op": "map", + "port": 94 + }, + { + "field": "Z95", + "inverse": false, + "op": "map", + "port": 95 + }, + { + "field": "Z96", + "inverse": false, + "op": "map", + "port": 96 + }, + { + "field": "Z97", + "inverse": false, + "op": "map", + "port": 97 + }, + { + "field": "Z98", + "inverse": false, + "op": "map", + "port": 98 + }, + { + "field": "Z99", + "inverse": false, + "op": "map", + "port": 99 + }, + { + "field": "Z100", + "inverse": false, + "op": "map", + "port": 100 + }, + { + "field": "Z101", + "inverse": false, + "op": "map", + "port": 101 + }, + { + "field": "Z102", + "inverse": false, + "op": "map", + "port": 102 + }, + { + "field": "Z103", + "inverse": false, + "op": "map", + "port": 103 + }, + { + "field": "Z104", + "inverse": false, + "op": "map", + "port": 104 + }, + { + "field": "Z105", + "inverse": false, + "op": "map", + "port": 105 + }, + { + "field": "Z106", + "inverse": false, + "op": "map", + "port": 106 + }, + { + "field": "Z107", + "inverse": false, + "op": "map", + "port": 107 + }, + { + "field": "Z108", + "inverse": false, + "op": "map", + "port": 108 + }, + { + "field": "Z109", + "inverse": false, + "op": "map", + "port": 109 + }, + { + "field": "T21", + "op": "line", + "port": 21, + "sign": -1 + }, + { + "field": "T37", + "op": "line", + "port": 37, + "sign": -1 + }, + { + "field": "T47", + "op": "line", + "port": 47, + "sign": -1 + }, + { + "field": "T76", + "op": "line", + "port": 76, + "sign": -1 + }, + { + "field": "T81", + "op": "line", + "port": 81, + "sign": -1 + }, + { + "field": "T87", + "op": "line", + "port": 87, + "sign": -1 + }, + { + "field": "T92", + "op": "line", + "port": 92, + "sign": -1 + }, + { + "field": "T110", + "op": "line", + "port": 110, + "sign": -1 + }, + { + "field": "T21", + "inverse": false, + "op": "map", + "port": 21 + }, + { + "field": "T37", + "inverse": false, + "op": "map", + "port": 37 + }, + { + "field": "T47", + "inverse": false, + "op": "map", + "port": 47 + }, + { + "field": "T76", + "inverse": false, + "op": "map", + "port": 76 + }, + { + "field": "T81", + "inverse": false, + "op": "map", + "port": 81 + }, + { + "field": "T87", + "inverse": false, + "op": "map", + "port": 87 + }, + { + "field": "T92", + "inverse": false, + "op": "map", + "port": 92 + }, + { + "field": "T110", + "inverse": false, + "op": "map", + "port": 110 + }, + { + "op": "private_sweep_begin" + }, + { + "field": "C", + "frame": "common", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "C", + "op": "add", + "src": "T76" + }, + { + "coefficient": "1", + "dst": "C", + "op": "add", + "src": "T81" + }, + { + "coefficient": "1", + "dst": "C", + "op": "add", + "src": "T87" + }, + { + "coefficient": "1", + "dst": "C", + "op": "add", + "src": "T92" + }, + { + "coefficient": "-1/4", + "dst": "Z2", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z9", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z10", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z11", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z12", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z17", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z18", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z19", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z22", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z23", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z24", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z25", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z31", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z32", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z33", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z34", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z35", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z38", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z39", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z40", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z45", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z48", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z49", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z50", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z54", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z55", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z56", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z61", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z62", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z63", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z70", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z71", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z72", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z77", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z79", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z85", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z89", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z90", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z91", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z94", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z98", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z100", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z101", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z102", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z103", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z107", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z108", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z109", + "op": "add", + "src": "C" + }, + { + "field": "C", + "frame": "identity", + "op": "clear" + }, + { + "field": "C", + "frame": "common", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "C", + "op": "add", + "src": "T76" + }, + { + "coefficient": "-1", + "dst": "C", + "op": "add", + "src": "T81" + }, + { + "coefficient": "1", + "dst": "C", + "op": "add", + "src": "T87" + }, + { + "coefficient": "-1", + "dst": "C", + "op": "add", + "src": "T92" + }, + { + "coefficient": "-1/4", + "dst": "Z1", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z2", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z3", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z4", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z5", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z6", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z8", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z9", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z10", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z11", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z25", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z26", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z28", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z29", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z30", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z58", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z59", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z60", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z61", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z62", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z63", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z64", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z65", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z66", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z67", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z68", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z69", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z70", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z71", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z72", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z73", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z74", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z75", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z79", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z80", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z82", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z83", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z84", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z86", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z88", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z89", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z90", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z91", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z93", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z94", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z95", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z96", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z97", + "op": "add", + "src": "C" + }, + { + "field": "C", + "frame": "identity", + "op": "clear" + }, + { + "field": "C", + "frame": "common", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "C", + "op": "add", + "src": "T76" + }, + { + "coefficient": "-1", + "dst": "C", + "op": "add", + "src": "T81" + }, + { + "coefficient": "-1", + "dst": "C", + "op": "add", + "src": "T87" + }, + { + "coefficient": "1", + "dst": "C", + "op": "add", + "src": "T92" + }, + { + "coefficient": "-1/4", + "dst": "Z1", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z6", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z12", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z13", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z14", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z15", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z16", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z17", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z18", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z19", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z28", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z29", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z30", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z31", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z38", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z39", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z40", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z41", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z42", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z43", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z44", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z51", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z52", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z53", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z54", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z55", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z56", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z58", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z59", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z60", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z73", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z74", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z75", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z77", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z78", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z82", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z83", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z84", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z86", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z93", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z99", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z100", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z101", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z102", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z103", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z104", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z105", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z106", + "op": "add", + "src": "C" + }, + { + "field": "C", + "frame": "identity", + "op": "clear" + }, + { + "field": "C", + "frame": "common", + "op": "clear" + }, + { + "coefficient": "-1", + "dst": "C", + "op": "add", + "src": "T76" + }, + { + "coefficient": "-1", + "dst": "C", + "op": "add", + "src": "T81" + }, + { + "coefficient": "1", + "dst": "C", + "op": "add", + "src": "T87" + }, + { + "coefficient": "1", + "dst": "C", + "op": "add", + "src": "T92" + }, + { + "coefficient": "-1/4", + "dst": "Z3", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z4", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z5", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z8", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z13", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z14", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z15", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z16", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z22", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z23", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z24", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z26", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z32", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z33", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z34", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z35", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z41", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z42", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z43", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z44", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z45", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z48", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z49", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z50", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z51", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z52", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z53", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z64", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z65", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z66", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z67", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z68", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z69", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z78", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z80", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z85", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z88", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z95", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z96", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z97", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z98", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z99", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z104", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z105", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z106", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z107", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z108", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z109", + "op": "add", + "src": "C" + }, + { + "field": "C", + "frame": "identity", + "op": "clear" + }, + { + "field": "C", + "frame": "common", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "C", + "op": "add", + "src": "T21" + }, + { + "coefficient": "1", + "dst": "C", + "op": "add", + "src": "T37" + }, + { + "coefficient": "1", + "dst": "C", + "op": "add", + "src": "T47" + }, + { + "coefficient": "1", + "dst": "C", + "op": "add", + "src": "T110" + }, + { + "coefficient": "1/4", + "dst": "Z1", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z3", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z6", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z8", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z10", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z11", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z12", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z14", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z15", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z17", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z24", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z26", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z28", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z31", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z32", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z35", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z38", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z41", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z42", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z45", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z48", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z52", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z53", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z56", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z58", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z62", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z63", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z66", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z67", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z70", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z71", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z75", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z77", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z80", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z82", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z85", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z86", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z88", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z90", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z91", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z93", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z95", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z98", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z100", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z103", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z105", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z106", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z107", + "op": "add", + "src": "C" + }, + { + "field": "C", + "frame": "identity", + "op": "clear" + }, + { + "field": "C", + "frame": "common", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "C", + "op": "add", + "src": "T21" + }, + { + "coefficient": "-1", + "dst": "C", + "op": "add", + "src": "T37" + }, + { + "coefficient": "1", + "dst": "C", + "op": "add", + "src": "T47" + }, + { + "coefficient": "-1", + "dst": "C", + "op": "add", + "src": "T110" + }, + { + "coefficient": "1/4", + "dst": "Z4", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z5", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z10", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z11", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z14", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z15", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z18", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z19", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z22", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z23", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z29", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z30", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z33", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z34", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z39", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z40", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z41", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z42", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z49", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z50", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z52", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z53", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z54", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z55", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z59", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z60", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z62", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z63", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z64", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z65", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z68", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z69", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z70", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z71", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z73", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z74", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z83", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z84", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z90", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z91", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z96", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z97", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z101", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z102", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z105", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z106", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z108", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z109", + "op": "add", + "src": "C" + }, + { + "field": "C", + "frame": "identity", + "op": "clear" + }, + { + "field": "C", + "frame": "common", + "op": "clear" + }, + { + "coefficient": "1", + "dst": "C", + "op": "add", + "src": "T21" + }, + { + "coefficient": "1", + "dst": "C", + "op": "add", + "src": "T37" + }, + { + "coefficient": "-1", + "dst": "C", + "op": "add", + "src": "T47" + }, + { + "coefficient": "-1", + "dst": "C", + "op": "add", + "src": "T110" + }, + { + "coefficient": "-1/4", + "dst": "Z2", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z3", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z8", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z9", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z12", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z13", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z16", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z17", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z22", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z23", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z25", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z26", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z29", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z30", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z31", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z33", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z34", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z38", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z43", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z44", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z49", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z50", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z51", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z56", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z59", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z60", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z61", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z66", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z67", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z72", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z73", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z74", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z77", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z78", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z79", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z80", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z83", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z84", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z88", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z89", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z94", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z95", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z99", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z100", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z103", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z104", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z108", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z109", + "op": "add", + "src": "C" + }, + { + "field": "C", + "frame": "identity", + "op": "clear" + }, + { + "field": "C", + "frame": "common", + "op": "clear" + }, + { + "coefficient": "-1", + "dst": "C", + "op": "add", + "src": "T21" + }, + { + "coefficient": "1", + "dst": "C", + "op": "add", + "src": "T37" + }, + { + "coefficient": "1", + "dst": "C", + "op": "add", + "src": "T47" + }, + { + "coefficient": "-1", + "dst": "C", + "op": "add", + "src": "T110" + }, + { + "coefficient": "1/4", + "dst": "Z1", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z2", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z4", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z5", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z6", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z9", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z13", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z16", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z18", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z19", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z24", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z25", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z28", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z32", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z35", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z39", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z40", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z43", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z44", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z45", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z48", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z51", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z54", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z55", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z58", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z61", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z64", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z65", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z68", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z69", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z72", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z75", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z78", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z79", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z82", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z85", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z86", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z89", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z93", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z94", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z96", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z97", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z98", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z99", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z101", + "op": "add", + "src": "C" + }, + { + "coefficient": "-1/4", + "dst": "Z102", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z104", + "op": "add", + "src": "C" + }, + { + "coefficient": "1/4", + "dst": "Z107", + "op": "add", + "src": "C" + }, + { + "field": "C", + "frame": "identity", + "op": "clear" + }, + { + "op": "private_sweep_end" + }, + { + "field": "T21", + "inverse": true, + "op": "map", + "port": 21 + }, + { + "field": "T37", + "inverse": true, + "op": "map", + "port": 37 + }, + { + "field": "T47", + "inverse": true, + "op": "map", + "port": 47 + }, + { + "field": "T76", + "inverse": true, + "op": "map", + "port": 76 + }, + { + "field": "T81", + "inverse": true, + "op": "map", + "port": 81 + }, + { + "field": "T87", + "inverse": true, + "op": "map", + "port": 87 + }, + { + "field": "T92", + "inverse": true, + "op": "map", + "port": 92 + }, + { + "field": "T110", + "inverse": true, + "op": "map", + "port": 110 + }, + { + "field": "T21", + "op": "line", + "port": 21, + "sign": 1 + }, + { + "field": "T37", + "op": "line", + "port": 37, + "sign": 1 + }, + { + "field": "T47", + "op": "line", + "port": 47, + "sign": 1 + }, + { + "field": "T76", + "op": "line", + "port": 76, + "sign": 1 + }, + { + "field": "T81", + "op": "line", + "port": 81, + "sign": 1 + }, + { + "field": "T87", + "op": "line", + "port": 87, + "sign": 1 + }, + { + "field": "T92", + "op": "line", + "port": 92, + "sign": 1 + }, + { + "field": "T110", + "op": "line", + "port": 110, + "sign": 1 + }, + { + "field": "Z1", + "inverse": true, + "op": "map", + "port": 1 + }, + { + "field": "Z2", + "inverse": true, + "op": "map", + "port": 2 + }, + { + "field": "Z3", + "inverse": true, + "op": "map", + "port": 3 + }, + { + "field": "Z4", + "inverse": true, + "op": "map", + "port": 4 + }, + { + "field": "Z5", + "inverse": true, + "op": "map", + "port": 5 + }, + { + "field": "Z6", + "inverse": true, + "op": "map", + "port": 6 + }, + { + "field": "Z8", + "inverse": true, + "op": "map", + "port": 8 + }, + { + "field": "Z9", + "inverse": true, + "op": "map", + "port": 9 + }, + { + "field": "Z10", + "inverse": true, + "op": "map", + "port": 10 + }, + { + "field": "Z11", + "inverse": true, + "op": "map", + "port": 11 + }, + { + "field": "Z12", + "inverse": true, + "op": "map", + "port": 12 + }, + { + "field": "Z13", + "inverse": true, + "op": "map", + "port": 13 + }, + { + "field": "Z14", + "inverse": true, + "op": "map", + "port": 14 + }, + { + "field": "Z15", + "inverse": true, + "op": "map", + "port": 15 + }, + { + "field": "Z16", + "inverse": true, + "op": "map", + "port": 16 + }, + { + "field": "Z17", + "inverse": true, + "op": "map", + "port": 17 + }, + { + "field": "Z18", + "inverse": true, + "op": "map", + "port": 18 + }, + { + "field": "Z19", + "inverse": true, + "op": "map", + "port": 19 + }, + { + "field": "Z22", + "inverse": true, + "op": "map", + "port": 22 + }, + { + "field": "Z23", + "inverse": true, + "op": "map", + "port": 23 + }, + { + "field": "Z24", + "inverse": true, + "op": "map", + "port": 24 + }, + { + "field": "Z25", + "inverse": true, + "op": "map", + "port": 25 + }, + { + "field": "Z26", + "inverse": true, + "op": "map", + "port": 26 + }, + { + "field": "Z28", + "inverse": true, + "op": "map", + "port": 28 + }, + { + "field": "Z29", + "inverse": true, + "op": "map", + "port": 29 + }, + { + "field": "Z30", + "inverse": true, + "op": "map", + "port": 30 + }, + { + "field": "Z31", + "inverse": true, + "op": "map", + "port": 31 + }, + { + "field": "Z32", + "inverse": true, + "op": "map", + "port": 32 + }, + { + "field": "Z33", + "inverse": true, + "op": "map", + "port": 33 + }, + { + "field": "Z34", + "inverse": true, + "op": "map", + "port": 34 + }, + { + "field": "Z35", + "inverse": true, + "op": "map", + "port": 35 + }, + { + "field": "Z38", + "inverse": true, + "op": "map", + "port": 38 + }, + { + "field": "Z39", + "inverse": true, + "op": "map", + "port": 39 + }, + { + "field": "Z40", + "inverse": true, + "op": "map", + "port": 40 + }, + { + "field": "Z41", + "inverse": true, + "op": "map", + "port": 41 + }, + { + "field": "Z42", + "inverse": true, + "op": "map", + "port": 42 + }, + { + "field": "Z43", + "inverse": true, + "op": "map", + "port": 43 + }, + { + "field": "Z44", + "inverse": true, + "op": "map", + "port": 44 + }, + { + "field": "Z45", + "inverse": true, + "op": "map", + "port": 45 + }, + { + "field": "Z48", + "inverse": true, + "op": "map", + "port": 48 + }, + { + "field": "Z49", + "inverse": true, + "op": "map", + "port": 49 + }, + { + "field": "Z50", + "inverse": true, + "op": "map", + "port": 50 + }, + { + "field": "Z51", + "inverse": true, + "op": "map", + "port": 51 + }, + { + "field": "Z52", + "inverse": true, + "op": "map", + "port": 52 + }, + { + "field": "Z53", + "inverse": true, + "op": "map", + "port": 53 + }, + { + "field": "Z54", + "inverse": true, + "op": "map", + "port": 54 + }, + { + "field": "Z55", + "inverse": true, + "op": "map", + "port": 55 + }, + { + "field": "Z56", + "inverse": true, + "op": "map", + "port": 56 + }, + { + "field": "Z58", + "inverse": true, + "op": "map", + "port": 58 + }, + { + "field": "Z59", + "inverse": true, + "op": "map", + "port": 59 + }, + { + "field": "Z60", + "inverse": true, + "op": "map", + "port": 60 + }, + { + "field": "Z61", + "inverse": true, + "op": "map", + "port": 61 + }, + { + "field": "Z62", + "inverse": true, + "op": "map", + "port": 62 + }, + { + "field": "Z63", + "inverse": true, + "op": "map", + "port": 63 + }, + { + "field": "Z64", + "inverse": true, + "op": "map", + "port": 64 + }, + { + "field": "Z65", + "inverse": true, + "op": "map", + "port": 65 + }, + { + "field": "Z66", + "inverse": true, + "op": "map", + "port": 66 + }, + { + "field": "Z67", + "inverse": true, + "op": "map", + "port": 67 + }, + { + "field": "Z68", + "inverse": true, + "op": "map", + "port": 68 + }, + { + "field": "Z69", + "inverse": true, + "op": "map", + "port": 69 + }, + { + "field": "Z70", + "inverse": true, + "op": "map", + "port": 70 + }, + { + "field": "Z71", + "inverse": true, + "op": "map", + "port": 71 + }, + { + "field": "Z72", + "inverse": true, + "op": "map", + "port": 72 + }, + { + "field": "Z73", + "inverse": true, + "op": "map", + "port": 73 + }, + { + "field": "Z74", + "inverse": true, + "op": "map", + "port": 74 + }, + { + "field": "Z75", + "inverse": true, + "op": "map", + "port": 75 + }, + { + "field": "Z77", + "inverse": true, + "op": "map", + "port": 77 + }, + { + "field": "Z78", + "inverse": true, + "op": "map", + "port": 78 + }, + { + "field": "Z79", + "inverse": true, + "op": "map", + "port": 79 + }, + { + "field": "Z80", + "inverse": true, + "op": "map", + "port": 80 + }, + { + "field": "Z82", + "inverse": true, + "op": "map", + "port": 82 + }, + { + "field": "Z83", + "inverse": true, + "op": "map", + "port": 83 + }, + { + "field": "Z84", + "inverse": true, + "op": "map", + "port": 84 + }, + { + "field": "Z85", + "inverse": true, + "op": "map", + "port": 85 + }, + { + "field": "Z86", + "inverse": true, + "op": "map", + "port": 86 + }, + { + "field": "Z88", + "inverse": true, + "op": "map", + "port": 88 + }, + { + "field": "Z89", + "inverse": true, + "op": "map", + "port": 89 + }, + { + "field": "Z90", + "inverse": true, + "op": "map", + "port": 90 + }, + { + "field": "Z91", + "inverse": true, + "op": "map", + "port": 91 + }, + { + "field": "Z93", + "inverse": true, + "op": "map", + "port": 93 + }, + { + "field": "Z94", + "inverse": true, + "op": "map", + "port": 94 + }, + { + "field": "Z95", + "inverse": true, + "op": "map", + "port": 95 + }, + { + "field": "Z96", + "inverse": true, + "op": "map", + "port": 96 + }, + { + "field": "Z97", + "inverse": true, + "op": "map", + "port": 97 + }, + { + "field": "Z98", + "inverse": true, + "op": "map", + "port": 98 + }, + { + "field": "Z99", + "inverse": true, + "op": "map", + "port": 99 + }, + { + "field": "Z100", + "inverse": true, + "op": "map", + "port": 100 + }, + { + "field": "Z101", + "inverse": true, + "op": "map", + "port": 101 + }, + { + "field": "Z102", + "inverse": true, + "op": "map", + "port": 102 + }, + { + "field": "Z103", + "inverse": true, + "op": "map", + "port": 103 + }, + { + "field": "Z104", + "inverse": true, + "op": "map", + "port": 104 + }, + { + "field": "Z105", + "inverse": true, + "op": "map", + "port": 105 + }, + { + "field": "Z106", + "inverse": true, + "op": "map", + "port": 106 + }, + { + "field": "Z107", + "inverse": true, + "op": "map", + "port": 107 + }, + { + "field": "Z108", + "inverse": true, + "op": "map", + "port": 108 + }, + { + "field": "Z109", + "inverse": true, + "op": "map", + "port": 109 + }, + { + "field": "Z1", + "op": "line", + "port": 1, + "sign": 1 + }, + { + "field": "Z2", + "op": "line", + "port": 2, + "sign": 1 + }, + { + "field": "Z3", + "op": "line", + "port": 3, + "sign": 1 + }, + { + "field": "Z4", + "op": "line", + "port": 4, + "sign": 1 + }, + { + "field": "Z5", + "op": "line", + "port": 5, + "sign": 1 + }, + { + "field": "Z6", + "op": "line", + "port": 6, + "sign": 1 + }, + { + "field": "Z8", + "op": "line", + "port": 8, + "sign": 1 + }, + { + "field": "Z9", + "op": "line", + "port": 9, + "sign": 1 + }, + { + "field": "Z10", + "op": "line", + "port": 10, + "sign": 1 + }, + { + "field": "Z11", + "op": "line", + "port": 11, + "sign": 1 + }, + { + "field": "Z12", + "op": "line", + "port": 12, + "sign": 1 + }, + { + "field": "Z13", + "op": "line", + "port": 13, + "sign": 1 + }, + { + "field": "Z14", + "op": "line", + "port": 14, + "sign": 1 + }, + { + "field": "Z15", + "op": "line", + "port": 15, + "sign": 1 + }, + { + "field": "Z16", + "op": "line", + "port": 16, + "sign": 1 + }, + { + "field": "Z17", + "op": "line", + "port": 17, + "sign": 1 + }, + { + "field": "Z18", + "op": "line", + "port": 18, + "sign": 1 + }, + { + "field": "Z19", + "op": "line", + "port": 19, + "sign": 1 + }, + { + "field": "Z22", + "op": "line", + "port": 22, + "sign": 1 + }, + { + "field": "Z23", + "op": "line", + "port": 23, + "sign": 1 + }, + { + "field": "Z24", + "op": "line", + "port": 24, + "sign": 1 + }, + { + "field": "Z25", + "op": "line", + "port": 25, + "sign": 1 + }, + { + "field": "Z26", + "op": "line", + "port": 26, + "sign": 1 + }, + { + "field": "Z28", + "op": "line", + "port": 28, + "sign": 1 + }, + { + "field": "Z29", + "op": "line", + "port": 29, + "sign": 1 + }, + { + "field": "Z30", + "op": "line", + "port": 30, + "sign": 1 + }, + { + "field": "Z31", + "op": "line", + "port": 31, + "sign": 1 + }, + { + "field": "Z32", + "op": "line", + "port": 32, + "sign": 1 + }, + { + "field": "Z33", + "op": "line", + "port": 33, + "sign": 1 + }, + { + "field": "Z34", + "op": "line", + "port": 34, + "sign": 1 + }, + { + "field": "Z35", + "op": "line", + "port": 35, + "sign": 1 + }, + { + "field": "Z38", + "op": "line", + "port": 38, + "sign": 1 + }, + { + "field": "Z39", + "op": "line", + "port": 39, + "sign": 1 + }, + { + "field": "Z40", + "op": "line", + "port": 40, + "sign": 1 + }, + { + "field": "Z41", + "op": "line", + "port": 41, + "sign": 1 + }, + { + "field": "Z42", + "op": "line", + "port": 42, + "sign": 1 + }, + { + "field": "Z43", + "op": "line", + "port": 43, + "sign": 1 + }, + { + "field": "Z44", + "op": "line", + "port": 44, + "sign": 1 + }, + { + "field": "Z45", + "op": "line", + "port": 45, + "sign": 1 + }, + { + "field": "Z48", + "op": "line", + "port": 48, + "sign": 1 + }, + { + "field": "Z49", + "op": "line", + "port": 49, + "sign": 1 + }, + { + "field": "Z50", + "op": "line", + "port": 50, + "sign": 1 + }, + { + "field": "Z51", + "op": "line", + "port": 51, + "sign": 1 + }, + { + "field": "Z52", + "op": "line", + "port": 52, + "sign": 1 + }, + { + "field": "Z53", + "op": "line", + "port": 53, + "sign": 1 + }, + { + "field": "Z54", + "op": "line", + "port": 54, + "sign": 1 + }, + { + "field": "Z55", + "op": "line", + "port": 55, + "sign": 1 + }, + { + "field": "Z56", + "op": "line", + "port": 56, + "sign": 1 + }, + { + "field": "Z58", + "op": "line", + "port": 58, + "sign": 1 + }, + { + "field": "Z59", + "op": "line", + "port": 59, + "sign": 1 + }, + { + "field": "Z60", + "op": "line", + "port": 60, + "sign": 1 + }, + { + "field": "Z61", + "op": "line", + "port": 61, + "sign": 1 + }, + { + "field": "Z62", + "op": "line", + "port": 62, + "sign": 1 + }, + { + "field": "Z63", + "op": "line", + "port": 63, + "sign": 1 + }, + { + "field": "Z64", + "op": "line", + "port": 64, + "sign": 1 + }, + { + "field": "Z65", + "op": "line", + "port": 65, + "sign": 1 + }, + { + "field": "Z66", + "op": "line", + "port": 66, + "sign": 1 + }, + { + "field": "Z67", + "op": "line", + "port": 67, + "sign": 1 + }, + { + "field": "Z68", + "op": "line", + "port": 68, + "sign": 1 + }, + { + "field": "Z69", + "op": "line", + "port": 69, + "sign": 1 + }, + { + "field": "Z70", + "op": "line", + "port": 70, + "sign": 1 + }, + { + "field": "Z71", + "op": "line", + "port": 71, + "sign": 1 + }, + { + "field": "Z72", + "op": "line", + "port": 72, + "sign": 1 + }, + { + "field": "Z73", + "op": "line", + "port": 73, + "sign": 1 + }, + { + "field": "Z74", + "op": "line", + "port": 74, + "sign": 1 + }, + { + "field": "Z75", + "op": "line", + "port": 75, + "sign": 1 + }, + { + "field": "Z77", + "op": "line", + "port": 77, + "sign": 1 + }, + { + "field": "Z78", + "op": "line", + "port": 78, + "sign": 1 + }, + { + "field": "Z79", + "op": "line", + "port": 79, + "sign": 1 + }, + { + "field": "Z80", + "op": "line", + "port": 80, + "sign": 1 + }, + { + "field": "Z82", + "op": "line", + "port": 82, + "sign": 1 + }, + { + "field": "Z83", + "op": "line", + "port": 83, + "sign": 1 + }, + { + "field": "Z84", + "op": "line", + "port": 84, + "sign": 1 + }, + { + "field": "Z85", + "op": "line", + "port": 85, + "sign": 1 + }, + { + "field": "Z86", + "op": "line", + "port": 86, + "sign": 1 + }, + { + "field": "Z88", + "op": "line", + "port": 88, + "sign": 1 + }, + { + "field": "Z89", + "op": "line", + "port": 89, + "sign": 1 + }, + { + "field": "Z90", + "op": "line", + "port": 90, + "sign": 1 + }, + { + "field": "Z91", + "op": "line", + "port": 91, + "sign": 1 + }, + { + "field": "Z93", + "op": "line", + "port": 93, + "sign": 1 + }, + { + "field": "Z94", + "op": "line", + "port": 94, + "sign": 1 + }, + { + "field": "Z95", + "op": "line", + "port": 95, + "sign": 1 + }, + { + "field": "Z96", + "op": "line", + "port": 96, + "sign": 1 + }, + { + "field": "Z97", + "op": "line", + "port": 97, + "sign": 1 + }, + { + "field": "Z98", + "op": "line", + "port": 98, + "sign": 1 + }, + { + "field": "Z99", + "op": "line", + "port": 99, + "sign": 1 + }, + { + "field": "Z100", + "op": "line", + "port": 100, + "sign": 1 + }, + { + "field": "Z101", + "op": "line", + "port": 101, + "sign": 1 + }, + { + "field": "Z102", + "op": "line", + "port": 102, + "sign": 1 + }, + { + "field": "Z103", + "op": "line", + "port": 103, + "sign": 1 + }, + { + "field": "Z104", + "op": "line", + "port": 104, + "sign": 1 + }, + { + "field": "Z105", + "op": "line", + "port": 105, + "sign": 1 + }, + { + "field": "Z106", + "op": "line", + "port": 106, + "sign": 1 + }, + { + "field": "Z107", + "op": "line", + "port": 107, + "sign": 1 + }, + { + "field": "Z108", + "op": "line", + "port": 108, + "sign": 1 + }, + { + "field": "Z109", + "op": "line", + "port": 109, + "sign": 1 + } +] diff --git a/research/qq16-l2-native-reconstruction/evidence/PR2468-PROOF.md b/research/qq16-l2-native-reconstruction/evidence/PR2468-PROOF.md new file mode 100644 index 0000000000..95b98d8b2a --- /dev/null +++ b/research/qq16-l2-native-reconstruction/evidence/PR2468-PROOF.md @@ -0,0 +1,139 @@ +# Future-X query at the post-B1 cut + +## Objects, available frames and extra storage + +Use the actual disjoint QQ16 A/T minors and their ordinary complement U of +size 96. Set `C=x2_U` immediately after `B_1_2`. The retained contract gives +each X source p at owner d the completed native frame + +``` +T_X(d) = F_(d U1), U1=L+E1. +``` + +The logical values C are arbitrary; in PR2443 they equal `-y_U^initial`. +No use is made of that equality, of selected endpoint values, or of a later +former-Y hole. The new word owns eight output arrays. It clears them before +use and returns them live in the common query frame. Those arrays are not +claimed to come free from the selected helper bank or to preserve dirty input. + +For p in U, let `q_p` be its actual nine-bit normal and let `rho_p=rho_2(p)`. +This involution fixes q_p and exchanges its eight chart axes with E2. Write +`delta_p=q_p+lift_2(beta_p)`. The source's future-Y alignment and inverse are + +``` +A_p = M(rho_p, delta_p), +A_p^-1 = M(rho_p, rho_p delta_p), +M(g,a) f(d,z_1,...,z_lambda) + = f(dg,z_1+d a,...,z_lambda+d a). +``` + +It changes owners and translates every payload layer. It does not apply g +to the payload address. All fields at different owner/port indices remain +independent. Every per-field map is a bijection of its full array. + +## The unavailable zero-line shortcut and the exact repair + +Let `T_c(d)=F_(d(E1+E2))` and let `D_p=M(rho_p,0)` be the logical route. +The retained bridge identity, for a Y-type source before chart 2, is + +``` +A_p [F_(d U1) C_(d q_p)^-1] = T_c(d) D_p. +``` + +Here `C_q=(1+i)I/2+(1-i)T_q/2` is the signed native rank-one line operator. +Since rho_p fixes q_p, omitting that inverse line leaves exactly C_q: + +``` +after A_p, the X source frame is T_c(d) C_(d q_p). +``` + +This residual is not the identity. At an identity-owner Fourier character +w with `q_p dot w=1`, its multiplier is i. The receipt supplies such a w for +each of the 96 actual ports. Therefore the future-Y scalar query cannot be +applied directly to these unnormalized X fields in its common output frame. +This does not exclude other physical implementations or other observation cuts. + +Normalize source p first with `C_(d q_p)^-1`. Native frames are products of +commuting address translations/line operators, so this changes its frame +to the required Y type while retaining its arbitrary logical value. Applying +A_p then puts it in frame T_c with logical content D_p C_p. All 96 source +fields now have exactly the same native frame at each common owner. + +Clear eight owned output arrays. Zero is compatible with T_c, so no native +line preparation of a nonzero dirty output is assumed. For each k, perform +the literal signed scalar additions + +``` +Q_k += R[k,p] * aligned_C_p, for p in U with R[k,p] != 0. +``` + +This yields `Q=R_U D_(2,U) C=B2 C`, in frame T_c. Scalar additions leave +every source field unchanged. Undo every A_p, then apply `C_(d q_p)` to each +source. Both physical and logical source endpoints are exactly restored. +The output arrays are intentionally retained; they are the requested observation. + +All normalization, alignment, accumulation, undo and restoration sweeps are +completed in that order before the next sweep. At a fixed owner, all ADDs +use different source and output fields in matching frames. Finishing each +full-cover sweep prevents reads from partially updated other owners. The +word can therefore be inserted before the next source-modifying operation, +subject to separate global scheduling and child-hosting obligations. + +## Literal rank-one kernels + +For every actual nonzero q in the nine-dimensional local block, choose an +invertible binary G with `G e0=q`. The verifier takes q as its first column +and the other eight coordinate axes except one pivot of q as the remaining +columns. Define P_G by sending the basis vector at address x to the basis +vector at address Gx. Then + +``` +P_G C_e0 P_G^-1 = C_q, +T_q P_G C_e0 P_G^-1 = C_q^-1. +``` + +The source rank-one primitive C_e0 has two Gaussian coefficients +`(1+i)/2` and `(1-i)/2`. Both signed words therefore use one rank-one child +and two monomial wrappers. The inverse translation is fused into the left +wrapper, exactly as in the retained QQ16 convention. The checker verifies +both Gaussian coefficients at every one of the 512 local basis addresses +for all 96 ports and both signs: 98,304 exact columns. External axes are +spectators. The identities lift ownerwise and to every positive tensor power. + +These are operator recipes and recursive rank counts. They do not themselves +assign available helper owners or bound the physical address implementation. + +## Phase and logical verification + +A field's Fourier phase is represented as a sum of binary parities with +integer coefficients modulo four. Such a function has a unique multilinear +polynomial of degree at most two modulo four: its linear coefficients are +modulo four and each cross coefficient is zero or two. Equality of these +polynomials is an identity on all 73-bit characters, not a random test. + +A native line appends the term `+/- (q dot w)`. A map M(g,a) changes each +phase axis v to gv and adds `2(a dot w)`. The checker applies exactly these +rules after every literal operation and requires matching phases for each +ADD. Alongside the phase it tracks an exact rational linear combination of +104 independent logical input arrays, carrying actual owner matrix products. +Native lines change frames; cover maps apply their logical owner routes. +Final checks require all 96 source rows to be the original independent input +and the eight output rows to be precisely R_U D_(2,U), with no dependence on +the discarded owned inputs. This jointly proves content and frame correctness +under the stated native semantics. + +## Complete local invoice and boundary + +There are 96 inverse and 96 positive lines, hence 192 rank-one children and +384 native wrapper maps. Each of 96 sources has one full-cover alignment and +one inverse, hence 192 full-cover maps. Each actual ordinary R column has +four signed unit coefficients, so there are 384 ADDs and eight CLEARs. +The retained per-real-component bounds are four primitives per ADD and one +per CLEAR; two components give `2*(384*4+8)=3088`. No SCALE or implicit COPY +is omitted. The eight owned output arrays are additional live storage. + +The result is a complete local operator read and an explicit local count, +not the complete PR2443 decoder or a favorable global bill. Other retained +cut arrays, query output conversions, stream/address costs, global child +delivery, storage lifetime, cleanup, precision and all-size supplier admission +remain open. This word alone does not change a moment or an exponent. diff --git a/research/qq16-l2-native-reconstruction/evidence/PR2468-verify.py b/research/qq16-l2-native-reconstruction/evidence/PR2468-verify.py new file mode 100644 index 0000000000..58c9c9b315 --- /dev/null +++ b/research/qq16-l2-native-reconstruction/evidence/PR2468-verify.py @@ -0,0 +1,316 @@ +#!/usr/bin/env python3 +"""Exact local QQ16 future-chart read, with borrowed sources restored. + +By ywz65 with substantial OpenAI Codex assistance, Apache-2.0. Source +reconstruction shares this author's method from the independent PR2456 audit; +no pending predecessor code is imported. No global supplier is claimed. +""" +import argparse +from collections import Counter +from copy import deepcopy +from fractions import Fraction as Q +from functools import lru_cache +import gzip +import hashlib +import io +import json +from pathlib import Path +import tarfile + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] +AXES = tuple(1 << i for i in range(73)) +A = (0, 7, 20, 27, 36, 46, 57, 111) +T = (21, 37, 47, 76, 81, 87, 92, 110) +U = tuple(p for p in range(112) if p not in A + T) +START = tuple((e, 1) for e in AXES[:17]) +COMMON = tuple((e, 1) for e in AXES[9:25]) +MEMBERS = { + "slots/local/CANONICAL-WORD.json.gz": "16bc0ebb04b4be6c0ade74badc6a0c0cdba4215eda86e4ff9f13abf8ecebd219", + "slots/local/LOCAL-PROGRAMS.json.gz": "241fde27d4e43f5a9cb6b128f9f76c5131a53d09f0371676163f914d0b0fef3a", + "t16/global/base/work/complex-nine-native/DATA-PHASES.json": "c5916ff312678f12aba403847643fbbc29f643acec60bdf836fa56cd3e8251fa", +} + + +def need(ok, why): + if not ok: + raise ValueError(why) + + +def sha(raw): + return hashlib.sha256(raw).hexdigest() + + +def act(columns, vector): + out = 0 + while vector: + bit = vector & -vector + out ^= columns[bit.bit_length() - 1] + vector ^= bit + return out + + +@lru_cache(None) +def multiply(g, h): + return tuple(act(g, v) for v in h) + + +def combine(a, b, coefficient=1): + result = dict(a) + for key, value in b.items(): + result[key] = result.get(key, Q(0)) + coefficient * value + return {key: value for key, value in result.items() if value} + + +def routed(g, row): + return {(variable, multiply(g, old)): value for (variable, old), value in row.items()} + + +@lru_cache(None) +def phase(terms): + linear, quadratic = [0] * 73, [0] * 73 + for vector, coefficient in terms: + bits = [i for i in range(73) if (vector >> i) & 1] + for i in bits: + linear[i] = (linear[i] + coefficient) % 4 + if coefficient % 2: + for j in bits: + if j > i: + quadratic[i] ^= 1 << j + return tuple(linear), tuple(quadratic) + + +def move_frame(terms, mapping): + g, shift = mapping + return tuple((act(g, vector), coefficient) for vector, coefficient in terms) + ((shift, 2),) + + +def load_sources(): + pins = json.loads((HERE / "SOURCES.json").read_text(encoding="utf-8")) + raw = {} + for item in pins["files"]: + if item["usage"] == "input": + data = (ROOT / item["path"]).read_bytes() + need(sha(data) == item["sha256"], "source hash: " + item["path"]) + raw[item["path"]] = data + packet = json.loads(gzip.decompress(raw["research/joint-query/certificate.json.gz"])) + decoded = {} + with tarfile.open(fileobj=io.BytesIO(raw["research/community-frontier1042-audit/selected-replay.tar.gz"]), mode="r:gz") as archive: + for name, digest in MEMBERS.items(): + matches = [item for item in archive.getmembers() if item.name == name] + need(len(matches) == 1 and matches[0].isfile(), "unique source member") + data = archive.extractfile(matches[0]).read() + need(sha(data) == digest, "member hash: " + name) + decoded[name.rsplit("/", 1)[-1]] = json.loads(gzip.decompress(data) if name.endswith("gz") else data) + word, programs = decoded["CANONICAL-WORD.json.gz"], decoded["LOCAL-PROGRAMS.json.gz"] + need((word["v"], 2 * word["v"] + word["R"]) == (112, 704), "source geometry") + rows = [{i: Q(1)} for i in range(712)] + for event in programs["forward"]: + if event == ["phase", "centers"]: + break + if event[0] != "scalar": + continue + op = event[1] + at = op[1][1] + (704 if op[1][0] == "C" else 0) + if op[0] == "clear": + rows[at] = {} + elif op[0] == "scale": + rows[at] = {j: x * Q(op[2], op[3]) for j, x in rows[at].items()} + else: + source = op[2][1] + (704 if op[2][0] == "C" else 0) + need(op[0] in ("add", "copy"), "known source gate") + rows[at] = dict(rows[source]) if op[0] == "copy" else combine(rows[at], rows[source], Q(op[3], op[4])) + else: + raise ValueError("missing source centre boundary") + R = [[rows[c].get(p, Q(0)) for p in range(112)] for c in word["centers"]] + need(R == [[Q(row.get(str(p), 0)) for p in range(112)] for row in packet["R_rows"]], "actual R") + need(tuple(packet["U_ports"]) == U and tuple(packet["A_ports"]) == A and tuple(packet["T_ports"]) == T, "actual partition") + need(all(x in (-1, 0, 1) for row in R for x in row), "signed unit coefficients") + need(all(sum(R[k][p] ** 2 for k in range(8)) == 4 for p in U), "four terms per ordinary port") + phases = decoded["DATA-PHASES.json"] + program = packet["programs"]["B_1_2"] + records = {} + for p in U: + source = phases["recipes"][p] + need(source["port"] == p, "port binding") + q = source["q"] + basis = source["idle_children"][0]["orthogonal_axes"][:8] + need(q < 512 and q.bit_count() % 2 == 1, "actual odd local port") + need(all((q & b).bit_count() % 2 == 0 for b in basis), "port-normal chart") + swaps = [b ^ AXES[17 + i] for i, b in enumerate(basis)] + g = tuple(e ^ act(swaps, sum(((e & s).bit_count() % 2) << i for i, s in enumerate(swaps))) for e in AXES) + shift = q ^ sum((((b.bit_count() - 1) // 2) % 2) << (17 + i) for i, b in enumerate(basis)) + inverse_shift = act(g, shift) + names = [event[2] for event in program if event[0] == "cover_map" and event[1] == ["L", 112 + p]] + need(len(names) == 4, "actual Y map pair inventory") + entry, exit_map = [packet["map_registry"][name] for name in names[:2]] + need(tuple(entry["owner_right_matrix_columns"]) == tuple(exit_map["owner_right_matrix_columns"]) == g, "actual future owner action") + need(entry["payload_translation_at_identity_owner"] == shift and exit_map["payload_translation_at_identity_owner"] == inverse_shift, "actual future payload shifts") + need(multiply(g, g) == AXES and act(g, q) == q, "involutive route fixes port") + records[p] = {"q": q, "g": g, "shift": shift, "inverse_shift": inverse_shift, "entry_name": names[0], "exit_name": names[1]} + return R, records, {name: sha(data) for name, data in raw.items()} + + +def literal_program(R): + # Whole sweeps are explicit barriers: no ADD is interleaved with alignment. + return ([{"op": "line", "port": p, "sign": -1} for p in U] + + [{"op": "map", "port": p, "inverse": False} for p in U] + + [{"op": "clear_output", "query": k} for k in range(8)] + + [{"op": "add", "query": k, "port": p, "coefficient": int(R[k][p])} for k in range(8) for p in U if R[k][p]] + + [{"op": "map", "port": p, "inverse": True} for p in U] + + [{"op": "line", "port": p, "sign": 1} for p in U]) + + +def replay(program, R, records, fault=None): + frames = {p: START for p in U} + frames.update({112 + k: () for k in range(8)}) + rows = {p: {(p, AXES): Q(1)} for p in frames} + trace = Counter() + for index, event in enumerate(program): + op = event["op"] + trace[op] += 1 + if op == "line": + p, sign = event["port"], event["sign"] + if fault == "omit_normalization" and sign == -1 and p == U[0]: + continue + if fault == "omit_restoration" and sign == 1 and p == U[0]: + continue + frames[p] += ((records[p]["q"], sign),) + elif op == "map": + p = event["port"] + record = records[p] + shift = record["inverse_shift"] if event["inverse"] else record["shift"] + if fault == "omit_payload_translation" and p == U[0]: + shift = 0 + if fault == "wrong_inverse_translation" and event["inverse"] and p == U[0]: + shift = record["shift"] + frames[p] = move_frame(frames[p], (record["g"], shift)) + rows[p] = routed(record["g"], rows[p]) + elif op == "clear_output": + at = 112 + event["query"] + if fault == "omit_output_clear" and event["query"] == 0: + # Keep a matching declared frame to isolate the dirty-input fault. + frames[at] = COMMON + continue + rows[at] = {} + frames[at] = COMMON + else: + need(op == "add", "known query operation") + p, at = event["port"], 112 + event["query"] + need(phase(frames[p]) == phase(frames[at]), "unmatched native scalar frames at event " + str(index)) + coefficient = event["coefficient"] + if fault == "wrong_query_coefficient" and event == next(x for x in program if x["op"] == "add"): + coefficient = -coefficient + rows[at] = combine(rows[at], rows[p], coefficient) + for p in U: + need(phase(frames[p]) == phase(START), "borrowed source frame not restored") + need(rows[p] == {(p, AXES): Q(1)}, "borrowed source content not restored") + for k in range(8): + need(phase(frames[112 + k]) == phase(COMMON), "query output frame") + expected = {(p, records[p]["g"]): R[k][p] for p in U if R[k][p]} + need(rows[112 + k] == expected, "exact future query or dirty output mismatch") + return dict(trace) + + +def rows_from_columns(columns): + return [sum(((columns[j] >> i) & 1) << j for j in range(9)) for i in range(9)] + + +def linear_map(rows, address): + return sum(((row & address).bit_count() % 2) << i for i, row in enumerate(rows)) + + +def line_recipe(q, sign): + pivot = (q & -q).bit_length() - 1 + columns = (q,) + tuple(1 << j for j in range(9) if j != pivot) + images = {act(columns, address): address for address in range(512)} + need(len(images) == 512, "invertible native wrapper") + inverse_columns = tuple(images[1 << i] for i in range(9)) + return {"rank": 1, "left_rows": rows_from_columns(columns), "left_offset": 0 if sign == 1 else q, "right_rows": rows_from_columns(inverse_columns)} + + +def kernel(recipe, address): + middle = linear_map(recipe["right_rows"], address) + a = linear_map(recipe["left_rows"], middle) ^ recipe["left_offset"] + b = linear_map(recipe["left_rows"], middle ^ 1) ^ recipe["left_offset"] + need(a != b, "two native kernel terms") + return {a: (1, 1), b: (1, -1)} # Gaussian numerators, common denominator 2. + + +def calculate(): + R, records, pins = load_sources() + program = literal_program(R) + trace = replay(program, R, records) + need(trace == {"line": 192, "map": 192, "clear_output": 8, "add": 384}, "literal invoice") + need(len(program) == 776, "literal event count") + controls = {} + for fault in ("omit_normalization", "omit_restoration", "omit_payload_translation", "wrong_inverse_translation", "omit_output_clear", "wrong_query_coefficient"): + try: + replay(program, R, records, fault) + except ValueError as error: + controls[fault] = str(error) + else: + raise ValueError("ineffective fault: " + fault) + # A first ADD before the whole alignment sweep must be rejected. + reordered = deepcopy(program) + target = next(i for i, event in enumerate(reordered) if event["op"] == "add") + event = reordered.pop(target) + first_map = next(i for i, item in enumerate(reordered) if item["op"] == "map") + reordered.insert(first_map, event) + try: + replay(reordered, R, records) + except ValueError as error: + controls["query_before_alignment_and_output_preparation"] = str(error) + else: + raise ValueError("early query control ineffective") + recipe_columns = 0 + recipes = {} + for p in U: + q = records[p]["q"] + for sign in (-1, 1): + recipe = line_recipe(q, sign) + for address in range(512): + need(kernel(recipe, address) == {address: (1, sign), address ^ q: (1, -sign)}, "exact signed rank-one native kernel") + recipe_columns += 1 + recipes[f"{p}:{sign}"] = recipe + bad = deepcopy(recipes[f"{U[0]}:-1"]) + bad["left_offset"] = 0 + need(kernel(bad, 0) != {0: (1, -1), records[U[0]]["q"]: (1, 1)}, "inverse line sign control") + controls["inverse_line_without_translation"] = "kernel differs at address zero" + # The unnormalized X field has precisely the residual C_q at the legal Y alignment. + residuals = {} + for p, record in records.items(): + aligned = move_frame(START, (record["g"], record["shift"])) + need(phase(aligned) == phase(COMMON + ((record["q"], 1),)), "exact future-X residual") + witness = (record["q"] & -record["q"]) + need(sum(c * ((v & witness).bit_count() % 2) for v, c in aligned) % 4 != sum(c * ((v & witness).bit_count() % 2) for v, c in COMMON) % 4, "residual is nonzero") + residuals[str(p)] = {"line": record["q"], "nonzero_character": witness} + invoice = {"rank_one_children": 192, "native_rank_mass": 192, "native_wrapper_maps": 384, + "full_cover_maps": 192, "signed_ADD_macros": 384, "CLEAR_macros": 8, + "scalar_real_primitive_allowance": 2 * (4 * 384 + 8), "owned_live_query_outputs": 8, + "borrowed_source_arrays_restored": 96, "literal_events": 776} + return {"status": "PASS_QQ16_FUTURE_X_QUERY", "source_sha256": pins, "member_sha256": MEMBERS, + "source_cut": "post-B_1_2 X_U in completed frame F_(L+E1)", "output_frame": "F_(E1+E2)", + "query": "R_U D_(2,U) C = B2 C", "formal_independent_inputs": 104, + "future_X_residuals": residuals, "invoice": invoice, "controls": controls, + "native_kernel_basis_columns": recipe_columns, "program": program, "native_recipes": recipes, + "scope": "Complete local native operator read with restored sources and eight owned outputs; global delivery, retention, physical map cost, recursive precision and supplier invoice are open"} + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--write-result", action="store_true") + args = parser.parse_args() + result = calculate() + encoded = json.dumps(result, sort_keys=True, indent=2, default=str) + "\n" + path = HERE / "RESULT.json" + if args.write_result: + with path.open("x", encoding="utf-8", newline="\n") as out: + out.write(encoded) + else: + need(path.read_text(encoding="utf-8") == encoded, "committed receipt mismatch") + print("PASS_QQ16_FUTURE_X_QUERY sources=96 outputs=8 children=192 cover_maps=192 native_columns=98304 controls=8 no_new_kappa") + + +if __name__ == "__main__": + main() diff --git a/research/qq16-l2-native-reconstruction/evidence/PR2470-README.md b/research/qq16-l2-native-reconstruction/evidence/PR2470-README.md new file mode 100644 index 0000000000..83d2b42eed --- /dev/null +++ b/research/qq16-l2-native-reconstruction/evidence/PR2470-README.md @@ -0,0 +1,260 @@ +# In-place availability of PR2443's two-cut QQ16 observations + +**Negative result (scoped screen). No kappa claim, no supplier, no controller.** +[PR2443](https://github.com/CrocSwap/integer-mult-bounds/pull/2443) (starship-s, +head `545c05e17243c962b112b91e7f84b4c1a41de7b8`) decodes all pair-0 inputs of +the conserved `F0/B_1_2` pair from 224 observed port arrays at two cuts. It +grants the retention of those arrays and calls its F0 record transient. This +package checks which of them are still held by a live field at a decode point +of the pinned 19-event QQ16 recipe. It answers the logical-trace part of PR2443 +open question 1 (native endpoint types stay open) and the storage term of open +question 2. + +**What is already known and what is new.** That pair 0 cannot be recovered from +final-only records under the 19-event schedule is PR2346's obstruction +(alephnan, head `653520d7`: the final-only observation map loses at least +`ceil(8|G|/7)` dimensions of pair 0's selected input). The PR2376 scope map +(commdata2338, head `157143ab`) warns against assuming that a decoder granted +the B1 cut works from final records. The qualitative d18 failure below is +consistent with, and largely implied by, that work. This package quantifies it. +New here: exact per-array counts at both decode points, the d1 split (104 live, +120 overwritten by B1), the scalar-multiple and same-port-span relaxations, +the checked recomputation leads L1/L2 with an L2-variant decoder, and the +transfer of the counts to the price3 convention. + +| item (cut) | arrays | live at d1 (after `B_1_2`) | live at d18 (after terminal) | first overwrite event | +|---|---:|---:|---:|---| +| `x1_A` (after F0) | 8 | 0 | 0 | 1 (`B_1_2`) | +| `x1_T` (after F0) | 8 | 0 | 0 | 1 (`B_1_2`) | +| `y1_A` (after F0) | 8 | 0 | 0 | 1 (`B_1_2`) | +| `y1_T` (after F0) | 8 | 0 | 0 | 1 (`B_1_2`) | +| `x1_S` (after F0) | 88 | 0 | 0 | 1 (`B_1_2`) | +| `y2_A` (after B1) | 8 | 8 (same field) | 0 | 3 (`F2`) | +| `C=x2_U` (after B1) | 96 | 96 (same field) | 0 | 2 (bridge `1->0`); 3 (`F2`) if pairs 1-3 are zero | +| **total copies needed** | 224 | **120** | **224** | | + +"Live" means equal, as a linear map of all 896 initial port arrays, to some +field of the four bank pairs at that point. The zero entries also hold under +three relaxations. The array is not a nonzero scalar multiple of any live +field. It is not in the span of the two fields `X_(k,p)`, `Y_(k,p)` at any one +port of any pair. Neither statement changes if a cover map `M(g,delta)` is +applied (see "Model" below). The counts do not change if the terminal also +exchanges selected fields, or if pairs 1-3 start at zero. + +Per owner per replica, the contract therefore needs these retained copies: + +- **d1:** 120 copies (all F0-cut arrays), each held across one call (`B_1_2`), + so 120 coordinate-calls. +- **d18:** all 224 copies. The 120 F0-cut arrays are held for 8 calls and the + 104 B1-cut arrays for 7 calls, so 1688 coordinate-calls. + +### Comparison with the #2074 pricing (inherited, unreviewed) + +philippeVV's four-bank finding (#2074; [fork](https://github.com/philippeVV/integer-mult-bounds) +commit `680d0997621a2cecfef2186ab143377658687825`, path +`research/joint-query-first-pair-catalogue/four-bank/`) says that with +`C = 0` the route "pays only for in-place or single-call storage". `price.py` +re-implements the `price3.py` convention (5F+4B QQ16 profile, rank-8 child +plus 8 mass per coordinate-call for centre-like storage, 72 mass per new live +family). It uses the pinned `ceiling.py`. Before transferring anything, it +reproduces three committed values of `price3.json` exactly: the selected +ceiling and the C=0 centre rows for 62 and 64 coordinates. The results are in +[PRICE.json](PRICE.json): + +| convention | max coordinate-calls/replica with any positive saving | max still beating the selected ceiling | census demand d1 / d18 | +|---|---:|---:|---| +| C=0, centre-like copy | 111 | 71 | 120 / 1688: no saving at either (L2 variant: 32) | +| C=0, new live family | 12 | 8 | 120 / 1688: no saving at either | +| C=64, centre-like copy | 39 | 0 | none beats selected | +| C=64, new live family | 4 | 0 | none beats selected | + +The literal PR2443 contract needs copies at both decode points. At the +favourable d1 point the copies are single-call storage, which philippeVV's +qualitative condition allows. The failure is quantitative: 120 coordinate-calls +exceed the C=0 centre-like break-even of 111 (any saving) and 71 (beat the +selected ceiling). **Under this convention the literal contract exceeds the C=0 +centre-like break-even even though its d1 storage is single-call.** By a +dimension count this is also the floor for PR2443's d1 read set: the 104 live +reads (`y2_A`, `C`) leave 120 of the 224 pair-0 input dimensions, so any linear +record that a decoder confined to those reads can use must retain at least 120 +coordinates per owner across B1. + +Three limits on this conclusion: + +- *Copy kind.* price3 also has a `line` kind (an in-place write that adds no + new live data). It is not used here because a retained copy is new live data: + the census shows that no live field holds it. If copies were priced as `line` + writes, this screen would not reject them. +- *Pair 0 only.* PR2443 recovers pair 0 only. #2074 Theorem B's 62 is the + four-bank total (four banks at `77N/5` each, rounded up); the inherited + per-bank floor is `ceil(77N/5)`, 16 per owner at that normalisation. A complete controller must also repair + banks 1-3, which also lose a query by Theorem A, so the pair-0 demand counted + here is a favourable lower bound on a full controller's storage. +- *Literal contract only.* Lead L2 (below) gives a variant that needs only 32 + coordinate-calls at d1, below both C=0 break-evens. So this negative result is + specific to PR2443's literal read set and is not evidence against a + compressed contract. + +This screens one contract under one inherited, unreviewed price convention. It +is not an impossibility theorem for QQ16 controllers. Note also that the +convention gives a free controller (zero retention) +179.5% over the selected +ceiling at C=0 and +0.28% at C=64 (PRICE.json rows `zero_retention`), so the +C=0/C=64 choice dominates every storage figure here. + +### Recomputation leads (not in-place availability) + +Two exact identities follow from CONSERVED-QQ16 (1) and (3). The checker also +verifies both in the model. + +- **L1.** F0, B1 and F2 conserve the 16 selected pair sums `X_V+Y_V=x_V+y_V`. + Nothing writes them afterwards, so they are live two-field sums at d1 and at + d18 (identity selected terminal). PR2443's last step `y_V=x1_V+y1_V-x_V` + only needs these sums. +- **L2.** At d1, `x1_U = X2_U + Y2_U - K_(1,U) ell_(1,T) x1_T`. The driver + `ell_(1,T) x1_T` is computable from the retained `x1_T` record, so the 88 + `x1_S` copies can be replaced by a same-port read of `Y2_U` (`X2_U = C` is + already read). The checker runs PR2443's decoder with these `x1_U` forms and + recovers all 224 pair-0 inputs from the 32 retained F0 selected arrays + (`x1_A, x1_T, y1_A, y1_T`) plus the live post-B1 reads `y2_A`, `C`, `Y2_U` + (RESULT.json `leads.L2_variant_d1`). Its storage demand is 32 + coordinate-calls. Under the inherited C=0 centre-like convention that is + storage-only +99.56% over the selected ceiling (PRICE.json row + `d1_L2_variant`); reads, their legality, chart maps and restoration are not + priced, so this is a lead, not a bound. L1 cannot replace `y1_A`/`y1_T`, + because the decoder queries them separately. Because `B_1_2` is invertible, + a decoder that may read the whole post-B1 state of pair 0 needs no copy at + all at d1. PR2443 excludes `y2_U` from its reads, so both are different + contracts. + +So the census prices the literal contract; at d1 that equals the information +floor for its read set, and only extra reads lower it. + +## Model, exactness and scope + +- **Maps:** CONSERVED-QQ16 equations (1) and (3). The checker binds them to the + packet's `F_contract`/`B_contract` strings. Pins: `R`, `K=R^T/4`, the + A/T/U96 sets and the Grams (U:48, A:4, T:4). +- **Recipe:** the literal 19-event `GLOBAL-TEMPLATE.json.gz` recipe (archive + member sha256 `a179dad8...`). Its local pairs are `0,0,0,1,1,2,2,3,3`. +- **Bridges and terminal:** semantics follow PR2346 section 1 (alephnan, head + `653520d7`). A bridge does `X_j,U += c X_i,U; Y_i,U -= c Y_j,U`. The + terminal does `(X_U,Y_U) -> (Y_U,-X_U)`; the selected terminal is identity or + the same exchange (variant). +- **Exactness:** every field is an exact rational linear form in the 896 + initial port arrays of four pairs. The executable instance is the + owner/payload-constant subspace, where every cover map + `M(g,delta)f(d,z)=f(d*g, z XOR d*delta)` is the identity. Any actual + equality, even up to a scalar or a cover map, restricts to an equality + there. So every "not live" entry is an exact counterexample for the actual + routed maps. The only "live" entries are the post-B1 arrays at d1, where no + event intervenes. The support argument proves them, and every survival claim + is checked against the symbolic write sets. +- **Consistency check:** in this model, PR2443's ordered decoder recovers all + 224 pair-0 inputs exactly, including `C=-y_U` and the two-sided `R_J` + inverse. This was implemented independently; no predecessor code is imported. + It runs on the payload-constant subspace only, so it does not validate + payload-sensitive charts: ywz65's PR2456 (head `665ba8d7`) shows that + payload-constant fixtures miss the logical-D vs physical-A chart fault. The + "not live" direction of the census is unaffected, since a restriction of an + actual equality is still an equality. +- **Not covered:** physical idle cover sweeps, terminal Y translations, + bank padding and phase adapters. These are invertible frame changes in the + inherited logical convention. They cannot make an overwritten logical value + live again. Also not covered: native read legality, read and chart-map cost, + cleanup, hosting, precision, and other contracts or schedules. + +## Negative controls (all must be rejected or change the receipt) + +Controls 1 and 4 are claim rejections (a false statement is tested against +the computed states). Controls 2, 3, 5 and 6 mutate the pipeline. + +1. Claiming `x1_A` survives B1 in place is rejected. +2. Dropping F2 (event 3) changes the d18 census to 216 copies. Eight arrays + are then live in place, and 104 are scalar multiples of live fields. +3. Dropping B1 (event 1) changes the d1 census to 0 copies. +4. Claiming `C=+y_U` is rejected. +5. A corrupted centre coefficient fails the Gram/source checks. +6. A wrong sign of the future logger `E_t` breaks PR2443's decoder. + +A wrong `11a -> 12a` coefficient in the backward `Y_T` output was also tried. +It does **not** break the decoder, because PR2443 never reads `y2_T`. That +mutation was therefore not used as a control. + +## Reproduce + +From the repository root (stdlib only; about 65 s and 50 s on one core): + +```sh +python3 -I -B research/qq16-cut-retention-census/verify.py +python3 -I -B research/qq16-cut-retention-census/price.py +``` + +Expected last lines: `PASS_NEGATIVE_CONTROLS 6`, `PASS_QQ16_CUT_RETENTION_CENSUS`, +then `PASS_QQ16_CUT_RETENTION_PRICE_TRANSFER`. Each script recomputes its JSON +and requires it to equal the committed [RESULT.json](RESULT.json) (receipt +`8c57f8f5...`) and [PRICE.json](PRICE.json). Per-array rows are in +[CENSUS-ROWS.json](CENSUS-ROWS.json); verify.py also requires them to equal +the recomputed rows. Registered replay: +`python3.12 scripts/research_package.py --package research/qq16-cut-retention-census`. +The checks were run with Python 3.14.4, since 3.12 was not installed locally. + +Base commit `0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2`. Input pins are in +[SOURCES.json](SOURCES.json). External, read-only pins: PR2443 `545c05e1`, +PR2346 `653520d7`, PR2174 `f79470a7`, and philippeVV `price3.py` sha256 +`1c2ca9a4...` (philippeVV/integer-mult-bounds commit +`680d0997621a2cecfef2186ab143377658687825`, +`research/joint-query-first-pair-catalogue/four-bank/`). price3 is not +vendored; its three reproduction values are hard-coded in `price.py`. + +## Open next questions + +1. **What is the smallest retained record for a final-only (d18) decode with + PR2443's read set plus legal final reads?** + - *Why it matters:* the literal contract needs 1688 coordinate-calls, while + the C=0 break-even is 71. For pair 0 alone the inherited Theorem B floor + is `ceil(77N/5)` per bank, 16 at the normalisation where 62 is the + four-bank total, and a full + controller must also repair banks 1-3. + - *First step:* carry the L2 variant (32 retained arrays plus a `Y2_U` + read) through F2..F8 and the terminal with this census code. + - *Blocker:* the legal native read types for former-Y endpoints and + `X+Y` sums. +2. **Can a controller use the d1 decode point at all?** + - *Why it matters:* the demand there is 120 for the literal contract, 32 + for the L2 variant, and 0 with full post-B1 reads, since `B_1_2` is + invertible. But a mid-schedule decode must restore what it reads before + F2. + - *First step:* price the CONSERVED-QQ16 inverse of B (`H_s`, `E_t`) as + reads plus restoration. + - *Blocker:* no priced read of `y2_U`/`X2_T` at the completed-X type. + ywz65's PR2468 (head `baa90ee8`, opened 11:49Z, + `research/qq16-future-x-query`) constructs a native local read of + `C=x2_U` at the post-B1 frame with restoration and leaves retained + observations open; this package defers to it for the read and supplies + the retention count it leaves open. +3. **Which centre charge applies to QQ16, C=0 or C=64?** This is the + maintainers' open question in #2074. Under C=64 no positive retention + budget beats the selected ceiling; even a free controller gains only +0.28%. + +## Credit + +The observation contract and decoder are from PR2443 (starship-s). The local +maps, packet and cover semantics are from Ali Romman (PR1969, +`research/joint-query`). The bridge/terminal semantics and the 19-event +binding are from alephnan (PR2346). The two-query recovery contract is from +commdata2338 (PR2174; also PR2153, PR2376). The unread basis and 88-port +threshold are from Gareth Davidson / bitplane (PR2432). The C=64 screen and +the `y2_A` pricing are from 1337isnot1337 (PR2079, PR2197). Theorem B and the +price3 convention are from Philippe Van Velzen (#2074, fork `680d0997`). The +trace method is from Ross Richardson (PR2104). The ceiling model is +`research/complex-local-word-ceiling`. The final-only obstruction is +alephnan's PR2346, and the contract scope map is commdata2338's PR2376 +(`157143ab`). Concurrent work: ywz65's PR2456 (head `665ba8d7`) audits +PR2443's operators with payload-sensitive fixtures, and ywz65's PR2468 (head +`baa90ee8`) constructs the native `C` read of open question 2. ToikY's PR2416 (head +`f2c93e76`) prices native retention of A-copy data at the `B_1_2[:80]` cut +(24 native lines vs 16) in a different cost model; it is not combined here. + +Prepared by thakrarsagar with substantial AI assistance from Claude +(Anthropic, Claude Opus 5.5). No independent human review is claimed. +Apache-2.0. diff --git a/research/qq16-l2-native-reconstruction/native_support.py b/research/qq16-l2-native-reconstruction/native_support.py new file mode 100644 index 0000000000..98a40a8980 --- /dev/null +++ b/research/qq16-l2-native-reconstruction/native_support.py @@ -0,0 +1,180 @@ +#!/usr/bin/env python3 +"""Exact QQ16 source/phase helpers adapted from ywz65 PR2468; see PREDECESSORS.json. + +By ywz65 with substantial OpenAI Codex assistance, Apache-2.0. Source +reconstruction shares this author's method from the independent PR2456 audit; +no pending predecessor code is imported. No global supplier is claimed. +""" +import argparse +from collections import Counter +from copy import deepcopy +from fractions import Fraction as Q +from functools import lru_cache +import gzip +import hashlib +import io +import json +from pathlib import Path +import tarfile + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] +AXES = tuple(1 << i for i in range(73)) +A = (0, 7, 20, 27, 36, 46, 57, 111) +T = (21, 37, 47, 76, 81, 87, 92, 110) +U = tuple(p for p in range(112) if p not in A + T) +START = tuple((e, 1) for e in AXES[:17]) +COMMON = tuple((e, 1) for e in AXES[9:17]) +MEMBERS = { + "slots/local/CANONICAL-WORD.json.gz": "16bc0ebb04b4be6c0ade74badc6a0c0cdba4215eda86e4ff9f13abf8ecebd219", + "slots/local/LOCAL-PROGRAMS.json.gz": "241fde27d4e43f5a9cb6b128f9f76c5131a53d09f0371676163f914d0b0fef3a", + "t16/global/base/work/complex-nine-native/DATA-PHASES.json": "c5916ff312678f12aba403847643fbbc29f643acec60bdf836fa56cd3e8251fa", +} + + +def need(ok, why): + if not ok: + raise ValueError(why) + + +def sha(raw): + return hashlib.sha256(raw).hexdigest() + + +def act(columns, vector): + out = 0 + while vector: + bit = vector & -vector + out ^= columns[bit.bit_length() - 1] + vector ^= bit + return out + + +@lru_cache(None) +def multiply(g, h): + return tuple(act(g, v) for v in h) + + +def combine(a, b, coefficient=1): + result = dict(a) + for key, value in b.items(): + result[key] = result.get(key, Q(0)) + coefficient * value + return {key: value for key, value in result.items() if value} + + +def routed(g, row): + return {(variable, multiply(g, old)): value for (variable, old), value in row.items()} + + +@lru_cache(None) +def phase(terms): + linear, quadratic = [0] * 73, [0] * 73 + for vector, coefficient in terms: + bits = [i for i in range(73) if (vector >> i) & 1] + for i in bits: + linear[i] = (linear[i] + coefficient) % 4 + if coefficient % 2: + for j in bits: + if j > i: + quadratic[i] ^= 1 << j + return tuple(linear), tuple(quadratic) + + +def move_frame(terms, mapping): + g, shift = mapping + return tuple((act(g, vector), coefficient) for vector, coefficient in terms) + ((shift, 2),) + + +def load_sources(): + pins = json.loads((HERE / "SOURCES.json").read_text(encoding="utf-8")) + raw = {} + for item in pins["files"]: + if item["usage"] == "input": + data = (ROOT / item["path"]).read_bytes() + need(sha(data) == item["sha256"], "source hash: " + item["path"]) + raw[item["path"]] = data + for item in pins['pending_sources']: + data = (ROOT / item['path']).read_bytes() + need(sha(data) == item['sha256'], 'pending source hash: ' + item['path']) + raw[item['path']] = data + packet = json.loads(gzip.decompress(raw["research/joint-query/certificate.json.gz"])) + decoded = {} + with tarfile.open(fileobj=io.BytesIO(raw["research/community-frontier1042-audit/selected-replay.tar.gz"]), mode="r:gz") as archive: + for name, digest in MEMBERS.items(): + matches = [item for item in archive.getmembers() if item.name == name] + need(len(matches) == 1 and matches[0].isfile(), "unique source member") + data = archive.extractfile(matches[0]).read() + need(sha(data) == digest, "member hash: " + name) + decoded[name.rsplit("/", 1)[-1]] = json.loads(gzip.decompress(data) if name.endswith("gz") else data) + word, programs = decoded["CANONICAL-WORD.json.gz"], decoded["LOCAL-PROGRAMS.json.gz"] + need((word["v"], 2 * word["v"] + word["R"]) == (112, 704), "source geometry") + rows = [{i: Q(1)} for i in range(712)] + for event in programs["forward"]: + if event == ["phase", "centers"]: + break + if event[0] != "scalar": + continue + op = event[1] + at = op[1][1] + (704 if op[1][0] == "C" else 0) + if op[0] == "clear": + rows[at] = {} + elif op[0] == "scale": + rows[at] = {j: x * Q(op[2], op[3]) for j, x in rows[at].items()} + else: + source = op[2][1] + (704 if op[2][0] == "C" else 0) + need(op[0] in ("add", "copy"), "known source gate") + rows[at] = dict(rows[source]) if op[0] == "copy" else combine(rows[at], rows[source], Q(op[3], op[4])) + else: + raise ValueError("missing source centre boundary") + R = [[rows[c].get(p, Q(0)) for p in range(112)] for c in word["centers"]] + need(R == [[Q(row.get(str(p), 0)) for p in range(112)] for row in packet["R_rows"]], "actual R") + need(tuple(packet["U_ports"]) == U and tuple(packet["A_ports"]) == A and tuple(packet["T_ports"]) == T, "actual partition") + need(all(x in (-1, 0, 1) for row in R for x in row), "signed unit coefficients") + need(all(sum(R[k][p] ** 2 for k in range(8)) == 4 for p in U), "four terms per ordinary port") + phases = decoded["DATA-PHASES.json"] + program = packet["programs"]["B_1_2"] + records = {} + for p in U + T: + source = phases["recipes"][p] + need(source["port"] == p, "port binding") + q = source["q"] + basis = source["idle_children"][0]["orthogonal_axes"][:8] + need(q < 512 and q.bit_count() % 2 == 1, "actual odd local port") + need(all((q & b).bit_count() % 2 == 0 for b in basis), "port-normal chart") + swaps = [b ^ AXES[9 + i] for i, b in enumerate(basis)] + g = tuple(e ^ act(swaps, sum(((e & s).bit_count() % 2) << i for i, s in enumerate(swaps))) for e in AXES) + shift = q ^ sum((((b.bit_count() - 1) // 2) % 2) << (9 + i) for i, b in enumerate(basis)) + inverse_shift = act(g, shift) + names = [event[2] for event in program if event[0] == "cover_map" and event[1] == ["L", 112 + p]] + need(len(names) == 4, "actual Y map pair inventory") + entry, exit_map = [packet["map_registry"][name] for name in names[2:]] + need(tuple(entry["owner_right_matrix_columns"]) == tuple(exit_map["owner_right_matrix_columns"]) == g, "actual current owner action") + need(entry["payload_translation_at_identity_owner"] == shift and exit_map["payload_translation_at_identity_owner"] == inverse_shift, "actual current payload shifts") + need(multiply(g, g) == AXES and act(g, q) == q, "involutive route fixes port") + records[p] = {"q": q, "g": g, "shift": shift, "inverse_shift": inverse_shift, "entry_name": names[2], "exit_name": names[3]} + return R, records, {name: sha(data) for name, data in raw.items()} + + +def rows_from_columns(columns): + return [sum(((columns[j] >> i) & 1) << j for j in range(9)) for i in range(9)] + + +def linear_map(rows, address): + return sum(((row & address).bit_count() % 2) << i for i, row in enumerate(rows)) + + +def line_recipe(q, sign): + pivot = (q & -q).bit_length() - 1 + columns = (q,) + tuple(1 << j for j in range(9) if j != pivot) + images = {act(columns, address): address for address in range(512)} + need(len(images) == 512, "invertible native wrapper") + inverse_columns = tuple(images[1 << i] for i in range(9)) + return {"rank": 1, "left_rows": rows_from_columns(columns), "left_offset": 0 if sign == 1 else q, "right_rows": rows_from_columns(inverse_columns)} + + +def kernel(recipe, address): + middle = linear_map(recipe["right_rows"], address) + a = linear_map(recipe["left_rows"], middle) ^ recipe["left_offset"] + b = linear_map(recipe["left_rows"], middle ^ 1) ^ recipe["left_offset"] + need(a != b, "two native kernel terms") + return {a: (1, 1), b: (1, -1)} # Gaussian numerators, common denominator 2. diff --git a/research/qq16-l2-native-reconstruction/test_verify.py b/research/qq16-l2-native-reconstruction/test_verify.py new file mode 100644 index 0000000000..a7662e631c --- /dev/null +++ b/research/qq16-l2-native-reconstruction/test_verify.py @@ -0,0 +1,111 @@ +#!/usr/bin/env python3 +"""Mutation, ownership and exported-source boundary checks; stdlib only.""" +from copy import deepcopy +import importlib.util +import json +import os +from pathlib import Path +import shutil +import subprocess +import sys +import tempfile +import unittest + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] +spec = importlib.util.spec_from_file_location('l2_verifier', HERE/'verify.py') +V = importlib.util.module_from_spec(spec) +spec.loader.exec_module(V) + + +class TestBoundaries(unittest.TestCase): + @classmethod + def setUpClass(cls): + cls.R, cls.records, _ = V.N.load_sources() + cls.word = V.program(cls.R) + cls.temp = tempfile.TemporaryDirectory(prefix='qq16-l2-') + cls.export = Path(cls.temp.name).resolve() + if not cls.export.is_relative_to(Path(tempfile.gettempdir()).resolve()): + raise RuntimeError('unexpected temporary export root') + cls.package = cls.export/'research'/HERE.name + shutil.copytree(HERE, cls.package, ignore=shutil.ignore_patterns('__pycache__')) + sources = json.loads((HERE/'SOURCES.json').read_text(encoding='utf-8')) + for item in sources['files']: + if item['usage'] == 'input': + target = cls.export/item['path'] + target.parent.mkdir(parents=True, exist_ok=True) + shutil.copyfile(ROOT/item['path'], target) + + @classmethod + def tearDownClass(cls): + cls.temp.cleanup() + + def run_export(self): + env = dict(os.environ) + env['PATH'] = '' + return subprocess.run([sys.executable, '-I', '-O', '-B', str(self.package/'verify.py')], + cwd=self.export, capture_output=True, text=True, env=env, timeout=60) + + def test_private_scratch_must_be_clean(self): + word = deepcopy(self.word) + last = max(i for i, e in enumerate(word) if e['op'] == 'clear' and e['field'] == 'C') + del word[last] + with self.assertRaisesRegex(ValueError, 'private owner body not clean'): + V.replay(word, self.R, self.records) + + def test_complete_alignment_precedes_scalar_body(self): + word = deepcopy(self.word) + index = next(i for i, e in enumerate(word) if e['op'] == 'map' and e['field'] == 'Z1' and not e['inverse']) + moved = word.pop(index) + index = next(i for i, e in enumerate(word) if e['op'] == 'add' and e['dst'] == 'Z1' and e['src'] == 'C') + word.insert(index+1, moved) + with self.assertRaisesRegex(ValueError, 'native ADD frame mismatch'): + V.replay(word, self.R, self.records) + + def test_git_free_optimized_export_is_read_only(self): + paths = [p for p in self.export.rglob('*') if p.is_file()] + before = {p: p.read_bytes() for p in paths} + result = self.run_export() + self.assertEqual(result.returncode, 0, result.stdout+result.stderr) + self.assertIn('PASS_QQ16_L2_NATIVE_RECONSTRUCTION', result.stdout) + self.assertEqual(before, {p: p.read_bytes() for p in paths}) + self.assertFalse(any(self.export.rglob('__pycache__'))) + + def test_receipt_and_literal_word_are_required(self): + for name, change in [('RESULT.json', lambda v: v['invoice'].__setitem__('native_rank_mass', 400)), + ('WORD.json', lambda v: v[0].__setitem__('sign', -1))]: + path = self.package/name + before = path.read_bytes() + try: + value = json.loads(before) + change(value) + path.write_text(json.dumps(value), encoding='utf-8') + result = self.run_export() + self.assertNotEqual(result.returncode, 0) + self.assertIn('committed '+name+' differs', result.stderr) + finally: + path.write_bytes(before) + path = self.package/'RESULT.json' + target = self.package/'RESULT.saved' + path.rename(target) + try: + self.assertNotEqual(self.run_export().returncode, 0) + finally: + target.rename(path) + + def test_cost_source_and_pending_evidence_drift_rejected(self): + for relative in ['research/joint-query/verify_scalar.py', + 'research/qq16-l2-native-reconstruction/evidence/PR2470-README.md']: + path = self.export/relative + before = path.read_bytes() + try: + path.write_bytes(before+b'\n# mutation\n') + result = self.run_export() + self.assertNotEqual(result.returncode, 0) + self.assertIn('source hash:', result.stderr) + finally: + path.write_bytes(before) + + +if __name__ == '__main__': + unittest.main() diff --git a/research/qq16-l2-native-reconstruction/verify.py b/research/qq16-l2-native-reconstruction/verify.py new file mode 100644 index 0000000000..05d62b9eb0 --- /dev/null +++ b/research/qq16-l2-native-reconstruction/verify.py @@ -0,0 +1,275 @@ +#!/usr/bin/env python3 +"""Source-bound native realization of PR2470's L2 old-cut reconstruction. + +New code by ywz65 with substantial OpenAI Codex assistance, Apache-2.0. +Source and phase helpers are adapted explicitly from PR2468, not an independent +reimplementation of that predecessor. No complete controller is claimed. +""" +import argparse +import ast +from collections import Counter +from copy import deepcopy +from fractions import Fraction as Q +import hashlib +import importlib.util +import json +from pathlib import Path + +HERE = Path(__file__).resolve().parent +spec = importlib.util.spec_from_file_location('l2_support', HERE/'native_support.py') +N = importlib.util.module_from_spec(spec) +spec.loader.exec_module(N) +need = N.need +OLD = tuple((e, 1) for e in N.AXES[:9]) +E1 = tuple(N.AXES[9:17]) + + +def field(side, p): + return f'{side}{p}' + + +def program(R): + out = [] + def add(op, **kwargs): + out.append(dict(op=op, **kwargs)) + # First form the owned sum in the current X frame. X itself is read only. + for p in N.U: + add('line', field=field('Y', p), port=p, sign=1) + for p in N.U: + add('clear', field=field('Z', p), frame='current') + add('add', dst=field('Z', p), src=field('X', p), coefficient='1') + add('add', dst=field('Z', p), src=field('Y', p), coefficient='1') + for p in N.U: + add('line', field=field('Y', p), port=p, sign=-1) + # The inherited positive rank-eight child, with a translated left wrapper, + # removes F_E1. It acts on owned outputs only. + for p in N.U: + add('remove_stage', field=field('Z', p), rank=8) + for side, ports in (('Z', N.U), ('T', N.T)): + for p in ports: + add('line', field=field(side, p), port=p, sign=-1) + for p in ports: + add('map', field=field(side, p), port=p, inverse=False) + # Whole owner sweep: this body executes completely at one owner at a time. + # C is one owned local scratch array; it is not a new cover-wide bank. + add('private_sweep_begin') + for k in range(8): + add('clear', field='C', frame='common') + for p in N.T: + if R[k][p]: + add('add', dst='C', src=field('T', p), coefficient=str(R[k][p])) + for p in N.U: + if R[k][p]: + add('add', dst=field('Z', p), src='C', coefficient=str(-R[k][p]/4)) + add('clear', field='C', frame='identity') + add('private_sweep_end') + for side, ports in (('T', N.T), ('Z', N.U)): + for p in ports: + add('map', field=field(side, p), port=p, inverse=True) + for p in ports: + add('line', field=field(side, p), port=p, sign=1) + return out + + +def replay(word, R, records, fault=None): + original = {} + for p in N.U: + original[field('X', p)] = N.START + original[field('Y', p)] = N.START + ((records[p]['q'], -1),) + for p in N.T: + original[field('T', p)] = OLD + frames = dict(original) + frames.update({field('Z', p): () for p in N.U}) + frames['C'] = () + rows = {key: {(key, N.AXES): Q(1)} for key in frames} + counts = Counter() + in_private = False + for index, e in enumerate(word): + op = e['op'] + counts[op] += 1 + if op == 'line': + if fault == 'omit_Y_normalization' and e['field'] == field('Y', N.U[0]) and e['sign'] == 1: + continue + if fault == 'omit_T_restoration' and e['field'] == field('T', N.T[0]) and e['sign'] == 1: + continue + frames[e['field']] += ((records[e['port']]['q'], e['sign']),) + elif op == 'remove_stage': + if fault == 'omit_accumulated_E1_removal': + continue + sign = 1 if fault == 'use_positive_E1' else -1 + frames[e['field']] += tuple((axis, sign) for axis in E1) + elif op == 'map': + rec = records[e['port']] + shift = rec['inverse_shift'] if e['inverse'] else rec['shift'] + if fault == 'omit_payload_translation' and e['port'] == N.U[0]: + shift = 0 + if fault == 'wrong_inverse_translation' and e['inverse'] and e['port'] == N.U[0]: + shift = rec['shift'] + frames[e['field']] = N.move_frame(frames[e['field']], (rec['g'], shift)) + rows[e['field']] = N.routed(rec['g'], rows[e['field']]) + elif op == 'clear': + if fault == 'omit_owned_output_clear' and e['field'] == field('Z', N.U[0]): + frames[e['field']] = N.START + continue + rows[e['field']] = {} + frames[e['field']] = {'current': N.START, 'common': N.COMMON, 'identity': ()}[e['frame']] + elif op == 'add': + dst, src = e['dst'], e['src'] + need(N.phase(frames[dst]) == N.phase(frames[src]), f'native ADD frame mismatch at {index}') + if 'C' in (dst, src): + need(in_private, 'private ADD outside whole-owner body') + c = Q(e['coefficient']) + if fault == 'wrong_correction_sign' and dst.startswith('Z') and src == 'C': + c = -c + rows[dst] = N.combine(rows[dst], rows[src], c) + elif op == 'private_sweep_begin': + need(not in_private, 'nested private sweep') + in_private = True + else: + need(op == 'private_sweep_end' and in_private, 'unknown event or private boundary') + need(not rows['C'] and not frames['C'], 'private owner body not clean') + in_private = False + need(not in_private and not rows['C'] and not frames['C'], 'final owned scratch cleanup') + for at, frame in original.items(): + need(N.phase(frames[at]) == N.phase(frame), 'borrowed source frame not restored: '+at) + need(rows[at] == {(at, N.AXES): Q(1)}, 'borrowed source content not restored: '+at) + expected = {} + for p in N.U: + row = {(field('X', p), N.AXES): Q(1), (field('Y', p), N.AXES): Q(1)} + for t in N.T: + c = -sum(R[k][p]*R[k][t] for k in range(8))/4 + if c: + row = N.combine(row, {(field('T', t), N.multiply(records[p]['g'], records[t]['g'])): c}) + expected[field('Z', p)] = row + need(N.phase(frames[field('Z', p)]) == N.phase(OLD), 'old-cut output frame') + need(rows[field('Z', p)] == row, 'ordered L2 operator or owned dirt mismatch') + return dict(counts), expected + + +def gaussian_multiply(a, b): + return (a[0]*b[0]-a[1]*b[1], a[0]*b[1]+a[1]*b[0]) + + +def native_kernels(records): + lines = 0 + for p in N.U + N.T: + q = records[p]['q'] + for sign in (-1, 1): + recipe = N.line_recipe(q, sign) + for address in range(512): + need(N.kernel(recipe, address) == {address: (1, sign), address ^ q: (1, -sign)}, 'rank-one wrapper kernel') + lines += 1 + # Embed canonical axes 0..7 into E1=9..16, leaving all other axes as + # spectators. The wrapper is an involutive coordinate permutation. + permutation = list(N.AXES) + for j in range(8): + permutation[j], permutation[j+9] = permutation[j+9], permutation[j] + need(N.multiply(tuple(permutation), tuple(permutation)) == N.AXES, 'rank-eight inverse wrapper') + shift = sum(E1) + coefficients = 0 + for source in range(256): + for destination in range(256): + difference = source ^ destination + actual = (1, 0) + expected = (1, 0) + for j in range(8): + # Positive F8 followed by translation of all eight axes. + bit = ((difference ^ 255) >> j) & 1 + actual = gaussian_multiply(actual, (1, -1) if bit else (1, 1)) + bit = (difference >> j) & 1 + expected = gaussian_multiply(expected, (1, 1) if bit else (1, -1)) + need(actual == expected, 'inverse rank-eight Gaussian coefficient') + coefficients += 1 + need(gaussian_multiply((1, 1), (1, 1)) != gaussian_multiply((1, -1), (1, -1)), 'native inverse sign control') + return {'rank_one_basis_columns': lines, 'rank_eight_matrix_coefficients': coefficients, + 'rank_eight_wrapper_columns': permutation, 'rank_eight_left_translation': shift, + 'rank_eight_denominator': 256} + + +def calculate(): + R, records, pins = N.load_sources() + word = program(R) + trace, expected = replay(word, R, records) + need(trace == {'line': 400, 'clear': 112, 'add': 608, 'remove_stage': 96, 'map': 208, + 'private_sweep_begin': 1, 'private_sweep_end': 1}, 'literal invoice') + controls = {} + for fault in ('omit_Y_normalization', 'omit_T_restoration', 'omit_accumulated_E1_removal', + 'use_positive_E1', 'omit_payload_translation', 'wrong_inverse_translation', + 'omit_owned_output_clear', 'wrong_correction_sign'): + try: + replay(word, R, records, fault) + except ValueError as error: + controls[fault] = str(error) + else: + raise ValueError('ineffective control: '+fault) + # An inverse translated route must act on the logical owner too. + bad_records = deepcopy(records) + p = N.U[0] + bad_records[p]['g'] = N.AXES + try: + replay(word, R, bad_records) + except ValueError as error: + controls['payload_only_owner_map'] = str(error) + else: + raise ValueError('owner-action control ineffective') + kernels = native_kernels(records) + # Use only the hash-authenticated scalar_cost function from the retained + # QQ16 bill. In particular, a quarter coefficient costs12, not8 primitives. + cost_path = N.ROOT/'research/joint-query/verify_scalar.py' + parsed = ast.parse(cost_path.read_bytes()) + functions = [n for n in parsed.body if isinstance(n, ast.FunctionDef) and n.name == 'scalar_cost'] + need(len(functions) == 1, 'retained scalar-cost function') + environment = {'F': Q, 'need': need} + exec(compile(ast.Module(body=functions, type_ignores=[]), str(cost_path), 'exec'), environment) + scalar = 0 + scalar_coefficients = Counter() + for event in word: + if event['op'] == 'clear': + scalar += environment['scalar_cost'](['clear']) + elif event['op'] == 'add': + c = Q(event['coefficient']) + scalar_coefficients[str(abs(c))] += 1 + scalar += environment['scalar_cost'](['add', None, None, c.numerator, c.denominator]) + need(dict(scalar_coefficients) == {'1': 224, '1/4': 384} and scalar == 6624, 'source scalar allowance') + # Explicit old/new-cut witness for the failed cheap route, on the full + # 73-bit phase polynomial rather than owner/payload-constant inputs. + failures = {} + for p in N.U: + rec = records[p] + cheap = N.move_frame(N.START+((rec['q'], -1),), (rec['g'], rec['shift'])) + need(N.phase(cheap) != N.phase(N.COMMON), 'cheap alignment unexpectedly legal') + failures[str(p)] = True + invoice = {'rank_one_children': 400, 'rank_eight_children': 96, 'native_rank_mass': 1168, + 'native_wrapper_maps': 992, 'full_cover_maps': 208, 'ADD_macros': 608, + 'CLEAR_macros': 112, 'scalar_real_primitive_allowance': scalar, + 'absolute_ADD_coefficients': dict(scalar_coefficients), + 'owned_reconstruction_output_arrays': 96, 'owned_private_scratch_arrays_per_owner': 1, + 'borrowed_source_arrays_unchanged': 200, 'retained_F0_T_source_arrays': 8, + 'post_B1_X_sources_read_only': 96, 'literal_events': len(word)} + operator = {at: [[v, list(g), str(c)] for (v, g), c in sorted(row.items())] for at, row in expected.items()} + return {'status': 'PASS_QQ16_L2_NATIVE_RECONSTRUCTION', 'source_sha256': pins, 'member_sha256': N.MEMBERS, + 'contract': 'Z_U = X2_U + Y2_U - D1_U^-1 K_U R_T D1_T retained_x1_T; output frame F_L', + 'source_variables': 200, 'invoice': invoice, 'trace': trace, 'controls': controls, + 'cheap_current_alignment_rejected_ports': len(failures), 'native_kernels': kernels, + 'operator_sha256': hashlib.sha256(json.dumps(operator, sort_keys=True).encode()).hexdigest(), + 'scope': 'One local native reconstruction; retained source delivery, full decoder, physical cover cost, hosting and supplier saving remain open'}, word + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--write', action='store_true') + args = parser.parse_args() + result, word = calculate() + for name, value in (('RESULT.json', result), ('WORD.json', word)): + path = HERE/name + if args.write: + with path.open('x', encoding='utf-8', newline='\n') as handle: + json.dump(value, handle, sort_keys=True, indent=2) + handle.write('\n') + else: + need(json.loads(path.read_text(encoding='utf-8')) == value, 'committed '+name+' differs') + print('PASS_QQ16_L2_NATIVE_RECONSTRUCTION sources=200 outputs=96 rank_mass=1168 controls=9 no_new_kappa') + + +if __name__ == '__main__': + main()