diff --git a/research/staged544-paid-native-fusion/.gitattributes b/research/staged544-paid-native-fusion/.gitattributes new file mode 100644 index 0000000000..614d5b6890 --- /dev/null +++ b/research/staged544-paid-native-fusion/.gitattributes @@ -0,0 +1,2 @@ +frozen/** -text +vendor/** -text diff --git a/research/staged544-paid-native-fusion/.gitignore b/research/staged544-paid-native-fusion/.gitignore new file mode 100644 index 0000000000..7a60b85e14 --- /dev/null +++ b/research/staged544-paid-native-fusion/.gitignore @@ -0,0 +1,2 @@ +__pycache__/ +*.pyc diff --git a/research/staged544-paid-native-fusion/BOUNDARY.json b/research/staged544-paid-native-fusion/BOUNDARY.json new file mode 100644 index 0000000000..f7d8015707 --- /dev/null +++ b/research/staged544-paid-native-fusion/BOUNDARY.json @@ -0,0 +1,158 @@ +{ + "warp_index_zero_based": 4, + "register": 333, + "pre_b_index": 1081, + "consumers": [ + 1081, + 1082, + 1083 + ], + "next_b_index": 1097, + "entrance": [ + 266, + 138, + 74, + 30, + 1 + ], + "exit": [ + 426, + 96, + 24, + 6, + 1 + ], + "next_frame": [ + 392, + 66, + 34, + 24, + 6, + 1 + ], + "G_columns": [ + 1, + 2, + 8, + 32, + 44, + 128, + 59, + 66, + 489 + ], + "warp": { + "matrix_rows": [ + 1, + 67, + 16, + 468, + 65, + 217, + 128, + 417, + 385 + ], + "offset": 458, + "quadratic_rows": [ + 251, + 65, + 464, + 209, + 269, + 385, + 335, + 301, + 244 + ], + "linear_Z4": [ + 1, + 2, + 2, + 0, + 2, + 2, + 3, + 2, + 2 + ], + "phase": 3 + }, + "child": { + "rank": 1, + "left": { + "matrix_rows": [ + 2, + 4, + 8, + 17, + 32, + 65, + 129, + 257, + 1 + ], + "offset": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "phase": 0 + }, + "right": { + "matrix_rows": [ + 424, + 1, + 34, + 4, + 264, + 16, + 256, + 320, + 384 + ], + "offset": 133, + "quadratic_rows": [ + 0, + 32, + 0, + 168, + 0, + 170, + 0, + 168, + 0 + ], + "linear_Z4": [ + 0, + 2, + 0, + 3, + 0, + 3, + 0, + 3, + 2 + ], + "phase": 3 + } + } +} diff --git a/research/staged544-paid-native-fusion/PROOF.md b/research/staged544-paid-native-fusion/PROOF.md new file mode 100644 index 0000000000..e5007f51f5 --- /dev/null +++ b/research/staged544-paid-native-fusion/PROOF.md @@ -0,0 +1,54 @@ +# A paid finite interface: one avoided materialization + +This is a finite `f=1` construction, not a native supplier admission or a lower bound on all implementations. At the actual fifth PR3945 native event, retaining an unmaterialized lender through its three immediate consumers and composing its next right monomial saves **1024 caller-real writes** against a stronger materialized implementation that already shares source loads and phase negations. Reads, negations, additions and exact halves are equal. Address/control cost, cycle preparation and the native tariff remain unresolved. A weaker, stage-separated implementation is reported only for comparison. + +## Literal boundary and exact operators + +Both pinned providers have `warps[4]=(1081,333,G,U,E)`. Immediately afterward, B1081/B1082/B1083 add lender333 to registers656/657/658 with coefficients −1,−1,+1 in frame E. No intervening scalar or native event touches333 before B1097, whose incoming lender frame V has rank6. We replace only these immediate output updates and the lender's pending frame transition; intervening instructions receive exactly the same destination values, and the lender cannot be observed until its next transition. + +Let M=T_E K_G T_U†. The retained PR3987 signed recipe gives a monomial with affine translation458 and global phase i³, not a homogeneous permutation. Let A=T_V T_E†=L C₀ R, with the exact rank-one child. BOUNDARY.json contains all matrix rows, offsets, quadratic phase coefficients and global phases. The sparse credited evaluator independently checks both identities on all512 input columns. The new dense evaluator uses full signed512-entry tables, including translations and global phases; it does not import the lowering compiler. + +For input arrays v,d₁,d₂,d₃, the materialized circuit returns + +- d₁−Mv, d₂−Mv, d₃+Mv; +- source L C₀ R Mv. + +The lazy circuit updates each destination at p_M(x) with i^q_M(x)v[x], and then applies the signed composition F=R∘M followed by C₀ and L. The four outputs therefore coincide. The verifier checks all2048 complex basis columns (all four arrays), not only the source column. All three implementations are complex-linear, so these columns establish equality for arbitrary complex caller contents. Two additional dense nonzero dirty-input challenges verify inverse return of all four arrays. Inverse integer ×4 alignment merely compares common-denominator representations; inverse operation counts are not used in the forward bill. + +## PR4002 phase compensation, on these actual frames + +Write D|x⟩=i^wt(x)|x⟩ and J_B=D P_B D†. The source kernel is K_B=J_B Z_t, with +`t_j=(q_B(2^j)−wt(B2^j)+1)/2 mod2`. +The verifier checks the full512-point identity, rather than guessing a phase-free matrix. For a canonical frame with r coordinate factors, + +T_U=J_B (Z_t C_[r] Z_t) J_B†. + +A flipped axis satisfies Z C_j Z=i C_j†. Consequently the adjointed factors require their central global i. The actual completed bases give tags7,14,31 for U,E,V, flipped axes [0,1,2], [1,2,3], [0,1,2,3,4], and global powers3,3,1. All512 columns of each compensated actual frame are checked. Dropping central compensation or its global phase is rejected. The PR4002 K-only composition law is not extrapolated to affine M: F is composed from the full signed tables directly. + +## Strong materialized comparator + +A fair comparator can combine materializing M with its consumers. During each permutation cycle, save the original source pair, preserve the following original pair, prepare both negatives once, and select the M-store and consumer operands from those four signed components. This shares the extra source load and phase negations that a stage-separated implementation wastes. `materialized_consumers()` implements precisely that comparator. It then applies R,C₀,L. + +The lazy implementation's sole caller-data advantage over this comparator is deletion of M's512 complex stores. All actual M,R,F coordinates are active; L has511 active coordinates. The final counts are in RESULT.json. This is not a globally optimal compiler claim: further downstream fusion could change both implementations. It is an exact comparison of three declared loop schedules at one genuine source boundary. + +## Scalar and storage microcontract + +A caller-real read/write accesses one real component. ADD performs a real sum; NEG a sign change; HALVE denotes an exact dyadic division. A phase quarter-turn uses swaps via operand selection plus the explicitly counted negations. The consumer kernel prepares −a,−b once per original source pair for both implementations. The child computes four sums/differences then four output combinations:8ADD,4NEG,4HALVE per pair. Dyadic values are exact; no rounding is modeled. If all caller components initially have absolute value at most B, consumer outputs are bounded by2B, and child integer numerators by4B. This needs two guard bits and one fractional bit; word size is a declared finite contract, not a general-f precision proof. + +Eight private real words are a constructive schedule upper bound, **not measured Python storage**. The witness harness `scratch_schedule.py` checks the following overwrite plans and explicit zero return from arbitrary private initial data: + +- Cycles with materialized consumers: slots0–1 saved,2–3 following,4–5 negatives,6–7 current destination. The signed routing selects aliases of slots0,1,4,5; update slots6–7, store, and reuse them for the next destination. Preserve slots2–3 until the cycle advances. +- Lazy consumers need only saved, negatives, destination (six words); monomial cycles fit within the same eight-word allocation. +- Child: slots0–3 hold a,b,c,d; slots4–7 receive a+c,b+d,a−c,b−d; overwrite0–3 with the four output numerators; store those slots with the exact half interpretation. + +The whole forward program reserves eight private words, clears them at entry and return (16 CLEAR operations), and reuses them throughout. It does not borrow or restore an extra dirty caller array. Python's lists are proof representations, not a claim about interpreter memory. Caller arrays are genuinely arbitrary and their prescribed transformed outputs, not their original contents, are preserved by the forward circuit; the inverse returns their inputs. + +## Routing setup is not free + +Each implementation retains three signed tables of512 entries×(9 destination bits+2 phase bits)=16896 bits. The lazy consumers still need M's full tags; they cannot erase them. The lazy set is M,F,L; materialized is M,R,L. Cycle-leader storage is792 versus252 bits; runtime leader reads are88 versus28. Each runtime reads1536 routing entries. These are explicit metadata categories, not a conversion to real arithmetic cost. + +Constructing F adds1024 table-entry reads,512 writes and512 mod4 additions; its temporary table is5632 bits. Cycle decomposition additionally visits512 points and uses512 visited bits plus leader records. The certificate lists this preparation separately and does not price its control/address arithmetic, allocation, cache behavior or hardware latency. The runtime write saving is therefore **not a net total physical-cost or amortization claim**. A native tariff with these terms, a general-f lift, and a fresh whole-supplier replay remain required before any asymptotic inference. Recursive child count and owner width remain unchanged. + +## Rejection and independence boundaries + +Eight semantic controls reject omitted affine translation, all phases, global i³, the adjoint warp, reversed R/M composition, missing central frame compensation, missing compensated global i and a changed source-bound recipe. Checks use explicit exceptions and also run with Python optimization enabled. The independent sparse evaluator was authored in PR3987 with substantial OpenAI assistance and is retained byte-for-byte; the lowering compiler is used only by optional generate.py. The new dense implementation is a different evaluator, not a fresh human review or proof-kernel certificate. Frozen native author receipts are not promoted to a full fresh supplier replay. diff --git a/research/staged544-paid-native-fusion/README.md b/research/staged544-paid-native-fusion/README.md new file mode 100644 index 0000000000..001aea8b12 --- /dev/null +++ b/research/staged544-paid-native-fusion/README.md @@ -0,0 +1,30 @@ +# Actual native phase fusion: 1024 fewer real writes at f=1 + +At the actual PR3945 lender333 boundary, a lazy signed-affine warp followed by its next rank-one child gives the same four arbitrary caller-array outputs as a materialized warp. Against a materialized comparator that already shares consumer loads and phase negations, it saves **1024 real writes** and no real reads or negations. Recursive-child and owner-width deltas are zero. This finite runtime traffic result does not establish a native tariff, total cost, a general-f lift, an admitted supplier or a new κ. + +[PROOF.md](PROOF.md) states the exact boundary, actual canonical-frame compensation from PR4002, complete counted runtime vector, eight-word constructive scratch schedule, setup/address limitations and comparison scope. [RESULT.json](RESULT.json) is replayed rather than trusted. All2048 complex basis columns of the four-array map agree for all three declared implementations. The exact source warp and successor child and all512 columns of each compensated frame are independently checked. Eight semantic controls must reject. The stronger comparator was added after adversarial review; the larger read/NEG gains of the stage-separated comparator are not claimed as intrinsic savings. + +## Reproduce + +From repository root: + +```sh +python3 scripts/research_package.py --package research/staged544-paid-native-fusion --check-only +python3 scripts/research_package.py --package research/staged544-paid-native-fusion +``` + +The ready manifest runs standard-library Python normal and `-O`, each bounded to600 seconds. Direct read-only replay is `python3 -B research/staged544-paid-native-fusion/verify.py`; use an isolated bytecode cache for direct runs. `generate.py OUTPUT` optionally regenerates BOUNDARY.json with the retained compiler; it is not part of independent verification. `--record` is an explicit author-only receipt generator and is not registered. + +The historical base20ecf2891d80b5acf18d980b2164fb44ea7faa90 records priority6 and selected κ0.001672660197076918; it is provenance only. [SOURCES.json](SOURCES.json) pins all external public bytes by commit/path/Git blob/SHA256. Their public PR heads may not be ancestors of main, so the package verifier checks retained exact bytes; generic provenance pins cover the base card and selected record. Package-local files automatically select this replay. An official committed export supports Git-free replay; full source provenance validation uses Git history. + +## Open next questions + +Structured fields are in [TASK.json](TASK.json). + +1. Can this actual lazy interface be lifted to the general-f native representation with bounded address/control, precision and dirty scratch? Start by specifying the source owner's allowed physical operations for lender333 and mapping each loop to them. The current f=1 contract is the blocker. +2. Does the1024-write benefit survive all setup and an optimized downstream consumer/child implementation? Start with a declared tariff and a stronger fused comparator, then charge table composition,512-point cycle preparation and address arithmetic. A measured wall-clock claim is presently unsupported. +3. Can a useful general-f implementation affect the full supplier bound? Preserve the rank-one child and exact source widths, rerun the source-bound owner/native/parent chain, and only then evaluate the selected inequality. The present recursive/owner deltas are zero. + +## Credit and assistance + +New dense circuits, compensation checks, boundary construction and proof: Chris R / Clear1nsight with substantial OpenAI Codex assistance, Apache-2.0. ToikY's [PR4002](https://github.com/CrocSwap/integer-mult-bounds/pull/4002), head d593941ea0a4926021cba9d01fe60500579e464f, supplies the explicit K/J phase-tag handoff. [PR3987](https://github.com/CrocSwap/integer-mult-bounds/pull/3987), head fc536202fdaa924158789a5ef59ac079bbe21922, supplies exact signed recipes and the independently written sparse evaluator. Dugongue's [PR3945](https://github.com/CrocSwap/integer-mult-bounds/pull/3945), head91f81d131252db704f945891da1ea54e29d46b8b, supplies the actual two native words and compiler lineage. Retained notices preserve dataisfire, CinnaDavis, Tekalign, icekylinx, DreamingOfClouds, Sagar Thakrar, roger-sato, ArhamTahir and earlier named authors; see frozen/NATIVE-LINEAGE-NOTICE, frozen/SOURCE-CREDITS.md and frozen/NOTICE-PR3945.md. Original source notices are copied unchanged and remain their authors' statements. The in-session adversarial review was another OpenAI agent, not independent human or third-party review. diff --git a/research/staged544-paid-native-fusion/RESULT.json b/research/staged544-paid-native-fusion/RESULT.json new file mode 100644 index 0000000000..9253d0455a --- /dev/null +++ b/research/staged544-paid-native-fusion/RESULT.json @@ -0,0 +1,190 @@ +{ + "status": "PASS_FINITE_PAID_NATIVE_FUSION", + "private_storage_schedule": { + "private_real_words_upper_bound": 8, + "whole_program_initial_and_final_clears": 16, + "schedule_witnesses": 25, + "kind": "constructive register schedule; not measured Python memory" + }, + "providers": { + "base": { + "word_sha256": "08e6c96fbe3dfec96cb8451b3867ef8c1a214109ecd1e5af7fcc28e0f05728d0", + "unchanged_local_profile": { + "1": 2482, + "2": 712, + "3": 218, + "4": 109, + "5": 20, + "8": 8 + }, + "unchanged_width_inventory": { + "5": 28, + "6": 18, + "7": 53, + "8": 96, + "9": 213 + } + }, + "extra": { + "word_sha256": "d83c2ec9cecc0ad092d34ea4080b28a4fd7199579356b6d5a8fc6cd53ff93299", + "unchanged_local_profile": { + "1": 2482, + "2": 712, + "3": 218, + "4": 109, + "5": 20, + "8": 8 + }, + "unchanged_width_inventory": { + "5": 28, + "6": 18, + "7": 53, + "8": 96, + "9": 213 + } + } + }, + "interfaces": { + "warp": { + "columns": 512, + "nonzero_coefficients": 512, + "gaussian_axis_phase_histogram": [ + 128, + 128, + 128, + 128 + ], + "operator_sha256": "35398839f9896ac23fedccbae5ffc00b4cc1c31fef28b97a82bd6a9a4bcef0e2" + }, + "next_climb": { + "columns": 512, + "nonzero_coefficients": 1024, + "gaussian_axis_phase_histogram": [ + 0, + 0, + 0, + 0 + ], + "operator_sha256": "74556c18b0a17cf6d9e5be7cd8c819341f907afe780fa44c9255adc8392c767c" + } + }, + "compensated_actual_frames": { + "entrance": { + "tag": 7, + "flipped_coordinate_axes": [ + 0, + 1, + 2 + ], + "global_i_power": 3 + }, + "exit": { + "tag": 14, + "flipped_coordinate_axes": [ + 1, + 2, + 3 + ], + "global_i_power": 3 + }, + "next_frame": { + "tag": 31, + "flipped_coordinate_axes": [ + 0, + 1, + 2, + 3, + 4 + ], + "global_i_power": 1 + } + }, + "physical": { + "basis_columns": 2048, + "output_complex_coordinates": 2048, + "operator_sha256": "5db32f91611f88c3af512462fb2d713bb868d4637a46df242745782ce34ade16", + "reference": { + "private_real_words": 8, + "private_word_clears": 16, + "cycle_leader_reads": 88, + "routing_entry_reads": 1536, + "caller_real_reads": 8190, + "real_negations": 3584, + "caller_real_writes": 7166, + "real_additions": 5120, + "exact_halves": 1024 + }, + "fused": { + "private_real_words": 8, + "private_word_clears": 16, + "routing_entry_reads": 1536, + "caller_real_reads": 7166, + "real_negations": 3072, + "real_additions": 5120, + "caller_real_writes": 6142, + "cycle_leader_reads": 28, + "exact_halves": 1024 + }, + "delta": { + "private_real_words": 0, + "private_word_clears": 0, + "cycle_leader_reads": -60, + "routing_entry_reads": 0, + "caller_real_reads": -1024, + "real_negations": -512, + "caller_real_writes": -1024, + "real_additions": 0, + "exact_halves": 0 + }, + "dirty_inverse_roundtrips": 2, + "stronger_materialized_baseline": { + "private_real_words": 8, + "private_word_clears": 16, + "cycle_leader_reads": 88, + "routing_entry_reads": 1536, + "caller_real_reads": 7166, + "real_negations": 3072, + "caller_real_writes": 7166, + "real_additions": 5120, + "exact_halves": 1024 + }, + "delta_vs_stronger": { + "private_real_words": 0, + "private_word_clears": 0, + "cycle_leader_reads": -60, + "routing_entry_reads": 0, + "caller_real_reads": 0, + "real_negations": 0, + "caller_real_writes": -1024, + "real_additions": 0, + "exact_halves": 0 + } + }, + "metadata": { + "route_table_bits": 16896, + "reference_cycle_leader_bits": 792, + "fused_cycle_leader_bits": 252, + "additional_fusion_preparation": { + "table_entry_reads": 1024, + "table_entry_writes": 512, + "table_entry_bits": 11, + "two_bit_mod4_additions": 512, + "cycle_decomposition_work": "One new 512-point permutation; cycle metadata is rebound, not free.", + "temporary_composition_table_bits": 5632, + "visited_bits": 512 + } + }, + "controls": [ + "omit actual affine translation", + "omit all phase tags", + "omit global i cubed", + "replace warp by adjoint", + "reverse right-monomial composition", + "drop actual central compensation", + "drop actual compensated global i", + "changed source-bound affine recipe" + ], + "recursive_child_delta": 0, + "owner_width_delta": 0, + "all_size_supplier_admitted": false +} diff --git a/research/staged544-paid-native-fusion/SOURCES.json b/research/staged544-paid-native-fusion/SOURCES.json new file mode 100644 index 0000000000..941854577f --- /dev/null +++ b/research/staged544-paid-native-fusion/SOURCES.json @@ -0,0 +1,129 @@ +{ + "schema_version": 1, + "base_commit": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "b1fea0c94436b236cc2b7d41a7be032811b94c81", + "sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "67f085acd86acd7d4e03922d9cf4b26bca66fed5", + "sha256": "47b42433f5a85809a3aadd29c2c339da2c6ed728e4f7762df6b88bccb7874cf0" + } + ], + "external_public_inputs": [ + { + "local_path": "frozen/NATIVE-LINEAGE-NOTICE", + "sha256": "ee0c73ca35877aad0e0b6adc560a3881cb82276dba4cf2d4fc58cd19e57cc420", + "origin_commit": "91f81d131252db704f945891da1ea54e29d46b8b", + "origin": "CrocSwap/integer-mult-bounds research/staged544-terminal-gap-fill; exact public frozen bytes, native receipts are author evidence only", + "origin_repository": "CrocSwap/integer-mult-bounds", + "origin_path": "research/staged544-terminal-gap-fill/native/NATIVE-LINEAGE-NOTICE", + "git_blob": "380e979f0e84e00a22bd890615d87cc4684ad740" + }, + { + "local_path": "frozen/WORD-base.json.gz", + "sha256": "08e6c96fbe3dfec96cb8451b3867ef8c1a214109ecd1e5af7fcc28e0f05728d0", + "origin_commit": "91f81d131252db704f945891da1ea54e29d46b8b", + "origin": "CrocSwap/integer-mult-bounds research/staged544-terminal-gap-fill; exact public frozen bytes, native receipts are author evidence only", + "origin_repository": "CrocSwap/integer-mult-bounds", + "origin_path": "research/staged544-terminal-gap-fill/inputs/NEW-base.json.gz", + "git_blob": "806784bf99d9d15004d2d227d06268556a0726c8" + }, + { + "local_path": "frozen/WORD-extra.json.gz", + "sha256": "d83c2ec9cecc0ad092d34ea4080b28a4fd7199579356b6d5a8fc6cd53ff93299", + "origin_commit": "91f81d131252db704f945891da1ea54e29d46b8b", + "origin": "CrocSwap/integer-mult-bounds research/staged544-terminal-gap-fill; exact public frozen bytes, native receipts are author evidence only", + "origin_repository": "CrocSwap/integer-mult-bounds", + "origin_path": "research/staged544-terminal-gap-fill/inputs/NEW-extra.json.gz", + "git_blob": "c531be7383ad3ba941600c7ced14e5e10d6d1c67" + }, + { + "local_path": "vendor/clifford_exact.py", + "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962", + "origin_commit": "91f81d131252db704f945891da1ea54e29d46b8b", + "origin": "native/vendor/native/new/code/borrow/vendor/clifford/clifford_exact.py", + "usage": "Only clifford_exact.py used in optional reference generation; independent verifier executes none of these sources", + "origin_repository": "CrocSwap/integer-mult-bounds", + "origin_path": "research/staged544-terminal-gap-fill/native/vendor/native/new/code/borrow/vendor/clifford/clifford_exact.py", + "git_blob": "166841a037f069249f6f7f6dedb89248812f59e2" + }, + { + "local_path": "vendor/exact_phase.py", + "sha256": "e3d76b3373ff40a83a4b212b3fe1c0b431b3cfdc807da601d6e7f273c02c6d30", + "git_blob": "4659b91e1b997a22e98a8631947aa79193fcf96f", + "origin_commit": "fc536202fdaa924158789a5ef59ac079bbe21922", + "origin_repository": "Clear1nsight/integer-mult-bounds", + "origin_path": "research/staged544-native-quadratic-audit/exact_phase.py", + "usage": "Exact credited PR3987 source bytes; source notice retained without rewriting" + }, + { + "local_path": "frozen/RECIPES.json", + "sha256": "64b85f6aef485026eebaec7acddb41999f57e074b0dfde8077b6543700cd684b", + "git_blob": "a24e14593fcbf447d874cba7c7125eeb1a803d6b", + "origin_commit": "fc536202fdaa924158789a5ef59ac079bbe21922", + "origin_repository": "Clear1nsight/integer-mult-bounds", + "origin_path": "research/staged544-native-quadratic-audit/RECIPES.json", + "usage": "Exact credited PR3987 source bytes; source notice retained without rewriting" + }, + { + "local_path": "frozen/SOURCE-CREDITS.md", + "sha256": "d4a13d8b8ed9cdb594f00efb3d1a336e09d934423330f02a1514308a720c278b", + "git_blob": "c054fad87eeaa510865e682ee0c976c4cd728da2", + "origin_commit": "fc536202fdaa924158789a5ef59ac079bbe21922", + "origin_repository": "Clear1nsight/integer-mult-bounds", + "origin_path": "research/staged544-native-quadratic-audit/SOURCE-CREDITS.md", + "usage": "Exact credited PR3987 source bytes; source notice retained without rewriting" + }, + { + "local_path": "frozen/NOTICE-PR3945.md", + "sha256": "6881464d7731757b63275f056cb9ef8406db04e76c73093d3e5b418529a879cc", + "git_blob": "6dcffa5dfbcf15cdffdcca56115e705e354a0907", + "origin_commit": "fc536202fdaa924158789a5ef59ac079bbe21922", + "origin_repository": "Clear1nsight/integer-mult-bounds", + "origin_path": "research/staged544-native-quadratic-audit/NOTICE-PR3945.md", + "usage": "Exact credited PR3987 source bytes; source notice retained without rewriting" + }, + { + "local_path": "frozen/TAG-PROOF.md", + "sha256": "5ef7a82ff08e20dc19c872f9fc01ee49c47cd00a9ea03088919c45bea7cc87e3", + "git_blob": "c87b16a3c5e0ceda2b0f3f3334c10ead5beebadd", + "origin_commit": "d593941ea0a4926021cba9d01fe60500579e464f", + "origin_repository": "CrocSwap/integer-mult-bounds", + "origin_path": "research/native-lift-phase-tags/PROOF.md", + "usage": "Exact PR4002 handoff proof/reference; independent verifier rederives actual canonical-frame compensation" + }, + { + "local_path": "frozen/tag_reference.py", + "sha256": "8aa750167e513a598286067a4edcd9d4c69506d1003cd5fd88eee81ac7f77276", + "git_blob": "c4b207bbf53b4942b3969ec5b40c6380ce8f2d4e", + "origin_commit": "d593941ea0a4926021cba9d01fe60500579e464f", + "origin_repository": "CrocSwap/integer-mult-bounds", + "origin_path": "research/native-lift-phase-tags/verify.py", + "usage": "Exact PR4002 handoff proof/reference; independent verifier rederives actual canonical-frame compensation" + }, + { + "local_path": "frozen/TAG-README.md", + "sha256": "1a53140fa38fa67a22127f71f34ea07b3630366b9936ddd862d20c241933071c", + "git_blob": "b8dbc1d30e9dafecb2ed3ff4925fdac56b92947c", + "origin_commit": "d593941ea0a4926021cba9d01fe60500579e464f", + "origin_repository": "CrocSwap/integer-mult-bounds", + "origin_path": "research/native-lift-phase-tags/README.md", + "usage": "Exact PR4002 handoff proof/reference; independent verifier rederives actual canonical-frame compensation" + }, + { + "local_path": "frozen/bw_emit.py", + "sha256": "99b59a6fa3feda86785e4225157dcb1a6169d256cec4f5e0acc9cea7a701df76", + "git_blob": "6d47f63ab7a533941b3881bbfd3ae4dac5f76932", + "origin_commit": "91f81d131252db704f945891da1ea54e29d46b8b", + "origin_repository": "CrocSwap/integer-mult-bounds", + "origin_path": "research/staged544-terminal-gap-fill/native/vendor/native/new/code/borrow/bw_emit.py", + "usage": "Read-only evidence that warp_event is symbolic and physical native tariff is absent" + } + ] +} diff --git a/research/staged544-paid-native-fusion/TASK.json b/research/staged544-paid-native-fusion/TASK.json new file mode 100644 index 0000000000..2efb19978d --- /dev/null +++ b/research/staged544-paid-native-fusion/TASK.json @@ -0,0 +1,78 @@ +{ + "schema_version": 1, + "task_id": "independent-moment", + "priority_revision": 6, + "base_commit": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "original_card": { + "id": "independent-moment", + "question": "Does one changed supplier or assembly claim lack a source-bound independent check of a specific new implication?", + "starting_points": [ + "certificates/selected-result.json", + "research/rank7-joint-endframes/README.md", + "docs/research/research-family-status.md" + ], + "methods": [ + "Independently reconstruct a coordinated frame/circuit change and its single-change control, then derive the complete rank and physical ledger.", + "Implement certified moment inequalities through a different exact enclosure method." + ], + "acceptance_gate": "Demonstrate independence, source binding, positive cases and semantic failure controls. Name the existing checks and the missing coverage. More digits or another equivalent evaluation of an unchanged root is not by itself new verification coverage.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read #2979 joint rank-7 end-frame proposal and the revision-6 evidence status. Its claimed kappa is not selected. Compare coordinated changes with the losing single-change controls and locate the complete physical ledger; an aggregate moment alone does not validate the mechanism.", + "scope": "Positive control / source-bound orientation only; this is not a new construction or full cold replay." + }, + "first_experiment": "Prioritize a bounded independent audit of #2979: reconstruct one joint group and its single-lowering control, check the declared frames/chronology, then trace changed children, idle widths and cleanup buffers into the complete invoice and both supplier caps. Choose one still-missing implication after checking existing audits. Stop with exact unresolved dependencies if full admission exceeds the session; do not launch a new lowering census on an unvalidated premise or substitute extra root digits for mechanism checking.", + "bottleneck_link": "Independent pricing prevents unsupported frontier claims and can reveal genuine accounting slack.", + "allowed_variations": [ + "Reconstruct either a source ledger or a numeric enclosure with a different method." + ], + "scope_change_triggers": [ + "Importing the primary function and calling its output independent verification.", + "Promoting #2979 from merged source archive to validated supplier solely from author PASS receipts or aggregate pricing." + ], + "overlap_terms": [ + "independent moment", + "rank histogram", + "exact enclosure", + "2979", + "rank7 joint endframes", + "paired extraction", + "joint lowering" + ] + }, + "scope_status": "refined", + "actual_scope": "Actual PR3945 native lender333 finite f=1 paid traffic comparison using PR4002 phase compensation and PR3987 signed recipes.", + "scope_change_reason": "The handoff changes the physical operation contract: lazy signed-affine consumers plus next-child right-monomial fusion. This is a finite source-bound interface check, not another phase-only lowering census.", + "bottleneck_link": "A concrete one-materialization write saving exposes a possible physical cost improvement, while the absent general-f/native tariff blocks any supplier or kappa consequence.", + "budget_minutes": 60, + "stop_rule": "Freeze the source-bound f=1 four-array circuit and matched stronger comparator; no recursive lowering sweep or selected-bound update.", + "outcome": "completed", + "evidence": "BOUNDARY.json source cut; RESULT.json exact receipts; PROOF.md derivation; circuit.py three compared loops; scratch_schedule.py private schedule; verify.py acceptance and rejection checks.", + "author": "Chris R / Clear1nsight with substantial OpenAI Codex assistance", + "ai_assistance": "Substantial OpenAI Codex assistance in derivation, code, exact verification and writing; same-session AI adversarial review, no independent human or proof-kernel endorsement.", + "open_questions": [ + { + "question": "Can the actual lazy boundary be implemented for general f?", + "why_it_matters": "Only a native-compatible implementation can enter the supplier cost.", + "first_step": "Specify lender333 physical primitive, address, precision and dirty scratch rules and lower this finite schedule against them.", + "blocked_by": "Missing owner-compatible general-f physical tariff." + }, + { + "question": "Does the write saving survive paid setup and stronger downstream fusion?", + "why_it_matters": "Runtime payload traffic alone does not price a complete execution.", + "first_step": "Charge signed-table composition, cycle preparation and address/control operations against a declared stronger comparator.", + "blocked_by": "No architecture-neutral tariff or amortization model." + }, + { + "question": "Can this change an admitted full supplier bound?", + "why_it_matters": "Recursive and owner-width deltas here are zero.", + "first_step": "After a general-f implementation exists, replay native/owner/parent contracts and re-evaluate the selected inequality.", + "blocked_by": "No fresh full supplier replay and no general-f admission." + } + ] +} diff --git a/research/staged544-paid-native-fusion/VERIFY.json b/research/staged544-paid-native-fusion/VERIFY.json new file mode 100644 index 0000000000..743e544ffa --- /dev/null +++ b/research/staged544-paid-native-fusion/VERIFY.json @@ -0,0 +1,28 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [], + "commands": [ + { + "argv": [ + "{python}", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 600, + "checks": "Exact source interfaces, compensated frames, all2048 columns against two baselines, dirty inverse return, eight semantic rejects and scratch schedule." + }, + { + "argv": [ + "{python}", + "-O", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 600, + "checks": "Same complete check with assertions disabled; all acceptance predicates use explicit exceptions." + } + ] +} diff --git a/research/staged544-paid-native-fusion/circuit.py b/research/staged544-paid-native-fusion/circuit.py new file mode 100644 index 0000000000..fed1e3a84c --- /dev/null +++ b/research/staged544-paid-native-fusion/circuit.py @@ -0,0 +1,150 @@ +"""Exact finite Gaussian-array circuits and explicit operational ledger. + +Chris R / Clear1nsight with substantial OpenAI Codex assistance. Apache-2.0. +This is a declared f=1 RAM microcontract, not the supplier's missing tariff. +""" +from collections import Counter + +N=512 + +def need(ok,message): + if not ok:raise ValueError(message) + +def cycles(p): + need(sorted(p)==list(range(N)),'permutation domain') + seen=set();out=[] + for start in range(N): + if start in seen:continue + row=[];x=start + while x not in seen:seen.add(x);row.append(x);x=p[x] + need(x==start,'closed permutation cycle');out.append(row) + return out + +def compose(a,b): + """Apply b then a; phases are attached to input columns.""" + ap,aq=a;bp,bq=b + return tuple(ap[x]for x in bp),tuple((bq[x]+aq[bp[x]])%4 for x in range(N)) + +def inverse(m): + p,q=m;back=[0]*N;phase=[0]*N + for x,y in enumerate(p):back[y]=x;phase[y]=-q[x]%4 + return tuple(back),tuple(phase) + +def neg(x,bill):bill['real_negations']+=1;return -x +def add(x,y,bill):bill['real_additions']+=1;return x+y +def sub(x,y,bill):return add(x,neg(y,bill),bill) + +def rotate(z,q,bill): + a,b=z + if q==0:return a,b + if q==1:return neg(b,bill),a + if q==2:return neg(a,bill),neg(b,bill) + return b,neg(a,bill) + +def load(v,i,bill):bill['caller_real_reads']+=2;return v[i] +def store(v,i,z,bill):bill['caller_real_writes']+=2;v[i]=z + +def monomial(v,m,bill): + """One in-place cycle pass; identity fixed points do not touch data.""" + p,q=m + for cyc in cycles(p): + bill['cycle_leader_reads']+=1 + bill['routing_entry_reads']+=len(cyc) + if len(cyc)==1 and q[cyc[0]]==0:continue + saved=load(v,cyc[0],bill) + for x in cyc: + y=p[x];following=load(v,y,bill)if y!=cyc[0]else None + store(v,y,rotate(saved,q[x],bill),bill);saved=following + +def consumers(v,targets,m,bill,undo=False): + """Three adjacent distinct consumers share each source load. + + Both signs of each real source component are prepared once. The phase + chooses already prepared operands; it is not an uncharged Pauli pass. + """ + if m is None:p=tuple(range(N));q=(0,)*N + else:p,q=m;bill['routing_entry_reads']+=N + coeffs=(2,2,0)if not undo else(0,0,2) + for x in range(N): + a,b=load(v,x,bill);na,nb=neg(a,bill),neg(b,bill) + choices=((a,b),(nb,a),(na,nb),(b,na)) + for target,sign in zip(targets,coeffs): + u,w=choices[(q[x]+sign)%4];c,d=load(target,p[x],bill) + store(target,p[x],(add(c,u,bill),add(d,w,bill)),bill) + +def materialized_consumers(v,targets,m,bill): + """Stronger baseline: consume each saved value during M's cycle pass. + + Reuse both prepared signs for M's own store as well as all consumers. + This fairly removes the naive baseline's extra source load and M NEG. + """ + p,q=m + for cyc in cycles(p): + bill['cycle_leader_reads']+=1;bill['routing_entry_reads']+=len(cyc) + saved=load(v,cyc[0],bill) + for x in cyc: + y=p[x];following=load(v,y,bill)if y!=cyc[0]else None + a,b=saved;na,nb=neg(a,bill),neg(b,bill) + choices=((a,b),(nb,a),(na,nb),(b,na)) + store(v,y,choices[q[x]],bill) + for target,sign in zip(targets,(2,2,0)): + u,w=choices[(q[x]+sign)%4];c,d=load(target,y,bill) + store(target,y,(add(c,u,bill),add(d,w,bill)),bill) + saved=following + +def child(v,bill,adjoint=False): + """C_0 or C_0 adjoint. Returned integer numerators have denominator2. + + This finite f=1 butterfly does not replace a general-f recursive child. + """ + for x in range(0,N,2): + a,b=load(v,x,bill);c,d=load(v,x+1,bill) + sr,si=add(a,c,bill),add(b,d,bill) + dr,di=sub(a,c,bill),sub(b,d,bill) + if not adjoint: + left=(sub(sr,di,bill),add(si,dr,bill)) + right=(add(sr,di,bill),sub(si,dr,bill)) + else: + left=(add(sr,di,bill),sub(si,dr,bill)) + right=(sub(sr,di,bill),add(si,dr,bill)) + store(v,x,left,bill);store(v,x+1,right,bill) + bill['exact_halves']+=4 + +def execute(arrays,M,R,L,fused=False,undo=False,joint=False): + """Four arbitrary complex arrays; no array starts clean or is discarded. + + Forward returns denominator exponents(1,0,0,0). Inverse expects those + exponents and returns all four arrays with denominator4. + """ + v,*targets=[list(z)for z in arrays];bill=Counter() + bill['private_real_words']=8;bill['private_word_clears']=16 + if undo: + monomial(v,inverse(L),bill);child(v,bill,True) + # The second exact half leaves source denominator4. Align destinations. + targets=[[(a*4,b*4)for a,b in z]for z in targets] + if fused: + monomial(v,inverse(compose(R,M)),bill) + consumers(v,targets,M,bill,True) + else: + monomial(v,inverse(R),bill);consumers(v,targets,None,bill,True) + monomial(v,inverse(M),bill) + return [v,*targets],2,dict(bill) + if joint:materialized_consumers(v,targets,M,bill) + else: + if not fused:monomial(v,M,bill) + consumers(v,targets,M if fused else None,bill) + monomial(v,compose(R,M)if fused else R,bill) + child(v,bill);monomial(v,L,bill) + return [v,*targets],1,dict(bill) + +def metadata(M,R,L): + F=compose(R,M) + # Three 512-entry tables retain all 9-bit destinations and 2-bit phases. + # The fused route retains M for its consumers; it cannot delete its tags. + return dict(route_table_bits=3*N*11, + reference_cycle_leader_bits=9*sum(len(cycles(m[0]))for m in (M,R,L)), + fused_cycle_leader_bits=9*sum(len(cycles(m[0]))for m in (F,L)), + additional_fusion_preparation=dict(table_entry_reads=2*N, + table_entry_writes=N,table_entry_bits=11, + two_bit_mod4_additions=N,cycle_decomposition_work='One new 512-point permutation; cycle metadata is rebound, not free.', + temporary_composition_table_bits=N*11,visited_bits=N)) diff --git a/research/staged544-paid-native-fusion/frozen/NATIVE-LINEAGE-NOTICE b/research/staged544-paid-native-fusion/frozen/NATIVE-LINEAGE-NOTICE new file mode 100644 index 0000000000..380e979f0e --- /dev/null +++ b/research/staged544-paid-native-fusion/frozen/NATIVE-LINEAGE-NOTICE @@ -0,0 +1,14 @@ +Anticipatory dirty borrowing: PR2226 (Cinna Davis / 1337isnot1337, with substantial OpenAI Codex assistance) is credited first. Its alias rule, changed-reference K_G handoffs, initial compensation and exact free-operator replay (vendored under new/code/borrow/vendor, see new/code/borrow/NOTICE-PR2226.md) are applied here to the T74 pivot-566+554 words; the native lowering, window-exact owner fill and independent audit of the borrow words are new in this package. Bootstrap carried-cutoff repair: PR1956 (Josie Elliston); Lemma G label/adapter checks and X/Y/Z mutants: PR1964 (thakrarsagar), extended here with borrow warp/zero-buffer controls. + +New research prepared by Rohan Arun with substantial OpenAI Codex assistance. Apache-2.0. Parent words and build recipe method derive from Jeremy Kothe PR1274 and Rohan Arun PR1218, with lineage credited in README.md. All inherited mathematical qualifications are retained. +Additional pivot555 and567 composition by Rohan Arun with substantial OpenAI Codex assistance. + +T74 exact-fill owner construction by Rohan Arun with substantial OpenAI Codex assistance. + +PR1377 grid refinement credited to Jeremy Kothe. Outer witness refinement by Rohan Arun with OpenAI Codex assistance; construction unchanged. + +Pivot-566 kernel, words, edits, rebuild.py and rebind.py: PR1625 (mdumitrean). Endpoint/outer-witness stacking, fine_cache.py and oracle stage by jeremykothe2 with oh-my-pi assistance. + +The preceding paragraphs are inherited source notices, not attribution of this derivative. +This joint twelve-source construction, generator, independent replay, hosting composition and package: Tekalign (@tekuuu), with substantial OpenAI Codex assistance. No independent human review claimed. +Credits: Cinna Davis/PR2226 anticipatory dirty borrowing; Tekalign/PR2436 four lifted targets; Jeremy Kothe/PR2462,2588,2673 source pipeline, source-label swap and order/fill; zxv/PR2530 eight aliases; Mason Hale/PR2696 concentrated source-partner assignment and independent local interpreter; Philippe Van Velzen/PR2559,2679 evacuation, six pre-life hosts and refit/alias; themilkman216/PR2621 priority order; Marius-Paul Dumitrean/PR2733 independent concentrated/pre-life composition; Vlado Vojdanovski/PR2322 generator utilities. PR2720's fixed-old-path cut obstruction motivates the changed premise. The retained owner/native/bit/modern outer lineage and their notices remain in the pinned source. New work Apache-2.0. diff --git a/research/staged544-paid-native-fusion/frozen/NOTICE-PR3945.md b/research/staged544-paid-native-fusion/frozen/NOTICE-PR3945.md new file mode 100644 index 0000000000..6dcffa5dfb --- /dev/null +++ b/research/staged544-paid-native-fusion/frozen/NOTICE-PR3945.md @@ -0,0 +1,20 @@ +# Attribution and scope + +New terminal-width/frame construction, idle-gap absorption proof, source-guarded recipe, independent finite checks and integration: Dugongue with substantial OpenAI Codex assistance, including three parallel Codex agents. Apache-2.0. AI implementation separation is not independent human review. + +Retain the following predecessor credit and all native/vendor notices: + +- dataisfire, PR3734: actual staged544 supplier and retained full source closure. zxv, PR3682: staged pair. Ross Richardson, PR3605: staged entrance, cleanup and residual checks. +- Erwan Secousses / ChaloupeMusic, PR3815, with retained PR3638 lineage: attained T360 owner clock and fill. The new allocation changes widths and offsets on that placement; it does not invent the source clock. +- hexapode, PR3802 and PR3875: previous complete endpoint combination and refinement. Dugongue, PR3857: prior general proof/evaluator work; PR3929: transported-frame compiler and concrete nonimproving example. +- Sagar Thakrar, PR3687: audit_core.py, retained byte for byte. Its header explicitly credits Arham Tahir's coupled-carrier audit, which it reimplements. roger-sato, PR3693: whole-word audit adapter in the inherited closure. Retained exact rational-price evaluator and source notices are unchanged. +- Jeremy Kothe: frame/preload machinery and PR2833 native rewrite; Lyy-iiis, PR2857; Dugongue, PR2863; philippeVV, PR2853, and all retained provider, owner, native/admission and outer contributors. +- Cinna Davis (@1337isnot1337), PR2226, with OpenAI Codex assistance: native exact Clifford/operator machinery. icekylinx, PR514/433, and retained native ancestry. +- DreamingOfClouds with Claude Opus 5.5: inherited wrapper/outer machinery; chafreaky, PR458, and its retained lineage. +- Tekalign (@tekuuu): sparse native acceleration; retain SPARSE-NOTICE, SPARSE-PROOF, Rohan Arun and all earlier authors/PRs listed by those files. The accelerator changes replay representation, not the certified word. + +The original contributor names already present in upstream sources are attribution. They are not new identification of the submitting GitHub account. All original licenses and source headers remain in place. No broad mathematical novelty, independent human approval, unconditional all-size multiplication bound or fresh Lean/kernel certification is claimed. + +Adjacent reviews were compared and credited: Chris R / Clear1nsight PR3883/3936, with substantial OpenAI Codex assistance, supplies the completed T385 execution/COPY-contract audit precedent; retain its ai-nanachi PR3647, Sagar Thakrar PR3700 and PR2809 physical-caller lineage. These are scoped comparison sources, not a new admission receipt for our changed T360 words. + +Also compare and credit Chris R / Clear1nsight PR3941 for its distinct neutral-first enumeration/middle-cut reduction, following PR3886/3734, Jeremy Kothe PR2957/2979 and Dugongue PR3863/ranked-pair/MathProof predecessors. Rohan Arun's PR3939 bit-pooling draft and its explicitly conditional PR3934 stack are acknowledged as higher draft endpoints on a different route; their data and extra assumptions are not imported into this supplier. diff --git a/research/staged544-paid-native-fusion/frozen/RECIPES.json b/research/staged544-paid-native-fusion/frozen/RECIPES.json new file mode 100644 index 0000000000..a24e14593f --- /dev/null +++ b/research/staged544-paid-native-fusion/frozen/RECIPES.json @@ -0,0 +1,4236 @@ +{ + "items": [ + { + "kind": "warp", + "G_columns": [ + 1, + 2, + 4, + 54, + 72, + 8, + 130, + 16, + 284 + ], + "entrance": [ + 257, + 161, + 70, + 19, + 13 + ], + "terminal": [ + 260, + 132, + 75, + 42, + 25 + ], + "sign": 1, + "recipe": { + "rank": 0, + "left": { + "matrix_rows": [ + 265, + 202, + 396, + 184, + 128, + 136, + 16, + 64, + 384 + ], + "offset": 426, + "quadratic_rows": [ + 264, + 200, + 392, + 119, + 184, + 152, + 202, + 246, + 5 + ], + "linear_Z4": [ + 0, + 2, + 0, + 2, + 1, + 2, + 1, + 1, + 0 + ], + "phase": 1 + }, + "right": null + }, + "coverage": [ + { + "provider": "base", + "kind": "warp", + "index": 42, + "register": 1, + "version": "new", + "sign": 1 + }, + { + "provider": "base", + "kind": "warp", + "index": 44, + "register": 6, + "version": "new", + "sign": 1 + }, + { + "provider": "extra", + "kind": "warp", + "index": 42, + "register": 1, + "version": "new", + "sign": 1 + }, + { + "provider": "extra", + "kind": "warp", + "index": 44, + "register": 6, + "version": "new", + "sign": 1 + } + ] + }, + { + "kind": "warp", + "G_columns": [ + 1, + 2, + 4, + 54, + 72, + 8, + 130, + 16, + 284 + ], + "entrance": [ + 260, + 132, + 75, + 42, + 25 + ], + "terminal": [ + 257, + 161, + 70, + 19, + 13 + ], + "sign": -1, + "recipe": { + "rank": 0, + "left": { + "matrix_rows": [ + 289, + 162, + 308, + 48, + 64, + 104, + 128, + 16, + 272 + ], + "offset": 330, + "quadratic_rows": [ + 288, + 160, + 304, + 96, + 20, + 207, + 104, + 162, + 5 + ], + "linear_Z4": [ + 0, + 2, + 0, + 0, + 3, + 0, + 3, + 1, + 0 + ], + "phase": 0 + }, + "right": null + }, + "coverage": [ + { + "provider": "base", + "kind": "warp", + "index": 42, + "register": 1, + "version": "new", + "sign": -1 + }, + { + "provider": "base", + "kind": "warp", + "index": 44, + "register": 6, + "version": "new", + "sign": -1 + }, + { + "provider": "extra", + "kind": "warp", + "index": 42, + "register": 1, + "version": "new", + "sign": -1 + }, + { + "provider": "extra", + "kind": "warp", + "index": 44, + "register": 6, + "version": "new", + "sign": -1 + } + ] + }, + { + "kind": "warp", + "G_columns": [ + 1, + 2, + 4, + 54, + 72, + 8, + 130, + 16, + 284 + ], + "entrance": [ + 260, + 132, + 75, + 51 + ], + "terminal": [ + 416, + 70, + 19, + 13 + ], + "sign": -1, + "recipe": { + "rank": 0, + "left": { + "matrix_rows": [ + 1, + 162, + 292, + 32, + 64, + 328, + 128, + 304, + 256 + ], + "offset": 75, + "quadratic_rows": [ + 0, + 160, + 288, + 320, + 288, + 182, + 328, + 162, + 348 + ], + "linear_Z4": [ + 2, + 2, + 0, + 0, + 0, + 1, + 3, + 1, + 3 + ], + "phase": 0 + }, + "right": null + }, + "coverage": [ + { + "provider": "base", + "kind": "warp", + "index": 42, + "register": 1, + "version": "old", + "sign": -1 + }, + { + "provider": "base", + "kind": "warp", + "index": 44, + "register": 6, + "version": "old", + "sign": -1 + }, + { + "provider": "extra", + "kind": "warp", + "index": 42, + "register": 1, + "version": "old", + "sign": -1 + }, + { + "provider": "extra", + "kind": "warp", + "index": 44, + "register": 6, + "version": "old", + "sign": -1 + } + ] + }, + { + "kind": "warp", + "G_columns": [ + 1, + 2, + 4, + 54, + 72, + 8, + 130, + 16, + 284 + ], + "entrance": [ + 416, + 70, + 19, + 13 + ], + "terminal": [ + 260, + 132, + 75, + 51 + ], + "sign": 1, + "recipe": { + "rank": 0, + "left": { + "matrix_rows": [ + 1, + 74, + 268, + 304, + 392, + 8, + 16, + 64, + 256 + ], + "offset": 183, + "quadratic_rows": [ + 0, + 72, + 264, + 206, + 304, + 272, + 74, + 264, + 436 + ], + "linear_Z4": [ + 2, + 2, + 2, + 1, + 3, + 0, + 1, + 2, + 3 + ], + "phase": 0 + }, + "right": null + }, + "coverage": [ + { + "provider": "base", + "kind": "warp", + "index": 42, + "register": 1, + "version": "old", + "sign": 1 + }, + { + "provider": "base", + "kind": "warp", + "index": 44, + "register": 6, + "version": "old", + "sign": 1 + }, + { + "provider": "extra", + "kind": "warp", + "index": 42, + "register": 1, + "version": "old", + "sign": 1 + }, + { + "provider": "extra", + "kind": "warp", + "index": 44, + "register": 6, + "version": "old", + "sign": 1 + } + ] + }, + { + "kind": "warp", + "G_columns": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 135, + 263 + ], + "entrance": [ + 259, + 131, + 75, + 42, + 25 + ], + "terminal": [ + 260, + 132, + 75, + 42, + 25 + ], + "sign": 1, + "recipe": { + "rank": 0, + "left": { + "matrix_rows": [ + 385, + 386, + 388, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "offset": 0, + "quadratic_rows": [ + 384, + 384, + 384, + 0, + 0, + 0, + 0, + 391, + 391 + ], + "linear_Z4": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 3, + 3 + ], + "phase": 0 + }, + "right": null + }, + "coverage": [ + { + "provider": "base", + "kind": "warp", + "index": 43, + "register": 4, + "version": "new", + "sign": 1 + }, + { + "provider": "extra", + "kind": "warp", + "index": 43, + "register": 4, + "version": "new", + "sign": 1 + } + ] + }, + { + "kind": "warp", + "G_columns": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 135, + 263 + ], + "entrance": [ + 259, + 131, + 75, + 51 + ], + "terminal": [ + 260, + 132, + 75, + 51 + ], + "sign": 1, + "recipe": { + "rank": 0, + "left": { + "matrix_rows": [ + 385, + 386, + 388, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "offset": 0, + "quadratic_rows": [ + 384, + 384, + 384, + 0, + 0, + 0, + 0, + 391, + 391 + ], + "linear_Z4": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 3, + 3 + ], + "phase": 0 + }, + "right": null + }, + "coverage": [ + { + "provider": "base", + "kind": "warp", + "index": 43, + "register": 4, + "version": "old", + "sign": 1 + }, + { + "provider": "extra", + "kind": "warp", + "index": 43, + "register": 4, + "version": "old", + "sign": 1 + } + ] + }, + { + "kind": "warp", + "G_columns": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 135, + 263 + ], + "entrance": [ + 260, + 132, + 75, + 42, + 25 + ], + "terminal": [ + 259, + 131, + 75, + 42, + 25 + ], + "sign": -1, + "recipe": { + "rank": 0, + "left": { + "matrix_rows": [ + 385, + 386, + 388, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "offset": 0, + "quadratic_rows": [ + 384, + 384, + 384, + 0, + 0, + 0, + 0, + 391, + 391 + ], + "linear_Z4": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 3, + 3 + ], + "phase": 0 + }, + "right": null + }, + "coverage": [ + { + "provider": "base", + "kind": "warp", + "index": 43, + "register": 4, + "version": "new", + "sign": -1 + }, + { + "provider": "extra", + "kind": "warp", + "index": 43, + "register": 4, + "version": "new", + "sign": -1 + } + ] + }, + { + "kind": "warp", + "G_columns": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 135, + 263 + ], + "entrance": [ + 260, + 132, + 75, + 51 + ], + "terminal": [ + 259, + 131, + 75, + 51 + ], + "sign": -1, + "recipe": { + "rank": 0, + "left": { + "matrix_rows": [ + 385, + 386, + 388, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "offset": 0, + "quadratic_rows": [ + 384, + 384, + 384, + 0, + 0, + 0, + 0, + 391, + 391 + ], + "linear_Z4": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 3, + 3 + ], + "phase": 0 + }, + "right": null + }, + "coverage": [ + { + "provider": "base", + "kind": "warp", + "index": 43, + "register": 4, + "version": "old", + "sign": -1 + }, + { + "provider": "extra", + "kind": "warp", + "index": 43, + "register": 4, + "version": "old", + "sign": -1 + } + ] + }, + { + "kind": "warp", + "G_columns": [ + 1, + 2, + 8, + 32, + 44, + 128, + 59, + 66, + 489 + ], + "entrance": [ + 266, + 138, + 74, + 30, + 1 + ], + "terminal": [ + 426, + 96, + 24, + 6, + 1 + ], + "sign": 1, + "recipe": { + "rank": 0, + "left": { + "matrix_rows": [ + 1, + 67, + 16, + 468, + 65, + 217, + 128, + 417, + 385 + ], + "offset": 458, + "quadratic_rows": [ + 251, + 65, + 464, + 209, + 269, + 385, + 335, + 301, + 244 + ], + "linear_Z4": [ + 1, + 2, + 2, + 0, + 2, + 2, + 3, + 2, + 2 + ], + "phase": 3 + }, + "right": null + }, + "coverage": [ + { + "provider": "base", + "kind": "warp", + "index": 4, + "register": 333, + "version": "new", + "sign": 1 + }, + { + "provider": "extra", + "kind": "warp", + "index": 4, + "register": 333, + "version": "new", + "sign": 1 + } + ] + }, + { + "kind": "warp", + "G_columns": [ + 1, + 2, + 8, + 32, + 44, + 128, + 59, + 66, + 489 + ], + "entrance": [ + 266, + 138, + 75, + 30 + ], + "terminal": [ + 427, + 96, + 24, + 6 + ], + "sign": 1, + "recipe": { + "rank": 0, + "left": { + "matrix_rows": [ + 449, + 66, + 16, + 468, + 64, + 216, + 128, + 416, + 384 + ], + "offset": 120, + "quadratic_rows": [ + 448, + 64, + 464, + 208, + 268, + 384, + 143, + 237, + 309 + ], + "linear_Z4": [ + 0, + 0, + 2, + 2, + 0, + 0, + 0, + 3, + 1 + ], + "phase": 0 + }, + "right": null + }, + "coverage": [ + { + "provider": "base", + "kind": "warp", + "index": 4, + "register": 333, + "version": "old", + "sign": 1 + }, + { + "provider": "extra", + "kind": "warp", + "index": 4, + "register": 333, + "version": "old", + "sign": 1 + } + ] + }, + { + "kind": "warp", + "G_columns": [ + 1, + 2, + 8, + 32, + 44, + 128, + 59, + 66, + 489 + ], + "entrance": [ + 426, + 96, + 24, + 6, + 1 + ], + "terminal": [ + 266, + 138, + 74, + 30, + 1 + ], + "sign": -1, + "recipe": { + "rank": 0, + "left": { + "matrix_rows": [ + 1, + 18, + 284, + 116, + 4, + 384, + 17, + 64, + 321 + ], + "offset": 138, + "quadratic_rows": [ + 336, + 16, + 360, + 276, + 379, + 84, + 309, + 256, + 221 + ], + "linear_Z4": [ + 2, + 2, + 2, + 0, + 3, + 2, + 2, + 0, + 0 + ], + "phase": 3 + }, + "right": null + }, + "coverage": [ + { + "provider": "base", + "kind": "warp", + "index": 4, + "register": 333, + "version": "new", + "sign": -1 + }, + { + "provider": "extra", + "kind": "warp", + "index": 4, + "register": 333, + "version": "new", + "sign": -1 + } + ] + }, + { + "kind": "warp", + "G_columns": [ + 1, + 2, + 8, + 32, + 44, + 128, + 59, + 66, + 489 + ], + "entrance": [ + 427, + 96, + 24, + 6 + ], + "terminal": [ + 266, + 138, + 75, + 30 + ], + "sign": -1, + "recipe": { + "rank": 0, + "left": { + "matrix_rows": [ + 273, + 18, + 284, + 116, + 4, + 384, + 16, + 64, + 320 + ], + "offset": 459, + "quadratic_rows": [ + 272, + 16, + 360, + 276, + 107, + 84, + 308, + 256, + 461 + ], + "linear_Z4": [ + 2, + 2, + 2, + 0, + 2, + 2, + 0, + 0, + 3 + ], + "phase": 0 + }, + "right": null + }, + "coverage": [ + { + "provider": "base", + "kind": "warp", + "index": 4, + "register": 333, + "version": "old", + "sign": -1 + }, + { + "provider": "extra", + "kind": "warp", + "index": 4, + "register": 333, + "version": "old", + "sign": -1 + } + ] + }, + { + "kind": "warp", + "G_columns": [ + 1, + 2, + 8, + 32, + 44, + 48, + 66, + 128, + 330 + ], + "entrance": [ + 384, + 74, + 44, + 30, + 1 + ], + "terminal": [ + 426, + 96, + 24, + 6, + 1 + ], + "sign": 1, + "recipe": { + "rank": 0, + "left": { + "matrix_rows": [ + 1, + 258, + 16, + 340, + 32, + 376, + 64, + 192, + 320 + ], + "offset": 466, + "quadratic_rows": [ + 0, + 256, + 336, + 368, + 44, + 376, + 428, + 64, + 366 + ], + "linear_Z4": [ + 0, + 2, + 0, + 0, + 0, + 3, + 0, + 2, + 1 + ], + "phase": 3 + }, + "right": null + }, + "coverage": [ + { + "provider": "base", + "kind": "warp", + "index": 5, + "register": 317, + "version": "new", + "sign": 1 + }, + { + "provider": "extra", + "kind": "warp", + "index": 5, + "register": 317, + "version": "new", + "sign": 1 + } + ] + }, + { + "kind": "warp", + "G_columns": [ + 1, + 2, + 8, + 32, + 44, + 48, + 66, + 128, + 330 + ], + "entrance": [ + 385, + 74, + 44, + 30 + ], + "terminal": [ + 427, + 96, + 24, + 6 + ], + "sign": 1, + "recipe": { + "rank": 0, + "left": { + "matrix_rows": [ + 65, + 258, + 16, + 340, + 32, + 376, + 64, + 192, + 320 + ], + "offset": 120, + "quadratic_rows": [ + 64, + 256, + 336, + 368, + 44, + 376, + 493, + 64, + 366 + ], + "linear_Z4": [ + 0, + 0, + 2, + 2, + 0, + 1, + 3, + 0, + 3 + ], + "phase": 0 + }, + "right": null + }, + "coverage": [ + { + "provider": "base", + "kind": "warp", + "index": 5, + "register": 317, + "version": "old", + "sign": 1 + }, + { + "provider": "extra", + "kind": "warp", + "index": 5, + "register": 317, + "version": "old", + "sign": 1 + } + ] + }, + { + "kind": "warp", + "G_columns": [ + 1, + 2, + 8, + 32, + 44, + 48, + 66, + 128, + 330 + ], + "entrance": [ + 426, + 96, + 24, + 6, + 1 + ], + "terminal": [ + 384, + 74, + 44, + 30, + 1 + ], + "sign": -1, + "recipe": { + "rank": 0, + "left": { + "matrix_rows": [ + 1, + 322, + 268, + 308, + 4, + 16, + 64, + 192, + 320 + ], + "offset": 102, + "quadratic_rows": [ + 0, + 320, + 56, + 260, + 308, + 276, + 194, + 64, + 314 + ], + "linear_Z4": [ + 0, + 2, + 2, + 2, + 3, + 0, + 3, + 0, + 1 + ], + "phase": 0 + }, + "right": null + }, + "coverage": [ + { + "provider": "base", + "kind": "warp", + "index": 5, + "register": 317, + "version": "new", + "sign": -1 + }, + { + "provider": "extra", + "kind": "warp", + "index": 5, + "register": 317, + "version": "new", + "sign": -1 + } + ] + }, + { + "kind": "warp", + "G_columns": [ + 1, + 2, + 8, + 32, + 44, + 48, + 66, + 128, + 330 + ], + "entrance": [ + 427, + 96, + 24, + 6 + ], + "terminal": [ + 385, + 74, + 44, + 30 + ], + "sign": -1, + "recipe": { + "rank": 0, + "left": { + "matrix_rows": [ + 65, + 322, + 268, + 308, + 4, + 16, + 64, + 192, + 320 + ], + "offset": 487, + "quadratic_rows": [ + 64, + 320, + 56, + 260, + 308, + 276, + 131, + 64, + 314 + ], + "linear_Z4": [ + 2, + 2, + 2, + 2, + 3, + 0, + 2, + 2, + 1 + ], + "phase": 3 + }, + "right": null + }, + "coverage": [ + { + "provider": "base", + "kind": "warp", + "index": 5, + "register": 317, + "version": "old", + "sign": -1 + }, + { + "provider": "extra", + "kind": "warp", + "index": 5, + "register": 317, + "version": "old", + "sign": -1 + } + ] + }, + { + "kind": "residual", + "entrance": [], + "terminal": [ + 257, + 137, + 67, + 37, + 22 + ], + "recipe": { + "rank": 5, + "left": { + "matrix_rows": [ + 46, + 85, + 147, + 265, + 22, + 5, + 3, + 9, + 1 + ], + "offset": 0, + "quadratic_rows": [ + 0, + 10, + 12, + 6, + 0, + 0, + 0, + 0, + 0 + ], + "linear_Z4": [ + 2, + 3, + 3, + 2, + 2, + 0, + 0, + 0, + 0 + ], + "phase": 0 + }, + "right": { + "matrix_rows": [ + 270, + 389, + 387, + 489, + 118, + 481, + 82, + 52, + 136 + ], + "offset": 31, + "quadratic_rows": [ + 15, + 171, + 205, + 103, + 0, + 106, + 108, + 6, + 0 + ], + "linear_Z4": [ + 1, + 1, + 1, + 2, + 2, + 1, + 1, + 0, + 2 + ], + "phase": 1 + } + }, + "coverage": [ + { + "provider": "base", + "kind": "terminal", + "helper": 369, + "version": "new" + }, + { + "provider": "base", + "kind": "terminal", + "helper": 371, + "version": "new" + }, + { + "provider": "base", + "kind": "terminal", + "helper": 373, + "version": "new" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 369, + "version": "new" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 371, + "version": "new" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 373, + "version": "new" + } + ] + }, + { + "kind": "residual", + "entrance": [], + "terminal": [ + 257, + 161, + 70, + 19, + 13 + ], + "recipe": { + "rank": 5, + "left": { + "matrix_rows": [ + 62, + 69, + 139, + 13, + 3, + 273, + 6, + 17, + 1 + ], + "offset": 0, + "quadratic_rows": [ + 0, + 18, + 20, + 16, + 14, + 0, + 0, + 0, + 0 + ], + "linear_Z4": [ + 2, + 3, + 3, + 2, + 2, + 0, + 0, + 0, + 0 + ], + "phase": 0 + }, + "right": { + "matrix_rows": [ + 294, + 389, + 387, + 477, + 441, + 409, + 82, + 76, + 160 + ], + "offset": 31, + "quadratic_rows": [ + 506, + 245, + 310, + 441, + 447, + 31, + 387, + 475, + 477 + ], + "linear_Z4": [ + 0, + 2, + 1, + 1, + 1, + 2, + 2, + 3, + 1 + ], + "phase": 1 + } + }, + "coverage": [ + { + "provider": "base", + "kind": "terminal", + "helper": 337, + "version": "new" + }, + { + "provider": "base", + "kind": "terminal", + "helper": 339, + "version": "new" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 337, + "version": "new" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 339, + "version": "new" + } + ] + }, + { + "kind": "residual", + "entrance": [], + "terminal": [ + 258, + 130, + 67, + 22, + 8 + ], + "recipe": { + "rank": 5, + "left": { + "matrix_rows": [ + 35, + 85, + 134, + 8, + 6, + 256, + 3, + 18, + 2 + ], + "offset": 0, + "quadratic_rows": [ + 20, + 18, + 17, + 0, + 23, + 0, + 0, + 0, + 0 + ], + "linear_Z4": [ + 2, + 3, + 2, + 2, + 3, + 0, + 0, + 0, + 0 + ], + "phase": 0 + }, + "right": { + "matrix_rows": [ + 467, + 389, + 470, + 8, + 338, + 65, + 466, + 20, + 32 + ], + "offset": 13, + "quadratic_rows": [ + 22, + 135, + 67, + 0, + 129, + 0, + 132, + 210, + 0 + ], + "linear_Z4": [ + 0, + 3, + 0, + 2, + 2, + 0, + 2, + 1, + 2 + ], + "phase": 3 + } + }, + "coverage": [ + { + "provider": "base", + "kind": "terminal", + "helper": 323, + "version": "new" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 323, + "version": "new" + } + ] + }, + { + "kind": "residual", + "entrance": [], + "terminal": [ + 259, + 131, + 75, + 42, + 25 + ], + "recipe": { + "rank": 5, + "left": { + "matrix_rows": [ + 58, + 81, + 128, + 268, + 13, + 6, + 7, + 19, + 3 + ], + "offset": 0, + "quadratic_rows": [ + 10, + 9, + 4, + 19, + 8, + 0, + 0, + 0, + 0 + ], + "linear_Z4": [ + 2, + 2, + 3, + 2, + 2, + 0, + 0, + 0, + 0 + ], + "phase": 0 + }, + "right": { + "matrix_rows": [ + 50, + 49, + 8, + 441, + 179, + 465, + 482, + 4, + 120 + ], + "offset": 27, + "quadratic_rows": [ + 235, + 353, + 0, + 449, + 176, + 179, + 11, + 441, + 138 + ], + "linear_Z4": [ + 1, + 2, + 0, + 0, + 3, + 3, + 2, + 1, + 2 + ], + "phase": 0 + } + }, + "coverage": [ + { + "provider": "base", + "kind": "terminal", + "helper": 385, + "version": "new" + }, + { + "provider": "base", + "kind": "terminal", + "helper": 387, + "version": "new" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 385, + "version": "new" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 387, + "version": "new" + } + ] + }, + { + "kind": "residual", + "entrance": [], + "terminal": [ + 259, + 131, + 75, + 51, + 7 + ], + "recipe": { + "rank": 5, + "left": { + "matrix_rows": [ + 63, + 95, + 3, + 133, + 265, + 9, + 5, + 17, + 1 + ], + "offset": 0, + "quadratic_rows": [ + 18, + 1, + 4, + 8, + 1, + 0, + 0, + 0, + 0 + ], + "linear_Z4": [ + 2, + 2, + 3, + 3, + 2, + 0, + 0, + 0, + 0 + ], + "phase": 0 + }, + "right": { + "matrix_rows": [ + 415, + 7, + 11, + 19, + 131, + 485, + 486, + 72, + 48 + ], + "offset": 18, + "quadratic_rows": [ + 231, + 231, + 415, + 468, + 428, + 19, + 11, + 415, + 156 + ], + "linear_Z4": [ + 1, + 1, + 3, + 2, + 2, + 2, + 2, + 3, + 0 + ], + "phase": 2 + } + }, + "coverage": [ + { + "provider": "base", + "kind": "terminal", + "helper": 389, + "version": "new" + }, + { + "provider": "base", + "kind": "terminal", + "helper": 394, + "version": "new" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 389, + "version": "new" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 394, + "version": "new" + } + ] + }, + { + "kind": "residual", + "entrance": [], + "terminal": [ + 262, + 134, + 102, + 22, + 8 + ], + "recipe": { + "rank": 5, + "left": { + "matrix_rows": [ + 32, + 92, + 156, + 2, + 5, + 265, + 9, + 17, + 1 + ], + "offset": 0, + "quadratic_rows": [ + 20, + 0, + 1, + 8, + 1, + 0, + 0, + 0, + 0 + ], + "linear_Z4": [ + 2, + 2, + 2, + 3, + 2, + 0, + 0, + 0, + 0 + ], + "phase": 0 + }, + "right": { + "matrix_rows": [ + 432, + 8, + 22, + 38, + 134, + 1, + 466, + 468, + 96 + ], + "offset": 23, + "quadratic_rows": [ + 0, + 358, + 358, + 0, + 432, + 470, + 38, + 432, + 182 + ], + "linear_Z4": [ + 0, + 3, + 3, + 2, + 1, + 0, + 2, + 1, + 2 + ], + "phase": 0 + } + }, + "coverage": [ + { + "provider": "base", + "kind": "terminal", + "helper": 353, + "version": "new" + }, + { + "provider": "base", + "kind": "terminal", + "helper": 355, + "version": "new" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 353, + "version": "new" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 355, + "version": "new" + } + ] + }, + { + "kind": "residual", + "entrance": [], + "terminal": [ + 262, + 134, + 102, + 30, + 1 + ], + "recipe": { + "rank": 5, + "left": { + "matrix_rows": [ + 1, + 60, + 92, + 134, + 6, + 266, + 10, + 18, + 2 + ], + "offset": 0, + "quadratic_rows": [ + 0, + 18, + 4, + 8, + 2, + 0, + 0, + 0, + 0 + ], + "linear_Z4": [ + 2, + 3, + 3, + 3, + 2, + 0, + 0, + 0, + 0 + ], + "phase": 0 + }, + "right": { + "matrix_rows": [ + 1, + 424, + 14, + 38, + 134, + 466, + 468, + 24, + 96 + ], + "offset": 17, + "quadratic_rows": [ + 0, + 382, + 382, + 438, + 14, + 462, + 38, + 424, + 174 + ], + "linear_Z4": [ + 2, + 1, + 1, + 2, + 2, + 2, + 2, + 3, + 0 + ], + "phase": 2 + } + }, + "coverage": [ + { + "provider": "base", + "kind": "terminal", + "helper": 357, + "version": "new" + }, + { + "provider": "base", + "kind": "terminal", + "helper": 362, + "version": "new" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 357, + "version": "new" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 362, + "version": "new" + } + ] + }, + { + "kind": "residual", + "entrance": [], + "terminal": [ + 266, + 138, + 74, + 30, + 1 + ], + "recipe": { + "rank": 5, + "left": { + "matrix_rows": [ + 1, + 60, + 70, + 156, + 6, + 256, + 10, + 18, + 2 + ], + "offset": 0, + "quadratic_rows": [ + 0, + 24, + 4, + 2, + 2, + 0, + 0, + 0, + 0 + ], + "linear_Z4": [ + 2, + 2, + 3, + 2, + 2, + 0, + 0, + 0, + 0 + ], + "phase": 0 + }, + "right": { + "matrix_rows": [ + 1, + 452, + 14, + 74, + 138, + 466, + 20, + 472, + 32 + ], + "offset": 27, + "quadratic_rows": [ + 0, + 286, + 474, + 286, + 14, + 0, + 452, + 452, + 206 + ], + "linear_Z4": [ + 2, + 3, + 0, + 3, + 2, + 0, + 1, + 1, + 2 + ], + "phase": 0 + } + }, + "coverage": [ + { + "provider": "base", + "kind": "terminal", + "helper": 330, + "version": "new" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 330, + "version": "new" + } + ] + }, + { + "kind": "residual", + "entrance": [], + "terminal": [ + 266, + 138, + 75, + 47, + 30 + ], + "recipe": { + "rank": 5, + "left": { + "matrix_rows": [ + 36, + 90, + 137, + 282, + 14, + 7, + 3, + 18, + 2 + ], + "offset": 0, + "quadratic_rows": [ + 12, + 24, + 9, + 15, + 2, + 0, + 0, + 0, + 0 + ], + "linear_Z4": [ + 2, + 2, + 2, + 3, + 2, + 0, + 0, + 0, + 0 + ], + "phase": 0 + }, + "right": { + "matrix_rows": [ + 84, + 506, + 81, + 46, + 138, + 97, + 498, + 52, + 504 + ], + "offset": 21, + "quadratic_rows": [ + 49, + 174, + 74, + 174, + 465, + 427, + 468, + 506, + 240 + ], + "linear_Z4": [ + 3, + 1, + 0, + 1, + 1, + 1, + 1, + 3, + 0 + ], + "phase": 3 + } + }, + "coverage": [ + { + "provider": "base", + "kind": "terminal", + "helper": 325, + "version": "new" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 325, + "version": "new" + } + ] + }, + { + "kind": "residual", + "entrance": [], + "terminal": [ + 273, + 145, + 85, + 51, + 8 + ], + "recipe": { + "rank": 5, + "left": { + "matrix_rows": [ + 54, + 67, + 133, + 8, + 278, + 3, + 5, + 17, + 1 + ], + "offset": 0, + "quadratic_rows": [ + 17, + 2, + 4, + 0, + 1, + 0, + 0, + 0, + 0 + ], + "linear_Z4": [ + 3, + 3, + 3, + 2, + 2, + 0, + 0, + 0, + 0 + ], + "phase": 0 + }, + "right": { + "matrix_rows": [ + 390, + 19, + 21, + 8, + 145, + 481, + 34, + 68, + 496 + ], + "offset": 24, + "quadratic_rows": [ + 375, + 437, + 467, + 0, + 375, + 19, + 21, + 390, + 151 + ], + "linear_Z4": [ + 1, + 2, + 2, + 2, + 1, + 2, + 2, + 3, + 0 + ], + "phase": 2 + } + }, + "coverage": [ + { + "provider": "base", + "kind": "terminal", + "helper": 293, + "version": "new" + }, + { + "provider": "base", + "kind": "terminal", + "helper": 298, + "version": "new" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 293, + "version": "new" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 298, + "version": "new" + } + ] + }, + { + "kind": "residual", + "entrance": [], + "terminal": [ + 384, + 131, + 75, + 51 + ], + "recipe": { + "rank": 4, + "left": { + "matrix_rows": [ + 31, + 47, + 64, + 131, + 261, + 5, + 3, + 1, + 8 + ], + "offset": 0, + "quadratic_rows": [ + 0, + 2, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "linear_Z4": [ + 2, + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0 + ], + "phase": 0 + }, + "right": { + "matrix_rows": [ + 411, + 11, + 19, + 131, + 481, + 482, + 4, + 72, + 48 + ], + "offset": 9, + "quadratic_rows": [ + 224, + 224, + 0, + 464, + 424, + 19, + 11, + 411, + 152 + ], + "linear_Z4": [ + 0, + 0, + 0, + 0, + 0, + 2, + 2, + 1, + 0 + ], + "phase": 2 + } + }, + "coverage": [ + { + "provider": "base", + "kind": "terminal", + "helper": 385, + "version": "old" + }, + { + "provider": "base", + "kind": "terminal", + "helper": 387, + "version": "old" + }, + { + "provider": "base", + "kind": "terminal", + "helper": 389, + "version": "old" + }, + { + "provider": "base", + "kind": "terminal", + "helper": 394, + "version": "old" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 385, + "version": "old" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 387, + "version": "old" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 389, + "version": "old" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 394, + "version": "old" + } + ] + }, + { + "kind": "residual", + "entrance": [], + "terminal": [ + 384, + 134, + 120, + 30 + ], + "recipe": { + "rank": 4, + "left": { + "matrix_rows": [ + 16, + 42, + 74, + 133, + 5, + 262, + 6, + 1, + 8 + ], + "offset": 0, + "quadratic_rows": [ + 0, + 2, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "linear_Z4": [ + 2, + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0 + ], + "phase": 0 + }, + "right": { + "matrix_rows": [ + 456, + 118, + 56, + 134, + 1, + 466, + 468, + 24, + 96 + ], + "offset": 10, + "quadratic_rows": [ + 0, + 288, + 288, + 480, + 64, + 14, + 408, + 456, + 206 + ], + "linear_Z4": [ + 0, + 2, + 2, + 2, + 2, + 0, + 2, + 3, + 2 + ], + "phase": 2 + } + }, + "coverage": [ + { + "provider": "base", + "kind": "terminal", + "helper": 353, + "version": "old" + }, + { + "provider": "base", + "kind": "terminal", + "helper": 355, + "version": "old" + }, + { + "provider": "base", + "kind": "terminal", + "helper": 357, + "version": "old" + }, + { + "provider": "base", + "kind": "terminal", + "helper": 362, + "version": "old" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 353, + "version": "old" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 355, + "version": "old" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 357, + "version": "old" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 362, + "version": "old" + } + ] + }, + { + "kind": "residual", + "entrance": [], + "terminal": [ + 384, + 193, + 75, + 30 + ], + "recipe": { + "rank": 4, + "left": { + "matrix_rows": [ + 26, + 37, + 70, + 133, + 6, + 256, + 10, + 1, + 8 + ], + "offset": 0, + "quadratic_rows": [ + 0, + 2, + 4, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "linear_Z4": [ + 2, + 3, + 3, + 2, + 0, + 0, + 0, + 0, + 0 + ], + "phase": 0 + }, + "right": { + "matrix_rows": [ + 74, + 389, + 14, + 193, + 65, + 466, + 20, + 472, + 32 + ], + "offset": 11, + "quadratic_rows": [ + 260, + 404, + 411, + 404, + 14, + 0, + 128, + 462, + 143 + ], + "linear_Z4": [ + 2, + 0, + 0, + 0, + 2, + 0, + 0, + 3, + 0 + ], + "phase": 3 + } + }, + "coverage": [ + { + "provider": "base", + "kind": "terminal", + "helper": 323, + "version": "old" + }, + { + "provider": "base", + "kind": "terminal", + "helper": 325, + "version": "old" + }, + { + "provider": "base", + "kind": "terminal", + "helper": 330, + "version": "old" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 323, + "version": "old" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 325, + "version": "old" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 330, + "version": "old" + } + ] + }, + { + "kind": "residual", + "entrance": [], + "terminal": [ + 384, + 196, + 85, + 51 + ], + "recipe": { + "rank": 4, + "left": { + "matrix_rows": [ + 22, + 35, + 73, + 128, + 262, + 3, + 9, + 4, + 8 + ], + "offset": 0, + "quadratic_rows": [ + 1, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "linear_Z4": [ + 3, + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0 + ], + "phase": 0 + }, + "right": { + "matrix_rows": [ + 390, + 19, + 81, + 196, + 481, + 34, + 68, + 8, + 496 + ], + "offset": 13, + "quadratic_rows": [ + 418, + 437, + 258, + 0, + 418, + 19, + 128, + 467, + 151 + ], + "linear_Z4": [ + 0, + 0, + 2, + 0, + 0, + 2, + 0, + 3, + 0 + ], + "phase": 3 + } + }, + "coverage": [ + { + "provider": "base", + "kind": "terminal", + "helper": 293, + "version": "old" + }, + { + "provider": "base", + "kind": "terminal", + "helper": 298, + "version": "old" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 293, + "version": "old" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 298, + "version": "old" + } + ] + }, + { + "kind": "residual", + "entrance": [], + "terminal": [ + 384, + 74, + 44, + 30, + 1 + ], + "recipe": { + "rank": 5, + "left": { + "matrix_rows": [ + 1, + 36, + 66, + 136, + 14, + 12, + 10, + 272, + 16 + ], + "offset": 0, + "quadratic_rows": [ + 0, + 4, + 2, + 8, + 16, + 0, + 0, + 0, + 0 + ], + "linear_Z4": [ + 2, + 2, + 2, + 3, + 3, + 0, + 0, + 0, + 0 + ], + "phase": 0 + }, + "right": { + "matrix_rows": [ + 1, + 100, + 98, + 8, + 128, + 82, + 52, + 120, + 384 + ], + "offset": 1, + "quadratic_rows": [ + 0, + 50, + 84, + 120, + 14, + 106, + 108, + 384, + 128 + ], + "linear_Z4": [ + 2, + 1, + 1, + 1, + 2, + 1, + 1, + 1, + 2 + ], + "phase": 1 + } + }, + "coverage": [ + { + "provider": "base", + "kind": "terminal", + "helper": 314, + "version": "new" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 314, + "version": "new" + } + ] + }, + { + "kind": "residual", + "entrance": [], + "terminal": [ + 385, + 66, + 36, + 22, + 8 + ], + "recipe": { + "rank": 5, + "left": { + "matrix_rows": [ + 33, + 84, + 146, + 8, + 22, + 4, + 2, + 257, + 1 + ], + "offset": 0, + "quadratic_rows": [ + 0, + 4, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "linear_Z4": [ + 2, + 2, + 2, + 2, + 2, + 0, + 0, + 0, + 0 + ], + "phase": 0 + }, + "right": { + "matrix_rows": [ + 385, + 100, + 98, + 8, + 118, + 257, + 82, + 52, + 384 + ], + "offset": 31, + "quadratic_rows": [ + 129, + 68, + 34, + 0, + 0, + 100, + 98, + 129, + 0 + ], + "linear_Z4": [ + 3, + 2, + 2, + 2, + 2, + 3, + 3, + 3, + 2 + ], + "phase": 1 + } + }, + "coverage": [ + { + "provider": "base", + "kind": "terminal", + "helper": 307, + "version": "new" + }, + { + "provider": "base", + "kind": "terminal", + "helper": 309, + "version": "new" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 307, + "version": "new" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 309, + "version": "new" + } + ] + }, + { + "kind": "residual", + "entrance": [], + "terminal": [ + 385, + 74, + 44, + 30 + ], + "recipe": { + "rank": 4, + "left": { + "matrix_rows": [ + 17, + 36, + 66, + 136, + 14, + 12, + 10, + 257, + 1 + ], + "offset": 0, + "quadratic_rows": [ + 0, + 4, + 2, + 8, + 0, + 0, + 0, + 0, + 0 + ], + "linear_Z4": [ + 2, + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0 + ], + "phase": 0 + }, + "right": { + "matrix_rows": [ + 385, + 100, + 98, + 8, + 257, + 82, + 52, + 120, + 384 + ], + "offset": 1, + "quadratic_rows": [ + 129, + 50, + 84, + 120, + 14, + 106, + 108, + 129, + 0 + ], + "linear_Z4": [ + 3, + 1, + 1, + 1, + 2, + 1, + 1, + 3, + 2 + ], + "phase": 1 + } + }, + "coverage": [ + { + "provider": "base", + "kind": "terminal", + "helper": 307, + "version": "old" + }, + { + "provider": "base", + "kind": "terminal", + "helper": 309, + "version": "old" + }, + { + "provider": "base", + "kind": "terminal", + "helper": 314, + "version": "old" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 307, + "version": "old" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 309, + "version": "old" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 314, + "version": "old" + } + ] + }, + { + "kind": "residual", + "entrance": [], + "terminal": [ + 388, + 67, + 33, + 18, + 8 + ], + "recipe": { + "rank": 5, + "left": { + "matrix_rows": [ + 34, + 81, + 132, + 8, + 18, + 1, + 3, + 260, + 4 + ], + "offset": 0, + "quadratic_rows": [ + 18, + 17, + 0, + 0, + 19, + 0, + 0, + 0, + 0 + ], + "linear_Z4": [ + 2, + 2, + 2, + 2, + 3, + 0, + 0, + 0, + 0 + ], + "phase": 0 + }, + "right": { + "matrix_rows": [ + 50, + 49, + 388, + 8, + 66, + 97, + 82, + 260, + 384 + ], + "offset": 15, + "quadratic_rows": [ + 81, + 32, + 132, + 0, + 65, + 66, + 49, + 132, + 0 + ], + "linear_Z4": [ + 3, + 0, + 3, + 2, + 0, + 0, + 0, + 3, + 2 + ], + "phase": 0 + } + }, + "coverage": [ + { + "provider": "base", + "kind": "terminal", + "helper": 282, + "version": "new" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 282, + "version": "new" + } + ] + }, + { + "kind": "residual", + "entrance": [], + "terminal": [ + 388, + 74, + 40, + 26, + 1 + ], + "recipe": { + "rank": 5, + "left": { + "matrix_rows": [ + 1, + 48, + 68, + 152, + 26, + 8, + 10, + 260, + 4 + ], + "offset": 0, + "quadratic_rows": [ + 0, + 18, + 0, + 8, + 2, + 0, + 0, + 0, + 0 + ], + "linear_Z4": [ + 2, + 3, + 2, + 3, + 2, + 0, + 0, + 0, + 0 + ], + "phase": 0 + }, + "right": { + "matrix_rows": [ + 1, + 80, + 388, + 8, + 58, + 82, + 260, + 120, + 384 + ], + "offset": 29, + "quadratic_rows": [ + 0, + 106, + 132, + 66, + 80, + 98, + 58, + 132, + 0 + ], + "linear_Z4": [ + 2, + 3, + 3, + 2, + 3, + 1, + 0, + 3, + 2 + ], + "phase": 0 + } + }, + "coverage": [ + { + "provider": "base", + "kind": "terminal", + "helper": 277, + "version": "new" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 277, + "version": "new" + } + ] + }, + { + "kind": "residual", + "entrance": [], + "terminal": [ + 388, + 75, + 41, + 26 + ], + "recipe": { + "rank": 4, + "left": { + "matrix_rows": [ + 18, + 33, + 68, + 136, + 10, + 9, + 11, + 260, + 4 + ], + "offset": 0, + "quadratic_rows": [ + 2, + 1, + 0, + 8, + 0, + 0, + 0, + 0, + 0 + ], + "linear_Z4": [ + 2, + 2, + 2, + 3, + 0, + 0, + 0, + 0, + 0 + ], + "phase": 0 + }, + "right": { + "matrix_rows": [ + 50, + 49, + 388, + 8, + 97, + 82, + 260, + 120, + 384 + ], + "offset": 4, + "quadratic_rows": [ + 81, + 98, + 132, + 120, + 57, + 58, + 11, + 132, + 0 + ], + "linear_Z4": [ + 1, + 1, + 3, + 1, + 1, + 1, + 2, + 3, + 2 + ], + "phase": 1 + } + }, + "coverage": [ + { + "provider": "base", + "kind": "terminal", + "helper": 277, + "version": "old" + }, + { + "provider": "base", + "kind": "terminal", + "helper": 282, + "version": "old" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 277, + "version": "old" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 282, + "version": "old" + } + ] + }, + { + "kind": "residual", + "entrance": [], + "terminal": [ + 392, + 67, + 35, + 16, + 6 + ], + "recipe": { + "rank": 5, + "left": { + "matrix_rows": [ + 48, + 82, + 2, + 132, + 8, + 19, + 3, + 260, + 4 + ], + "offset": 0, + "quadratic_rows": [ + 17, + 2, + 0, + 0, + 1, + 0, + 0, + 0, + 0 + ], + "linear_Z4": [ + 3, + 3, + 2, + 2, + 2, + 0, + 0, + 0, + 0 + ], + "phase": 0 + }, + "right": { + "matrix_rows": [ + 96, + 2, + 392, + 16, + 39, + 97, + 102, + 264, + 384 + ], + "offset": 30, + "quadratic_rows": [ + 71, + 65, + 69, + 136, + 0, + 96, + 39, + 136, + 0 + ], + "linear_Z4": [ + 3, + 2, + 1, + 3, + 2, + 3, + 0, + 3, + 2 + ], + "phase": 0 + } + }, + "coverage": [ + { + "provider": "base", + "kind": "terminal", + "helper": 378, + "version": "new" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 378, + "version": "new" + } + ] + }, + { + "kind": "residual", + "entrance": [], + "terminal": [ + 392, + 67, + 37, + 22 + ], + "recipe": { + "rank": 4, + "left": { + "matrix_rows": [ + 18, + 41, + 75, + 132, + 10, + 1, + 3, + 260, + 4 + ], + "offset": 0, + "quadratic_rows": [ + 1, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "linear_Z4": [ + 3, + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0 + ], + "phase": 0 + }, + "right": { + "matrix_rows": [ + 6, + 5, + 392, + 118, + 97, + 82, + 52, + 264, + 384 + ], + "offset": 15, + "quadratic_rows": [ + 101, + 32, + 69, + 136, + 0, + 3, + 5, + 136, + 0 + ], + "linear_Z4": [ + 3, + 2, + 1, + 3, + 2, + 2, + 2, + 3, + 2 + ], + "phase": 0 + } + }, + "coverage": [ + { + "provider": "base", + "kind": "terminal", + "helper": 369, + "version": "old" + }, + { + "provider": "base", + "kind": "terminal", + "helper": 371, + "version": "old" + }, + { + "provider": "base", + "kind": "terminal", + "helper": 373, + "version": "old" + }, + { + "provider": "base", + "kind": "terminal", + "helper": 378, + "version": "old" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 369, + "version": "old" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 371, + "version": "old" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 373, + "version": "old" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 378, + "version": "old" + } + ] + }, + { + "kind": "residual", + "entrance": [], + "terminal": [ + 416, + 70, + 18, + 12, + 1 + ], + "recipe": { + "rank": 5, + "left": { + "matrix_rows": [ + 1, + 36, + 74, + 12, + 2, + 144, + 6, + 272, + 16 + ], + "offset": 0, + "quadratic_rows": [ + 0, + 12, + 10, + 14, + 0, + 0, + 0, + 0, + 0 + ], + "linear_Z4": [ + 2, + 2, + 2, + 3, + 2, + 0, + 0, + 0, + 0 + ], + "phase": 0 + }, + "right": { + "matrix_rows": [ + 1, + 28, + 26, + 68, + 416, + 82, + 76, + 288, + 384 + ], + "offset": 23, + "quadratic_rows": [ + 0, + 74, + 16, + 66, + 68, + 160, + 26, + 160, + 0 + ], + "linear_Z4": [ + 2, + 3, + 0, + 0, + 0, + 3, + 0, + 3, + 2 + ], + "phase": 0 + } + }, + "coverage": [ + { + "provider": "base", + "kind": "terminal", + "helper": 341, + "version": "new" + }, + { + "provider": "base", + "kind": "terminal", + "helper": 346, + "version": "new" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 341, + "version": "new" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 346, + "version": "new" + } + ] + }, + { + "kind": "residual", + "entrance": [], + "terminal": [ + 416, + 70, + 19, + 13 + ], + "recipe": { + "rank": 4, + "left": { + "matrix_rows": [ + 22, + 33, + 71, + 5, + 3, + 136, + 2, + 264, + 8 + ], + "offset": 0, + "quadratic_rows": [ + 1, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "linear_Z4": [ + 3, + 3, + 2, + 2, + 0, + 0, + 0, + 0, + 0 + ], + "phase": 0 + }, + "right": { + "matrix_rows": [ + 6, + 5, + 93, + 416, + 25, + 82, + 76, + 288, + 384 + ], + "offset": 15, + "quadratic_rows": [ + 64, + 86, + 22, + 0, + 6, + 160, + 3, + 160, + 0 + ], + "linear_Z4": [ + 2, + 3, + 1, + 2, + 2, + 3, + 2, + 3, + 2 + ], + "phase": 0 + } + }, + "coverage": [ + { + "provider": "base", + "kind": "terminal", + "helper": 337, + "version": "old" + }, + { + "provider": "base", + "kind": "terminal", + "helper": 339, + "version": "old" + }, + { + "provider": "base", + "kind": "terminal", + "helper": 341, + "version": "old" + }, + { + "provider": "base", + "kind": "terminal", + "helper": 346, + "version": "old" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 337, + "version": "old" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 339, + "version": "old" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 341, + "version": "old" + }, + { + "provider": "extra", + "kind": "terminal", + "helper": 346, + "version": "old" + } + ] + } + ] +} diff --git a/research/staged544-paid-native-fusion/frozen/SOURCE-CREDITS.md b/research/staged544-paid-native-fusion/frozen/SOURCE-CREDITS.md new file mode 100644 index 0000000000..c054fad87e --- /dev/null +++ b/research/staged544-paid-native-fusion/frozen/SOURCE-CREDITS.md @@ -0,0 +1,14 @@ +# Source credit and independence + +New work: dataisfire with substantial OpenAI Codex assistance, Apache-2.0. No independent human review, fresh third-party AI review or proof-kernel verification is claimed. + +The construction extends [PR3682](https://github.com/CrocSwap/integer-mult-bounds/pull/3682), head431e6c6023ef352c41696469de7fb614cd4ded8c. Its retimed word, actual T360 source clock and immutable native/parent framework are retained. The complete new source/receipt snapshot is bound by REPLAY-INPUTS.json. The new ordinary source stage is an explicit pinned record applied after the unchanged predecessor reconstruction. + +- [PR3605](https://github.com/CrocSwap/integer-mult-bounds/pull/3605), Ross Richardson, supplies the staged-entrance mechanism, literal cleanup and exact Gaussian residual-check pattern. staged_pair.py is retained; the new544 shear and its proof are separate. +- [PR3638](https://github.com/CrocSwap/integer-mult-bounds/pull/3638), head d62e1acd7518a231440383f0d0dddf54d6edf8c1, supplies the T360 source-window clock, chronological aggregate model and integral-network/literal construction, with its retained PR3605 and earlier credits. The new inventory, integer incumbent and literal fill are recomputed. No predecessor owner receipt is used as proof of the new fill. +- [PR3687](https://github.com/CrocSwap/integer-mult-bounds/pull/3687) and [PR3693](https://github.com/CrocSwap/integer-mult-bounds/pull/3693), Sagar Thakrar and roger-sato with their credited AI assistance, supply audit_core.py and the whole-word semantics adapter audit_verify.py. These bytes are retained and reused. They are independent of the current constructor in the stated interpreter scope, not a newly written independent audit or new reviewer approval. +- The coupled-word source lineage includes PR3133, PR2979, Marius-Paul Dumitrean, dcharb78, Jeremy Kothe and the retained native/owner/block-norm/outer authors. All notices and scientific engines inside the source snapshot remain intact. + +owner_audit.py is a standalone standard-library adaptation of the source-window/family/prefix/invoice predicates in PR3638's independent_literal.py. It imports no producer, optimizer or retained owner checker. Its source template, plan and actual native canonical words are authenticated inputs. Three controls mutate actual literal roles and must fail for the intended reason. It shares the credited contract interpretation; it is not evidence of independent human agreement. + +The rational finite-price enclosure is retained from the PR3682 sources. New script adapters bind it to the actual finite histogram. Native forward/backward scalar replay, wrapper/phase lowering and all-column warp recipes were freshly run for both new words; unchanged native and parent ancestry is explicitly reused. The separate new544 span(414,51) residual check includes global Gaussian phase. diff --git a/research/staged544-paid-native-fusion/frozen/TAG-PROOF.md b/research/staged544-paid-native-fusion/frozen/TAG-PROOF.md new file mode 100644 index 0000000000..c87b16a3c5 --- /dev/null +++ b/research/staged544-paid-native-fusion/frozen/TAG-PROOF.md @@ -0,0 +1,195 @@ +# Explicit phase tags for the source-defined native lift + +## Scope and conventions + +Chris R / Clear1nsight's PR3987, scientific head +`fc536202fdaa924158789a5ef59ac079bbe21922`, already proves that the canonical +lift cocycle is an even linear character and supplies the actual inverse +witness with defect `Z_256`. Its source uses the correct adjoint; there is no +author bug to repair. The present addition is an explicit trivialization of +that cocycle, an arbitrary signed-word tag rule and the required compensation +when using the normalized section inside a frame. The representation-theoretic +conjugation below is elementary; it is not claimed as a new general Clifford +construction or as a native compiler modification. + +Retain the source's ket convention, binary column matrices and right-to-left +operator composition. For `x in F_2^n`, + +``` +P_G |x> = |Gx>, Z_t |x> = (-1)^(t dot x)|x>, +D |x> = i^wt(x)|x>. +``` + +All matrix operations in binary forms are over F_2; Hamming weights are +ordinary integers, reduced modulo four only in phases. Take any positive n +and any invertible binary G. Define exactly the source's canonical refinement + +``` +Q_G = I + G^-T G^-1, +q_Q(y) = sum_j Q_jj y_j + 2 sum_(j = i^q_(Q_G)(Gx) |Gx>. +``` + +These are ideal exact operators on arbitrary Gaussian-dyadic amplitudes. +No numerical precision, tape, owner, native tariff or all-size admission is +implied by a phase identity. + +## The normalization tag + +Set `J_G=D P_G D^-1`. Then + +``` +J_G |x> = i^(wt(Gx)-wt(x)) |Gx>, +J_H J_G = J_(HG), J_G^adjoint = J_(G^-1). +``` + +These equalities include global phase, because they follow by cancellation +of the same D factors. This section is generally different from K_G. + +For completeness, the difference of their exponents is precisely an even +linear character. Both `q_(Q_G)(Gx)` and `wt(Gx)-wt(x)` have polar form +`2 x^t(G^tG+I)y mod4`. Their parities agree: the diagonal of Q_G is +`j+G^-T j`, where j is the all-ones vector, so its pairing with Gx is +`j dot Gx+j dot x`. Their difference is therefore even, vanishes at zero, +and has zero polar form. Dividing it by two gives a binary linear functional. +Consequently there is a unique input mask t_G with + +``` +q_(Q_G)(Gx) - wt(Gx) + wt(x) = 2(t_G dot x) mod4, +K_G = J_G Z_(t_G), J_G = K_G Z_(t_G). +``` + +Its coefficients require only coordinate inputs: + +``` +(t_G)_j = [q_(Q_G)(G e_j)-wt(G e_j)+1]_4 / 2, +``` + +where the bracket is the residue 0 or 2. Binary inversion and these quadratic +evaluations use polynomial work in n, rather than enumerating all 2^n states. +The universal statement follows from the polar/parity argument, not from +sampling the coordinate inputs. All K and J operators fix `|0>` exactly; +there is no unspecified scalar phase in this normalization. + +## Cocycle, inverse and arbitrary signed words + +Since `Z_t J_G=J_G Z_(G^t t)`, the source cocycle has the explicit form + +``` +K_H K_G = K_(HG) Z_(ell(G,H)), +ell(G,H) = t_G + G^t t_H + t_(HG). +``` + +Masks add by XOR. This is the source's already-proved cocycle with a specified +coboundary, not a claim that the canonical K section itself composes strictly. +For the source-defined witness, + +``` +G = [1,2,8,32,44,128,59,66,489], +G^-1 = [1,2,28,4,79,8,130,32,431], +t_G = 144, t_(G^-1) = 68, +ell(G,G^-1) = 144 + G^t 68 = 256. +``` + +Thus the credited witness `K_(G^-1) K_G=Z_256` remains intact. Its exact +inverse rule is + +``` +K_G^adjoint = Z_(ell(G,G^-1)) K_(G^-1) + = J_(G^-1) Z_(G^-T t_G). +``` + +The side of a tag matters; input and output masks are not interchangeable. + +For a chronological word `W=K_(G_s)^(epsilon_s)...K_(G_1)^(epsilon_1)`, +with each epsilon either +1 or -1, put + +``` +H_i = G_i, d_i=t_(G_i) if epsilon_i=+1; +H_i = G_i^-1, d_i=G_i^-T t_(G_i) if epsilon_i=-1. +``` + +Starting with `P_0=I,v_0=0`, update in chronological order + +``` +P_i = H_i P_(i-1), +v_i = v_(i-1) + P_(i-1)^t d_i. +``` + +Induction using the Z/J commutation rule proves + +``` +W = J_(P_s) Z_(v_s) + = K_(P_s) Z_(v_s+t_(P_s)). +``` + +This is an exact word certificate in the stated K/adjoint alphabet. It does +not normalize arbitrary serialized Clifford recipes, translations or inserted +nonmonomial children without their additional relations. A binary product +alone omits the final mask and need not determine the signed word. + +## A frame cannot silently change its lift convention + +For the source frame `T=K_B C_[r] K_B^adjoint`, compensation gives + +``` +T = J_B (Z_(t_B) C_[r] Z_(t_B)) J_B^adjoint. +``` + +Replacing the middle expression by C_[r] generally changes the intended +native action. To see the exact change, let +`C_u=((1+i)I+(1-i)X_u)/2`, with `X_u|x>=|x+u>`. Then + +``` +Z_t C_u Z_t = C_u if t dot u=0, +Z_t C_u Z_t = i C_u^adjoint if t dot u=1. +``` + +The second branch has a necessary global i. For a product of commuting +coordinate C gates, k selected directions therefore contribute i^k and become +adjoints; the other directions remain unchanged. The new independent checker +corroborates both branches on all 512 columns for the witness tag 144 with +u=1 and u=16, rejecting omission of i. These are deliberately constructed +calibration primitives, not a claim that this exact frame or occurrence is +present in the supplier word. + +Using J internally is consequently a change of signed-lift convention that +requires retained compensating tags, retagged central children and rebound +interfaces. This package leaves the author's existing correct adjoints and +recipes unchanged. It does not assign a free physical implementation to Z +passes or to their possible fusion with neighboring operations. + +## Evidence and remaining obligations + +Six unchanged PR3987 exports bind the definitions, recipes and retained +notices. RECIPES.json contains 40 descriptors and exactly four distinct binary +maps in its changed warp-interface subset. This is not the complete PR3945 +native inventory. The source's 20,480 full local action comparisons and original +inverse/cocycle results retain their original credit; they are not newly +claimed by extracting these four maps. + +The primary checker constructs the tags and word certificates symbolically. +The separate checker imports no primary or predecessor executable. It uses +row/permutation tables, exhaustive permutation inversion and direct weight +phases, checking the four maps and inverses on all 512 states, their 16 ordered +pair products, and every prefix of an eight-gate signed-word fixture. Pair +products and this word are algebraic controls, not asserted chronological +adjacencies in the supplier. It additionally checks all 168 elements of +GL(3,2), all 28,224 ordered pairs on eight states, and 5,376 exact frame columns. +Its compensated frames agree, while 2,688 naive unretagged frame columns +differ. Gaussian numerators are integer pairs with explicit dyadic denominators; +no floating tolerance accepts an equality. These finite checks corroborate the +written arbitrary-dimension and arbitrary-word proof. + +No complete native serialization, full emitted-program replay, recipe +replacement, dirty-buffer return, physical scratch/routing/owner/tape bound, +uniform precision theorem, passing supplier invoice, selected frontier update, +human acceptance or proof-kernel verification is claimed. The useful next step +is a separately priced integration of this explicit tag discipline into one +named physical interface, not a free replacement of K by J. + +Prepared by ToikY with substantial OpenAI Codex assistance and separate AI +implementation/review contexts. Credit Chris R / Clear1nsight's PR3987, +Dugongue's PR3945/3929, Cinna Davis's PR2226, dataisfire's PR3734 and the full +retained native/compiler/phase/owner lineage in the unchanged notices. +Apache-2.0. diff --git a/research/staged544-paid-native-fusion/frozen/TAG-README.md b/research/staged544-paid-native-fusion/frozen/TAG-README.md new file mode 100644 index 0000000000..b8dbc1d30e --- /dev/null +++ b/research/staged544-paid-native-fusion/frozen/TAG-README.md @@ -0,0 +1,101 @@ +# Explicit phase tags for canonical native lifts + +For the exact canonical lift used in [PR3987](https://github.com/CrocSwap/integer-mult-bounds/pull/3987), +this package gives an explicit phase tag, a compositional certificate for any +signed word of those lifts, and the compensation required inside a native frame. +The result is an elementary source-bound normalization lemma and tool. + +Let `D|x>=i^wt(x)|x>` and `J_G=D P_G D^-1`. Then + +``` +K_G = J_G Z_tG, J_H J_G = J_HG, +ell(G,H) = tG + G^t tH + tHG, +(tG)_j = [q_G(G e_j)-wt(G e_j)+1]_4 / 2. +``` + +The bracket is always 0 or 2. [PROOF.md](PROOF.md) proves the formula for every +invertible binary G in every positive dimension using the exact polar form and +parity, then derives arbitrary signed-word certificates without enumerating +the whole state space. The implementation obtains tags from n coordinate +evaluations and tracks their pullbacks in chronological order. `word_certificate` +returns the binary product and both the residual canonical tag and normalized +section tag; optional signs distinguish a canonical binary-inverse lift from +the actual adjoint. + +Chris R / Clear1nsight's PR3987 already proves the general even-linear cocycle +and supplies the actual inverse-defect witness. Those are predecessor results. +The addition here is its explicit coboundary/normalization, signed-word rule and +required central-frame compensation. For its actual witness the input tags are +144 and 68, recovering the credited defect256. The original source already +uses correct adjoints; no author bug or compiler replacement is claimed. + +## The compensation is part of the result + +For `T=K_B C_[r] K_B^adjoint`, the same operator is +`J_B (Z_tB C_[r] Z_tB) J_B^adjoint`. Dropping the middle tags generally changes +T. For the source primitive `C_u=((1+i)I+(1-i)X_u)/2`, an anticommuting tag +gives **`Z_t C_u Z_t=i C_u^adjoint`**, including the necessary global i. +For commuting coordinate primitives, k flipped directions contribute i^k. +The checks include exact calibration counterexamples to the untagged frame +and to omission of this global phase. They are not claimed source occurrences. + +Switching to J therefore requires compensating tags, rebinding the actual +recipes and a paid physical contract. No Pauli pass, global phase, owner change, +precision bound or native implementation is priced as free. No supplier or κ +improvement follows here. + +## Reproduce and evidence + +Standard-library Python3.12, from the repository root: + +```sh +python3.12 -B scripts/research_package.py --package research/native-lift-phase-tags +``` + +`verify.py` authenticates all six retained source exports, extracts only the +four changed-interface maps in the frozen recipe subset, constructs the new +tags/certificates and checks the formulas on all512 states,16 ordered pairs and +a six-gate signed word. These pair/word fixtures are algebraic controls, not +asserted supplier adjacencies. `CERTIFICATE.json` is checked with exact types. +No predecessor executable is imported. + +`independent.py` uses separate rows, exhaustive permutation inversion and direct +weight phases. It checks all168 elements of GL(3,2), all28,224 ordered pairs on +all8 states,5,376 compensated frame columns, the actual maps on512 states and +eight signed-word prefixes. It finds2,688 differing columns when middle tags +are deliberately dropped and checks both central-C branches on1,024 columns. +Finite corroboration and the general proof have distinct scopes. Neither is +human or proof-kernel acceptance. + +`test_verify.py` adds semantic and actual CLI damaged-input controls, normal +and optimized execution, and a read-only Git-free positive export. The package +is self-contained: no pending commit, canonical live fixture, network or +third-party dependency is needed for the three standalone commands. The source +notice's original CRLF bytes are preserved by package-local Git attributes. + +## Open next questions + +1. **One priced physical interface.** Pin an actual K/adjoint/frame sequence, + attach all input/output tags, and compare the compensated word against its + original action. This tests whether the algebra helps compilation. A complete + signed native recipe, caller/helper return and nonzero physical tariff are + not supplied here; stop before expansion if the full bill is unfavorable. +2. **Broader recipe alphabet.** A serialized Clifford word may include + translations and nonmonomial children. Start with one exact such boundary + and state the extra relations and global phase before applying this tag rule. + The proved alphabet is only K_G and its adjoint; the complete PR3945 native + inventory and emitted program are outside the retained four-map subset. + +## Credit + +New normalization proof, word certificates and tests: ToikY with substantial +OpenAI Codex assistance, including separate AI math/test contexts. Apache-2.0. +Chris R / Clear1nsight's PR3987 at +`fc536202fdaa924158789a5ef59ac079bbe21922` owns the audited source convention, +general cocycle proof, inverse witness and finite interface audit. Six source +files are retained byte-for-byte. Credit Dugongue PR3945/3929, dataisfire PR3734, +Cinna Davis PR2226, Tekalign, icekylinx, DreamingOfClouds, Sagar Thakrar, +roger-sato, Arham Tahir and the retained native/compiler/phase/owner lineage in +`source/SOURCE-CREDITS.md` and `source/NOTICE-PR3945.md`. Those broader claims +were not replayed or admitted here. Frozen sources and selected frontier remain +unchanged. TASK records handoff-first selection and changed catalogue scope. diff --git a/research/staged544-paid-native-fusion/frozen/WORD-base.json.gz b/research/staged544-paid-native-fusion/frozen/WORD-base.json.gz new file mode 100644 index 0000000000..806784bf99 Binary files /dev/null and b/research/staged544-paid-native-fusion/frozen/WORD-base.json.gz differ diff --git a/research/staged544-paid-native-fusion/frozen/WORD-extra.json.gz b/research/staged544-paid-native-fusion/frozen/WORD-extra.json.gz new file mode 100644 index 0000000000..c531be7383 Binary files /dev/null and b/research/staged544-paid-native-fusion/frozen/WORD-extra.json.gz differ diff --git a/research/staged544-paid-native-fusion/frozen/bw_emit.py b/research/staged544-paid-native-fusion/frozen/bw_emit.py new file mode 100644 index 0000000000..6d47f63ab7 --- /dev/null +++ b/research/staged544-paid-native-fusion/frozen/bw_emit.py @@ -0,0 +1,192 @@ +# Warp-aware copy of hpe_emit_local.py (GK / PR #433 lineage: icekylinx with Codex assistance; DreamingOfClouds with Claude Opus 5.5). +# BW: every change for anticipatory dirty borrowing (PR2226, Cinna Davis @1337isnot1337, with OpenAI Codex assistance) is marked "BW:". +# On a word without warps / zero buffers / twisted additions the behaviour equals hpe_emit_local.py. +"""Emit both local programs of a BORROW canonical word: scalar macros, climbs, centres, wrappers, monomial warps, zero buffers. + +A warp event ['warp', r, op, f0, f1] is the rank-zero logical reference change K_G^{+-1} of register r moving it from +frame f0 to frame f1 (G(f0) = f1 for op > 0, G^-1(f0) = f1 for op < 0). The same event stream serves both orientations: +the inverse-transpose of a monomial K_G is the monomial conj(K_G) (same permutation, conjugated phases), a different +formal symbol of the free operator algebra, and the exact column check of the physical product is run for both. +""" +if not __debug__: + raise RuntimeError('assertions must remain enabled') # every check of this stage is an assert +import sys as _sys, os as _os; _sys.path.insert(0, _os.path.dirname(_os.path.abspath(__file__))) +import gzip,hashlib,json +from collections import Counter +from fractions import Fraction as Q +from pathlib import Path + +OUT=Path(_sys.argv[1]);cp=OUT/'CANONICAL-WORD.json.gz' +c=json.load(gzip.open(cp)) +frames=c['frames'];v,R,h=c['v'],c['R'],c['h'];n=2*v+R +def digest(x):return hashlib.sha256(json.dumps(x,sort_keys=True,separators=(',',':')).encode()).hexdigest() +def basis(vs): + b={} + for x in vs: + for p in sorted(b,reverse=True): + if x>>p&1:x^=b[p] + if x: + p=x.bit_length()-1 + for q in b: + if b[q]>>p&1:b[q]^=x + b[p]=x + return tuple(b[p] for p in sorted(b,reverse=True)) +def reg(x):return list(x) if isinstance(x,list) else ['L',x] # BW: ['Z', c] is a private zero buffer +def dual(e): + e=list(e) + if e[0]=='add':e[1],e[2]=e[2],e[1];e[3]*=-1 + else:e[2],e[3]=e[3],e[2] + return e +def scalar(e,back): + e=dual(e) if back else list(e) + if e[0]=='add':return ['add',reg(e[1]),reg(e[2]),e[3],e[4]] + return ['scale',reg(e[1]),e[2],e[3]] +def primitive_bound(e): + if e[0] in ('clear','copy'):return 1 + q=Q(e[3],e[4]) if e[0]=='add' else Q(e[2],e[3]) + a,b=abs(q.numerator),q.denominator + assert b&(b-1)==0 + if e[0]=='scale': + assert a&(a-1)==0 + return abs(a.bit_length()-b.bit_length())+int(q<0) + return 3+(a.bit_length()-1)+a.bit_count()+(b.bit_length()-1) +def lregs(e):return [r for r in ([e[1]]+([e[2]] if e[0]=='add' else [])) if not isinstance(r,list)] + +def expand(e): + """BW: a twisted addition t += c*W(s) at frame zero: warp s by W, add, unwarp (all rank zero at frame 0).""" + if e[0]!='tadd':return [e] + _,t,s,word,a,b,f=e + return [['warp',s,op,0,0] for op in reversed(word)]+[['add',t,s,a,b,0]]+[['warp',s,-op,0,0] for op in word] + +def emit(back): + out=[];cur=c['start'].copy() + def event(e):out.append(e) + def scal(e,f):event(['scalar',e,f]) + def warp(e): + _,r,op,f0,f1=e + if isinstance(r,list):assert r[0]=='Z' and f0==f1==1 + else: + assert cur[r]==f0,('warp frame mismatch',r,cur[r],f0);cur[r]=f1 + event(['warp',reg(r),op,f0,f1]) + event(['phase','zero_frame_precondition']) + for e0 in c['precondition']+c['compensation']: + for e in expand(e0): + if e[0]=='warp':warp(e);continue + regs=lregs(e) + assert all(c['start'][r]==0 for r in regs) + scal(scalar(e,back),0) + event(['phase','entry_adapters']) + entering=[r for r,f in enumerate(c['start']) if r>=2*v and f!=0] + hpe={r for r in range(2*v,n) if c['final'][r]!=1} + wrapped=sorted(set(entering)|hpe) + for r,f in enumerate(c['start']): + if r in wrapped:event(['residual_adapter','pre',r,f]+([c['final'][r]] if c['final'][r]!=1 else [])) + else:event(['adapter','old_to_new',r,f]) + def climb(r,f,part): + old=cur[r] + if old==f:return + assert basis(frames[old]+frames[f])==tuple(frames[f]) + rank=len(frames[f])-len(frames[old]);assert rank>0 + event(['climb',part,r,old,f,rank]);cur[r]=f + for part in ('A','centers','B')+(('cleanup_tail',) if c.get('tail') else ())+('final',): + event(['phase',part]) + if part in ('A','B','cleanup_tail'): + for e in (c['tail'] if part=='cleanup_tail' else c[part]): + if e[0]=='warp':warp(e);continue # BW: monomial reference change, no climb + for r in lregs(e):climb(r,e[-1],part) + scal(scalar(e,back),e[-1]) + elif part=='centers': + lv=lambda r:c.get('target_levels',{}).get(str(r-v),0) + assert all(cur[r]==lv(r) for r in range(v,2*v)) + for k,r in enumerate(c['centers']): + cf=c['center_frames'][k];assert cur[r]==cf + terms=[e for e in c['cut'] if e[2]==r] + path=[cf]+sorted({lv(e[1]) for e in terms}-{cf},key=lambda x:-len(frames[x])) + C=['C',k] + if not back: + scal(['clear',C],cf);scal(['copy',C,['L',r]],cf) + for a in range(len(path)): + if a>0:event(['center',k,path[a-1],path[a],len(frames[path[a-1]])-len(frames[path[a]])]) + for e in terms: + if lv(e[1])==path[a]:scal(['add',['L',e[1]],C,e[3],e[4]],path[a]) + scal(['clear',C],path[-1]) + else: + scal(['clear',C],path[-1]) + for a in range(len(path)-1,-1,-1): + for e in terms: + if lv(e[1])==path[a]:scal(['add',C,['L',e[1]],e[3],e[4]],path[a]) + if a>0:event(['center',k,path[a],path[a-1],len(frames[path[a-1]])-len(frames[path[a]])]) + scal(['add',['L',r],C,-1,1],cf);scal(['clear',C],cf) + else: + for r,f in enumerate(c['final']):climb(r,f,part) + event(['phase','exit_adapters']) + for r,f in enumerate(c['final']): + if r not in hpe:event(['adapter','new_to_old',r,f]) + event(['phase','full_frame_cleanup']) + zb=c.get('zero_buffers',[]) + for z in zb:event(['zero_buffer','alloc',z]) # BW: private FULL-frame zero buffers stand in for the restored (hyperplane-ended) helpers + for e in c['cleanup']: + if e[0]=='warp':warp(e);continue + regs=lregs(e) + assert all(c['final'][r]==1 for r in regs) + assert all(r[0]=='Z' and r[1] in zb for r in [e[1]]+([e[2]] if e[0]=='add' else []) if isinstance(r,list)) + scal(scalar(e,back),1) + for z in zb:event(['zero_buffer','free',z]) + for r in wrapped:event(['residual_adapter','post',r,c['start'][r]]+([c['final'][r]] if r in hpe else [])) + event(['phase','done']) + return out + +def add_row(dst,src,q): + for j,x in src.items(): + z=dst.get(j,Q(0))+q*x + if z:dst[j]=z + else:dst.pop(j,None) +def warp_row(row,op): + out={} + for (var,word),x in row.items(): + word=word[1:] if word and word[0]==-op else (op,)+word + out[var,word]=x + return out + +def check_local(events,back): + # BW: literal scalar replay of the emitted stream in the free warp algebra (rows over (register, warp word)), centres and zero buffers. + state={('L',r):{(r,()):Q(1)} for r in range(n)};live=[];paid=Counter();prims=0;macros=0;zlive=set();nwarp=0 + for e in events: + if e[0]=='climb':assert not live;paid[e[5]]+=1 + elif e[0]=='center':assert live==[e[1]];paid[e[4]]+=1 + elif e[0]=='zero_buffer': + z=e[2] + if e[1]=='alloc':assert z not in zlive;zlive.add(z);state['Z',z]={} + else:assert not state['Z',z] and z in zlive;zlive.remove(z) + elif e[0]=='warp': + t=tuple(e[1]);nwarp+=1;state[t]=warp_row(state[t],e[2]) + elif e[0]=='scalar': + op=e[1];tag=op[0];t=tuple(op[1]);macros+=1;prims+=2*primitive_bound(op) + if tag=='clear': + state[t]={} + if t[0]=='C' and t[1] in live:live.remove(t[1]) + elif tag=='copy':state[t]={(var,w):x for (var,w),x in state.get(tuple(op[2]),{}).items()};live.append(t[1]) + elif tag=='scale':state[t]={j:Q(op[2],op[3])*x for j,x in state[t].items()} + else: + s=tuple(op[2]);q=Q(op[3],op[4]);row=state.setdefault(t,{}) + if t[0]=='C' and t[1] not in live:live.append(t[1]) + add_row(row,state.get(s,{}),q) + assert not live and not zlive and all(not row for r,row in state.items() if r[0] in 'CZ') + for r in range(n): + expected={(r,()):Q(1)} + if back and r>i)&1)<>j)&1),None) + need(pivot is not None,'singular binary map') + rows[j],rows[pivot]=rows[pivot],rows[j] + for i in range(n): + if i!=j and (rows[i]>>j)&1:rows[i]^=rows[j] + return tuple(sum(((rows[i]>>(n+j))&1)<0,'nonempty binary columns') + g=tuple(g);n=len(g) + need(all(type(x) is int and 0<=x<1<>i)&1: + ans+=((row>>i)&1)+2*((row&y&~((1<<(i+1))-1)).bit_count()) + return ans%4 + +def canonical_phase(g,x): + g=normal(g);y=apply(g,x) + return _q(quadratic(g),y) + +def section_phase(g,x):return (apply(g,x).bit_count()-x.bit_count())%4 + +@lru_cache(maxsize=None) +def _tag(g): + result=0 + for j,col in enumerate(g): + diff=(_q(quadratic(g),col)-(col.bit_count()-1))%4 + need(diff%2==0,'even phase-section difference') + result|=(diff//2)<>i)&1)<>j&1);a[j],a[k]=a[k],a[j] + for i in range(n): + if i!=j and a[i]>>j&1:a[i]^=a[j] + assert [r&((1<>n for r in a) +def basis_extend(cols,n): + out=[] + for x in list(cols)+[1<len(out):out.append(x) + assert len(out)==n + return tuple(out) +def nullspace(rows,n): + a=list(rows);p=[];k=0 + for j in range(n): + t=next((i for i in range(k,len(a)) if a[i]>>j&1),None) + if t is None:continue + a[t],a[k]=a[k],a[t] + for i in range(len(a)): + if i!=k and a[i]>>j&1:a[i]^=a[k] + p.append(j);k+=1 + return tuple((1<>j)&1)<>i&1:out=pmul(out,T[i]) + for i in range(n): + if z>>i&1:out=pmul(out,T[n+i]) + return out +def compose(A,B):return tuple(apply(A,p) for p in B) +def inverse(T): + n=len(T)//2;cols=[x|(z<>n;u,v,p=apply(T,(x,z,0));assert (u,v)==identity(n)[j][:2];out.append((x,z,(-p)%4)) + return tuple(out) +def qvalue(Q,alpha,x,n): + return (sum(alpha[i] for i in range(n) if x>>i&1)+2*sum(parity((Q[i]>>(i+1))&(x>>(i+1))) for i in range(n) if x>>i&1))%4 +def mul_i(a,p): + x,y=a;p%=4 + return [(x,y),(-y,x),(-x,-y),(y,-x)][p] +@dataclass +class Op: + n:int + tab:tuple + circuit:list + def then(self,b): + assert self.n==b.n + return Op(self.n,compose(b.tab,self.tab),self.circuit+b.circuit) + def adjoint(self): + circ=[] + for e in reversed(self.circuit): + if e[0]=='P':circ.append(('P',inv(e[1],self.n))) + elif e[0]=='D':circ.append(('D',e[1],tuple((-x)%4 for x in e[2]))) + elif e[0]=='C':circ.append(('C',e[1],-e[2])) + elif e[0]=='phase':circ.append(('phase',(-e[1])%4)) + else:circ.append(e) + return Op(self.n,inverse(self.tab),circ) + def zero_state(self,basis=0): + N=1<>i)&1 for i in range(n)) + assert all(alpha[i]%2==(Q[i]>>i)&1 for i in range(n)) + return Op(n,tuple([(1<>i&1 else 0,1<>i&1 else 0) for i in range(n)]),[('C',q,sgn)]) +def xgate(n,b):return Op(n,tuple([(1<>i)&1)) for i in range(n)]),[('X',b)]) +def fourier(n,axes=None): + out=ident(n) + for i in range(n) if axes is None else axes:out=out.then(cgate(n,1<len(selected):picks.append(j);selected.append(x) + assert len(picks)==r and all(x>>r==0 for x in Bcols) + Br=transpose(selected,r);Bi=inv(Br,r);Dr=transpose([Dcols[j]&((1<>i&1] + q.append((sum(gram[i][i] for i in bits)+2*sum(gram[i][j]for i in bits for j in bits if i>j)&1)==((quad[j]>>i)&1)for i in range(N)for j in range(N)),'symmetric quadratic form') + need(all(alpha[i]%2==((quad[i]>>i)&1)for i in range(N)),'quadratic parity') + perm=[];phasev=[] + for x in range(SIZE): + perm.append(sum(((r&x).bit_count()%2)<>i&1] + phasev.append((phase+sum(alpha[i]for i in bits)+2*sum((quad[i]>>j)&1 for i in bits for j in bits if i0 else 2]+=1 + elif not r:phase_hist[1 if s>0 else 3]+=1 + digest.update(json.dumps([x,da,sorted(a.items())],separators=(',',':')).encode()) + return dict(columns=SIZE,nonzero_coefficients=support,gaussian_axis_phase_histogram=phase_hist,operator_sha256=digest.hexdigest()) + +def lift_cocycle(G,H): + """K_H K_G = K_(HG) Z_ell. Exact finite Z4 phase defect.""" + gp,gq=kernel(tuple(G));hp,hq=kernel(tuple(H)) + HG=tuple(lin(H,c)for c in G);cp,cq=kernel(HG) + defect=[(gq[x]+hq[gp[x]]-cq[x])%4 for x in range(SIZE)] + ell=sum((defect[1<>j&1)and not omit_compensation;v,d=e.coordinate(v,[j],flip);den+=d + if flip: + flips+=1 + if not omit_global:v={x:(-s,r)for x,(r,s)in v.items()} + return e.mono(v,J),den,dict(tag=t,flipped_coordinate_axes=[j for j in range(len(U))if t>>j&1],global_i_power=flips%4) + +def frames(b): + result={} + for label in ['entrance','exit','next_frame']: + for x in range(512): + a,da=e.frame({x:(1,0)},b[label]);z,dz,info=compensated_frame({x:(1,0)},b[label]);need(e.equal(a,da,z,dz),'actual compensated frame') + result[label]=info + return result + +def exact_interfaces(b): + warp=dict(kind='warp',entrance=b['entrance'],terminal=b['exit'],G_columns=b['G_columns'],sign=1,recipe=dict(rank=0,left=b['warp'],right=None)) + climb=dict(kind='residual',entrance=b['exit'],terminal=b['next_frame'],recipe=b['child']) + return dict(warp=e.check_item(warp),next_climb=e.check_item(climb)) + +def compare(M,R,L): + digest=hashlib.sha256();reference_bill=fused_bill=strong_bill=None + for register in range(4): + for column in range(512): + data=[[(0,0)]*512 for _ in range(4)];data[register][column]=(1,0) + a,da,ab=c.execute(data,M,R,L);b,db,bb=c.execute(data,M,R,L,True) + z,dz,zb=c.execute(data,M,R,L,joint=True) + need(a==b==z and da==db==dz,'complete dirty linear map') + need(strong_bill is None or zb==strong_bill,'data-independent stronger baseline bill');strong_bill=zb + need(reference_bill is None or ab==reference_bill,'data-independent reference bill');need(fused_bill is None or bb==fused_bill,'data-independent fused bill') + reference_bill,fused_bill=ab,bb;digest.update(json.dumps([register,column,a],separators=(',',':')).encode()) + dirty=[[(37*x+11*r-7000,19*x-23*r+91)for x in range(512)]for r in range(4)] + for fused in [False,True]: + out,_,_=c.execute(dirty,M,R,L,fused);back,den,_=c.execute(out,M,R,L,fused,True) + need(den==2 and all(z==[(a*4,b*4)for a,b in src]for z,src in zip(back,dirty)),'arbitrary dirty inverse return') + return dict(basis_columns=2048,output_complex_coordinates=2048,operator_sha256=digest.hexdigest(),reference=reference_bill,fused=fused_bill,delta={k:fused_bill[k]-reference_bill[k]for k in reference_bill},dirty_inverse_roundtrips=2,stronger_materialized_baseline=strong_bill,delta_vs_stronger={k:fused_bill[k]-strong_bill[k]for k in strong_bill}) + +def controls(b,M,R,L): + results=[];data=[[(0,0)]*512 for _ in range(4)];data[0][0]=(1,0);baseline=c.execute(data,M,R,L)[0] + def bad(name,wrongM=None,wrongR=None,wrongL=None): + got=c.execute(data,wrongM or M,wrongR or R,wrongL or L,True)[0];need(got!=baseline,'control accepted: '+name);results.append(name) + mp,mq=M + bad('omit actual affine translation',(tuple(y^458 for y in mp),mq));bad('omit all phase tags',(mp,(0,)*512));bad('omit global i cubed',(mp,tuple((q-3)%4 for q in mq))) + bad('replace warp by adjoint',c.inverse(M));bad('reverse right-monomial composition',wrongR=c.compose(c.compose(M,R),c.inverse(M))) + for name,kwargs in [('drop actual central compensation',dict(omit_compensation=True)),('drop actual compensated global i',dict(omit_global=True))]: + found=False + for label in ['entrance','exit','next_frame']: + for x in range(512): + good,d=e.frame({x:(1,0)},b[label]);wrong,dd,_=compensated_frame({x:(1,0)},b[label],**kwargs) + if not e.equal(good,d,wrong,dd):found=True;break + if found:break + need(found,'missing actual frame rejection witness');results.append(name) + z=copy.deepcopy(b);z['warp']['offset']=0 + try:bind(z) + except ValueError:results.append('changed source-bound affine recipe') + else:raise ValueError('source control accepted') + return results + +def main(): + parser=argparse.ArgumentParser();parser.add_argument('--record',action='store_true');args=parser.parse_args() + authenticate();b=read(P/'BOUNDARY.json');providers=bind(b);M,R,L=e.decoded(b['warp']),e.decoded(b['child']['right']),e.decoded(b['child']['left']) + interfaces=exact_interfaces(b);compensation=frames(b);physical=compare(M,R,L) + need(physical['delta']['caller_real_reads']==-1024 and physical['delta']['caller_real_writes']==-1024,'actual traffic saving');need(physical['delta']['real_negations']==-512,'phase operations fully charged') + need(all(physical['delta'][k]==0 for k in ['real_additions','exact_halves','private_real_words','private_word_clears','routing_entry_reads']),'unchanged physical charges') + need(physical['delta_vs_stronger']['caller_real_reads']==0 and physical['delta_vs_stronger']['caller_real_writes']==-1024 and physical['delta_vs_stronger']['real_negations']==0,'strong comparator credit') + result=dict(status='PASS_FINITE_PAID_NATIVE_FUSION',private_storage_schedule=scratch_schedule.check(),providers=providers,interfaces=interfaces,compensated_actual_frames=compensation,physical=physical,metadata=c.metadata(M,R,L),controls=controls(b,M,R,L),recursive_child_delta=0,owner_width_delta=0,all_size_supplier_admitted=False) + if args.record:(P/'RESULT.json').write_text(json.dumps(result,indent=2)+'\n') + else:need(result==read(P/'RESULT.json'),'result receipt mismatch') + print(json.dumps(dict(status=result['status'],columns=physical['basis_columns'],caller_real_writes_saved_vs_stronger=1024,caller_real_reads_saved_vs_stronger=0,real_negations_saved_vs_stronger=0,recursive_child_delta=0,controls=len(result['controls']),scope='actual f=1 four-array interface; no native tariff or supplier admission'),sort_keys=True)) +if __name__=='__main__':main()