diff --git a/.github/workflows/p112-common-slice.yml b/.github/workflows/p112-common-slice.yml index 37f99ca573..48047f61c4 100644 --- a/.github/workflows/p112-common-slice.yml +++ b/.github/workflows/p112-common-slice.yml @@ -15,9 +15,9 @@ jobs: if: github.repository == 'CrocSwap/integer-mult-bounds' runs-on: ubuntu-24.04 timeout-minutes: 20 - env: - TMPDIR: ${{ runner.temp }}/p112-common-slice steps: + - name: Initialise P112 work directory + run: echo "TMPDIR=$RUNNER_TEMP/p112-common-slice" >> "$GITHUB_ENV" - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 with: fetch-depth: 0 diff --git a/research/p104-inplace-entrance/COSTS.md b/research/p104-inplace-entrance/COSTS.md new file mode 100644 index 0000000000..c1b31f97cb --- /dev/null +++ b/research/p104-inplace-entrance/COSTS.md @@ -0,0 +1,180 @@ +# Exact local invoice and conditional consumer stop + +The in-place entrance completion reduces scalar ADD work and improves the +native-only concave tariff. It still fails the retained five-forward/four-dual +consumer model after substituting its **newly constructed** profile. This is a +local construction with a conditional stopping result; it supplies no improved +supplier or selected bound. + +Counts below are the source-derived outputs of [invoice.py](invoice.py), the +actual wrapper census in [native.py](native.py), and the serialized +[PROGRAM.json](PROGRAM.json). Source hashes and predecessor provenance are in +[SOURCES.json](SOURCES.json). The cost units remain separate throughout. + +## Scalar work, return, and native children + +Each field has 512 Gaussian entries, hence 1,024 real components. A unit +Gaussian bank ADD/SUB therefore costs 1,024 real ADD/SUB operations. Integer +coefficients are expanded into repeated unit operations. Each fractional source +read is implemented by exact componentwise halving, the signed ADD, and source +restoration by doubling before the next original event. A quarter read uses two +half passes and two restoring double passes. These are separately charged. + +| Scope | Unit Gaussian bank ADD/SUB | Real ADD/SUB | Exact real halves | Restoring real doubles | +| --- | ---: | ---: | ---: | ---: | +| Removed original events | 1,364 | 1,396,736 | 98,304 | 98,304 | +| New entrance completion | 887 | 908,288 | 105,472 | 105,472 | +| Original full word | 4,353 | 4,457,472 | 2,750,464 | 2,750,464 | +| Changed full word | 3,876 | 3,969,024 | 2,757,632 | 2,757,632 | + +Thus the substitution saves 488,448 scalar real ADD/SUB operations and adds +7,168 exact halves and 7,168 restoring doubles. The 787 weighted ADDs in the +factor notation are **887 unit operations**: 247 for dirty preconditioning, +393 for gathering, and 247 for scattering. Exactly 103 Y sources are halved +and immediately restored; Y1 is unused by this completion. + +| Scope | Native calls | Native rank mass | Coordinate C pairs | +| --- | ---: | ---: | ---: | +| Removed original events | 473 | 889 | 227,584 | +| New entrance completion | 145 | 889 | 227,584 | +| Original full word | 2,070 | 3,542 | 906,752 | +| Changed full word | 1,742 | 3,542 | 906,752 | + +The new profile is $52H_1+93H_9$. The 4,027-event retained projection and +1,238-operation prelude together have 5,265 serialized operations. Removing +the old complement removes 104 whole-bank sign events; 104 such signs remain +in the projection and require their own 106,496 real negations. All eight +original private-C zero/erase lifetimes remain. The prelude adds no private +Gaussian bank: its eight dirty accumulators are required X outputs, and their +original contributions are preserved. Literal native-pair arithmetic is not +included in the scalar ADD table. + +## Wrappers and widths remain charges + +The actual 145 native occurrences have 290 monomial wrappers. Their 148,480 +address entries form 97,840 cycles. Direct cycle permutations require 50,640 +Gaussian SWAPs; the recorded phases additionally require 61,440 real SWAPs and +148,480 real negations. A Gaussian SWAP exchanges two Gaussian entries, hence +two pairs of real components. Its two-real-SWAP lowering would total 162,720 +real SWAPs including phase rotations. +These are explicit operation inventories, not free relabelings or a completed +machine tariff. The old omitted wrappers are outside this comparison; a +difference of complete physical bills is not claimed. + +Let $H_X$ bound real and imaginary components after the singleton-to-empty +entrance maps, and let $H_Y$ bound the **actual unhalved** common-frame Y +fields. The fixed schedule's scalar row envelope is + +$$ +\max\{8H_X+95H_Y,\ 11H_X+64H_Y,\ 12H_X+49H_Y,\ 14H_X\}. +$$ + +Consequently $103H$, with $H=\max(H_X,H_Y)$, is a uniform bound. The +equal-bound maximizing row has weights $(8,95)$ at prelude operation 929, +equivalently scalar operation 877; indices are zero-based. Its +$8H_X+95H_Y$ value alone is not a uniform bound for independently varying +inputs. Entrance/exit native growth and signed-floor temporaries require +additional bounds. + +The dense physical fixture's observed peak, 11,232, measures stored field +values after complete operations. It does not measure internal native-pair +temporaries or prove a universal width allowance. Python oracle arrays, +dictionaries and temporary vectors are verification storage, not claimed +physical workspace. + +## New profile substituted into the named consumer + +Jose Manuel's original stopping insight and Vasek's +[PR2744 consumer audit](../p104-consumer-budget-audit/README.md) concern fixed +predecessor profiles. Their theorem does not automatically cover this +resynthesis. `invoice.consumer_stop` performs a new substitution, retaining +the same explicit coverage assumptions: + +- Width $m=73$, $W=832$ original families, five fixed forward calls and four + calls of this newly constructed dual word. +- Favorable persistent credit $P=3014$ per call, leaving + $I=72\cdot832-9\cdot3014=32778$ paid coverage units. +- Up to 416 integer rank units forgiven per dual, with the new decomposition + otherwise fixed; other positive children have rank at most 73. +- Every auxiliary bank adds 73 paid coverage units and one family; all other + charges are nonnegative. + +The unchanged forward mass is 3,070. The nine-call profile, after favorable +H1 forgiveness, has H1 count 9,680 and total mass 27,854. The certified bounds + +$$ +\log 73>4,\qquad \log(73/r)>2\quad(2\le r\le9) +$$ + +give the new slope + +$$ +L=4(9680)+2(27854-9680)=75068. +$$ + +For every finite number $B\ge0$ of fully paid auxiliary banks and primitive +saving $01+\frac{75068a-104}{73(832+B)}. +$$ + +At the retained benchmark + +$$ +\kappa=\frac{836330098538459}{500000000000000000},\qquad +75068\kappa-104= +\frac{2695406959271260053}{125000000000000000}>0. +$$ + +With no auxiliary banks this gives the exact lower bound + +$$ +M_0(\kappa)> +\frac{7594695406959271260053}{7592000000000000000000}>1. +$$ + +The retained transfer requires primitive saving greater than this tested +multiplication saving. The lower bound increases with $a$, so this consumer +fails already under the more favorable test. Additional resynthesis, changed +coverage, or a different consumer requires a new calculation. + +The native-only gain is real: concavity gives the old omitted tariff at least + +$$ +421+52\,9^s, +$$ + +while the new tariff is $52+93\,9^s$. Their difference is at least + +$$ +41(9-9^s)>0\quad(0\le s<1), +$$ + +with equal rank mass at $s=1$. This gain does not discharge the consumer's +remaining coverage or physical charges. + +## Obligations and stopping decision + +| Boundary | Established here or explicitly inherited | Remaining obligation | +| --- | --- | --- | +| Local operator | Exact scalar matrix, dirty preservation, source return, 53 native certificates and dense literal comparison | Actual supplier invocation with these fields | +| Source domain | Local 93 dirty fields in B9 and Y in 4B9; common full-word sufficient domain: 104 Y in 4B9, 78 N in 2B9, 176 other inputs in B9 | Paid preparation from a named upstream input | +| Storage | No added Gaussian bank; eight inherited private-C lifetimes retained | Owners, allowed source mutation, component scratch and legal erasure implementation | +| Width and addressing | Scalar envelope and explicit wrapper inventory | Finite caller widths, temporary headroom, routing and controller lowering | +| Recursive supplier | Exact conditional model rejection | All-size/rounded-child transfer and a different favorable complete bill | + +Stop dependent owner or supplier construction aimed at beating the selected +target with this exact five-forward/four-dual model. The local identity remains +useful evidence; the failed favorable model does not justify further physical +construction along that route. + +Credit Jose Manuel (`jmbarrancoml`) first for the consumer-budget observation, +then Vasek (`flyingviper`)/PR2744 for its conditional audit; Ross Richardson's +PR2458 forward binding and PR2445 word; ywz65's P104/native/dual lineage; +Hiroki Kumazaki's PR3446 retained projection; Nick Petalas's PR3462 factor, +PR3469 adapters and PR3416 covariance; Jeremy Kothe's retained compiler lineage; +and Tekalign's PR3218 phase-sensitive criterion and the earlier compiler authors +retained in [SOURCES.json](SOURCES.json). This package contributes the +dirty-basis entrance schedule and its new profile substitution, with substantial +OpenAI assistance. Predecessor credit and notices remain in force. diff --git a/research/p104-inplace-entrance/NATIVE.json b/research/p104-inplace-entrance/NATIVE.json new file mode 100644 index 0000000000..2e37a3bb94 --- /dev/null +++ b/research/p104-inplace-entrance/NATIVE.json @@ -0,0 +1,4412 @@ +{ + "empty_to_full": { + "new": [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ], + "old": [], + "recipe": { + "left": { + "linear_Z4": [ + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 9, + "right": { + "linear_Z4": [ + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2 + ], + "matrix_rows": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 3, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + } + }, + "schema_version": 1, + "x_to_empty": { + "X0": { + "new": [], + "old": [ + 386 + ], + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 2, + 5, + 8, + 16, + 32, + 64, + 128, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 0, + 3, + 0, + 0, + 0, + 0, + 0, + 3, + 2 + ], + "matrix_rows": [ + 386, + 1, + 258, + 4, + 8, + 16, + 32, + 64, + 384 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 0, + 130, + 0, + 0, + 0, + 0, + 0, + 130, + 0 + ] + } + } + }, + "X10": { + "new": [], + "old": [ + 295 + ], + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 3, + 5, + 9, + 16, + 32, + 65, + 128, + 256, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 0, + 3, + 0, + 0, + 2 + ], + "matrix_rows": [ + 295, + 257, + 258, + 260, + 8, + 16, + 288, + 64, + 128 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 39, + 39, + 39, + 0, + 0, + 39, + 0, + 0, + 0 + ] + } + } + }, + "X101": { + "new": [], + "old": [ + 439 + ], + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 3, + 5, + 9, + 16, + 33, + 65, + 128, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 3, + 3, + 3, + 0, + 3, + 3, + 0, + 3, + 2 + ], + "matrix_rows": [ + 439, + 257, + 258, + 260, + 8, + 272, + 288, + 64, + 384 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 183, + 183, + 183, + 0, + 183, + 183, + 0, + 183, + 0 + ] + } + } + }, + "X102": { + "new": [], + "old": [ + 296 + ], + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 2, + 4, + 8, + 17, + 32, + 65, + 128, + 256, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 3, + 0, + 3, + 0, + 0, + 2 + ], + "matrix_rows": [ + 296, + 1, + 2, + 4, + 264, + 16, + 288, + 64, + 128 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 0, + 0, + 0, + 40, + 0, + 40, + 0, + 0, + 0 + ] + } + } + }, + "X11": { + "new": [], + "old": [ + 309 + ], + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 3, + 4, + 9, + 16, + 33, + 65, + 128, + 256, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 3, + 0, + 3, + 0, + 3, + 3, + 0, + 0, + 2 + ], + "matrix_rows": [ + 309, + 257, + 2, + 260, + 8, + 272, + 288, + 64, + 128 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 53, + 0, + 53, + 0, + 53, + 53, + 0, + 0, + 0 + ] + } + } + }, + "X12": { + "new": [], + "old": [ + 346 + ], + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 2, + 5, + 8, + 17, + 33, + 64, + 129, + 256, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 0, + 3, + 0, + 3, + 3, + 0, + 3, + 0, + 2 + ], + "matrix_rows": [ + 346, + 1, + 258, + 4, + 264, + 272, + 32, + 320, + 128 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 0, + 90, + 0, + 90, + 90, + 0, + 90, + 0, + 0 + ] + } + } + }, + "X15": { + "new": [], + "old": [ + 32 + ], + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 2, + 4, + 8, + 16, + 32, + 1, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 0, + 0 + ], + "matrix_rows": [ + 32, + 1, + 2, + 4, + 8, + 16, + 64, + 128, + 256 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + } + }, + "X16": { + "new": [], + "old": [ + 79 + ], + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 3, + 5, + 9, + 17, + 32, + 64, + 1, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 3, + 3, + 3, + 3, + 0, + 0, + 2, + 0, + 0 + ], + "matrix_rows": [ + 79, + 65, + 66, + 68, + 72, + 16, + 32, + 128, + 256 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 15, + 15, + 15, + 15, + 0, + 0, + 0, + 0, + 0 + ] + } + } + }, + "X17": { + "new": [], + "old": [ + 93 + ], + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 3, + 4, + 9, + 17, + 33, + 64, + 1, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 3, + 0, + 3, + 3, + 3, + 0, + 2, + 0, + 0 + ], + "matrix_rows": [ + 93, + 65, + 2, + 68, + 72, + 80, + 32, + 128, + 256 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 29, + 0, + 29, + 29, + 29, + 0, + 0, + 0, + 0 + ] + } + } + }, + "X21": { + "new": [], + "old": [ + 26 + ], + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 2, + 5, + 8, + 17, + 1, + 32, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 0, + 3, + 0, + 3, + 2, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 26, + 1, + 18, + 4, + 24, + 32, + 64, + 128, + 256 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 0, + 10, + 0, + 10, + 0, + 0, + 0, + 0, + 0 + ] + } + } + }, + "X24": { + "new": [], + "old": [ + 223 + ], + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 3, + 5, + 9, + 17, + 33, + 64, + 129, + 1, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 3, + 3, + 3, + 3, + 3, + 0, + 3, + 2, + 0 + ], + "matrix_rows": [ + 223, + 129, + 130, + 132, + 136, + 144, + 32, + 192, + 256 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 95, + 95, + 95, + 95, + 95, + 0, + 95, + 0, + 0 + ] + } + } + }, + "X25": { + "new": [], + "old": [ + 176 + ], + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 2, + 4, + 8, + 16, + 33, + 65, + 128, + 1, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 0, + 3, + 3, + 0, + 2, + 0 + ], + "matrix_rows": [ + 176, + 1, + 2, + 4, + 8, + 144, + 160, + 64, + 256 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 48, + 48, + 0, + 0, + 0 + ] + } + } + }, + "X26": { + "new": [], + "old": [ + 162 + ], + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 2, + 5, + 8, + 16, + 32, + 65, + 128, + 1, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 0, + 3, + 0, + 0, + 0, + 3, + 0, + 2, + 0 + ], + "matrix_rows": [ + 162, + 1, + 130, + 4, + 8, + 16, + 160, + 64, + 256 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 0, + 34, + 0, + 0, + 0, + 34, + 0, + 0, + 0 + ] + } + } + }, + "X30": { + "new": [], + "old": [ + 229 + ], + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 3, + 4, + 9, + 16, + 32, + 65, + 129, + 1, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 3, + 0, + 3, + 0, + 0, + 3, + 3, + 2, + 0 + ], + "matrix_rows": [ + 229, + 129, + 2, + 132, + 8, + 16, + 160, + 192, + 256 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 101, + 0, + 101, + 0, + 0, + 101, + 101, + 0, + 0 + ] + } + } + }, + "X31": { + "new": [], + "old": [ + 122 + ], + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 2, + 5, + 8, + 17, + 33, + 65, + 1, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 0, + 3, + 0, + 3, + 3, + 3, + 2, + 0, + 0 + ], + "matrix_rows": [ + 122, + 1, + 66, + 4, + 72, + 80, + 96, + 128, + 256 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 0, + 58, + 0, + 58, + 58, + 58, + 0, + 0, + 0 + ] + } + } + }, + "X33": { + "new": [], + "old": [ + 494 + ], + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 2, + 5, + 9, + 17, + 32, + 65, + 129, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 0, + 3, + 3, + 3, + 0, + 3, + 3, + 3, + 2 + ], + "matrix_rows": [ + 494, + 1, + 258, + 260, + 264, + 16, + 288, + 320, + 384 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 0, + 238, + 238, + 238, + 0, + 238, + 238, + 238, + 0 + ] + } + } + }, + "X34": { + "new": [], + "old": [ + 385 + ], + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 3, + 4, + 8, + 16, + 32, + 64, + 128, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 3, + 2 + ], + "matrix_rows": [ + 385, + 257, + 2, + 4, + 8, + 16, + 32, + 64, + 384 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 129, + 0, + 0, + 0, + 0, + 0, + 0, + 129, + 0 + ] + } + } + }, + "X37": { + "new": [], + "old": [ + 425 + ], + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 3, + 4, + 8, + 17, + 32, + 65, + 128, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 3, + 0, + 0, + 3, + 0, + 3, + 0, + 3, + 2 + ], + "matrix_rows": [ + 425, + 257, + 2, + 4, + 264, + 16, + 288, + 64, + 384 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 169, + 0, + 0, + 169, + 0, + 169, + 0, + 169, + 0 + ] + } + } + }, + "X38": { + "new": [], + "old": [ + 454 + ], + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 2, + 5, + 9, + 16, + 32, + 64, + 129, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 0, + 3, + 3, + 0, + 0, + 0, + 3, + 3, + 2 + ], + "matrix_rows": [ + 454, + 1, + 258, + 260, + 8, + 16, + 32, + 320, + 384 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 0, + 198, + 198, + 0, + 0, + 0, + 198, + 198, + 0 + ] + } + } + }, + "X39": { + "new": [], + "old": [ + 468 + ], + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 2, + 4, + 9, + 16, + 33, + 64, + 129, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 0, + 0, + 3, + 0, + 3, + 0, + 3, + 3, + 2 + ], + "matrix_rows": [ + 468, + 1, + 2, + 260, + 8, + 272, + 32, + 320, + 384 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 0, + 0, + 212, + 0, + 212, + 0, + 212, + 212, + 0 + ] + } + } + }, + "X41": { + "new": [], + "old": [ + 310 + ], + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 2, + 5, + 9, + 16, + 33, + 65, + 128, + 256, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 0, + 3, + 3, + 0, + 3, + 3, + 0, + 0, + 2 + ], + "matrix_rows": [ + 310, + 1, + 258, + 260, + 8, + 272, + 288, + 64, + 128 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 0, + 54, + 54, + 0, + 54, + 54, + 0, + 0, + 0 + ] + } + } + }, + "X42": { + "new": [], + "old": [ + 345 + ], + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 3, + 4, + 8, + 17, + 33, + 64, + 129, + 256, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 3, + 0, + 0, + 3, + 3, + 0, + 3, + 0, + 2 + ], + "matrix_rows": [ + 345, + 257, + 2, + 4, + 264, + 272, + 32, + 320, + 128 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 89, + 0, + 0, + 89, + 89, + 0, + 89, + 0, + 0 + ] + } + } + }, + "X43": { + "new": [], + "old": [ + 331 + ], + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 3, + 5, + 8, + 17, + 32, + 64, + 129, + 256, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 3, + 3, + 0, + 3, + 0, + 0, + 3, + 0, + 2 + ], + "matrix_rows": [ + 331, + 257, + 258, + 4, + 264, + 16, + 32, + 320, + 128 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 75, + 75, + 0, + 75, + 0, + 0, + 75, + 0, + 0 + ] + } + } + }, + "X47": { + "new": [], + "old": [ + 94 + ], + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 2, + 5, + 9, + 17, + 33, + 64, + 1, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 0, + 3, + 3, + 3, + 3, + 0, + 2, + 0, + 0 + ], + "matrix_rows": [ + 94, + 1, + 66, + 68, + 72, + 80, + 32, + 128, + 256 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 0, + 30, + 30, + 30, + 30, + 0, + 0, + 0, + 0 + ] + } + } + }, + "X5": { + "new": [], + "old": [ + 440 + ], + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 2, + 4, + 8, + 17, + 33, + 65, + 128, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 3, + 3, + 3, + 0, + 3, + 2 + ], + "matrix_rows": [ + 440, + 1, + 2, + 4, + 264, + 272, + 288, + 64, + 384 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 0, + 0, + 0, + 184, + 184, + 184, + 0, + 184, + 0 + ] + } + } + }, + "X51": { + "new": [], + "old": [ + 25 + ], + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 3, + 4, + 8, + 17, + 1, + 32, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 3, + 0, + 0, + 3, + 2, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 25, + 17, + 2, + 4, + 24, + 32, + 64, + 128, + 256 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 9, + 0, + 0, + 9, + 0, + 0, + 0, + 0, + 0 + ] + } + } + }, + "X52": { + "new": [], + "old": [ + 11 + ], + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 3, + 5, + 8, + 1, + 16, + 32, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 3, + 3, + 0, + 2, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 9, + 10, + 4, + 16, + 32, + 64, + 128, + 256 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + } + }, + "X53": { + "new": [], + "old": [ + 100 + ], + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 2, + 4, + 9, + 16, + 32, + 65, + 1, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 0, + 0, + 3, + 0, + 0, + 3, + 2, + 0, + 0 + ], + "matrix_rows": [ + 100, + 1, + 2, + 68, + 8, + 16, + 96, + 128, + 256 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 0, + 0, + 36, + 0, + 0, + 36, + 0, + 0, + 0 + ] + } + } + }, + "X55": { + "new": [], + "old": [ + 134 + ], + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 2, + 5, + 9, + 16, + 32, + 64, + 128, + 1, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 0, + 3, + 3, + 0, + 0, + 0, + 0, + 2, + 0 + ], + "matrix_rows": [ + 134, + 1, + 130, + 132, + 8, + 16, + 32, + 64, + 256 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 0, + 6, + 6, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + } + }, + "X56": { + "new": [], + "old": [ + 148 + ], + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 2, + 4, + 9, + 16, + 33, + 64, + 128, + 1, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 0, + 0, + 3, + 0, + 3, + 0, + 0, + 2, + 0 + ], + "matrix_rows": [ + 148, + 1, + 2, + 132, + 8, + 144, + 32, + 64, + 256 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 0, + 0, + 20, + 0, + 20, + 0, + 0, + 0, + 0 + ] + } + } + }, + "X57": { + "new": [], + "old": [ + 251 + ], + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 3, + 5, + 8, + 17, + 33, + 65, + 129, + 1, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 3, + 3, + 0, + 3, + 3, + 3, + 3, + 2, + 0 + ], + "matrix_rows": [ + 251, + 129, + 130, + 4, + 136, + 144, + 160, + 192, + 256 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 123, + 123, + 0, + 123, + 123, + 123, + 123, + 0, + 0 + ] + } + } + }, + "X6": { + "new": [], + "old": [ + 426 + ], + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 2, + 5, + 8, + 17, + 32, + 65, + 128, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 0, + 3, + 0, + 3, + 0, + 3, + 0, + 3, + 2 + ], + "matrix_rows": [ + 426, + 1, + 258, + 4, + 264, + 16, + 288, + 64, + 384 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 0, + 170, + 0, + 170, + 0, + 170, + 0, + 170, + 0 + ] + } + } + }, + "X60": { + "new": [], + "old": [ + 211 + ], + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 3, + 5, + 8, + 16, + 33, + 64, + 129, + 1, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 3, + 3, + 0, + 0, + 3, + 0, + 3, + 2, + 0 + ], + "matrix_rows": [ + 211, + 129, + 130, + 4, + 8, + 144, + 32, + 192, + 256 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 83, + 83, + 0, + 0, + 83, + 0, + 83, + 0, + 0 + ] + } + } + }, + "X61": { + "new": [], + "old": [ + 188 + ], + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 2, + 4, + 9, + 17, + 33, + 65, + 128, + 1, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 0, + 0, + 3, + 3, + 3, + 3, + 0, + 2, + 0 + ], + "matrix_rows": [ + 188, + 1, + 2, + 132, + 136, + 144, + 160, + 64, + 256 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 0, + 0, + 60, + 60, + 60, + 60, + 0, + 0, + 0 + ] + } + } + }, + "X62": { + "new": [], + "old": [ + 174 + ], + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 2, + 5, + 9, + 17, + 32, + 65, + 128, + 1, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 0, + 3, + 3, + 3, + 0, + 3, + 0, + 2, + 0 + ], + "matrix_rows": [ + 174, + 1, + 130, + 132, + 136, + 16, + 160, + 64, + 256 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 0, + 46, + 46, + 46, + 0, + 46, + 0, + 0, + 0 + ] + } + } + }, + "X63": { + "new": [], + "old": [ + 161 + ], + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 3, + 4, + 8, + 16, + 32, + 65, + 128, + 1, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 3, + 0, + 0, + 0, + 0, + 3, + 0, + 2, + 0 + ], + "matrix_rows": [ + 161, + 129, + 2, + 4, + 8, + 16, + 160, + 64, + 256 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 33, + 0, + 0, + 0, + 0, + 33, + 0, + 0, + 0 + ] + } + } + }, + "X67": { + "new": [], + "old": [ + 230 + ], + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 2, + 5, + 9, + 16, + 32, + 65, + 129, + 1, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 0, + 3, + 3, + 0, + 0, + 3, + 3, + 2, + 0 + ], + "matrix_rows": [ + 230, + 1, + 130, + 132, + 8, + 16, + 160, + 192, + 256 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 0, + 102, + 102, + 0, + 0, + 102, + 102, + 0, + 0 + ] + } + } + }, + "X68": { + "new": [], + "old": [ + 244 + ], + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 2, + 4, + 9, + 16, + 33, + 65, + 129, + 1, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 0, + 0, + 3, + 0, + 3, + 3, + 3, + 2, + 0 + ], + "matrix_rows": [ + 244, + 1, + 2, + 132, + 8, + 144, + 160, + 192, + 256 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 0, + 0, + 116, + 0, + 116, + 116, + 116, + 0, + 0 + ] + } + } + }, + "X69": { + "new": [], + "old": [ + 155 + ], + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 3, + 5, + 8, + 17, + 33, + 64, + 128, + 1, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 3, + 3, + 0, + 3, + 3, + 0, + 0, + 2, + 0 + ], + "matrix_rows": [ + 155, + 129, + 130, + 4, + 136, + 144, + 32, + 64, + 256 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 27, + 27, + 0, + 27, + 27, + 0, + 0, + 0, + 0 + ] + } + } + }, + "X71": { + "new": [], + "old": [ + 121 + ], + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 3, + 4, + 8, + 17, + 33, + 65, + 1, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 3, + 0, + 0, + 3, + 3, + 3, + 2, + 0, + 0 + ], + "matrix_rows": [ + 121, + 65, + 2, + 4, + 72, + 80, + 96, + 128, + 256 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 57, + 0, + 0, + 57, + 57, + 57, + 0, + 0, + 0 + ] + } + } + }, + "X72": { + "new": [], + "old": [ + 107 + ], + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 3, + 5, + 8, + 17, + 32, + 65, + 1, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 3, + 3, + 0, + 3, + 0, + 3, + 2, + 0, + 0 + ], + "matrix_rows": [ + 107, + 65, + 66, + 4, + 72, + 16, + 96, + 128, + 256 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 43, + 43, + 0, + 43, + 0, + 43, + 0, + 0, + 0 + ] + } + } + }, + "X73": { + "new": [], + "old": [ + 4 + ], + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 2, + 4, + 1, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 0, + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 1, + 2, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + } + }, + "X76": { + "new": [], + "old": [ + 44 + ], + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 2, + 4, + 9, + 17, + 32, + 1, + 64, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 0, + 0, + 3, + 3, + 0, + 2, + 0, + 0, + 0 + ], + "matrix_rows": [ + 44, + 1, + 2, + 36, + 40, + 16, + 64, + 128, + 256 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 0, + 0, + 12, + 12, + 0, + 0, + 0, + 0, + 0 + ] + } + } + }, + "X77": { + "new": [], + "old": [ + 67 + ], + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 3, + 5, + 8, + 16, + 32, + 64, + 1, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 3, + 3, + 0, + 0, + 0, + 0, + 2, + 0, + 0 + ], + "matrix_rows": [ + 67, + 65, + 66, + 4, + 8, + 16, + 32, + 128, + 256 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + } + }, + "X78": { + "new": [], + "old": [ + 81 + ], + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 3, + 4, + 8, + 16, + 33, + 64, + 1, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 3, + 0, + 0, + 0, + 3, + 0, + 2, + 0, + 0 + ], + "matrix_rows": [ + 81, + 65, + 2, + 4, + 8, + 80, + 32, + 128, + 256 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 17, + 0, + 0, + 0, + 17, + 0, + 0, + 0, + 0 + ] + } + } + }, + "X82": { + "new": [], + "old": [ + 324 + ], + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 2, + 4, + 9, + 16, + 32, + 64, + 129, + 256, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 0, + 0, + 3, + 0, + 0, + 0, + 3, + 0, + 2 + ], + "matrix_rows": [ + 324, + 1, + 2, + 260, + 8, + 16, + 32, + 320, + 128 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 0, + 0, + 68, + 0, + 0, + 0, + 68, + 0, + 0 + ] + } + } + }, + "X86": { + "new": [], + "old": [ + 475 + ], + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 3, + 5, + 8, + 17, + 33, + 64, + 129, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 3, + 3, + 0, + 3, + 3, + 0, + 3, + 3, + 2 + ], + "matrix_rows": [ + 475, + 257, + 258, + 4, + 264, + 272, + 32, + 320, + 384 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 219, + 219, + 0, + 219, + 219, + 0, + 219, + 219, + 0 + ] + } + } + }, + "X90": { + "new": [], + "old": [ + 398 + ], + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 2, + 5, + 9, + 17, + 32, + 64, + 128, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 0, + 3, + 3, + 3, + 0, + 0, + 0, + 3, + 2 + ], + "matrix_rows": [ + 398, + 1, + 258, + 260, + 264, + 16, + 32, + 64, + 384 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 0, + 142, + 142, + 142, + 0, + 0, + 0, + 142, + 0 + ] + } + } + }, + "X91": { + "new": [], + "old": [ + 481 + ], + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 3, + 4, + 8, + 16, + 32, + 65, + 129, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 3, + 0, + 0, + 0, + 0, + 3, + 3, + 3, + 2 + ], + "matrix_rows": [ + 481, + 257, + 2, + 4, + 8, + 16, + 288, + 320, + 384 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 225, + 0, + 0, + 0, + 0, + 225, + 225, + 225, + 0 + ] + } + } + }, + "X93": { + "new": [], + "old": [ + 82 + ], + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 2, + 5, + 8, + 16, + 33, + 64, + 1, + 128, + 256 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 0, + 3, + 0, + 0, + 3, + 0, + 2, + 0, + 0 + ], + "matrix_rows": [ + 82, + 1, + 66, + 4, + 8, + 80, + 32, + 128, + 256 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 0, + 18, + 0, + 0, + 18, + 0, + 0, + 0, + 0 + ] + } + } + }, + "X96": { + "new": [], + "old": [ + 397 + ], + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 3, + 4, + 9, + 17, + 32, + 64, + 128, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 3, + 0, + 3, + 3, + 0, + 0, + 0, + 3, + 2 + ], + "matrix_rows": [ + 397, + 257, + 2, + 260, + 264, + 16, + 32, + 64, + 384 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 141, + 0, + 141, + 141, + 0, + 0, + 0, + 141, + 0 + ] + } + } + }, + "X97": { + "new": [], + "old": [ + 482 + ], + "recipe": { + "left": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 2, + 5, + 8, + 16, + 32, + 65, + 129, + 257, + 1 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 1, + "right": { + "linear_Z4": [ + 0, + 3, + 0, + 0, + 0, + 3, + 3, + 3, + 2 + ], + "matrix_rows": [ + 482, + 1, + 258, + 4, + 8, + 16, + 288, + 320, + 384 + ], + "offset": 1, + "phase": 1, + "quadratic_rows": [ + 0, + 226, + 0, + 0, + 0, + 226, + 226, + 226, + 0 + ] + } + } + } + } +} diff --git a/research/p104-inplace-entrance/PROGRAM.json b/research/p104-inplace-entrance/PROGRAM.json new file mode 100644 index 0000000000..8cf76603bc --- /dev/null +++ b/research/p104-inplace-entrance/PROGRAM.json @@ -0,0 +1,10905 @@ +{ + "program": [ + [ + "native", + "X0", + "enter" + ], + [ + "native", + "X5", + "enter" + ], + [ + "native", + "X6", + "enter" + ], + [ + "native", + "X10", + "enter" + ], + [ + "native", + "X11", + "enter" + ], + [ + "native", + "X12", + "enter" + ], + [ + "native", + "X15", + "enter" + ], + [ + "native", + "X16", + "enter" + ], + [ + "native", + "X17", + "enter" + ], + [ + "native", + "X21", + "enter" + ], + [ + "native", + "X24", + "enter" + ], + [ + "native", + "X25", + "enter" + ], + [ + "native", + "X26", + "enter" + ], + [ + "native", + "X30", + "enter" + ], + [ + "native", + "X31", + "enter" + ], + [ + "native", + "X33", + "enter" + ], + [ + "native", + "X34", + "enter" + ], + [ + "native", + "X37", + "enter" + ], + [ + "native", + "X38", + "enter" + ], + [ + "native", + "X39", + "enter" + ], + [ + "native", + "X41", + "enter" + ], + [ + "native", + "X42", + "enter" + ], + [ + "native", + "X43", + "enter" + ], + [ + "native", + "X47", + "enter" + ], + [ + "native", + "X51", + "enter" + ], + [ + "native", + "X52", + "enter" + ], + [ + "native", + "X53", + "enter" + ], + [ + "native", + "X55", + "enter" + ], + [ + "native", + "X56", + "enter" + ], + [ + "native", + "X57", + "enter" + ], + [ + "native", + "X60", + "enter" + ], + [ + "native", + "X61", + "enter" + ], + [ + "native", + "X62", + "enter" + ], + [ + "native", + "X63", + "enter" + ], + [ + "native", + "X67", + "enter" + ], + [ + "native", + "X68", + "enter" + ], + [ + "native", + "X69", + "enter" + ], + [ + "native", + "X71", + "enter" + ], + [ + "native", + "X72", + "enter" + ], + [ + "native", + "X73", + "enter" + ], + [ + "native", + "X76", + "enter" + ], + [ + "native", + "X77", + "enter" + ], + [ + "native", + "X78", + "enter" + ], + [ + "native", + "X82", + "enter" + ], + [ + "native", + "X86", + "enter" + ], + [ + "native", + "X90", + "enter" + ], + [ + "native", + "X91", + "enter" + ], + [ + "native", + "X93", + "enter" + ], + [ + "native", + "X96", + "enter" + ], + [ + "native", + "X97", + "enter" + ], + [ + "native", + "X101", + "enter" + ], + [ + "native", + "X102", + "enter" + ], + [ + "add", + "X5", + "X33", + 1 + ], + [ + "add", + "X5", + "X33", + 1 + ], + [ + "add", + "X5", + "X102", + -1 + ], + [ + "add", + "X5", + "X11", + -1 + ], + [ + "add", + "X5", + "X12", + 1 + ], + [ + "add", + "X5", + "X12", + 1 + ], + [ + "add", + "X5", + "X12", + 1 + ], + [ + "add", + "X5", + "X15", + 1 + ], + [ + "add", + "X5", + "X24", + 1 + ], + [ + "add", + "X6", + "X101", + -1 + ], + [ + "add", + "X6", + "X102", + 1 + ], + [ + "add", + "X6", + "X11", + -1 + ], + [ + "add", + "X10", + "X33", + 1 + ], + [ + "add", + "X10", + "X33", + 1 + ], + [ + "add", + "X10", + "X101", + 1 + ], + [ + "add", + "X10", + "X102", + -1 + ], + [ + "add", + "X10", + "X102", + -1 + ], + [ + "add", + "X10", + "X11", + -1 + ], + [ + "add", + "X10", + "X12", + 1 + ], + [ + "add", + "X10", + "X12", + 1 + ], + [ + "add", + "X10", + "X12", + 1 + ], + [ + "add", + "X10", + "X15", + 1 + ], + [ + "add", + "X10", + "X24", + 1 + ], + [ + "add", + "X16", + "X11", + 1 + ], + [ + "add", + "X16", + "X12", + -1 + ], + [ + "add", + "X16", + "X15", + -1 + ], + [ + "add", + "X17", + "X33", + -1 + ], + [ + "add", + "X17", + "X33", + -1 + ], + [ + "add", + "X17", + "X101", + -1 + ], + [ + "add", + "X17", + "X102", + 1 + ], + [ + "add", + "X17", + "X102", + 1 + ], + [ + "add", + "X17", + "X11", + 1 + ], + [ + "add", + "X17", + "X12", + -1 + ], + [ + "add", + "X17", + "X12", + -1 + ], + [ + "add", + "X17", + "X12", + -1 + ], + [ + "add", + "X17", + "X12", + -1 + ], + [ + "add", + "X17", + "X15", + -1 + ], + [ + "add", + "X17", + "X15", + -1 + ], + [ + "add", + "X17", + "X24", + -1 + ], + [ + "add", + "X21", + "X101", + -1 + ], + [ + "add", + "X21", + "X102", + 1 + ], + [ + "add", + "X21", + "X12", + -1 + ], + [ + "add", + "X21", + "X15", + -1 + ], + [ + "add", + "X25", + "X11", + 1 + ], + [ + "add", + "X25", + "X12", + -1 + ], + [ + "add", + "X25", + "X24", + -1 + ], + [ + "add", + "X26", + "X33", + -1 + ], + [ + "add", + "X26", + "X33", + -1 + ], + [ + "add", + "X26", + "X101", + -1 + ], + [ + "add", + "X26", + "X102", + 1 + ], + [ + "add", + "X26", + "X102", + 1 + ], + [ + "add", + "X26", + "X11", + 1 + ], + [ + "add", + "X26", + "X12", + -1 + ], + [ + "add", + "X26", + "X12", + -1 + ], + [ + "add", + "X26", + "X12", + -1 + ], + [ + "add", + "X26", + "X12", + -1 + ], + [ + "add", + "X26", + "X15", + -1 + ], + [ + "add", + "X26", + "X24", + -1 + ], + [ + "add", + "X26", + "X24", + -1 + ], + [ + "add", + "X30", + "X101", + -1 + ], + [ + "add", + "X30", + "X102", + 1 + ], + [ + "add", + "X30", + "X12", + -1 + ], + [ + "add", + "X30", + "X24", + -1 + ], + [ + "add", + "X31", + "X12", + -1 + ], + [ + "add", + "X31", + "X24", + -1 + ], + [ + "add", + "X34", + "X33", + -1 + ], + [ + "add", + "X34", + "X11", + 1 + ], + [ + "add", + "X34", + "X12", + -1 + ], + [ + "add", + "X37", + "X33", + 1 + ], + [ + "add", + "X37", + "X102", + -1 + ], + [ + "add", + "X37", + "X11", + -1 + ], + [ + "add", + "X37", + "X12", + 1 + ], + [ + "add", + "X37", + "X12", + 1 + ], + [ + "add", + "X37", + "X12", + 1 + ], + [ + "add", + "X37", + "X15", + 1 + ], + [ + "add", + "X37", + "X24", + 1 + ], + [ + "add", + "X38", + "X33", + 1 + ], + [ + "add", + "X38", + "X102", + -1 + ], + [ + "add", + "X38", + "X12", + 1 + ], + [ + "add", + "X38", + "X12", + 1 + ], + [ + "add", + "X38", + "X15", + 1 + ], + [ + "add", + "X38", + "X24", + 1 + ], + [ + "add", + "X39", + "X33", + -1 + ], + [ + "add", + "X39", + "X101", + -1 + ], + [ + "add", + "X39", + "X102", + 1 + ], + [ + "add", + "X39", + "X12", + -1 + ], + [ + "add", + "X41", + "X33", + 1 + ], + [ + "add", + "X41", + "X101", + 1 + ], + [ + "add", + "X41", + "X102", + -1 + ], + [ + "add", + "X41", + "X102", + -1 + ], + [ + "add", + "X41", + "X11", + -1 + ], + [ + "add", + "X41", + "X12", + 1 + ], + [ + "add", + "X41", + "X12", + 1 + ], + [ + "add", + "X41", + "X12", + 1 + ], + [ + "add", + "X41", + "X15", + 1 + ], + [ + "add", + "X41", + "X24", + 1 + ], + [ + "add", + "X42", + "X33", + 1 + ], + [ + "add", + "X42", + "X101", + 1 + ], + [ + "add", + "X42", + "X102", + -1 + ], + [ + "add", + "X42", + "X102", + -1 + ], + [ + "add", + "X42", + "X12", + 1 + ], + [ + "add", + "X42", + "X12", + 1 + ], + [ + "add", + "X42", + "X15", + 1 + ], + [ + "add", + "X42", + "X24", + 1 + ], + [ + "add", + "X43", + "X33", + -1 + ], + [ + "add", + "X43", + "X12", + -1 + ], + [ + "add", + "X47", + "X33", + -1 + ], + [ + "add", + "X47", + "X11", + 1 + ], + [ + "add", + "X47", + "X12", + -1 + ], + [ + "add", + "X47", + "X15", + -1 + ], + [ + "add", + "X51", + "X33", + 1 + ], + [ + "add", + "X51", + "X102", + -1 + ], + [ + "add", + "X51", + "X12", + 1 + ], + [ + "add", + "X51", + "X12", + 1 + ], + [ + "add", + "X51", + "X24", + 1 + ], + [ + "add", + "X52", + "X33", + -1 + ], + [ + "add", + "X52", + "X101", + -1 + ], + [ + "add", + "X52", + "X102", + 1 + ], + [ + "add", + "X52", + "X12", + -1 + ], + [ + "add", + "X52", + "X15", + -1 + ], + [ + "add", + "X53", + "X33", + -1 + ], + [ + "add", + "X53", + "X101", + -1 + ], + [ + "add", + "X53", + "X102", + 1 + ], + [ + "add", + "X53", + "X11", + 1 + ], + [ + "add", + "X53", + "X12", + -1 + ], + [ + "add", + "X53", + "X12", + -1 + ], + [ + "add", + "X53", + "X15", + -1 + ], + [ + "add", + "X55", + "X33", + 1 + ], + [ + "add", + "X55", + "X101", + 1 + ], + [ + "add", + "X55", + "X102", + -1 + ], + [ + "add", + "X55", + "X102", + -1 + ], + [ + "add", + "X55", + "X12", + 1 + ], + [ + "add", + "X55", + "X12", + 1 + ], + [ + "add", + "X55", + "X24", + 1 + ], + [ + "add", + "X56", + "X33", + -1 + ], + [ + "add", + "X56", + "X12", + -1 + ], + [ + "add", + "X56", + "X15", + -1 + ], + [ + "add", + "X57", + "X33", + -1 + ], + [ + "add", + "X57", + "X11", + 1 + ], + [ + "add", + "X57", + "X12", + -1 + ], + [ + "add", + "X57", + "X12", + -1 + ], + [ + "add", + "X57", + "X15", + -1 + ], + [ + "add", + "X60", + "X33", + 1 + ], + [ + "add", + "X60", + "X102", + -1 + ], + [ + "add", + "X60", + "X11", + -1 + ], + [ + "add", + "X60", + "X12", + 1 + ], + [ + "add", + "X60", + "X12", + 1 + ], + [ + "add", + "X60", + "X24", + 1 + ], + [ + "add", + "X61", + "X33", + 1 + ], + [ + "add", + "X61", + "X102", + -1 + ], + [ + "add", + "X61", + "X12", + 1 + ], + [ + "add", + "X61", + "X24", + 1 + ], + [ + "add", + "X62", + "X33", + -1 + ], + [ + "add", + "X62", + "X101", + -1 + ], + [ + "add", + "X62", + "X102", + 1 + ], + [ + "add", + "X62", + "X12", + -1 + ], + [ + "add", + "X62", + "X12", + -1 + ], + [ + "add", + "X62", + "X15", + -1 + ], + [ + "add", + "X63", + "X33", + -1 + ], + [ + "add", + "X63", + "X11", + 1 + ], + [ + "add", + "X63", + "X12", + -1 + ], + [ + "add", + "X63", + "X24", + -1 + ], + [ + "add", + "X67", + "X33", + 1 + ], + [ + "add", + "X67", + "X102", + -1 + ], + [ + "add", + "X67", + "X12", + 1 + ], + [ + "add", + "X67", + "X12", + 1 + ], + [ + "add", + "X67", + "X15", + 1 + ], + [ + "add", + "X68", + "X33", + -1 + ], + [ + "add", + "X68", + "X101", + -1 + ], + [ + "add", + "X68", + "X102", + 1 + ], + [ + "add", + "X68", + "X12", + -1 + ], + [ + "add", + "X68", + "X24", + -1 + ], + [ + "add", + "X69", + "X33", + -1 + ], + [ + "add", + "X69", + "X101", + -1 + ], + [ + "add", + "X69", + "X102", + 1 + ], + [ + "add", + "X69", + "X11", + 1 + ], + [ + "add", + "X69", + "X12", + -1 + ], + [ + "add", + "X69", + "X12", + -1 + ], + [ + "add", + "X69", + "X24", + -1 + ], + [ + "add", + "X71", + "X33", + 1 + ], + [ + "add", + "X71", + "X101", + 1 + ], + [ + "add", + "X71", + "X102", + -1 + ], + [ + "add", + "X71", + "X102", + -1 + ], + [ + "add", + "X71", + "X12", + 1 + ], + [ + "add", + "X71", + "X12", + 1 + ], + [ + "add", + "X71", + "X15", + 1 + ], + [ + "add", + "X72", + "X33", + -1 + ], + [ + "add", + "X72", + "X12", + -1 + ], + [ + "add", + "X72", + "X24", + -1 + ], + [ + "add", + "X73", + "X33", + -1 + ], + [ + "add", + "X73", + "X11", + 1 + ], + [ + "add", + "X73", + "X12", + -1 + ], + [ + "add", + "X73", + "X12", + -1 + ], + [ + "add", + "X73", + "X24", + -1 + ], + [ + "add", + "X76", + "X33", + 1 + ], + [ + "add", + "X76", + "X102", + -1 + ], + [ + "add", + "X76", + "X11", + -1 + ], + [ + "add", + "X76", + "X12", + 1 + ], + [ + "add", + "X76", + "X12", + 1 + ], + [ + "add", + "X76", + "X15", + 1 + ], + [ + "add", + "X77", + "X33", + 1 + ], + [ + "add", + "X77", + "X102", + -1 + ], + [ + "add", + "X77", + "X12", + 1 + ], + [ + "add", + "X77", + "X15", + 1 + ], + [ + "add", + "X78", + "X33", + -1 + ], + [ + "add", + "X78", + "X101", + -1 + ], + [ + "add", + "X78", + "X102", + 1 + ], + [ + "add", + "X78", + "X12", + -1 + ], + [ + "add", + "X78", + "X12", + -1 + ], + [ + "add", + "X78", + "X24", + -1 + ], + [ + "add", + "X82", + "X33", + -1 + ], + [ + "add", + "X82", + "X101", + -1 + ], + [ + "add", + "X82", + "X102", + 1 + ], + [ + "add", + "X82", + "X11", + 1 + ], + [ + "add", + "X82", + "X12", + -1 + ], + [ + "add", + "X82", + "X12", + -1 + ], + [ + "add", + "X82", + "X15", + -1 + ], + [ + "add", + "X82", + "X24", + -1 + ], + [ + "add", + "X86", + "X33", + -1 + ], + [ + "add", + "X86", + "X11", + 1 + ], + [ + "add", + "X86", + "X12", + -1 + ], + [ + "add", + "X86", + "X12", + -1 + ], + [ + "add", + "X86", + "X15", + -1 + ], + [ + "add", + "X86", + "X24", + -1 + ], + [ + "add", + "X90", + "X33", + -1 + ], + [ + "add", + "X90", + "X101", + -1 + ], + [ + "add", + "X90", + "X102", + 1 + ], + [ + "add", + "X90", + "X12", + -1 + ], + [ + "add", + "X90", + "X12", + -1 + ], + [ + "add", + "X90", + "X15", + -1 + ], + [ + "add", + "X90", + "X24", + -1 + ], + [ + "add", + "X91", + "X33", + -1 + ], + [ + "add", + "X91", + "X101", + -1 + ], + [ + "add", + "X91", + "X102", + 1 + ], + [ + "add", + "X91", + "X11", + 1 + ], + [ + "add", + "X91", + "X12", + -1 + ], + [ + "add", + "X91", + "X12", + -1 + ], + [ + "add", + "X91", + "X12", + -1 + ], + [ + "add", + "X91", + "X15", + -1 + ], + [ + "add", + "X91", + "X24", + -1 + ], + [ + "add", + "X93", + "X102", + -1 + ], + [ + "add", + "X93", + "X12", + 1 + ], + [ + "add", + "X93", + "X15", + 1 + ], + [ + "add", + "X96", + "X102", + -1 + ], + [ + "add", + "X96", + "X12", + 1 + ], + [ + "add", + "X97", + "X102", + -1 + ], + [ + "add", + "X97", + "X11", + 1 + ], + [ + "half", + "Y0" + ], + [ + "add", + "X0", + "Y0", + -1 + ], + [ + "add", + "X0", + "Y0", + -1 + ], + [ + "double", + "Y0" + ], + [ + "half", + "Y2" + ], + [ + "add", + "X0", + "Y2", + -1 + ], + [ + "add", + "X11", + "Y2", + -1 + ], + [ + "add", + "X12", + "Y2", + -1 + ], + [ + "add", + "X15", + "Y2", + 1 + ], + [ + "add", + "X24", + "Y2", + 1 + ], + [ + "double", + "Y2" + ], + [ + "half", + "Y3" + ], + [ + "add", + "X33", + "Y3", + 1 + ], + [ + "add", + "X101", + "Y3", + -1 + ], + [ + "add", + "X11", + "Y3", + 1 + ], + [ + "double", + "Y3" + ], + [ + "half", + "Y4" + ], + [ + "add", + "X0", + "Y4", + -1 + ], + [ + "add", + "X101", + "Y4", + -1 + ], + [ + "double", + "Y4" + ], + [ + "half", + "Y5" + ], + [ + "add", + "X0", + "Y5", + 1 + ], + [ + "add", + "X33", + "Y5", + 1 + ], + [ + "add", + "X101", + "Y5", + -1 + ], + [ + "double", + "Y5" + ], + [ + "half", + "Y6" + ], + [ + "add", + "X101", + "Y6", + -1 + ], + [ + "add", + "X11", + "Y6", + -1 + ], + [ + "double", + "Y6" + ], + [ + "half", + "Y7" + ], + [ + "add", + "X0", + "Y7", + 1 + ], + [ + "add", + "X102", + "Y7", + -1 + ], + [ + "add", + "X11", + "Y7", + -1 + ], + [ + "add", + "X15", + "Y7", + -1 + ], + [ + "add", + "X24", + "Y7", + -1 + ], + [ + "double", + "Y7" + ], + [ + "half", + "Y8" + ], + [ + "add", + "X33", + "Y8", + 1 + ], + [ + "add", + "X102", + "Y8", + -1 + ], + [ + "add", + "X12", + "Y8", + -1 + ], + [ + "double", + "Y8" + ], + [ + "half", + "Y9" + ], + [ + "add", + "X0", + "Y9", + -1 + ], + [ + "add", + "X102", + "Y9", + -1 + ], + [ + "add", + "X11", + "Y9", + -1 + ], + [ + "add", + "X12", + "Y9", + -1 + ], + [ + "double", + "Y9" + ], + [ + "half", + "Y10" + ], + [ + "add", + "X0", + "Y10", + 1 + ], + [ + "add", + "X33", + "Y10", + 1 + ], + [ + "add", + "X102", + "Y10", + -1 + ], + [ + "add", + "X11", + "Y10", + -1 + ], + [ + "add", + "X12", + "Y10", + -1 + ], + [ + "double", + "Y10" + ], + [ + "half", + "Y11" + ], + [ + "add", + "X102", + "Y11", + -1 + ], + [ + "add", + "X11", + "Y11", + -1 + ], + [ + "add", + "X11", + "Y11", + -1 + ], + [ + "add", + "X12", + "Y11", + -1 + ], + [ + "double", + "Y11" + ], + [ + "half", + "Y12" + ], + [ + "add", + "X0", + "Y12", + -1 + ], + [ + "add", + "X33", + "Y12", + 1 + ], + [ + "add", + "X102", + "Y12", + -1 + ], + [ + "add", + "X11", + "Y12", + -1 + ], + [ + "add", + "X12", + "Y12", + -1 + ], + [ + "add", + "X12", + "Y12", + -1 + ], + [ + "add", + "X15", + "Y12", + 1 + ], + [ + "add", + "X24", + "Y12", + 1 + ], + [ + "double", + "Y12" + ], + [ + "half", + "Y13" + ], + [ + "add", + "X33", + "Y13", + 1 + ], + [ + "add", + "X101", + "Y13", + -1 + ], + [ + "add", + "X102", + "Y13", + -1 + ], + [ + "add", + "X11", + "Y13", + -1 + ], + [ + "add", + "X12", + "Y13", + -1 + ], + [ + "double", + "Y13" + ], + [ + "half", + "Y14" + ], + [ + "add", + "X101", + "Y14", + 1 + ], + [ + "add", + "X15", + "Y14", + -1 + ], + [ + "double", + "Y14" + ], + [ + "half", + "Y15" + ], + [ + "add", + "X0", + "Y15", + 1 + ], + [ + "add", + "X12", + "Y15", + 1 + ], + [ + "add", + "X15", + "Y15", + -1 + ], + [ + "add", + "X15", + "Y15", + -1 + ], + [ + "add", + "X24", + "Y15", + -1 + ], + [ + "double", + "Y15" + ], + [ + "half", + "Y16" + ], + [ + "add", + "X33", + "Y16", + 1 + ], + [ + "add", + "X11", + "Y16", + 1 + ], + [ + "add", + "X15", + "Y16", + -1 + ], + [ + "double", + "Y16" + ], + [ + "half", + "Y17" + ], + [ + "add", + "X0", + "Y17", + -1 + ], + [ + "add", + "X15", + "Y17", + -1 + ], + [ + "double", + "Y17" + ], + [ + "half", + "Y18" + ], + [ + "add", + "X0", + "Y18", + 1 + ], + [ + "add", + "X33", + "Y18", + 1 + ], + [ + "add", + "X15", + "Y18", + -1 + ], + [ + "double", + "Y18" + ], + [ + "half", + "Y19" + ], + [ + "add", + "X11", + "Y19", + -1 + ], + [ + "add", + "X15", + "Y19", + -1 + ], + [ + "double", + "Y19" + ], + [ + "half", + "Y20" + ], + [ + "add", + "X0", + "Y20", + -1 + ], + [ + "add", + "X33", + "Y20", + 1 + ], + [ + "add", + "X12", + "Y20", + -1 + ], + [ + "add", + "X24", + "Y20", + 1 + ], + [ + "double", + "Y20" + ], + [ + "half", + "Y21" + ], + [ + "add", + "X33", + "Y21", + 1 + ], + [ + "add", + "X101", + "Y21", + -1 + ], + [ + "add", + "X15", + "Y21", + -1 + ], + [ + "double", + "Y21" + ], + [ + "half", + "Y22" + ], + [ + "add", + "X102", + "Y22", + 1 + ], + [ + "add", + "X11", + "Y22", + 1 + ], + [ + "add", + "X12", + "Y22", + 1 + ], + [ + "add", + "X24", + "Y22", + -1 + ], + [ + "double", + "Y22" + ], + [ + "half", + "Y23" + ], + [ + "add", + "X101", + "Y23", + 1 + ], + [ + "add", + "X24", + "Y23", + -1 + ], + [ + "double", + "Y23" + ], + [ + "half", + "Y24" + ], + [ + "add", + "X0", + "Y24", + 1 + ], + [ + "add", + "X12", + "Y24", + 1 + ], + [ + "add", + "X15", + "Y24", + -1 + ], + [ + "add", + "X24", + "Y24", + -1 + ], + [ + "add", + "X24", + "Y24", + -1 + ], + [ + "double", + "Y24" + ], + [ + "half", + "Y25" + ], + [ + "add", + "X33", + "Y25", + 1 + ], + [ + "add", + "X11", + "Y25", + 1 + ], + [ + "add", + "X24", + "Y25", + -1 + ], + [ + "double", + "Y25" + ], + [ + "half", + "Y26" + ], + [ + "add", + "X0", + "Y26", + -1 + ], + [ + "add", + "X24", + "Y26", + -1 + ], + [ + "double", + "Y26" + ], + [ + "half", + "Y27" + ], + [ + "add", + "X0", + "Y27", + 1 + ], + [ + "add", + "X33", + "Y27", + 1 + ], + [ + "add", + "X24", + "Y27", + -1 + ], + [ + "double", + "Y27" + ], + [ + "half", + "Y28" + ], + [ + "add", + "X11", + "Y28", + -1 + ], + [ + "add", + "X24", + "Y28", + -1 + ], + [ + "double", + "Y28" + ], + [ + "half", + "Y29" + ], + [ + "add", + "X0", + "Y29", + -1 + ], + [ + "add", + "X33", + "Y29", + 1 + ], + [ + "add", + "X12", + "Y29", + -1 + ], + [ + "add", + "X15", + "Y29", + 1 + ], + [ + "double", + "Y29" + ], + [ + "half", + "Y30" + ], + [ + "add", + "X33", + "Y30", + 1 + ], + [ + "add", + "X101", + "Y30", + -1 + ], + [ + "add", + "X24", + "Y30", + -1 + ], + [ + "double", + "Y30" + ], + [ + "half", + "Y31" + ], + [ + "add", + "X33", + "Y31", + 1 + ], + [ + "add", + "X102", + "Y31", + -1 + ], + [ + "add", + "X11", + "Y31", + -1 + ], + [ + "add", + "X12", + "Y31", + -1 + ], + [ + "add", + "X24", + "Y31", + -1 + ], + [ + "double", + "Y31" + ], + [ + "half", + "Y32" + ], + [ + "add", + "X33", + "Y32", + 1 + ], + [ + "add", + "X15", + "Y32", + -1 + ], + [ + "add", + "X24", + "Y32", + -1 + ], + [ + "double", + "Y32" + ], + [ + "half", + "Y33" + ], + [ + "add", + "X33", + "Y33", + -1 + ], + [ + "add", + "X33", + "Y33", + -1 + ], + [ + "add", + "X12", + "Y33", + 1 + ], + [ + "double", + "Y33" + ], + [ + "half", + "Y34" + ], + [ + "add", + "X0", + "Y34", + -1 + ], + [ + "add", + "X33", + "Y34", + -1 + ], + [ + "add", + "X11", + "Y34", + 1 + ], + [ + "add", + "X15", + "Y34", + 1 + ], + [ + "add", + "X24", + "Y34", + 1 + ], + [ + "double", + "Y34" + ], + [ + "half", + "Y35" + ], + [ + "add", + "X33", + "Y35", + -1 + ], + [ + "add", + "X15", + "Y35", + 1 + ], + [ + "add", + "X24", + "Y35", + 1 + ], + [ + "double", + "Y35" + ], + [ + "half", + "Y36" + ], + [ + "add", + "X33", + "Y36", + -1 + ], + [ + "add", + "X101", + "Y36", + -1 + ], + [ + "add", + "X11", + "Y36", + 1 + ], + [ + "add", + "X12", + "Y36", + 1 + ], + [ + "double", + "Y36" + ], + [ + "half", + "Y37" + ], + [ + "add", + "X0", + "Y37", + 1 + ], + [ + "add", + "X33", + "Y37", + -1 + ], + [ + "add", + "X101", + "Y37", + -1 + ], + [ + "add", + "X12", + "Y37", + 1 + ], + [ + "double", + "Y37" + ], + [ + "half", + "Y38" + ], + [ + "add", + "X101", + "Y38", + -1 + ], + [ + "add", + "X11", + "Y38", + 1 + ], + [ + "add", + "X15", + "Y38", + 1 + ], + [ + "add", + "X24", + "Y38", + 1 + ], + [ + "double", + "Y38" + ], + [ + "half", + "Y39" + ], + [ + "add", + "X0", + "Y39", + -1 + ], + [ + "add", + "X33", + "Y39", + -1 + ], + [ + "add", + "X101", + "Y39", + -1 + ], + [ + "add", + "X15", + "Y39", + 1 + ], + [ + "add", + "X24", + "Y39", + 1 + ], + [ + "double", + "Y39" + ], + [ + "half", + "Y40" + ], + [ + "add", + "X33", + "Y40", + -1 + ], + [ + "add", + "X102", + "Y40", + -1 + ], + [ + "double", + "Y40" + ], + [ + "half", + "Y41" + ], + [ + "add", + "X0", + "Y41", + 1 + ], + [ + "add", + "X33", + "Y41", + -1 + ], + [ + "add", + "X102", + "Y41", + -1 + ], + [ + "add", + "X11", + "Y41", + -1 + ], + [ + "double", + "Y41" + ], + [ + "half", + "Y42" + ], + [ + "add", + "X102", + "Y42", + -1 + ], + [ + "add", + "X12", + "Y42", + -1 + ], + [ + "add", + "X15", + "Y42", + 1 + ], + [ + "add", + "X24", + "Y42", + 1 + ], + [ + "double", + "Y42" + ], + [ + "half", + "Y43" + ], + [ + "add", + "X0", + "Y43", + -1 + ], + [ + "add", + "X33", + "Y43", + -1 + ], + [ + "add", + "X102", + "Y43", + -1 + ], + [ + "add", + "X11", + "Y43", + -1 + ], + [ + "add", + "X12", + "Y43", + -1 + ], + [ + "add", + "X15", + "Y43", + 1 + ], + [ + "add", + "X24", + "Y43", + 1 + ], + [ + "double", + "Y43" + ], + [ + "half", + "Y44" + ], + [ + "add", + "X0", + "Y44", + 1 + ], + [ + "add", + "X101", + "Y44", + -1 + ], + [ + "add", + "X102", + "Y44", + -1 + ], + [ + "double", + "Y44" + ], + [ + "half", + "Y45" + ], + [ + "add", + "X33", + "Y45", + -1 + ], + [ + "add", + "X101", + "Y45", + -1 + ], + [ + "add", + "X102", + "Y45", + -1 + ], + [ + "add", + "X11", + "Y45", + -1 + ], + [ + "double", + "Y45" + ], + [ + "half", + "Y46" + ], + [ + "add", + "X0", + "Y46", + -1 + ], + [ + "add", + "X101", + "Y46", + -1 + ], + [ + "add", + "X102", + "Y46", + -1 + ], + [ + "add", + "X12", + "Y46", + -1 + ], + [ + "add", + "X15", + "Y46", + 1 + ], + [ + "add", + "X24", + "Y46", + 1 + ], + [ + "double", + "Y46" + ], + [ + "half", + "Y47" + ], + [ + "add", + "X33", + "Y47", + -1 + ], + [ + "add", + "X11", + "Y47", + 1 + ], + [ + "add", + "X12", + "Y47", + 1 + ], + [ + "add", + "X15", + "Y47", + -1 + ], + [ + "double", + "Y47" + ], + [ + "half", + "Y48" + ], + [ + "add", + "X0", + "Y48", + 1 + ], + [ + "add", + "X33", + "Y48", + -1 + ], + [ + "add", + "X12", + "Y48", + 1 + ], + [ + "add", + "X15", + "Y48", + -1 + ], + [ + "double", + "Y48" + ], + [ + "half", + "Y49" + ], + [ + "add", + "X11", + "Y49", + 1 + ], + [ + "add", + "X24", + "Y49", + 1 + ], + [ + "double", + "Y49" + ], + [ + "half", + "Y50" + ], + [ + "add", + "X0", + "Y50", + -1 + ], + [ + "add", + "X33", + "Y50", + -1 + ], + [ + "add", + "X24", + "Y50", + 1 + ], + [ + "double", + "Y50" + ], + [ + "half", + "Y51" + ], + [ + "add", + "X0", + "Y51", + 1 + ], + [ + "add", + "X101", + "Y51", + -1 + ], + [ + "add", + "X11", + "Y51", + 1 + ], + [ + "add", + "X12", + "Y51", + 1 + ], + [ + "add", + "X15", + "Y51", + -1 + ], + [ + "double", + "Y51" + ], + [ + "half", + "Y52" + ], + [ + "add", + "X33", + "Y52", + -1 + ], + [ + "add", + "X101", + "Y52", + -1 + ], + [ + "add", + "X12", + "Y52", + 1 + ], + [ + "add", + "X15", + "Y52", + -1 + ], + [ + "double", + "Y52" + ], + [ + "half", + "Y53" + ], + [ + "add", + "X0", + "Y53", + -1 + ], + [ + "add", + "X101", + "Y53", + -1 + ], + [ + "add", + "X11", + "Y53", + 1 + ], + [ + "add", + "X24", + "Y53", + 1 + ], + [ + "double", + "Y53" + ], + [ + "half", + "Y54" + ], + [ + "add", + "X101", + "Y54", + -1 + ], + [ + "add", + "X24", + "Y54", + 1 + ], + [ + "double", + "Y54" + ], + [ + "half", + "Y55" + ], + [ + "add", + "X0", + "Y55", + 1 + ], + [ + "add", + "X102", + "Y55", + -1 + ], + [ + "add", + "X15", + "Y55", + -1 + ], + [ + "double", + "Y55" + ], + [ + "half", + "Y56" + ], + [ + "add", + "X33", + "Y56", + -1 + ], + [ + "add", + "X102", + "Y56", + -1 + ], + [ + "add", + "X11", + "Y56", + -1 + ], + [ + "add", + "X15", + "Y56", + -1 + ], + [ + "double", + "Y56" + ], + [ + "half", + "Y57" + ], + [ + "add", + "X0", + "Y57", + -1 + ], + [ + "add", + "X102", + "Y57", + -1 + ], + [ + "add", + "X12", + "Y57", + -1 + ], + [ + "add", + "X24", + "Y57", + 1 + ], + [ + "double", + "Y57" + ], + [ + "half", + "Y58" + ], + [ + "add", + "X102", + "Y58", + -1 + ], + [ + "add", + "X11", + "Y58", + -1 + ], + [ + "add", + "X12", + "Y58", + -1 + ], + [ + "add", + "X24", + "Y58", + 1 + ], + [ + "double", + "Y58" + ], + [ + "half", + "Y59" + ], + [ + "add", + "X101", + "Y59", + -1 + ], + [ + "add", + "X102", + "Y59", + -1 + ], + [ + "add", + "X15", + "Y59", + -1 + ], + [ + "double", + "Y59" + ], + [ + "half", + "Y60" + ], + [ + "add", + "X0", + "Y60", + 1 + ], + [ + "add", + "X101", + "Y60", + -1 + ], + [ + "add", + "X102", + "Y60", + -1 + ], + [ + "add", + "X11", + "Y60", + -1 + ], + [ + "add", + "X15", + "Y60", + -1 + ], + [ + "double", + "Y60" + ], + [ + "half", + "Y61" + ], + [ + "add", + "X33", + "Y61", + 1 + ], + [ + "add", + "X101", + "Y61", + -1 + ], + [ + "add", + "X102", + "Y61", + -1 + ], + [ + "add", + "X12", + "Y61", + -1 + ], + [ + "add", + "X24", + "Y61", + 1 + ], + [ + "double", + "Y61" + ], + [ + "half", + "Y62" + ], + [ + "add", + "X0", + "Y62", + -1 + ], + [ + "add", + "X101", + "Y62", + -1 + ], + [ + "add", + "X102", + "Y62", + -1 + ], + [ + "add", + "X11", + "Y62", + -1 + ], + [ + "add", + "X12", + "Y62", + -1 + ], + [ + "add", + "X24", + "Y62", + 1 + ], + [ + "double", + "Y62" + ], + [ + "half", + "Y63" + ], + [ + "add", + "X33", + "Y63", + -1 + ], + [ + "add", + "X11", + "Y63", + 1 + ], + [ + "add", + "X12", + "Y63", + 1 + ], + [ + "add", + "X24", + "Y63", + -1 + ], + [ + "double", + "Y63" + ], + [ + "half", + "Y64" + ], + [ + "add", + "X0", + "Y64", + 1 + ], + [ + "add", + "X33", + "Y64", + -1 + ], + [ + "add", + "X12", + "Y64", + 1 + ], + [ + "add", + "X24", + "Y64", + -1 + ], + [ + "double", + "Y64" + ], + [ + "half", + "Y65" + ], + [ + "add", + "X11", + "Y65", + 1 + ], + [ + "add", + "X15", + "Y65", + 1 + ], + [ + "double", + "Y65" + ], + [ + "half", + "Y66" + ], + [ + "add", + "X0", + "Y66", + -1 + ], + [ + "add", + "X33", + "Y66", + -1 + ], + [ + "add", + "X15", + "Y66", + 1 + ], + [ + "double", + "Y66" + ], + [ + "half", + "Y67" + ], + [ + "add", + "X0", + "Y67", + 1 + ], + [ + "add", + "X101", + "Y67", + -1 + ], + [ + "add", + "X11", + "Y67", + 1 + ], + [ + "add", + "X12", + "Y67", + 1 + ], + [ + "add", + "X24", + "Y67", + -1 + ], + [ + "double", + "Y67" + ], + [ + "half", + "Y68" + ], + [ + "add", + "X33", + "Y68", + -1 + ], + [ + "add", + "X101", + "Y68", + -1 + ], + [ + "add", + "X12", + "Y68", + 1 + ], + [ + "add", + "X24", + "Y68", + -1 + ], + [ + "double", + "Y68" + ], + [ + "half", + "Y69" + ], + [ + "add", + "X0", + "Y69", + -1 + ], + [ + "add", + "X101", + "Y69", + -1 + ], + [ + "add", + "X11", + "Y69", + 1 + ], + [ + "add", + "X15", + "Y69", + 1 + ], + [ + "double", + "Y69" + ], + [ + "half", + "Y70" + ], + [ + "add", + "X101", + "Y70", + -1 + ], + [ + "add", + "X15", + "Y70", + 1 + ], + [ + "double", + "Y70" + ], + [ + "half", + "Y71" + ], + [ + "add", + "X0", + "Y71", + 1 + ], + [ + "add", + "X102", + "Y71", + -1 + ], + [ + "add", + "X24", + "Y71", + -1 + ], + [ + "double", + "Y71" + ], + [ + "half", + "Y72" + ], + [ + "add", + "X33", + "Y72", + -1 + ], + [ + "add", + "X102", + "Y72", + -1 + ], + [ + "add", + "X11", + "Y72", + -1 + ], + [ + "add", + "X24", + "Y72", + -1 + ], + [ + "double", + "Y72" + ], + [ + "half", + "Y73" + ], + [ + "add", + "X0", + "Y73", + -1 + ], + [ + "add", + "X102", + "Y73", + -1 + ], + [ + "add", + "X12", + "Y73", + -1 + ], + [ + "add", + "X15", + "Y73", + 1 + ], + [ + "double", + "Y73" + ], + [ + "half", + "Y74" + ], + [ + "add", + "X102", + "Y74", + -1 + ], + [ + "add", + "X11", + "Y74", + -1 + ], + [ + "add", + "X12", + "Y74", + -1 + ], + [ + "add", + "X15", + "Y74", + 1 + ], + [ + "double", + "Y74" + ], + [ + "half", + "Y75" + ], + [ + "add", + "X101", + "Y75", + -1 + ], + [ + "add", + "X102", + "Y75", + -1 + ], + [ + "add", + "X24", + "Y75", + -1 + ], + [ + "double", + "Y75" + ], + [ + "half", + "Y76" + ], + [ + "add", + "X0", + "Y76", + 1 + ], + [ + "add", + "X101", + "Y76", + -1 + ], + [ + "add", + "X102", + "Y76", + -1 + ], + [ + "add", + "X11", + "Y76", + -1 + ], + [ + "add", + "X24", + "Y76", + -1 + ], + [ + "double", + "Y76" + ], + [ + "half", + "Y77" + ], + [ + "add", + "X33", + "Y77", + 1 + ], + [ + "add", + "X101", + "Y77", + -1 + ], + [ + "add", + "X102", + "Y77", + -1 + ], + [ + "add", + "X12", + "Y77", + -1 + ], + [ + "add", + "X15", + "Y77", + 1 + ], + [ + "double", + "Y77" + ], + [ + "half", + "Y78" + ], + [ + "add", + "X0", + "Y78", + -1 + ], + [ + "add", + "X101", + "Y78", + -1 + ], + [ + "add", + "X102", + "Y78", + -1 + ], + [ + "add", + "X11", + "Y78", + -1 + ], + [ + "add", + "X12", + "Y78", + -1 + ], + [ + "add", + "X15", + "Y78", + 1 + ], + [ + "double", + "Y78" + ], + [ + "half", + "Y79" + ], + [ + "add", + "X0", + "Y79", + 1 + ], + [ + "add", + "X11", + "Y79", + 1 + ], + [ + "add", + "X12", + "Y79", + 1 + ], + [ + "add", + "X15", + "Y79", + -1 + ], + [ + "add", + "X24", + "Y79", + -1 + ], + [ + "double", + "Y79" + ], + [ + "half", + "Y80" + ], + [ + "add", + "X33", + "Y80", + -1 + ], + [ + "add", + "X12", + "Y80", + 1 + ], + [ + "add", + "X15", + "Y80", + -1 + ], + [ + "add", + "X24", + "Y80", + -1 + ], + [ + "double", + "Y80" + ], + [ + "half", + "Y81" + ], + [ + "add", + "X0", + "Y81", + -1 + ], + [ + "add", + "X11", + "Y81", + 1 + ], + [ + "double", + "Y81" + ], + [ + "half", + "Y82" + ], + [ + "add", + "X101", + "Y82", + -1 + ], + [ + "add", + "X11", + "Y82", + 1 + ], + [ + "add", + "X12", + "Y82", + 1 + ], + [ + "add", + "X15", + "Y82", + -1 + ], + [ + "add", + "X24", + "Y82", + -1 + ], + [ + "double", + "Y82" + ], + [ + "half", + "Y83" + ], + [ + "add", + "X0", + "Y83", + 1 + ], + [ + "add", + "X101", + "Y83", + -1 + ], + [ + "add", + "X12", + "Y83", + 1 + ], + [ + "add", + "X15", + "Y83", + -1 + ], + [ + "add", + "X24", + "Y83", + -1 + ], + [ + "double", + "Y83" + ], + [ + "half", + "Y84" + ], + [ + "add", + "X33", + "Y84", + 1 + ], + [ + "add", + "X101", + "Y84", + -1 + ], + [ + "add", + "X11", + "Y84", + 1 + ], + [ + "double", + "Y84" + ], + [ + "half", + "Y85" + ], + [ + "add", + "X0", + "Y85", + -1 + ], + [ + "add", + "X101", + "Y85", + -1 + ], + [ + "double", + "Y85" + ], + [ + "half", + "Y86" + ], + [ + "add", + "X102", + "Y86", + -1 + ], + [ + "add", + "X15", + "Y86", + -1 + ], + [ + "add", + "X24", + "Y86", + -1 + ], + [ + "double", + "Y86" + ], + [ + "half", + "Y87" + ], + [ + "add", + "X0", + "Y87", + 1 + ], + [ + "add", + "X102", + "Y87", + -1 + ], + [ + "add", + "X11", + "Y87", + -1 + ], + [ + "add", + "X15", + "Y87", + -1 + ], + [ + "add", + "X24", + "Y87", + -1 + ], + [ + "double", + "Y87" + ], + [ + "half", + "Y88" + ], + [ + "add", + "X33", + "Y88", + 1 + ], + [ + "add", + "X102", + "Y88", + -1 + ], + [ + "add", + "X12", + "Y88", + -1 + ], + [ + "double", + "Y88" + ], + [ + "half", + "Y89" + ], + [ + "add", + "X0", + "Y89", + -1 + ], + [ + "add", + "X102", + "Y89", + -1 + ], + [ + "add", + "X11", + "Y89", + -1 + ], + [ + "add", + "X12", + "Y89", + -1 + ], + [ + "double", + "Y89" + ], + [ + "half", + "Y90" + ], + [ + "add", + "X101", + "Y90", + -1 + ], + [ + "add", + "X102", + "Y90", + -1 + ], + [ + "add", + "X11", + "Y90", + -1 + ], + [ + "add", + "X15", + "Y90", + -1 + ], + [ + "add", + "X24", + "Y90", + -1 + ], + [ + "double", + "Y90" + ], + [ + "half", + "Y91" + ], + [ + "add", + "X0", + "Y91", + -1 + ], + [ + "add", + "X33", + "Y91", + 1 + ], + [ + "add", + "X101", + "Y91", + -1 + ], + [ + "add", + "X102", + "Y91", + -1 + ], + [ + "add", + "X12", + "Y91", + -1 + ], + [ + "double", + "Y91" + ], + [ + "half", + "Y92" + ], + [ + "add", + "X33", + "Y92", + 1 + ], + [ + "add", + "X101", + "Y92", + -1 + ], + [ + "add", + "X102", + "Y92", + -1 + ], + [ + "add", + "X11", + "Y92", + -1 + ], + [ + "add", + "X12", + "Y92", + -1 + ], + [ + "double", + "Y92" + ], + [ + "half", + "Y93" + ], + [ + "add", + "X33", + "Y93", + -1 + ], + [ + "add", + "X101", + "Y93", + -1 + ], + [ + "add", + "X102", + "Y93", + -1 + ], + [ + "add", + "X15", + "Y93", + 1 + ], + [ + "double", + "Y93" + ], + [ + "half", + "Y94" + ], + [ + "add", + "X33", + "Y94", + -1 + ], + [ + "add", + "X101", + "Y94", + -1 + ], + [ + "add", + "X11", + "Y94", + 1 + ], + [ + "add", + "X12", + "Y94", + 1 + ], + [ + "double", + "Y94" + ], + [ + "half", + "Y95" + ], + [ + "add", + "X33", + "Y95", + -1 + ], + [ + "add", + "X102", + "Y95", + -1 + ], + [ + "double", + "Y95" + ], + [ + "half", + "Y96" + ], + [ + "add", + "X0", + "Y96", + 1 + ], + [ + "add", + "X33", + "Y96", + -1 + ], + [ + "add", + "X101", + "Y96", + -1 + ], + [ + "add", + "X102", + "Y96", + -1 + ], + [ + "add", + "X12", + "Y96", + 1 + ], + [ + "add", + "X15", + "Y96", + -1 + ], + [ + "add", + "X24", + "Y96", + -1 + ], + [ + "double", + "Y96" + ], + [ + "half", + "Y97" + ], + [ + "add", + "X101", + "Y97", + -1 + ], + [ + "add", + "X102", + "Y97", + -1 + ], + [ + "add", + "X11", + "Y97", + 1 + ], + [ + "double", + "Y97" + ], + [ + "half", + "Y98" + ], + [ + "add", + "X0", + "Y98", + 1 + ], + [ + "add", + "X101", + "Y98", + -1 + ], + [ + "add", + "X102", + "Y98", + -1 + ], + [ + "double", + "Y98" + ], + [ + "half", + "Y99" + ], + [ + "add", + "X33", + "Y99", + -1 + ], + [ + "add", + "X101", + "Y99", + -1 + ], + [ + "add", + "X102", + "Y99", + -1 + ], + [ + "add", + "X11", + "Y99", + -1 + ], + [ + "double", + "Y99" + ], + [ + "half", + "Y100" + ], + [ + "add", + "X0", + "Y100", + -1 + ], + [ + "add", + "X101", + "Y100", + -1 + ], + [ + "add", + "X102", + "Y100", + -1 + ], + [ + "add", + "X12", + "Y100", + -1 + ], + [ + "add", + "X15", + "Y100", + 1 + ], + [ + "add", + "X24", + "Y100", + 1 + ], + [ + "double", + "Y100" + ], + [ + "half", + "Y101" + ], + [ + "add", + "X101", + "Y101", + -1 + ], + [ + "add", + "X101", + "Y101", + -1 + ], + [ + "add", + "X102", + "Y101", + -1 + ], + [ + "double", + "Y101" + ], + [ + "half", + "Y102" + ], + [ + "add", + "X101", + "Y102", + -1 + ], + [ + "add", + "X102", + "Y102", + -1 + ], + [ + "add", + "X102", + "Y102", + -1 + ], + [ + "add", + "X11", + "Y102", + -1 + ], + [ + "add", + "X12", + "Y102", + -1 + ], + [ + "double", + "Y102" + ], + [ + "half", + "Y103" + ], + [ + "add", + "X101", + "Y103", + -1 + ], + [ + "add", + "X102", + "Y103", + -1 + ], + [ + "add", + "X15", + "Y103", + -1 + ], + [ + "double", + "Y103" + ], + [ + "add", + "X5", + "X33", + -1 + ], + [ + "add", + "X5", + "X33", + -1 + ], + [ + "add", + "X5", + "X102", + 1 + ], + [ + "add", + "X5", + "X11", + 1 + ], + [ + "add", + "X5", + "X12", + -1 + ], + [ + "add", + "X5", + "X12", + -1 + ], + [ + "add", + "X5", + "X12", + -1 + ], + [ + "add", + "X5", + "X15", + -1 + ], + [ + "add", + "X5", + "X24", + -1 + ], + [ + "add", + "X6", + "X101", + 1 + ], + [ + "add", + "X6", + "X102", + -1 + ], + [ + "add", + "X6", + "X11", + 1 + ], + [ + "add", + "X10", + "X33", + -1 + ], + [ + "add", + "X10", + "X33", + -1 + ], + [ + "add", + "X10", + "X101", + -1 + ], + [ + "add", + "X10", + "X102", + 1 + ], + [ + "add", + "X10", + "X102", + 1 + ], + [ + "add", + "X10", + "X11", + 1 + ], + [ + "add", + "X10", + "X12", + -1 + ], + [ + "add", + "X10", + "X12", + -1 + ], + [ + "add", + "X10", + "X12", + -1 + ], + [ + "add", + "X10", + "X15", + -1 + ], + [ + "add", + "X10", + "X24", + -1 + ], + [ + "add", + "X16", + "X11", + -1 + ], + [ + "add", + "X16", + "X12", + 1 + ], + [ + "add", + "X16", + "X15", + 1 + ], + [ + "add", + "X17", + "X33", + 1 + ], + [ + "add", + "X17", + "X33", + 1 + ], + [ + "add", + "X17", + "X101", + 1 + ], + [ + "add", + "X17", + "X102", + -1 + ], + [ + "add", + "X17", + "X102", + -1 + ], + [ + "add", + "X17", + "X11", + -1 + ], + [ + "add", + "X17", + "X12", + 1 + ], + [ + "add", + "X17", + "X12", + 1 + ], + [ + "add", + "X17", + "X12", + 1 + ], + [ + "add", + "X17", + "X12", + 1 + ], + [ + "add", + "X17", + "X15", + 1 + ], + [ + "add", + "X17", + "X15", + 1 + ], + [ + "add", + "X17", + "X24", + 1 + ], + [ + "add", + "X21", + "X101", + 1 + ], + [ + "add", + "X21", + "X102", + -1 + ], + [ + "add", + "X21", + "X12", + 1 + ], + [ + "add", + "X21", + "X15", + 1 + ], + [ + "add", + "X25", + "X11", + -1 + ], + [ + "add", + "X25", + "X12", + 1 + ], + [ + "add", + "X25", + "X24", + 1 + ], + [ + "add", + "X26", + "X33", + 1 + ], + [ + "add", + "X26", + "X33", + 1 + ], + [ + "add", + "X26", + "X101", + 1 + ], + [ + "add", + "X26", + "X102", + -1 + ], + [ + "add", + "X26", + "X102", + -1 + ], + [ + "add", + "X26", + "X11", + -1 + ], + [ + "add", + "X26", + "X12", + 1 + ], + [ + "add", + "X26", + "X12", + 1 + ], + [ + "add", + "X26", + "X12", + 1 + ], + [ + "add", + "X26", + "X12", + 1 + ], + [ + "add", + "X26", + "X15", + 1 + ], + [ + "add", + "X26", + "X24", + 1 + ], + [ + "add", + "X26", + "X24", + 1 + ], + [ + "add", + "X30", + "X101", + 1 + ], + [ + "add", + "X30", + "X102", + -1 + ], + [ + "add", + "X30", + "X12", + 1 + ], + [ + "add", + "X30", + "X24", + 1 + ], + [ + "add", + "X31", + "X12", + 1 + ], + [ + "add", + "X31", + "X24", + 1 + ], + [ + "add", + "X34", + "X33", + 1 + ], + [ + "add", + "X34", + "X11", + -1 + ], + [ + "add", + "X34", + "X12", + 1 + ], + [ + "add", + "X37", + "X33", + -1 + ], + [ + "add", + "X37", + "X102", + 1 + ], + [ + "add", + "X37", + "X11", + 1 + ], + [ + "add", + "X37", + "X12", + -1 + ], + [ + "add", + "X37", + "X12", + -1 + ], + [ + "add", + "X37", + "X12", + -1 + ], + [ + "add", + "X37", + "X15", + -1 + ], + [ + "add", + "X37", + "X24", + -1 + ], + [ + "add", + "X38", + "X33", + -1 + ], + [ + "add", + "X38", + "X102", + 1 + ], + [ + "add", + "X38", + "X12", + -1 + ], + [ + "add", + "X38", + "X12", + -1 + ], + [ + "add", + "X38", + "X15", + -1 + ], + [ + "add", + "X38", + "X24", + -1 + ], + [ + "add", + "X39", + "X33", + 1 + ], + [ + "add", + "X39", + "X101", + 1 + ], + [ + "add", + "X39", + "X102", + -1 + ], + [ + "add", + "X39", + "X12", + 1 + ], + [ + "add", + "X41", + "X33", + -1 + ], + [ + "add", + "X41", + "X101", + -1 + ], + [ + "add", + "X41", + "X102", + 1 + ], + [ + "add", + "X41", + "X102", + 1 + ], + [ + "add", + "X41", + "X11", + 1 + ], + [ + "add", + "X41", + "X12", + -1 + ], + [ + "add", + "X41", + "X12", + -1 + ], + [ + "add", + "X41", + "X12", + -1 + ], + [ + "add", + "X41", + "X15", + -1 + ], + [ + "add", + "X41", + "X24", + -1 + ], + [ + "add", + "X42", + "X33", + -1 + ], + [ + "add", + "X42", + "X101", + -1 + ], + [ + "add", + "X42", + "X102", + 1 + ], + [ + "add", + "X42", + "X102", + 1 + ], + [ + "add", + "X42", + "X12", + -1 + ], + [ + "add", + "X42", + "X12", + -1 + ], + [ + "add", + "X42", + "X15", + -1 + ], + [ + "add", + "X42", + "X24", + -1 + ], + [ + "add", + "X43", + "X33", + 1 + ], + [ + "add", + "X43", + "X12", + 1 + ], + [ + "add", + "X47", + "X33", + 1 + ], + [ + "add", + "X47", + "X11", + -1 + ], + [ + "add", + "X47", + "X12", + 1 + ], + [ + "add", + "X47", + "X15", + 1 + ], + [ + "add", + "X51", + "X33", + -1 + ], + [ + "add", + "X51", + "X102", + 1 + ], + [ + "add", + "X51", + "X12", + -1 + ], + [ + "add", + "X51", + "X12", + -1 + ], + [ + "add", + "X51", + "X24", + -1 + ], + [ + "add", + "X52", + "X33", + 1 + ], + [ + "add", + "X52", + "X101", + 1 + ], + [ + "add", + "X52", + "X102", + -1 + ], + [ + "add", + "X52", + "X12", + 1 + ], + [ + "add", + "X52", + "X15", + 1 + ], + [ + "add", + "X53", + "X33", + 1 + ], + [ + "add", + "X53", + "X101", + 1 + ], + [ + "add", + "X53", + "X102", + -1 + ], + [ + "add", + "X53", + "X11", + -1 + ], + [ + "add", + "X53", + "X12", + 1 + ], + [ + "add", + "X53", + "X12", + 1 + ], + [ + "add", + "X53", + "X15", + 1 + ], + [ + "add", + "X55", + "X33", + -1 + ], + [ + "add", + "X55", + "X101", + -1 + ], + [ + "add", + "X55", + "X102", + 1 + ], + [ + "add", + "X55", + "X102", + 1 + ], + [ + "add", + "X55", + "X12", + -1 + ], + [ + "add", + "X55", + "X12", + -1 + ], + [ + "add", + "X55", + "X24", + -1 + ], + [ + "add", + "X56", + "X33", + 1 + ], + [ + "add", + "X56", + "X12", + 1 + ], + [ + "add", + "X56", + "X15", + 1 + ], + [ + "add", + "X57", + "X33", + 1 + ], + [ + "add", + "X57", + "X11", + -1 + ], + [ + "add", + "X57", + "X12", + 1 + ], + [ + "add", + "X57", + "X12", + 1 + ], + [ + "add", + "X57", + "X15", + 1 + ], + [ + "add", + "X60", + "X33", + -1 + ], + [ + "add", + "X60", + "X102", + 1 + ], + [ + "add", + "X60", + "X11", + 1 + ], + [ + "add", + "X60", + "X12", + -1 + ], + [ + "add", + "X60", + "X12", + -1 + ], + [ + "add", + "X60", + "X24", + -1 + ], + [ + "add", + "X61", + "X33", + -1 + ], + [ + "add", + "X61", + "X102", + 1 + ], + [ + "add", + "X61", + "X12", + -1 + ], + [ + "add", + "X61", + "X24", + -1 + ], + [ + "add", + "X62", + "X33", + 1 + ], + [ + "add", + "X62", + "X101", + 1 + ], + [ + "add", + "X62", + "X102", + -1 + ], + [ + "add", + "X62", + "X12", + 1 + ], + [ + "add", + "X62", + "X12", + 1 + ], + [ + "add", + "X62", + "X15", + 1 + ], + [ + "add", + "X63", + "X33", + 1 + ], + [ + "add", + "X63", + "X11", + -1 + ], + [ + "add", + "X63", + "X12", + 1 + ], + [ + "add", + "X63", + "X24", + 1 + ], + [ + "add", + "X67", + "X33", + -1 + ], + [ + "add", + "X67", + "X102", + 1 + ], + [ + "add", + "X67", + "X12", + -1 + ], + [ + "add", + "X67", + "X12", + -1 + ], + [ + "add", + "X67", + "X15", + -1 + ], + [ + "add", + "X68", + "X33", + 1 + ], + [ + "add", + "X68", + "X101", + 1 + ], + [ + "add", + "X68", + "X102", + -1 + ], + [ + "add", + "X68", + "X12", + 1 + ], + [ + "add", + "X68", + "X24", + 1 + ], + [ + "add", + "X69", + "X33", + 1 + ], + [ + "add", + "X69", + "X101", + 1 + ], + [ + "add", + "X69", + "X102", + -1 + ], + [ + "add", + "X69", + "X11", + -1 + ], + [ + "add", + "X69", + "X12", + 1 + ], + [ + "add", + "X69", + "X12", + 1 + ], + [ + "add", + "X69", + "X24", + 1 + ], + [ + "add", + "X71", + "X33", + -1 + ], + [ + "add", + "X71", + "X101", + -1 + ], + [ + "add", + "X71", + "X102", + 1 + ], + [ + "add", + "X71", + "X102", + 1 + ], + [ + "add", + "X71", + "X12", + -1 + ], + [ + "add", + "X71", + "X12", + -1 + ], + [ + "add", + "X71", + "X15", + -1 + ], + [ + "add", + "X72", + "X33", + 1 + ], + [ + "add", + "X72", + "X12", + 1 + ], + [ + "add", + "X72", + "X24", + 1 + ], + [ + "add", + "X73", + "X33", + 1 + ], + [ + "add", + "X73", + "X11", + -1 + ], + [ + "add", + "X73", + "X12", + 1 + ], + [ + "add", + "X73", + "X12", + 1 + ], + [ + "add", + "X73", + "X24", + 1 + ], + [ + "add", + "X76", + "X33", + -1 + ], + [ + "add", + "X76", + "X102", + 1 + ], + [ + "add", + "X76", + "X11", + 1 + ], + [ + "add", + "X76", + "X12", + -1 + ], + [ + "add", + "X76", + "X12", + -1 + ], + [ + "add", + "X76", + "X15", + -1 + ], + [ + "add", + "X77", + "X33", + -1 + ], + [ + "add", + "X77", + "X102", + 1 + ], + [ + "add", + "X77", + "X12", + -1 + ], + [ + "add", + "X77", + "X15", + -1 + ], + [ + "add", + "X78", + "X33", + 1 + ], + [ + "add", + "X78", + "X101", + 1 + ], + [ + "add", + "X78", + "X102", + -1 + ], + [ + "add", + "X78", + "X12", + 1 + ], + [ + "add", + "X78", + "X12", + 1 + ], + [ + "add", + "X78", + "X24", + 1 + ], + [ + "add", + "X82", + "X33", + 1 + ], + [ + "add", + "X82", + "X101", + 1 + ], + [ + "add", + "X82", + "X102", + -1 + ], + [ + "add", + "X82", + "X11", + -1 + ], + [ + "add", + "X82", + "X12", + 1 + ], + [ + "add", + "X82", + "X12", + 1 + ], + [ + "add", + "X82", + "X15", + 1 + ], + [ + "add", + "X82", + "X24", + 1 + ], + [ + "add", + "X86", + "X33", + 1 + ], + [ + "add", + "X86", + "X11", + -1 + ], + [ + "add", + "X86", + "X12", + 1 + ], + [ + "add", + "X86", + "X12", + 1 + ], + [ + "add", + "X86", + "X15", + 1 + ], + [ + "add", + "X86", + "X24", + 1 + ], + [ + "add", + "X90", + "X33", + 1 + ], + [ + "add", + "X90", + "X101", + 1 + ], + [ + "add", + "X90", + "X102", + -1 + ], + [ + "add", + "X90", + "X12", + 1 + ], + [ + "add", + "X90", + "X12", + 1 + ], + [ + "add", + "X90", + "X15", + 1 + ], + [ + "add", + "X90", + "X24", + 1 + ], + [ + "add", + "X91", + "X33", + 1 + ], + [ + "add", + "X91", + "X101", + 1 + ], + [ + "add", + "X91", + "X102", + -1 + ], + [ + "add", + "X91", + "X11", + -1 + ], + [ + "add", + "X91", + "X12", + 1 + ], + [ + "add", + "X91", + "X12", + 1 + ], + [ + "add", + "X91", + "X12", + 1 + ], + [ + "add", + "X91", + "X15", + 1 + ], + [ + "add", + "X91", + "X24", + 1 + ], + [ + "add", + "X93", + "X102", + 1 + ], + [ + "add", + "X93", + "X12", + -1 + ], + [ + "add", + "X93", + "X15", + -1 + ], + [ + "add", + "X96", + "X102", + 1 + ], + [ + "add", + "X96", + "X12", + -1 + ], + [ + "add", + "X97", + "X102", + 1 + ], + [ + "add", + "X97", + "X11", + -1 + ], + [ + "native", + "X0", + "finish" + ], + [ + "native", + "X5", + "finish" + ], + [ + "native", + "X6", + "finish" + ], + [ + "native", + "X10", + "finish" + ], + [ + "native", + "X11", + "finish" + ], + [ + "native", + "X12", + "finish" + ], + [ + "native", + "X15", + "finish" + ], + [ + "native", + "X16", + "finish" + ], + [ + "native", + "X17", + "finish" + ], + [ + "native", + "X21", + "finish" + ], + [ + "native", + "X24", + "finish" + ], + [ + "native", + "X25", + "finish" + ], + [ + "native", + "X26", + "finish" + ], + [ + "native", + "X30", + "finish" + ], + [ + "native", + "X31", + "finish" + ], + [ + "native", + "X33", + "finish" + ], + [ + "native", + "X34", + "finish" + ], + [ + "native", + "X37", + "finish" + ], + [ + "native", + "X38", + "finish" + ], + [ + "native", + "X39", + "finish" + ], + [ + "native", + "X41", + "finish" + ], + [ + "native", + "X42", + "finish" + ], + [ + "native", + "X43", + "finish" + ], + [ + "native", + "X47", + "finish" + ], + [ + "native", + "X51", + "finish" + ], + [ + "native", + "X52", + "finish" + ], + [ + "native", + "X53", + "finish" + ], + [ + "native", + "X55", + "finish" + ], + [ + "native", + "X56", + "finish" + ], + [ + "native", + "X57", + "finish" + ], + [ + "native", + "X60", + "finish" + ], + [ + "native", + "X61", + "finish" + ], + [ + "native", + "X62", + "finish" + ], + [ + "native", + "X63", + "finish" + ], + [ + "native", + "X67", + "finish" + ], + [ + "native", + "X68", + "finish" + ], + [ + "native", + "X69", + "finish" + ], + [ + "native", + "X71", + "finish" + ], + [ + "native", + "X72", + "finish" + ], + [ + "native", + "X73", + "finish" + ], + [ + "native", + "X76", + "finish" + ], + [ + "native", + "X77", + "finish" + ], + [ + "native", + "X78", + "finish" + ], + [ + "native", + "X82", + "finish" + ], + [ + "native", + "X86", + "finish" + ], + [ + "native", + "X90", + "finish" + ], + [ + "native", + "X91", + "finish" + ], + [ + "native", + "X93", + "finish" + ], + [ + "native", + "X96", + "finish" + ], + [ + "native", + "X97", + "finish" + ], + [ + "native", + "X101", + "finish" + ], + [ + "native", + "X102", + "finish" + ], + [ + "native", + "G2", + "finish" + ], + [ + "native", + "G3", + "finish" + ], + [ + "native", + "G9", + "finish" + ], + [ + "native", + "N5", + "finish" + ], + [ + "native", + "N10", + "finish" + ], + [ + "native", + "N12", + "finish" + ], + [ + "native", + "N15", + "finish" + ], + [ + "native", + "N17", + "finish" + ], + [ + "native", + "N24", + "finish" + ], + [ + "native", + "N26", + "finish" + ], + [ + "native", + "N37", + "finish" + ], + [ + "native", + "N38", + "finish" + ], + [ + "native", + "N39", + "finish" + ], + [ + "native", + "N41", + "finish" + ], + [ + "native", + "N42", + "finish" + ], + [ + "native", + "N43", + "finish" + ], + [ + "native", + "N47", + "finish" + ], + [ + "native", + "N51", + "finish" + ], + [ + "native", + "N52", + "finish" + ], + [ + "native", + "N53", + "finish" + ], + [ + "native", + "N55", + "finish" + ], + [ + "native", + "N56", + "finish" + ], + [ + "native", + "N57", + "finish" + ], + [ + "native", + "N60", + "finish" + ], + [ + "native", + "N61", + "finish" + ], + [ + "native", + "N62", + "finish" + ], + [ + "native", + "N63", + "finish" + ], + [ + "native", + "N67", + "finish" + ], + [ + "native", + "N68", + "finish" + ], + [ + "native", + "N69", + "finish" + ], + [ + "native", + "N71", + "finish" + ], + [ + "native", + "N72", + "finish" + ], + [ + "native", + "N73", + "finish" + ], + [ + "native", + "N76", + "finish" + ], + [ + "native", + "N77", + "finish" + ], + [ + "native", + "N78", + "finish" + ], + [ + "native", + "N82", + "finish" + ], + [ + "native", + "N86", + "finish" + ], + [ + "native", + "N90", + "finish" + ], + [ + "native", + "N91", + "finish" + ], + [ + "native", + "N96", + "finish" + ] + ], + "retained_original_event_indices": [ + 1, + 2, + 3, + 4, + 7, + 8, + 9, + 13, + 14, + 18, + 19, + 20, + 22, + 23, + 27, + 28, + 29, + 32, + 35, + 36, + 40, + 44, + 45, + 46, + 48, + 49, + 50, + 54, + 58, + 59, + 64, + 65, + 66, + 70, + 74, + 75, + 79, + 80, + 81, + 83, + 84, + 85, + 87, + 88, + 89, + 92, + 94, + 95, + 98, + 99, + 100, + 103, + 104, + 105, + 106, + 107, + 108, + 109, + 110, + 111, + 112, + 113, + 114, + 115, + 116, + 117, + 118, + 119, + 120, + 121, + 122, + 123, + 124, + 125, + 126, + 127, + 128, + 129, + 130, + 131, + 132, + 133, + 134, + 135, + 136, + 137, + 138, + 139, + 140, + 141, + 142, + 143, + 144, + 145, + 146, + 147, + 148, + 149, + 150, + 151, + 152, + 153, + 154, + 155, + 156, + 157, + 158, + 159, + 160, + 161, + 162, + 163, + 164, + 165, + 166, + 167, + 168, + 169, + 170, + 171, + 172, + 173, + 174, + 175, + 176, + 177, + 178, + 179, + 180, + 181, + 182, + 183, + 184, + 185, + 186, + 187, + 188, + 189, + 190, + 191, + 192, + 193, + 194, + 195, + 196, + 197, + 198, + 199, + 200, + 201, + 202, + 203, + 204, + 205, + 206, + 207, + 209, + 210, + 211, + 212, + 215, + 216, + 217, + 221, + 222, + 226, + 227, + 228, + 230, + 231, + 235, + 236, + 237, + 240, + 243, + 244, + 248, + 252, + 253, + 254, + 256, + 257, + 258, + 262, + 266, + 267, + 272, + 273, + 274, + 278, + 282, + 283, + 287, + 288, + 289, + 291, + 292, + 293, + 295, + 296, + 297, + 300, + 302, + 303, + 306, + 307, + 308, + 311, + 312, + 313, + 315, + 318, + 319, + 320, + 322, + 323, + 324, + 326, + 327, + 328, + 332, + 333, + 337, + 341, + 342, + 343, + 348, + 349, + 353, + 357, + 358, + 359, + 361, + 362, + 363, + 367, + 371, + 372, + 375, + 376, + 379, + 380, + 385, + 386, + 388, + 389, + 394, + 395, + 396, + 397, + 404, + 405, + 412, + 413, + 414, + 415, + 416, + 417, + 419, + 420, + 422, + 424, + 426, + 428, + 430, + 431, + 434, + 436, + 438, + 439, + 441, + 443, + 445, + 447, + 448, + 449, + 452, + 453, + 454, + 455, + 464, + 465, + 466, + 467, + 472, + 473, + 474, + 475, + 478, + 479, + 480, + 481, + 482, + 483, + 484, + 485, + 486, + 487, + 488, + 489, + 490, + 491, + 492, + 493, + 494, + 495, + 496, + 497, + 498, + 499, + 500, + 501, + 502, + 503, + 504, + 505, + 506, + 507, + 508, + 509, + 510, + 511, + 512, + 513, + 514, + 515, + 516, + 517, + 518, + 519, + 520, + 521, + 522, + 523, + 524, + 525, + 526, + 527, + 528, + 529, + 530, + 531, + 532, + 533, + 534, + 535, + 536, + 537, + 538, + 539, + 540, + 541, + 542, + 543, + 544, + 545, + 547, + 549, + 551, + 553, + 555, + 556, + 558, + 560, + 563, + 564, + 566, + 568, + 570, + 572, + 574, + 575, + 577, + 578, + 581, + 582, + 587, + 588, + 591, + 592, + 593, + 594, + 598, + 599, + 600, + 602, + 605, + 606, + 607, + 611, + 612, + 617, + 618, + 620, + 621, + 622, + 629, + 630, + 634, + 635, + 639, + 640, + 646, + 647, + 649, + 651, + 653, + 654, + 655, + 657, + 659, + 660, + 664, + 665, + 667, + 668, + 672, + 673, + 674, + 675, + 679, + 680, + 683, + 685, + 687, + 689, + 690, + 692, + 695, + 696, + 697, + 698, + 701, + 703, + 704, + 706, + 708, + 709, + 710, + 711, + 716, + 718, + 724, + 726, + 728, + 730, + 735, + 737, + 739, + 741, + 742, + 744, + 747, + 748, + 749, + 750, + 752, + 754, + 756, + 757, + 758, + 760, + 761, + 762, + 766, + 767, + 771, + 775, + 776, + 777, + 779, + 780, + 781, + 785, + 786, + 788, + 790, + 791, + 792, + 796, + 797, + 801, + 802, + 803, + 806, + 807, + 808, + 809, + 810, + 812, + 813, + 814, + 816, + 820, + 824, + 828, + 835, + 839, + 842, + 843, + 845, + 849, + 850, + 851, + 854, + 855, + 856, + 857, + 862, + 863, + 864, + 865, + 866, + 867, + 874, + 875, + 882, + 883, + 884, + 885, + 892, + 893, + 896, + 897, + 902, + 903, + 905, + 906, + 908, + 909, + 910, + 911, + 912, + 913, + 914, + 915, + 916, + 917, + 918, + 919, + 920, + 921, + 922, + 923, + 924, + 925, + 926, + 927, + 928, + 929, + 930, + 931, + 932, + 933, + 934, + 935, + 936, + 937, + 938, + 939, + 940, + 941, + 942, + 943, + 944, + 945, + 946, + 947, + 948, + 949, + 950, + 951, + 952, + 953, + 954, + 955, + 956, + 957, + 958, + 959, + 960, + 961, + 962, + 963, + 964, + 965, + 966, + 967, + 968, + 969, + 970, + 971, + 972, + 973, + 974, + 975, + 976, + 977, + 978, + 979, + 980, + 981, + 982, + 983, + 984, + 985, + 986, + 987, + 988, + 989, + 990, + 991, + 992, + 993, + 994, + 995, + 996, + 997, + 998, + 999, + 1000, + 1001, + 1002, + 1003, + 1004, + 1005, + 1006, + 1007, + 1008, + 1009, + 1010, + 1011, + 1012, + 1013, + 1014, + 1015, + 1016, + 1017, + 1018, + 1019, + 1020, + 1021, + 1022, + 1023, + 1024, + 1025, + 1026, + 1027, + 1028, + 1029, + 1030, + 1031, + 1032, + 1033, + 1034, + 1035, + 1036, + 1037, + 1038, + 1039, + 1040, + 1041, + 1042, + 1043, + 1044, + 1045, + 1046, + 1047, + 1048, + 1049, + 1050, + 1051, + 1052, + 1053, + 1054, + 1055, + 1056, + 1057, + 1058, + 1059, + 1060, + 1061, + 1062, + 1063, + 1064, + 1065, + 1066, + 1067, + 1068, + 1069, + 1070, + 1071, + 1072, + 1073, + 1074, + 1075, + 1076, + 1077, + 1078, + 1079, + 1080, + 1081, + 1082, + 1083, + 1084, + 1085, + 1086, + 1087, + 1088, + 1089, + 1090, + 1091, + 1092, + 1093, + 1094, + 1095, + 1096, + 1097, + 1098, + 1099, + 1100, + 1101, + 1102, + 1103, + 1104, + 1105, + 1106, + 1107, + 1108, + 1109, + 1110, + 1111, + 1112, + 1113, + 1114, + 1115, + 1116, + 1117, + 1118, + 1119, + 1120, + 1121, + 1122, + 1123, + 1124, + 1125, + 1126, + 1127, + 1128, + 1129, + 1130, + 1131, + 1132, + 1133, + 1134, + 1135, + 1136, + 1137, + 1138, + 1139, + 1140, + 1141, + 1142, + 1143, + 1144, + 1145, + 1146, + 1147, + 1148, + 1149, + 1150, + 1151, + 1152, + 1153, + 1154, + 1155, + 1156, + 1157, + 1158, + 1159, + 1160, + 1161, + 1162, + 1163, + 1164, + 1165, + 1166, + 1167, + 1168, + 1169, + 1170, + 1171, + 1172, + 1173, + 1174, + 1175, + 1176, + 1177, + 1178, + 1179, + 1180, + 1181, + 1182, + 1183, + 1184, + 1185, + 1186, + 1187, + 1188, + 1189, + 1190, + 1191, + 1192, + 1193, + 1194, + 1195, + 1196, + 1197, + 1198, + 1199, + 1200, + 1201, + 1202, + 1203, + 1204, + 1205, + 1206, + 1207, + 1208, + 1209, + 1210, + 1211, + 1212, + 1213, + 1214, + 1215, + 1216, + 1217, + 1218, + 1219, + 1220, + 1221, + 1222, + 1223, + 1224, + 1225, + 1226, + 1227, + 1228, + 1229, + 1230, + 1231, + 1232, + 1233, + 1234, + 1235, + 1236, + 1237, + 1238, + 1239, + 1240, + 1241, + 1242, + 1243, + 1244, + 1245, + 1246, + 1247, + 1248, + 1249, + 1250, + 1251, + 1252, + 1253, + 1254, + 1255, + 1256, + 1257, + 1258, + 1259, + 1260, + 1261, + 1262, + 1263, + 1264, + 1265, + 1266, + 1267, + 1268, + 1269, + 1270, + 1271, + 1272, + 1273, + 1274, + 1275, + 1276, + 1277, + 1278, + 1279, + 1280, + 1281, + 1282, + 1283, + 1284, + 1285, + 1286, + 1287, + 1288, + 1289, + 1290, + 1291, + 1292, + 1293, + 1294, + 1295, + 1296, + 1297, + 1298, + 1299, + 1300, + 1301, + 1302, + 1303, + 1304, + 1305, + 1306, + 1307, + 1308, + 1309, + 1310, + 1311, + 1312, + 1313, + 1314, + 1315, + 1316, + 1317, + 1318, + 1319, + 1320, + 1321, + 1322, + 1323, + 1324, + 1325, + 1326, + 1327, + 1328, + 1329, + 1330, + 1331, + 1332, + 1333, + 1334, + 1335, + 1336, + 1337, + 1338, + 1339, + 1340, + 1341, + 1342, + 1343, + 1344, + 1345, + 1346, + 1347, + 1348, + 1349, + 1350, + 1351, + 1352, + 1353, + 1354, + 1355, + 1356, + 1357, + 1358, + 1359, + 1360, + 1361, + 1362, + 1363, + 1364, + 1365, + 1366, + 1367, + 1368, + 1369, + 1370, + 1371, + 1372, + 1373, + 1374, + 1375, + 1376, + 1377, + 1378, + 1379, + 1380, + 1381, + 1382, + 1383, + 1384, + 1385, + 1386, + 1387, + 1388, + 1389, + 1390, + 1391, + 1392, + 1393, + 1394, + 1395, + 1396, + 1397, + 1398, + 1399, + 1400, + 1401, + 1402, + 1403, + 1404, + 1405, + 1406, + 1407, + 1408, + 1409, + 1410, + 1411, + 1412, + 1413, + 1414, + 1415, + 1416, + 1417, + 1418, + 1419, + 1420, + 1421, + 1422, + 1423, + 1424, + 1425, + 1426, + 1427, + 1428, + 1429, + 1430, + 1431, + 1432, + 1433, + 1434, + 1435, + 1436, + 1437, + 1438, + 1439, + 1440, + 1441, + 1442, + 1443, + 1444, + 1445, + 1446, + 1447, + 1448, + 1449, + 1450, + 1451, + 1452, + 1453, + 1454, + 1455, + 1456, + 1457, + 1458, + 1459, + 1460, + 1461, + 1462, + 1463, + 1464, + 1465, + 1466, + 1467, + 1468, + 1469, + 1470, + 1471, + 1472, + 1473, + 1474, + 1475, + 1476, + 1477, + 1478, + 1479, + 1480, + 1481, + 1482, + 1483, + 1484, + 1485, + 1486, + 1487, + 1488, + 1489, + 1490, + 1491, + 1492, + 1493, + 1494, + 1495, + 1496, + 1497, + 1498, + 1499, + 1500, + 1501, + 1502, + 1503, + 1504, + 1505, + 1506, + 1507, + 1508, + 1509, + 1510, + 1511, + 1512, + 1513, + 1514, + 1515, + 1516, + 1517, + 1518, + 1519, + 1520, + 1521, + 1522, + 1523, + 1524, + 1525, + 1526, + 1527, + 1528, + 1529, + 1530, + 1531, + 1532, + 1533, + 1534, + 1535, + 1536, + 1537, + 1538, + 1539, + 1540, + 1541, + 1542, + 1543, + 1544, + 1545, + 1546, + 1547, + 1548, + 1549, + 1550, + 1551, + 1552, + 1553, + 1554, + 1555, + 1556, + 1557, + 1558, + 1559, + 1560, + 1561, + 1562, + 1563, + 1564, + 1565, + 1566, + 1567, + 1568, + 1569, + 1570, + 1571, + 1572, + 1573, + 1574, + 1575, + 1576, + 1577, + 1578, + 1579, + 1580, + 1581, + 1582, + 1583, + 1584, + 1585, + 1586, + 1587, + 1588, + 1589, + 1590, + 1591, + 1592, + 1593, + 1594, + 1595, + 1596, + 1597, + 1598, + 1599, + 1600, + 1601, + 1602, + 1603, + 1604, + 1605, + 1606, + 1607, + 1608, + 1609, + 1610, + 1611, + 1612, + 1613, + 1614, + 1615, + 1616, + 1617, + 1618, + 1619, + 1620, + 1621, + 1622, + 1623, + 1624, + 1625, + 1626, + 1627, + 1628, + 1629, + 1630, + 1631, + 1632, + 1633, + 1634, + 1635, + 1636, + 1637, + 1638, + 1639, + 1640, + 1641, + 1642, + 1643, + 1644, + 1645, + 1646, + 1647, + 1648, + 1649, + 1650, + 1651, + 1652, + 1653, + 1654, + 1655, + 1656, + 1657, + 1658, + 1659, + 1660, + 1661, + 1662, + 1663, + 1664, + 1665, + 1666, + 1667, + 1668, + 1669, + 1670, + 1671, + 1672, + 1673, + 1674, + 1675, + 1676, + 1677, + 1678, + 1679, + 1680, + 1681, + 1682, + 1683, + 1684, + 1685, + 1686, + 1687, + 1688, + 1689, + 1690, + 1691, + 1692, + 1693, + 1694, + 1695, + 1696, + 1697, + 1698, + 1699, + 1700, + 1701, + 1702, + 1703, + 1704, + 1705, + 1706, + 1707, + 1708, + 1709, + 1710, + 1711, + 1712, + 1713, + 1714, + 1715, + 1716, + 1717, + 1718, + 1719, + 1720, + 1721, + 1722, + 1723, + 1724, + 1725, + 1726, + 1727, + 1728, + 1729, + 1730, + 1731, + 1732, + 1733, + 1734, + 1735, + 1736, + 1737, + 1738, + 1739, + 1740, + 1741, + 1742, + 1743, + 1744, + 1745, + 1746, + 1747, + 1748, + 1749, + 1750, + 1751, + 1752, + 1753, + 1754, + 1755, + 1756, + 1757, + 1758, + 1759, + 1760, + 1761, + 1762, + 1763, + 1764, + 1765, + 1766, + 1767, + 1768, + 1769, + 1770, + 1771, + 1772, + 1773, + 1774, + 1775, + 1776, + 1777, + 1778, + 1779, + 1780, + 1781, + 1782, + 1783, + 1784, + 1785, + 1786, + 1787, + 1788, + 1789, + 1790, + 1791, + 1792, + 1793, + 1794, + 1795, + 1796, + 1797, + 1798, + 1799, + 1800, + 1801, + 1802, + 1803, + 1804, + 1805, + 1806, + 1807, + 1808, + 1809, + 1810, + 1811, + 1812, + 1813, + 1814, + 1815, + 1816, + 1817, + 1818, + 1819, + 1820, + 1821, + 1822, + 1823, + 1824, + 1825, + 1826, + 1827, + 1828, + 1829, + 1830, + 1831, + 1832, + 1833, + 1834, + 1835, + 1836, + 1837, + 1838, + 1839, + 1840, + 1841, + 1842, + 1843, + 1844, + 1845, + 1846, + 1847, + 1848, + 1849, + 1850, + 1851, + 1852, + 1853, + 1854, + 1855, + 1856, + 1857, + 1858, + 1859, + 1860, + 1861, + 1862, + 1863, + 1864, + 1865, + 1866, + 1867, + 1868, + 1869, + 1870, + 1871, + 1872, + 1873, + 1874, + 1875, + 1876, + 1877, + 1878, + 1879, + 1880, + 1881, + 1882, + 1883, + 1884, + 1885, + 1886, + 1887, + 1888, + 1889, + 1890, + 1891, + 1892, + 1893, + 1894, + 1895, + 1896, + 1897, + 1898, + 1899, + 1900, + 1901, + 1902, + 1903, + 1904, + 1905, + 1906, + 1907, + 1908, + 1909, + 1910, + 1911, + 1912, + 1913, + 1914, + 1915, + 1916, + 1917, + 1918, + 1919, + 1920, + 1921, + 1922, + 1923, + 1924, + 1925, + 1926, + 1927, + 1928, + 1929, + 1930, + 1931, + 1932, + 1933, + 1934, + 1935, + 1936, + 1937, + 1938, + 1939, + 1940, + 1941, + 1942, + 1943, + 1944, + 1945, + 1946, + 1947, + 1948, + 1949, + 1950, + 1951, + 1952, + 1953, + 1954, + 1955, + 1956, + 1957, + 1958, + 1959, + 1960, + 1961, + 1962, + 1963, + 1964, + 1965, + 1966, + 1967, + 1968, + 1969, + 1970, + 1971, + 1972, + 1973, + 1974, + 1975, + 1976, + 1977, + 1978, + 1979, + 1980, + 1981, + 1982, + 1983, + 1984, + 1985, + 1986, + 1987, + 1988, + 1989, + 1990, + 1991, + 1992, + 1993, + 1994, + 1995, + 1996, + 1997, + 1998, + 1999, + 2000, + 2001, + 2002, + 2003, + 2004, + 2005, + 2006, + 2007, + 2008, + 2009, + 2010, + 2011, + 2012, + 2013, + 2014, + 2015, + 2016, + 2017, + 2018, + 2019, + 2020, + 2021, + 2022, + 2023, + 2024, + 2025, + 2026, + 2027, + 2028, + 2029, + 2030, + 2031, + 2032, + 2033, + 2034, + 2035, + 2036, + 2037, + 2038, + 2039, + 2040, + 2041, + 2042, + 2043, + 2044, + 2045, + 2046, + 2047, + 2048, + 2049, + 2050, + 2051, + 2052, + 2053, + 2054, + 2055, + 2056, + 2057, + 2058, + 2059, + 2060, + 2061, + 2062, + 2063, + 2064, + 2065, + 2066, + 2067, + 2068, + 2069, + 2070, + 2071, + 2072, + 2073, + 2074, + 2075, + 2076, + 2077, + 2078, + 2079, + 2080, + 2081, + 2082, + 2083, + 2084, + 2085, + 2086, + 2087, + 2088, + 2089, + 2090, + 2091, + 2092, + 2093, + 2094, + 2095, + 2096, + 2097, + 2098, + 2099, + 2100, + 2101, + 2102, + 2103, + 2104, + 2105, + 2106, + 2107, + 2108, + 2109, + 2110, + 2111, + 2112, + 2113, + 2114, + 2115, + 2116, + 2117, + 2118, + 2119, + 2120, + 2121, + 2122, + 2123, + 2124, + 2125, + 2126, + 2127, + 2128, + 2129, + 2130, + 2131, + 2132, + 2133, + 2134, + 2135, + 2136, + 2137, + 2138, + 2139, + 2140, + 2141, + 2142, + 2143, + 2144, + 2145, + 2146, + 2147, + 2148, + 2149, + 2150, + 2151, + 2152, + 2153, + 2154, + 2155, + 2156, + 2157, + 2158, + 2159, + 2160, + 2161, + 2162, + 2163, + 2164, + 2165, + 2166, + 2167, + 2168, + 2169, + 2170, + 2171, + 2172, + 2173, + 2174, + 2175, + 2176, + 2177, + 2178, + 2179, + 2180, + 2181, + 2182, + 2183, + 2184, + 2185, + 2186, + 2187, + 2188, + 2189, + 2190, + 2191, + 2192, + 2193, + 2194, + 2195, + 2196, + 2197, + 2198, + 2199, + 2200, + 2201, + 2202, + 2203, + 2204, + 2205, + 2206, + 2207, + 2208, + 2209, + 2210, + 2211, + 2212, + 2213, + 2214, + 2215, + 2216, + 2217, + 2218, + 2219, + 2220, + 2221, + 2222, + 2223, + 2224, + 2225, + 2226, + 2227, + 2228, + 2229, + 2230, + 2231, + 2232, + 2233, + 2234, + 2235, + 2236, + 2237, + 2238, + 2239, + 2240, + 2241, + 2242, + 2243, + 2244, + 2245, + 2246, + 2247, + 2248, + 2249, + 2250, + 2251, + 2252, + 2253, + 2254, + 2255, + 2256, + 2257, + 2258, + 2259, + 2260, + 2261, + 2262, + 2263, + 2264, + 2265, + 2266, + 2267, + 2268, + 2269, + 2270, + 2271, + 2272, + 2273, + 2274, + 2275, + 2276, + 2277, + 2278, + 2279, + 2280, + 2281, + 2282, + 2283, + 2284, + 2285, + 2286, + 2287, + 2288, + 2289, + 2290, + 2291, + 2292, + 2293, + 2294, + 2295, + 2296, + 2297, + 2298, + 2299, + 2300, + 2301, + 2302, + 2303, + 2304, + 2305, + 2306, + 2307, + 2308, + 2309, + 2310, + 2311, + 2312, + 2313, + 2314, + 2315, + 2316, + 2317, + 2318, + 2319, + 2320, + 2321, + 2322, + 2323, + 2324, + 2325, + 2326, + 2327, + 2328, + 2329, + 2330, + 2331, + 2332, + 2333, + 2334, + 2335, + 2336, + 2337, + 2338, + 2339, + 2340, + 2341, + 2342, + 2343, + 2344, + 2345, + 2346, + 2347, + 2348, + 2349, + 2350, + 2351, + 2352, + 2353, + 2354, + 2355, + 2356, + 2357, + 2358, + 2359, + 2360, + 2361, + 2362, + 2363, + 2364, + 2365, + 2366, + 2367, + 2368, + 2369, + 2370, + 2371, + 2372, + 2373, + 2374, + 2375, + 2376, + 2377, + 2378, + 2379, + 2380, + 2381, + 2382, + 2383, + 2384, + 2385, + 2386, + 2387, + 2388, + 2389, + 2390, + 2391, + 2392, + 2393, + 2394, + 2395, + 2396, + 2397, + 2398, + 2399, + 2400, + 2401, + 2402, + 2403, + 2404, + 2405, + 2406, + 2407, + 2408, + 2409, + 2410, + 2411, + 2412, + 2413, + 2414, + 2415, + 2416, + 2417, + 2418, + 2419, + 2420, + 2421, + 2422, + 2423, + 2424, + 2425, + 2426, + 2427, + 2428, + 2429, + 2430, + 2431, + 2432, + 2433, + 2434, + 2435, + 2436, + 2437, + 2438, + 2439, + 2440, + 2441, + 2442, + 2443, + 2444, + 2445, + 2446, + 2447, + 2448, + 2449, + 2450, + 2451, + 2452, + 2453, + 2454, + 2455, + 2456, + 2457, + 2458, + 2459, + 2460, + 2461, + 2462, + 2463, + 2464, + 2465, + 2466, + 2467, + 2468, + 2469, + 2470, + 2471, + 2472, + 2473, + 2474, + 2475, + 2476, + 2477, + 2478, + 2479, + 2480, + 2481, + 2482, + 2483, + 2484, + 2485, + 2486, + 2487, + 2488, + 2489, + 2490, + 2491, + 2492, + 2493, + 2494, + 2495, + 2496, + 2497, + 2498, + 2499, + 2500, + 2501, + 2502, + 2503, + 2504, + 2505, + 2506, + 2507, + 2508, + 2509, + 2510, + 2511, + 2512, + 2513, + 2514, + 2515, + 2516, + 2517, + 2518, + 2519, + 2520, + 2521, + 2522, + 2523, + 2524, + 2525, + 2526, + 2527, + 2528, + 2529, + 2530, + 2531, + 2532, + 2533, + 2534, + 2535, + 2536, + 2537, + 2538, + 2539, + 2540, + 2541, + 2542, + 2543, + 2544, + 2545, + 2546, + 2547, + 2548, + 2549, + 2550, + 2551, + 2552, + 2553, + 2554, + 2555, + 2556, + 2557, + 2558, + 2559, + 2560, + 2561, + 2562, + 2563, + 2564, + 2565, + 2566, + 2567, + 2568, + 2569, + 2570, + 2571, + 2572, + 2573, + 2574, + 2575, + 2576, + 2591, + 2592, + 2593, + 2594, + 2595, + 2596, + 2597, + 2598, + 2599, + 2610, + 2611, + 2612, + 2613, + 2614, + 2615, + 2618, + 2619, + 2620, + 2621, + 2622, + 2625, + 2626, + 2627, + 2628, + 2629, + 2630, + 2631, + 2632, + 2633, + 2634, + 2635, + 2636, + 2637, + 2648, + 2649, + 2654, + 2665, + 2666, + 2667, + 2668, + 2669, + 2670, + 2671, + 2672, + 2673, + 2674, + 2675, + 2676, + 2677, + 2678, + 2679, + 2680, + 2682, + 2683, + 2684, + 2685, + 2691, + 2692, + 2693, + 2699, + 2700, + 2701, + 2704, + 2705, + 2708, + 2709, + 2723, + 2724, + 2725, + 2726, + 2727, + 2738, + 2739, + 2744, + 2749, + 2756, + 2757, + 2758, + 2759, + 2760, + 2761, + 2762, + 2763, + 2764, + 2765, + 2766, + 2767, + 2768, + 2769, + 2770, + 2771, + 2772, + 2773, + 2774, + 2775, + 2776, + 2777, + 2778, + 2779, + 2780, + 2781, + 2782, + 2783, + 2784, + 2787, + 2789, + 2790, + 2799, + 2800, + 2807, + 2808, + 2814, + 2815, + 2819, + 2827, + 2830, + 2835, + 2840, + 2841, + 2843, + 2844, + 2845, + 2846, + 2847, + 2848, + 2849, + 2850, + 2851, + 2852, + 2853, + 2854, + 2855, + 2856, + 2857, + 2858, + 2859, + 2860, + 2861, + 2862, + 2863, + 2864, + 2865, + 2866, + 2867, + 2868, + 2869, + 2870, + 2871, + 2872, + 2873, + 2874, + 2875, + 2876, + 2878, + 2885, + 2889, + 2890, + 2900, + 2906, + 2907, + 2909, + 2911, + 2914, + 2915, + 2916, + 2917, + 2918, + 2919, + 2920, + 2921, + 2922, + 2923, + 2924, + 2925, + 2926, + 2927, + 2928, + 2929, + 2930, + 2931, + 2932, + 2933, + 2934, + 2935, + 2936, + 2937, + 2938, + 2939, + 2940, + 2941, + 2942, + 2943, + 2944, + 2953, + 2955, + 2958, + 2960, + 2961, + 2962, + 2963, + 2964, + 2965, + 2966, + 2967, + 2968, + 2969, + 2970, + 2971, + 2972, + 2973, + 2974, + 2975, + 2976, + 2977, + 2978, + 2979, + 2980, + 2984, + 2985, + 2986, + 2987, + 2988, + 2989, + 2990, + 2991, + 2992, + 2993, + 2994, + 2997, + 2998, + 2999, + 3000, + 3001, + 3003, + 3004, + 3005, + 3006, + 3007, + 3008, + 3009, + 3010, + 3011, + 3012, + 3013, + 3014, + 3015, + 3016, + 3017, + 3018, + 3019, + 3020, + 3021, + 3022, + 3023, + 3024, + 3025, + 3026, + 3029, + 3030, + 3031, + 3032, + 3033, + 3035, + 3036, + 3037, + 3038, + 3039, + 3040, + 3041, + 3042, + 3043, + 3044, + 3045, + 3046, + 3047, + 3048, + 3049, + 3050, + 3051, + 3052, + 3053, + 3054, + 3055, + 3056, + 3085, + 3086, + 3087, + 3088, + 3089, + 3090, + 3091, + 3092, + 3093, + 3094, + 3095, + 3096, + 3097, + 3098, + 3099, + 3100, + 3101, + 3102, + 3123, + 3124, + 3125, + 3126, + 3127, + 3128, + 3129, + 3130, + 3131, + 3132, + 3133, + 3134, + 3139, + 3140, + 3141, + 3142, + 3143, + 3144, + 3145, + 3146, + 3147, + 3148, + 3153, + 3154, + 3155, + 3156, + 3157, + 3158, + 3159, + 3160, + 3161, + 3162, + 3163, + 3164, + 3165, + 3166, + 3167, + 3168, + 3169, + 3170, + 3171, + 3172, + 3173, + 3174, + 3175, + 3176, + 3177, + 3178, + 3199, + 3200, + 3201, + 3202, + 3211, + 3212, + 3233, + 3234, + 3235, + 3236, + 3237, + 3238, + 3239, + 3240, + 3241, + 3242, + 3243, + 3244, + 3245, + 3246, + 3247, + 3248, + 3249, + 3250, + 3251, + 3252, + 3253, + 3254, + 3255, + 3256, + 3257, + 3258, + 3259, + 3260, + 3261, + 3262, + 3263, + 3264, + 3265, + 3268, + 3269, + 3270, + 3271, + 3272, + 3273, + 3274, + 3275, + 3276, + 3287, + 3288, + 3289, + 3290, + 3291, + 3292, + 3293, + 3304, + 3305, + 3306, + 3307, + 3308, + 3309, + 3310, + 3315, + 3316, + 3317, + 3318, + 3323, + 3324, + 3325, + 3326, + 3327, + 3354, + 3355, + 3356, + 3357, + 3358, + 3359, + 3360, + 3361, + 3362, + 3363, + 3364, + 3379, + 3386, + 3387, + 3388, + 3389, + 3390, + 3399, + 3400, + 3409, + 3410, + 3411, + 3424, + 3425, + 3426, + 3427, + 3428, + 3429, + 3430, + 3431, + 3432, + 3433, + 3434, + 3435, + 3436, + 3437, + 3438, + 3439, + 3440, + 3441, + 3442, + 3443, + 3444, + 3445, + 3446, + 3447, + 3448, + 3449, + 3450, + 3451, + 3452, + 3453, + 3454, + 3455, + 3456, + 3457, + 3458, + 3459, + 3460, + 3461, + 3462, + 3463, + 3464, + 3465, + 3466, + 3467, + 3468, + 3469, + 3470, + 3471, + 3472, + 3473, + 3474, + 3475, + 3476, + 3477, + 3478, + 3479, + 3480, + 3481, + 3482, + 3483, + 3484, + 3485, + 3490, + 3491, + 3492, + 3495, + 3496, + 3497, + 3498, + 3499, + 3513, + 3518, + 3519, + 3520, + 3521, + 3522, + 3535, + 3536, + 3537, + 3538, + 3539, + 3546, + 3551, + 3552, + 3553, + 3554, + 3555, + 3562, + 3563, + 3564, + 3571, + 3578, + 3581, + 3582, + 3587, + 3588, + 3589, + 3598, + 3599, + 3600, + 3609, + 3610, + 3611, + 3612, + 3613, + 3616, + 3617, + 3618, + 3619, + 3620, + 3621, + 3622, + 3623, + 3624, + 3625, + 3626, + 3627, + 3628, + 3629, + 3630, + 3631, + 3632, + 3633, + 3634, + 3635, + 3636, + 3637, + 3638, + 3639, + 3640, + 3641, + 3642, + 3643, + 3644, + 3645, + 3646, + 3647, + 3648, + 3649, + 3650, + 3651, + 3652, + 3653, + 3654, + 3655, + 3656, + 3657, + 3658, + 3659, + 3660, + 3661, + 3662, + 3663, + 3664, + 3665, + 3666, + 3667, + 3668, + 3669, + 3670, + 3671, + 3672, + 3673, + 3674, + 3675, + 3676, + 3677, + 3678, + 3679, + 3680, + 3681, + 3682, + 3683, + 3684, + 3685, + 3686, + 3687, + 3688, + 3689, + 3690, + 3691, + 3692, + 3693, + 3696, + 3697, + 3709, + 3714, + 3715, + 3716, + 3721, + 3724, + 3725, + 3726, + 3727, + 3728, + 3737, + 3742, + 3747, + 3750, + 3751, + 3752, + 3759, + 3764, + 3765, + 3766, + 3767, + 3768, + 3771, + 3772, + 3773, + 3776, + 3777, + 3778, + 3783, + 3784, + 3785, + 3786, + 3787, + 3788, + 3789, + 3790, + 3791, + 3792, + 3793, + 3794, + 3795, + 3796, + 3797, + 3798, + 3799, + 3800, + 3801, + 3802, + 3803, + 3804, + 3805, + 3806, + 3807, + 3808, + 3809, + 3810, + 3811, + 3812, + 3813, + 3814, + 3815, + 3816, + 3817, + 3818, + 3819, + 3820, + 3821, + 3822, + 3823, + 3824, + 3825, + 3826, + 3827, + 3828, + 3829, + 3830, + 3831, + 3832, + 3833, + 3834, + 3835, + 3836, + 3837, + 3838, + 3839, + 3840, + 3841, + 3842, + 3843, + 3844, + 3845, + 3846, + 3847, + 3848, + 3849, + 3850, + 3851, + 3852, + 3853, + 3854, + 3855, + 3856, + 3857, + 3858, + 3859, + 3860, + 3869, + 3872, + 3875, + 3878, + 3883, + 3884, + 3885, + 3886, + 3889, + 3890, + 3891, + 3894, + 3897, + 3898, + 3899, + 3902, + 3903, + 3904, + 3905, + 3906, + 3907, + 3908, + 3909, + 3910, + 3911, + 3912, + 3913, + 3914, + 3915, + 3916, + 3917, + 3918, + 3919, + 3920, + 3921, + 3922, + 3923, + 3924, + 3925, + 3926, + 3927, + 3928, + 3929, + 3930, + 3931, + 3932, + 3933, + 3934, + 3935, + 3936, + 3937, + 3938, + 3939, + 3940, + 3941, + 3942, + 3943, + 3944, + 3945, + 3946, + 3947, + 3948, + 3949, + 3950, + 3951, + 3952, + 3953, + 3954, + 3955, + 3956, + 3957, + 3958, + 3959, + 3960, + 3961, + 3965, + 3968, + 3971, + 3972, + 3973, + 3974, + 3975, + 3976, + 3977, + 3978, + 3979, + 3980, + 3981, + 3982, + 3983, + 3984, + 3985, + 3986, + 3987, + 3988, + 3989, + 3990, + 3991, + 3992, + 3993, + 3994, + 3995, + 3996, + 3997, + 4020, + 4021, + 4022, + 4023, + 4024, + 4025, + 4026, + 4027, + 4028, + 4029, + 4030, + 4061, + 4062, + 4063, + 4064, + 4065, + 4066, + 4067, + 4068, + 4069, + 4070, + 4071, + 4072, + 4073, + 4074, + 4075, + 4076, + 4077, + 4078, + 4079, + 4080, + 4081, + 4082, + 4083, + 4084, + 4085, + 4086, + 4087, + 4088, + 4089, + 4090, + 4091, + 4092, + 4093, + 4094, + 4095, + 4096, + 4097, + 4098, + 4099, + 4100, + 4101, + 4102, + 4103, + 4104, + 4105, + 4106, + 4111, + 4112, + 4113, + 4114, + 4115, + 4116, + 4117, + 4118, + 4119, + 4120, + 4121, + 4122, + 4125, + 4126, + 4127, + 4128, + 4129, + 4130, + 4131, + 4132, + 4133, + 4134, + 4135, + 4136, + 4137, + 4138, + 4139, + 4140, + 4141, + 4142, + 4143, + 4144, + 4145, + 4146, + 4147, + 4148, + 4149, + 4150, + 4151, + 4152, + 4153, + 4154, + 4155, + 4156, + 4157, + 4158, + 4159, + 4160, + 4161, + 4162, + 4163, + 4164, + 4165, + 4166, + 4167, + 4168, + 4169, + 4170, + 4171, + 4172, + 4173, + 4174, + 4175, + 4176, + 4177, + 4178, + 4179, + 4180, + 4181, + 4182, + 4183, + 4184, + 4185, + 4186, + 4187, + 4188, + 4189, + 4190, + 4191, + 4192, + 4193, + 4194, + 4195, + 4196, + 4197, + 4198, + 4199, + 4200, + 4201, + 4202, + 4203, + 4204, + 4205, + 4206, + 4207, + 4208, + 4209, + 4210, + 4211, + 4212, + 4213, + 4214, + 4215, + 4216, + 4217, + 4218, + 4219, + 4220, + 4221, + 4222, + 4223, + 4224, + 4225, + 4226, + 4227, + 4228, + 4229, + 4230, + 4231, + 4232, + 4233, + 4234, + 4235, + 4236, + 4237, + 4238, + 4239, + 4240, + 4241, + 4242, + 4243, + 4244, + 4245, + 4246, + 4247, + 4248, + 4249, + 4250, + 4251, + 4252, + 4253, + 4254, + 4255, + 4256, + 4257, + 4258, + 4259, + 4260, + 4261, + 4262, + 4263, + 4264, + 4265, + 4266, + 4267, + 4268, + 4269, + 4270, + 4271, + 4272, + 4273, + 4274, + 4275, + 4276, + 4277, + 4278, + 4279, + 4280, + 4281, + 4282, + 4283, + 4284, + 4285, + 4286, + 4287, + 4288, + 4289, + 4290, + 4291, + 4292, + 4293, + 4294, + 4295, + 4296, + 4297, + 4298, + 4299, + 4300, + 4301, + 4302, + 4303, + 4304, + 4305, + 4306, + 4307, + 4308, + 4309, + 4310, + 4311, + 4312, + 4313, + 4314, + 4315, + 4316, + 4317, + 4318, + 4319, + 4320, + 4321, + 4322, + 4323, + 4324, + 4325, + 4326, + 4327, + 4328, + 4329, + 4330, + 4331, + 4332, + 4333, + 4334, + 4335, + 4336, + 4337, + 4338, + 4339, + 4340, + 4341, + 4342, + 4343, + 4344, + 4345, + 4346, + 4347, + 4348, + 4349, + 4350, + 4351, + 4352, + 4353, + 4354, + 4355, + 4356, + 4357, + 4358, + 4359, + 4360, + 4361, + 4362, + 4363, + 4364, + 4365, + 4366, + 4367, + 4368, + 4369, + 4370, + 4371, + 4372, + 4373, + 4374, + 4375, + 4376, + 4377, + 4378, + 4379, + 4380, + 4381, + 4382, + 4383, + 4384, + 4385, + 4386, + 4387, + 4388, + 4389, + 4390, + 4391, + 4392, + 4393, + 4394, + 4395, + 4396, + 4397, + 4398, + 4399, + 4400, + 4401, + 4402, + 4403, + 4404, + 4405, + 4406, + 4407, + 4408, + 4409, + 4410, + 4411, + 4412, + 4413, + 4414, + 4415, + 4416, + 4417, + 4418, + 4419, + 4420, + 4421, + 4422, + 4423, + 4424, + 4425, + 4426, + 4427, + 4428, + 4429, + 4430, + 4431, + 4432, + 4433, + 4434, + 4435, + 4436, + 4437, + 4438, + 4439, + 4440, + 4441, + 4442, + 4443, + 4444, + 4445, + 4446, + 4447, + 4448, + 4449, + 4450, + 4451, + 4452, + 4453, + 4454, + 4455, + 4456, + 4457, + 4458, + 4459, + 4460, + 4461, + 4462, + 4463, + 4464, + 4465, + 4466, + 4467, + 4468, + 4469, + 4470, + 4471, + 4472, + 4473, + 4474, + 4475, + 4476, + 4477, + 4478, + 4479, + 4480, + 4481, + 4482, + 4483, + 4484, + 4485, + 4486, + 4487, + 4488, + 4489, + 4490, + 4491, + 4492, + 4493, + 4494, + 4495, + 4496, + 4497, + 4498, + 4499, + 4500, + 4501, + 4502, + 4503, + 4504, + 4505, + 4506, + 4507, + 4508, + 4509, + 4510, + 4511, + 4512, + 4513, + 4514, + 4515, + 4516, + 4517, + 4518, + 4519, + 4520, + 4521, + 4522, + 4523, + 4524, + 4525, + 4526, + 4527, + 4528, + 4529, + 4530, + 4531, + 4532, + 4533, + 4534, + 4535, + 4536, + 4537, + 4538, + 4539, + 4540, + 4541, + 4542, + 4543, + 4544, + 4545, + 4546, + 4547, + 4548, + 4549, + 4550, + 4551, + 4552, + 4553, + 4554, + 4555, + 4556, + 4557, + 4558, + 4559, + 4560, + 4561, + 4562, + 4563, + 4564, + 4565, + 4566, + 4567, + 4568, + 4569, + 4570, + 4571, + 4572, + 4573, + 4574, + 4575, + 4576, + 4577, + 4578, + 4579, + 4580, + 4581, + 4582, + 4583, + 4584, + 4585, + 4586, + 4587, + 4588, + 4589, + 4590, + 4591, + 4593, + 4596, + 4597, + 4598, + 4600, + 4601, + 4602, + 4604, + 4605, + 4606, + 4610, + 4611, + 4615, + 4619, + 4620, + 4621, + 4626, + 4627, + 4631, + 4635, + 4636, + 4637, + 4639, + 4640, + 4641, + 4645, + 4649, + 4650, + 4651, + 4652, + 4655, + 4656, + 4661, + 4662, + 4664, + 4665, + 4666, + 4667, + 4670, + 4671, + 4672, + 4673, + 4678, + 4679, + 4680, + 4681, + 4690, + 4691, + 4692, + 4693, + 4696, + 4697, + 4698, + 4700, + 4702, + 4704, + 4706, + 4707, + 4709, + 4711, + 4714, + 4715, + 4717, + 4719, + 4721, + 4723, + 4725, + 4726, + 4728, + 4729, + 4730, + 4731, + 4732, + 4733, + 4740, + 4741, + 4748, + 4749, + 4750, + 4751, + 4756, + 4757, + 4758, + 4759, + 4760, + 4761, + 4765, + 4766, + 4767, + 4774, + 4775, + 4776, + 4777, + 4778, + 4779, + 4780, + 4781, + 4782, + 4786, + 4787, + 4788, + 4789, + 4790, + 4791, + 4792, + 4793, + 4794, + 4798, + 4799, + 4800, + 4801, + 4802, + 4803, + 4804, + 4805, + 4806, + 4816, + 4817, + 4818, + 4819, + 4820, + 4821, + 4831, + 4832, + 4833, + 4843, + 4844, + 4845, + 4846, + 4847, + 4848, + 4849, + 4850, + 4851, + 4864, + 4865, + 4866, + 4867, + 4868, + 4869, + 4879, + 4880, + 4881, + 4891, + 4892, + 4893, + 4894, + 4895, + 4896, + 4897, + 4898, + 4899, + 4903, + 4904, + 4905, + 4906, + 4907, + 4908, + 4909, + 4910, + 4911, + 4921, + 4922, + 4923, + 4933, + 4934, + 4935, + 4936, + 4937, + 4938, + 4939, + 4941, + 4942, + 4944, + 4945, + 4946, + 4947, + 4948, + 4949, + 4950, + 4957, + 4958, + 4959, + 4960, + 4961, + 4962, + 4975, + 4976, + 4977, + 4978, + 4979, + 4980, + 4984, + 4985, + 4986, + 4987, + 4988, + 4989, + 4990, + 4991, + 4993, + 4995, + 4997, + 4999, + 5001, + 5002, + 5004, + 5006, + 5009, + 5010, + 5012, + 5014, + 5016, + 5018, + 5020, + 5021, + 5022, + 5023, + 5024, + 5027, + 5028, + 5033, + 5034, + 5036, + 5037, + 5038, + 5039, + 5042, + 5043, + 5044, + 5045, + 5046, + 5047, + 5054, + 5055, + 5062, + 5063, + 5064, + 5065, + 5070, + 5071, + 5072, + 5075, + 5076, + 5081, + 5082, + 5084, + 5085, + 5087, + 5088, + 5089, + 5090, + 5093, + 5094, + 5095, + 5099, + 5100, + 5104, + 5105, + 5106, + 5108, + 5109, + 5113, + 5114, + 5115, + 5118, + 5121, + 5122, + 5126, + 5130, + 5131, + 5132, + 5134, + 5135, + 5136, + 5140, + 5144, + 5145, + 5150, + 5151, + 5152, + 5156, + 5160, + 5161, + 5165, + 5166, + 5167, + 5169, + 5170, + 5171, + 5173, + 5174, + 5175, + 5178, + 5180, + 5181, + 5184, + 5185, + 5186, + 5189, + 5191, + 5192, + 5193, + 5194, + 5197, + 5198, + 5199, + 5203, + 5204, + 5208, + 5209, + 5210, + 5212, + 5213, + 5217, + 5218, + 5219, + 5222, + 5225, + 5226, + 5230, + 5234, + 5235, + 5236, + 5238, + 5239, + 5240, + 5244, + 5248, + 5249, + 5254, + 5255, + 5256, + 5260, + 5264, + 5265, + 5269, + 5270, + 5271, + 5273, + 5274, + 5275, + 5277, + 5278, + 5279, + 5282, + 5284, + 5285, + 5288, + 5289, + 5290, + 5293, + 5294, + 5295, + 5296, + 5297, + 5298, + 5299, + 5300, + 5301, + 5302, + 5303, + 5304, + 5305, + 5306, + 5307, + 5308, + 5309, + 5310, + 5311, + 5312, + 5313, + 5314, + 5315, + 5316, + 5317, + 5318, + 5319, + 5320, + 5321, + 5322, + 5323, + 5324, + 5325, + 5326, + 5327, + 5328, + 5329, + 5330, + 5331, + 5332, + 5333, + 5334, + 5335, + 5336, + 5337, + 5338, + 5339, + 5340, + 5341, + 5342, + 5343, + 5344, + 5345, + 5346, + 5347, + 5348, + 5349, + 5350, + 5351, + 5352, + 5353, + 5354, + 5355, + 5356, + 5357, + 5358, + 5359, + 5360, + 5361, + 5362, + 5363, + 5364, + 5365, + 5366, + 5367, + 5368, + 5369, + 5370, + 5371, + 5372, + 5373, + 5374, + 5375, + 5376, + 5377, + 5378, + 5379, + 5380, + 5381, + 5382, + 5383, + 5384, + 5385, + 5386, + 5387, + 5388, + 5389, + 5390, + 5391, + 5392, + 5393, + 5394, + 5395, + 5396, + 5397 + ], + "schema_version": 1 +} diff --git a/research/p104-inplace-entrance/PROOF.md b/research/p104-inplace-entrance/PROOF.md new file mode 100644 index 0000000000..b5474f06b6 --- /dev/null +++ b/research/p104-inplace-entrance/PROOF.md @@ -0,0 +1,188 @@ +# An in-place completion at the actual P104 entrance + +Clear1nsight, with substantial OpenAI assistance. New material is Apache-2.0; +predecessor authorship and notices remain in force. + +## Statement and source boundary + +The supplied program replaces the omitted part of the pinned 5,398-event P104 +word by a 1,238-operation entrance program, followed by the unchanged +4,027-event projection. It has the same complete physical endpoint map, +including arbitrary admitted dirty offsets and all 358 final frames. The +result closes a chronological, common-frame access obligation. It does not +establish a complete physical supplier or a new multiplication exponent. + +The projection is credited to [PR #3446](https://github.com/CrocSwap/integer-mult-bounds/pull/3446), +Hiroki Kumazaki; the rank-eight residual and integer factorization to +[PR #3462](https://github.com/CrocSwap/integer-mult-bounds/pull/3462), Nick Petalas; +and the endpoint-adapter construction to +[PR #3469](https://github.com/CrocSwap/integer-mult-bounds/pull/3469), Nick Petalas. +Their exact retained sources, the original WORD/native lineage, and executable +dependencies are bound in [SOURCES.json](SOURCES.json). + +The method of using dirty outputs as accumulators while restoring modified +inputs is general: see Jean-Guillaume Dumas and Bruno Grenet, +[In-place accumulation of fast multiplication formulae](https://arxiv.org/abs/2307.12712), +ISSAC 2024. The contribution here is its source-bound P104 realization and bill, +not that general accumulation principle or the predecessor factorization. + +## 1. Why the correction can move to the entrance + +Let $J_f$ denote the retained Delta chart of frame $f$. Work first with +chart-normalized public fields: the physical value of normalized $z$ in frame +$f$ is $J_fz$. Let $W$ be the original normalized endpoint operator and $S$ +the normalized operator of the projection. The source reconstruction proves + +$$ +W=S+K,\qquad K_{X,Y}=\frac12 CA, +$$ + +where $A$ has eight rows and 104 Y columns, and $C$ has 52 X rows and eight +columns. Every other block of $K$ is zero. + +The dependency reconstruction retains exactly the predecessor's event-index +digest. Every retained event neither reads nor writes any of the 93 omitted +public banks. Consequently $S$ acts identically on them and has no dependence +on their initial values in its other outputs. It also preserves every +normalized Y field. Since the image of $K$ lies in the omitted X banks and +$K$ reads only Y, + +$$ +SK=KS=K,\qquad K^2=0,\qquad W=S(I+K)=(I+K)S. +$$ + +These equalities concern the normalized operators. Physical frames are still +owed. At the actual entrance all Y banks are in the empty frame. The new +prefix computes $I+K$ there and delivers all 93 omitted banks in their required +full frame + +$$F=[256,128,64,32,16,8,4,2,1].$$ + +It restores every retained public field to its identical entrance value and +frame. Thus the original retained trace executes from exactly its original +state, including its eight private lifetimes. Its disjointness makes the +already completed omitted banks irrelevant to that trace. + +## 2. Dirty-output accumulation and source return + +Use the following ordered eight pivot X banks: + +```text +X0, X33, X101, X102, X11, X12, X15, X24. +``` + +The actual rows of $C$ on these banks are $I_8$. Write their values as $x_P$, +and the other 44 X values as $x_T$. First move all 52 X banks from their +actual singleton entrance frames to the empty frame. Then perform + +$$ +x_T\leftarrow x_T-C_Tx_P,\qquad +x_P\leftarrow x_P+\frac12 AY,\qquad +x_T\leftarrow x_T+C_Tx_P. +$$ + +The entire first stage precedes every gather. The last stage uses the updated +pivots, so its result is +$x_T-C_Tx_P+C_T(x_P+AY/2)=x_T+C_TAY/2$. +The pivots themselves have their required updates because $C_P=I_8$. +No dirty value is assumed zero or discarded. + +For each active Y column, halve that bank once, execute its signed unit ADDs +into the eight pivots, then double it immediately. This realizes coefficients +of magnitude two by repeated unit ADDs and returns the source before advancing +to the next column. Exactly 103 columns are active. Y1 is unused by this +correction but remains live and is used by the retained projection. + +Finally move all 52 X and the other 41 omitted banks from empty to $F$. +The latter are 38 N banks and G2, G3, G9; they retain their normalized dirty +values. Sources and outputs have distinct physical roles. The prefix needs +temporarily writable, restored Y access and no additional Gaussian bank. +Arithmetic registers, monomial workspace, routing and controllers still need +their own implementations. + +## 3. The new native maps include their phases + +There are 52 actual singleton-to-empty maps of rank one and a shared +empty-to-full map of rank nine, used 93 times. Each requested map is +$J_{\rm new}J_{\rm old}^{-1}$. The pinned compiler synthesizes its affine +quadratic-phase monomials and positive native child. + +The separately written PR #3416 checker compares each of the 53 distinct +recipes with the direct canonical-chart expression. It checks all 18 signed +Pauli actions and a complete 512-entry exact Gaussian-dyadic anchor. Equality +of the signed actions makes the ratio commute with all binary X and Z: +commutation with Z makes it diagonal, and commutation with X makes it scalar. +The nonzero anchor fixes that scalar to one. This covers global phase as well +as address action. An extra-$i$ control specifically fails the anchor check. + +An additional elimination computes the requested B-block rank, and separately +enumerated monomial maps agree with the checker's maps. These are 53 new-map +certificates; the historical 1,245-class native census is inherited, not +reexecuted. The common rank-nine recipe also matches PR #3469's retained +certificate. Total new native work is 145 calls, rank mass 889, and 227,584 +Gaussian pairs in the fixed 512-coordinate model. + +## 4. Exactness domains and the universal implication + +Put $R=\mathbb Z[i]$, $\pi=1+i$, and + +$$B_9=E_9R^{512},\qquad +E_9=\begin{pmatrix}1&0\\1&\pi\end{pmatrix}^{\otimes9}.$$ + +The pinned [PR #3382](https://github.com/CrocSwap/integer-mult-bounds/pull/3382) +module lemmas and [PR #3416](https://github.com/CrocSwap/integer-mult-bounds/pull/3416) +covariance theorem supply the chart/native interpretation. Their admitted +monomials and native coordinate factors preserve $B_9$; on this domain the +literal signed-floor pairs equal their integral ideal pairs. + +Locally, all 93 physical dirty inputs may lie in $B_9$, and all 104 Y inputs +must lie in $4B_9$. Inverse entrance charts preserve the dirty domain. +Temporary Y halves lie in $2B_9$; integer ADDs preserve $B_9$; subsequent +charts therefore have exact literal executions. The halves are exact also +for negative components. + +For a common sufficient domain of the complete old and new programs, require +all 104 Y banks in $4B_9$, all 78 N banks in $2B_9$, and the other 176 public +banks in $B_9$. This stronger domain is not claimed minimal. Assign one +independent $B_9$ symbol to each normalized entrance bank, with weights +respectively four, two and one. The exact rational row interpreter checks +that every fractional ADD increment and every resulting state has integer +symbol coefficients, throughout both programs. Every private erasure has +the zero symbolic row. This induction, together with the pinned native +lemmas, proves universal literal admission and equality. It checks 128,164 +final matrix entries and all 358 final frames. Weakening N100 alone fails the +increment condition at original event 312. + +## 5. Finite evidence, costs and limits + +The independent physical engine imports no candidate or predecessor executable. +It reconstructs charts directly, executes the serialized 1,238-operation +prefix on one dense signed fixture, checks all 227,584 completed floor pairs, +and compares all 93 dirty outputs and 104 returned Y arrays. This finite +fixture complements the universal symbolic and native arguments; it does not +replace them. + +The prefix has 887 unit Gaussian ADD/SUBs, 103 field halves and 103 field +doublings. Its local native tariff is $52+93\,9^s$. For $0\le s\le1$, +concavity gives + +$$r^s\ge1+(r-1)(9^s-1)/8\quad(1\le r\le9).$$ + +The original omitted 473 calls have rank mass 889, hence tariff at least +$421+52\,9^s$. The local improvement is therefore at least +$41(9-9^s)>0$ for $0\le s<1$, with equal mass at $s=1$. +The changed full profile nevertheless misses the selected target under the +explicit favorable complete-consumer screen in [COSTS.md](COSTS.md). + +The finite engine caps input magnitude at 8,192 bits and stored work at +8,224 bits. Observed peaks concern fields after complete program operations, +not native-pair temporaries. Let $H_X$ bound X components after entering the +empty frame and $H_Y$ bound the actual unhalved Y components. The scalar-row +envelope, derived and checked in COSTS, is + +$$\max\{8H_X+95H_Y,\;11H_X+64H_Y,\;12H_X+49H_Y,\;14H_X\}.$$ + +It is at most $103H$ for $H=\max(H_X,H_Y)$. Adapter and temporary headroom +are separate obligations. Python verification allocations do not establish +physical workspace, precision, access, all-size recursion or a fully paid bill. +Stop at this exact local interface and retain the stated consumer obstruction. diff --git a/research/p104-inplace-entrance/README.md b/research/p104-inplace-entrance/README.md new file mode 100644 index 0000000000..8eb6a0e836 --- /dev/null +++ b/research/p104-inplace-entrance/README.md @@ -0,0 +1,152 @@ +# An in-place entrance completion for the actual P104 projection + +The omitted P104 completion can execute at the original WORD entrance using +eight existing dirty output banks as accumulators. The new prefix supplies +the required output frames, restores every temporarily modified Y source, +and needs no additional Gaussian query bank. Follow it by the exact PR3446 +projection to obtain the original word's complete endpoint map. + +The omitted section changes from **473 native calls to 145**, at the same +rank mass **889**. Its native power tariff strictly improves for every +exponent `0 <= s < 1`. This is a local result. The resulting full dual profile +still rejects the selected target under the inherited five-forward/four-dual +consumer, even before its other nonnegative charges. The decision is to +retain the local interface and **pause dependent supplier construction within +that consumer model**. No selected-frontier update is proposed. + +## What is new + +[PR3462](https://github.com/CrocSwap/integer-mult-bounds/pull/3462) already +establishes the residual factorisation `R=CA/2`, its rank eight, and an abstract +dirty-helper completion. [PR3469](https://github.com/CrocSwap/integer-mult-bounds/pull/3469) +already supplies isolated omitted-bank endpoint adapters. This package binds +scalar acquisition to the original common empty frame, uses required output +storage in place of a private query bank, and interleaves exact native maps +with a concrete restored-source schedule. + +The mathematical idea comes from Dumas and Grenet's +[In-place accumulation of fast multiplication formulae](https://arxiv.org/abs/2307.12712), +ISSAC 2024. Their general accumulation method is credited, rather than claimed +as new. The P104 contribution is its source-specific placement, exact Gaussian +domain, native phases, dirty compensation, and consumer-budget consequence. + +The eight pivot outputs are `X0, X33, X101, X102, X11, X12, X15, X24`. +Their rows of C form the identity. For basis dirt b and other output dirt n, +the scalar section performs + +\[ +n\leftarrow n-C_Nb,\qquad b\leftarrow b+AY/2,\qquad n\leftarrow n+C_Nb. +\] + +The final step uses the updated basis, so the dirt cancels correctly. The +whole pre-subtraction finishes before any basis update. Each of 103 active Y +fields is halved, used for its A column, and immediately doubled back. Y1 is +unused by this prefix, but remains required by the projection. + +## Exact scope + +The local prefix accepts the 93 omitted physical fields in B9 and all 104 Y +fields in 4B9, with their actual WORD entrance frames. Y must be temporarily +writable. Every Y returns in its entrance frame before the retained word +starts; all 93 outputs reach the required full final frame. The eight basis +banks are updated outputs, not borrowed helpers required to keep their +original contents. + +For a common sufficient domain on which both complete programs execute +literally and exactly, take **104 Y fields in 4B9, all 78 N fields in 2B9, +and the other 176 public fields in B9**. This is not a minimal-domain claim. +The symbolic verifier proves every scalar increment is a B9 combination of +independent input variables and every private erasure is zero. With the +pinned PR3382 module and PR3416 native-covariance lemmas, this gives an +arbitrary-input implication on that product domain. The finite physical +fixture independently checks the new prefix; it does not rerun all +historical native correctness proofs. + +`PROGRAM.json` contains the 1,238-operation prefix and 4,027 retained original +event indices. `NATIVE.json` contains its 53 distinct native recipes. Normal +verification reads and checks both exported artifacts, including their +agreement with regeneration, and executes the published schedule. + +## Evidence and reproduction + +Run from the repository root with Python 3.12 and no third-party packages. + +```sh +python3.12 -B scripts/research_package.py --package research/p104-inplace-entrance +``` + +| Check | Coverage | +|---|---| +| Full symbolic endpoint comparison | All 128,164 coefficients of the 358-field map and all 358 final frames | +| Projection reconstruction | Separate graph and bitset implementations, 4,027 events, no omitted-bank reads or writes | +| New native certification | 53 maps, signed Pauli images, exact global-phase anchors, independent wrapper enumeration, and minimal ranks | +| Independent literal physical fixture | 93 dirty outputs plus 104 restored Y fields, all 100,864 Gaussian coordinates compared before hashes | +| Literal native arithmetic | 145 calls and 227,584 completed signed-floor pairs, each compared with its integral ideal output | +| Negative controls | Dirty preconditioning, source restoration, N100/Y1 divisibility, odd halves, module entrance, and wrong native phase | +| Cost implications | Exact native/scalar inventories, scalar width envelope, concavity comparison, and rational consumer rejection | + +The complementary implementations are `primary.py`, `native.py`, +`physical.py`, and `invoice.py`. The compiler and separate Pauli/phase checker +are authenticated predecessor inputs. The physical and invoice engines import +no predecessor executable. `verify.py` captures source and implementation +bytes, rejects typed artifact drift, compares full arrays, and checks that +inputs remain unchanged. Normal and optimised replay are registered. + +See [PROOF.md](PROOF.md), [COSTS.md](COSTS.md), and [RECEIPT.json](RECEIPT.json) +for the derivation and exact evidence. Timings are not proof fields. +Proof-assistant verification and independent human acceptance are unclaimed. + +## Decision and alternatives + +A simple clean-query entrance alternative would keep the 52 direct rank-eight +X maps, finish 41 other outputs, and take eight query fields from empty to full +and back. Its profile is `52H8 + (41 + 16)H9`, with rank mass 929, which is +40 above the omitted section. The dirty-output method avoids those query +return maps and preserves mass 889. It improves the local native tariff, but +the inherited consumer still fails its favourable relaxation. + +This changes the scalar network and the placement of native calls. It is +outside [PR3594](https://github.com/CrocSwap/integer-mult-bounds/pull/3594)'s +fixed four-read commuting-retiming family. It does not materialise the +coefficient caller left open by [PR3577](https://github.com/CrocSwap/integer-mult-bounds/pull/3577). +The actual caller here is the WORD entrance followed by PR3446's projection. + +## Open next questions + +1. Can a changed **complete consumer or coverage law** use this local word and + pass its own favourable cost screen? First supply a source-bound bill that + explicitly changes a failed assumption, including the replacement cost. + Actual owners, idle coverage, and finite widths remain blockers. +2. Can a changed scalar/native network reduce the remaining full dual tariff + enough to alter that decision? First price the complete proposed delta, + including source acquisition, return maps, and unchanged forward calls. + A more concentrated abstract histogram is not a realised replacement word. +3. Is there an independently specified caller that benefits after width, + routing, and monomial costs? First identify its actual physical banks, + entrance frames, allowed temporary writes, and required observables. The + local identity supplies no global ownership or all-size transfer theorem. + +These are reopening questions, not automatic follow-on implementation tasks. +Structured questions and the stopping rule are in [TASK.json](TASK.json). + +## Sources and credit + +Canonical scientific base is `20ecf2891d80b5acf18d980b2164fb44ea7faa90`, +priority revision 6. [SOURCES.json](SOURCES.json) pins the exact inputs and +historical task/selected record. All frozen predecessors remain unchanged. +The canonical investigation is +[Discussion 2750, comment 19014226](https://github.com/CrocSwap/integer-mult-bounds/discussions/2750#discussioncomment-19014226). + +Credit Nick Petalas's PR3462 factorisation and PR3469 adapters, Hiroki +KUMAZAKI's PR3446 projection, the PR3382/3416 exact-module and native proofs, +ywz65's PR2586 WORD, and their geometry, channel, compiler, and rounded +arithmetic predecessors. Credit Dumas and Grenet for the general in-place +accumulation method. Credit Jose Manuel's original Discussion 2619 budget +finding and Vasek's PR2744 source/coverage audit, retaining Ross Richardson's +PR2458 forward profile and the paired-chain coverage lineage. PR3554/3577 +supplied the assigned caller questions. No new rank-eight or lattice theorem +is claimed here. + +Prepared by Clear1nsight with substantial OpenAI assistance from a root agent +and three concurrent specialist agents. New work is Apache-2.0. Archival +retention, successful replay, and scientific supplier admission are distinct. diff --git a/research/p104-inplace-entrance/RECEIPT.json b/research/p104-inplace-entrance/RECEIPT.json new file mode 100644 index 0000000000..6faa5157f2 --- /dev/null +++ b/research/p104-inplace-entrance/RECEIPT.json @@ -0,0 +1,4120 @@ +{ + "SOURCES_sha256": "d160d608c2bd3b7d5470b268ac746ad604bbfcb9e0d41b3a29175c623ca33f5d", + "artifact_sha256": { + "NATIVE.json": "795a8c4e096a42a2f2c5875c354a4d4b56515cf8ffdfd5767a82713cf7f84dbd", + "PROGRAM.json": "608c5c66a6eb7af2fc75d32e2b353a8074a50ef0bdb848c7211c59f3b7a176e6" + }, + "dirty_controls": { + "compared_banks": 197, + "controls": [ + { + "all_Y_restored": true, + "control": "omit_precondition", + "differing_banks": [ + { + "bank": "X10", + "expected_multiple_of_u": "0", + "observed_multiple_of_u": "1" + }, + { + "bank": "X16", + "expected_multiple_of_u": "0", + "observed_multiple_of_u": "-1" + }, + { + "bank": "X17", + "expected_multiple_of_u": "0", + "observed_multiple_of_u": "-1" + }, + { + "bank": "X25", + "expected_multiple_of_u": "0", + "observed_multiple_of_u": "-1" + }, + { + "bank": "X26", + "expected_multiple_of_u": "0", + "observed_multiple_of_u": "-1" + }, + { + "bank": "X34", + "expected_multiple_of_u": "0", + "observed_multiple_of_u": "-1" + }, + { + "bank": "X37", + "expected_multiple_of_u": "0", + "observed_multiple_of_u": "1" + }, + { + "bank": "X41", + "expected_multiple_of_u": "0", + "observed_multiple_of_u": "1" + }, + { + "bank": "X47", + "expected_multiple_of_u": "0", + "observed_multiple_of_u": "-1" + }, + { + "bank": "X5", + "expected_multiple_of_u": "0", + "observed_multiple_of_u": "1" + }, + { + "bank": "X53", + "expected_multiple_of_u": "0", + "observed_multiple_of_u": "-1" + }, + { + "bank": "X57", + "expected_multiple_of_u": "0", + "observed_multiple_of_u": "-1" + }, + { + "bank": "X6", + "expected_multiple_of_u": "0", + "observed_multiple_of_u": "1" + }, + { + "bank": "X60", + "expected_multiple_of_u": "0", + "observed_multiple_of_u": "1" + }, + { + "bank": "X63", + "expected_multiple_of_u": "0", + "observed_multiple_of_u": "-1" + }, + { + "bank": "X69", + "expected_multiple_of_u": "0", + "observed_multiple_of_u": "-1" + }, + { + "bank": "X73", + "expected_multiple_of_u": "0", + "observed_multiple_of_u": "-1" + }, + { + "bank": "X76", + "expected_multiple_of_u": "0", + "observed_multiple_of_u": "1" + }, + { + "bank": "X82", + "expected_multiple_of_u": "0", + "observed_multiple_of_u": "-1" + }, + { + "bank": "X86", + "expected_multiple_of_u": "0", + "observed_multiple_of_u": "-1" + }, + { + "bank": "X91", + "expected_multiple_of_u": "0", + "observed_multiple_of_u": "-1" + }, + { + "bank": "X97", + "expected_multiple_of_u": "0", + "observed_multiple_of_u": "-1" + } + ], + "executed_program_operations": 991, + "input_multiples_of_u": { + "X11": 1 + }, + "status": "REJECTED_BY_OUTPUT" + }, + { + "all_Y_restored": true, + "control": "late_precondition", + "differing_banks": [ + { + "bank": "X16", + "expected_multiple_of_u": "-2", + "observed_multiple_of_u": "0" + }, + { + "bank": "X21", + "expected_multiple_of_u": "-2", + "observed_multiple_of_u": "0" + }, + { + "bank": "X25", + "expected_multiple_of_u": "-2", + "observed_multiple_of_u": "0" + }, + { + "bank": "X30", + "expected_multiple_of_u": "-2", + "observed_multiple_of_u": "0" + }, + { + "bank": "X38", + "expected_multiple_of_u": "-2", + "observed_multiple_of_u": "0" + }, + { + "bank": "X41", + "expected_multiple_of_u": "2", + "observed_multiple_of_u": "0" + }, + { + "bank": "X43", + "expected_multiple_of_u": "2", + "observed_multiple_of_u": "0" + }, + { + "bank": "X5", + "expected_multiple_of_u": "-2", + "observed_multiple_of_u": "0" + }, + { + "bank": "X51", + "expected_multiple_of_u": "-2", + "observed_multiple_of_u": "0" + }, + { + "bank": "X53", + "expected_multiple_of_u": "-2", + "observed_multiple_of_u": "0" + }, + { + "bank": "X56", + "expected_multiple_of_u": "2", + "observed_multiple_of_u": "0" + }, + { + "bank": "X61", + "expected_multiple_of_u": "-2", + "observed_multiple_of_u": "0" + }, + { + "bank": "X67", + "expected_multiple_of_u": "-2", + "observed_multiple_of_u": "0" + }, + { + "bank": "X69", + "expected_multiple_of_u": "-2", + "observed_multiple_of_u": "0" + }, + { + "bank": "X72", + "expected_multiple_of_u": "2", + "observed_multiple_of_u": "0" + }, + { + "bank": "X77", + "expected_multiple_of_u": "-2", + "observed_multiple_of_u": "0" + }, + { + "bank": "X82", + "expected_multiple_of_u": "-2", + "observed_multiple_of_u": "0" + }, + { + "bank": "X91", + "expected_multiple_of_u": "-2", + "observed_multiple_of_u": "0" + }, + { + "bank": "X97", + "expected_multiple_of_u": "-2", + "observed_multiple_of_u": "0" + } + ], + "executed_program_operations": 1238, + "input_multiples_of_u": { + "Y3": 4 + }, + "status": "REJECTED_BY_OUTPUT" + } + ], + "interpretation": "Normalized multiples of one B9 vector u; native charts omitted", + "oracle": "X_initial + C*A*Y_initial/2; all other banks unchanged", + "original_full_bank_oracle_matches": 2, + "original_program_operations": 1238, + "precondition_ADDs": 247, + "status": "PASS" + }, + "global_phase_control": "Altered scalar i rejected by exact global-phase anchor.", + "implementation_and_proof_sha256": { + "COSTS.md": "07768c7c42cfdb99f780e96423d13787ade1faefda66d44df9986da67a646e6c", + "PROOF.md": "e72a2a0a34ba1c3c226da1e99326ec14e2fb913a74788463bb7013aa8d4954af", + "README.md": "7a65c25d71acb7d8cc9752d0e220679857c05f9c43af93a953a463a1a04fe6b0", + "TASK.json": "6b5227217bda70e24efc9f2d99637dd0973421847d0e0c14586237a83cdc40be", + "VERIFY.json": "de8f0a49a154857ed0fbffeb4d4fc478a1496e0bfc1f9077c0747d8be2ac5efb", + "controls.py": "f5967b3627405efe453dfffa75f546f1e96e6c948d5ccbe5632697b4c8ad27d6", + "invoice.py": "8910efa1b0cbe803d3f47b9ed803b4584a9ff0065d704af4e2c59dfe07edfbee", + "native.py": "28b26fbfcd67008cfd1c158427755f48041ed5e20551c3dd97e96920f9d2838b", + "physical.py": "fc5c00d735a493ef97f978c473b433b12f4c02ee89ca99910570a11cd383931f", + "primary.py": "031660f98b56e703a7e5fe0fdbaafd5a188ecdd629cb74b2ec35208f86b2703f", + "verify.py": "856793b59bcef5d5ab0411e4e0ad17f0a42fc128303d72531c2025f74a01ed7d" + }, + "input_sha256": { + "LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "NOTICE": "b49022cb4104d90b182e4c335f670faf45529025b15db77bf0291835083c28bd", + "research/gmx-t74-borrow43-handoff/new/fastnative/NATIVE-LINEAGE-NOTICE": "ee0c73ca35877aad0e0b6adc560a3881cb82276dba4cf2d4fc58cd19e57cc420", + "research/gmx-t74-borrow43-handoff/new/fastnative/vendor/native/new/code/borrow/vendor/clifford/clifford_exact.py": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962", + "research/p104-consumer-budget-audit/README.md": "13694215d0c1a245b392f7155e8395b9c4bad9c5db3558833c784d9449616417", + "research/p104-native-channel/notices/FRAME-SA504-NOTICE.md": "a92f49c5ced455160fbedcc8954e3c9255e3605e88ad12ae5a84f1c4302986f1", + "research/p104-native-channel/notices/PR1862-NOTICE.md": "d86f31a4c0bafd4271fe0c0e087a7fc1cd72d5b705e3739c4ba3e9241b7ba3f9", + "research/p104-native-channel/notices/PR1972-NOTICE.md": "2d9c60fdeda14a8609f2b210fe0873ee0318788130637db9e5e79d487243ab7d", + "research/p104-omitted-completion/CERTIFICATE.json": "f68a2e6f3bd771b9692772909df200102350a80deda35532f3cc348b75d0c044", + "research/p104-omitted-frame-adapters/ADAPTERS.json": "db424edfb316f06f4913946b2b0cafa2f200b75392cacb35244b8705db02387c", + "research/p104-omitted-frame-adapters/inputs/ORIGINS.json": "c28888fb28c6c4defab5dd4b17150001d7435a6e7346a705ca0a266b67e1598c", + "research/p104-omitted-frame-adapters/inputs/PR3416_verify.py": "d9fa70e7feb0032048b84b7a3e63628d56b206030b2f6b6a5c001b470bb9d049", + "research/p104-rounded-collector/inputs/NATIVE.json.gz": "ab91c78835c3e10cf3b2cb8a5d4e0b7cfc3df1ae5a811298d27842f2193e1e3d", + "research/p104-rounded-collector/inputs/WORD.json": "cec1fb3fbd0067b500ad5119a62ba60685be718e769374d7ec8abdd2beaa7e50", + "research/p104-stagewise-entrance/inputs/PR3382_PROOF.md": "1ca8c0e7e78f0f39de6cff7accc68ccd3901bfb50759bf7a2e2896bcf63bf081", + "research/p104-stagewise-entrance/inputs/PR3416_PROOF.md": "0dc1c35158902299fc8748c8baf89205483562f041e9050580e6579c331ebeb5" + }, + "invoice": { + "changed_full": { + "coordinate_C_pairs": 906752, + "native_calls": 1742, + "native_profile": { + "1": 1316, + "2": 61, + "3": 74, + "4": 86, + "5": 33, + "6": 25, + "7": 46, + "8": 8, + "9": 93 + }, + "native_rank_mass": 3542, + "new_private_C_lifetimes": 0, + "original_private_C_lifetimes": 8, + "scalar_exact_half_and_double_change_each": 7168, + "scalar_exact_real_halves": 2757632, + "scalar_real_ADD_change": -488448, + "scalar_real_ADDs": 3969024, + "scalar_real_doublings": 2757632 + }, + "closure": { + "event_sha256": "66113bcd513a17eac24f43944a8759bdae1bb2a85e2b9900122f281c5c676dc8", + "events": 4027, + "inputs": 265, + "omitted_banks": 93, + "projection_reads_or_writes_omitted": false + }, + "conditional_consumer_stop": { + "W": 832, + "auxiliary_bank_scope": "every finite B>=0; fixed m, fully paid 73 units per added bank", + "dual_calls": 4, + "exp2_rational_upper": "134800213/18243225", + "exp4_rational_upper": "377139364267/6907548375", + "forgiven_profile": { + "1": 9680, + "2": 614, + "3": 726, + "4": 864, + "5": 372, + "6": 310, + "7": 524, + "8": 72, + "9": 372 + }, + "forgiven_rank_mass": 27854, + "forgiven_zero_saving_bound": "583/584", + "forward_calls": 5, + "fully_paid_B_lower_bound": "1 + (75068*a-104)/(73*(832+B))", + "kappa": "836330098538459/500000000000000000", + "linear_lower_slope": 75068, + "m": 73, + "no_bank_selected_lower_bound": "7594695406959271260053/7592000000000000000000", + "persistent_credit_per_call": 3014, + "rank_forgiveness_per_dual": 416, + "remaining_coverage_mass": 32778, + "remaining_hypotheses": [ + "unchanged forward profile", + "new dual decomposition fixed apart from allowed rank deletion", + "all other positive children rank<=73", + "coverage law and endpoint credit unchanged", + "all other charges nonnegative; source admission and ownership not supplied" + ], + "scope": "Conditional new fixed-profile substitution under the retained PR2744 five-forward/four-dual coverage assumptions; not a universal P104 barrier", + "slope_times_kappa_minus_104": "2695406959271260053/125000000000000000", + "unforgiven_zero_saving_bound": "599/584" + }, + "entrance_completion": { + "A_l1": 393, + "A_nonzeros": 385, + "C_nonbasis_l1": 247, + "C_nonbasis_nonzeros": 201, + "basis": [ + "X0", + "X33", + "X101", + "X102", + "X11", + "X12", + "X15", + "X24" + ], + "basis_identity_checked": true, + "exact_real_doublings": 105472, + "exact_real_halves": 105472, + "inactive_Y": [ + "Y1" + ], + "native_calls": 145, + "native_profile": { + "1": 52, + "9": 93 + }, + "native_rank_mass": 889, + "new_private_Gaussian_banks": 0, + "real_ADDs": 908288, + "schedule": "Xnonbasis-=C_N*Xbasis; Xbasis+=A*Y/2 by source columns; Xnonbasis+=C_N*Xbasis", + "temporarily_halved_restored_Y_banks": 103, + "unit_Gaussian_bank_ADDs": 887, + "weighted_ADDs": 787 + }, + "evidence_limits": "Exact symbolic structure, coefficient and rational tariff checks; no native matrix/rounded replay or full-word endpoint proof is performed by this module.", + "native_concavity_gain": { + "equal_mass": 889, + "majorization_prefixes_checked": 473, + "new_calls": 145, + "new_tariff": "52 + 93*9^s", + "old_calls": 473, + "old_minus_new_lower_bound": "41*(9-9^s)", + "old_tariff_lower_bound": "421 + 52*9^s", + "positive_sqrt_chord_control": { + "certified_gain_at_least": 246, + "new_exact": 331, + "old_lower": 577, + "s": "1/2" + }, + "prefix_difference_sha256": "4fd4aef216cbc83a4b9916b372ea77002c35d383765345ab422e27792997dbb5", + "scope": "Strict improvement for 0<=s<1; equality at s=1; native-only profile tariff, with monomials and all physical/outer charges separate" + }, + "native_occurrences_bound": 2070, + "not_priced": [ + "actual source preparation", + "monomial swaps and phases", + "native-pair temporary implementation", + "global ownership and routing", + "caller heights and widths", + "idle packing realization", + "recursive/all-size transfer", + "actual physical-machine runtime" + ], + "original_full": { + "coordinate_C_pairs": 906752, + "native_calls": 2070, + "native_profile": { + "1": 1632, + "2": 74, + "3": 86, + "4": 104, + "5": 48, + "6": 42, + "7": 76, + "8": 8 + }, + "native_rank_mass": 3542, + "operations": { + "add": 3104, + "erase": 8, + "sign": 208, + "transport": 2070, + "zero": 8 + }, + "scalar_exact_half_bank_passes": 2686, + "scalar_exact_real_halves": 2750464, + "scalar_real_ADDs": 4457472, + "scalar_source_restoring_real_doublings": 2750464, + "scalar_unit_Gaussian_bank_ADDs": 4353, + "weighted_ADD_coefficients": { + "-1": 258, + "-1/2": 95, + "-1/4": 714, + "-2": 642, + "1": 159, + "1/2": 95, + "1/4": 534, + "2": 607 + } + }, + "projection": { + "coordinate_C_pairs": 679168, + "native_calls": 1597, + "native_profile": { + "1": 1264, + "2": 61, + "3": 74, + "4": 86, + "5": 33, + "6": 25, + "7": 46, + "8": 8 + }, + "native_rank_mass": 2653, + "operations": { + "add": 2310, + "erase": 8, + "sign": 104, + "transport": 1597, + "zero": 8 + }, + "scalar_exact_half_bank_passes": 2590, + "scalar_exact_real_halves": 2652160, + "scalar_real_ADDs": 3060736, + "scalar_source_restoring_real_doublings": 2652160, + "scalar_unit_Gaussian_bank_ADDs": 2989, + "weighted_ADD_coefficients": { + "-1": 175, + "-1/2": 47, + "-1/4": 714, + "-2": 342, + "1": 114, + "1/2": 47, + "1/4": 534, + "2": 337 + } + }, + "removed_program": { + "coordinate_C_pairs": 227584, + "native_calls": 473, + "native_profile": { + "1": 368, + "2": 13, + "3": 12, + "4": 18, + "5": 15, + "6": 17, + "7": 30 + }, + "native_rank_mass": 889, + "operations": { + "add": 794, + "sign": 104, + "transport": 473 + }, + "scalar_exact_half_bank_passes": 96, + "scalar_exact_real_halves": 98304, + "scalar_real_ADDs": 1396736, + "scalar_source_restoring_real_doublings": 98304, + "scalar_unit_Gaussian_bank_ADDs": 1364, + "weighted_ADD_coefficients": { + "-1": 83, + "-1/2": 48, + "-2": 300, + "1": 45, + "1/2": 48, + "2": 270 + } + }, + "scalar_invoice_contract": "Integer weighted ADDs repeat unit Gaussian ADDs. Each original fractional ADD temporarily divides its mutable source, performs its signed unit ADD, and restores the source by doubling before the next original event. The source-row audit proves exact divisibility at those reads. No new Gaussian workspace is used by the entrance completion.", + "schema_version": 1, + "source_domain": { + "common_original_and_new_caller": { + "N_2B9": [ + "N10", + "N100", + "N12", + "N15", + "N17", + "N18", + "N2", + "N20", + "N24", + "N26", + "N27", + "N29", + "N33", + "N34", + "N35", + "N36", + "N37", + "N38", + "N39", + "N4", + "N40", + "N41", + "N42", + "N43", + "N44", + "N45", + "N46", + "N47", + "N48", + "N49", + "N5", + "N50", + "N51", + "N52", + "N53", + "N54", + "N55", + "N56", + "N57", + "N58", + "N59", + "N60", + "N61", + "N62", + "N63", + "N64", + "N65", + "N66", + "N67", + "N68", + "N69", + "N7", + "N70", + "N71", + "N72", + "N73", + "N74", + "N75", + "N76", + "N77", + "N78", + "N79", + "N80", + "N81", + "N82", + "N83", + "N84", + "N85", + "N86", + "N87", + "N88", + "N89", + "N9", + "N90", + "N91", + "N92", + "N96", + "N98" + ], + "Y_4B9": 104, + "other_B9": 176 + }, + "full_fractional_reads": { + "N": 190, + "Y": 1248 + }, + "full_source_rows": { + "N_and_Y_normalized_endpoints_restore": true, + "first_N_half_events": { + "N10": 384, + "N100": 312, + "N12": 383, + "N15": 382, + "N17": 381, + "N18": 380, + "N2": 389, + "N20": 379, + "N24": 378, + "N26": 377, + "N27": 376, + "N29": 375, + "N33": 374, + "N34": 373, + "N35": 372, + "N36": 371, + "N37": 370, + "N38": 369, + "N39": 368, + "N4": 388, + "N40": 367, + "N41": 366, + "N42": 365, + "N43": 364, + "N44": 363, + "N45": 362, + "N46": 361, + "N47": 360, + "N48": 359, + "N49": 358, + "N5": 387, + "N50": 357, + "N51": 356, + "N52": 355, + "N53": 354, + "N54": 353, + "N55": 352, + "N56": 351, + "N57": 350, + "N58": 349, + "N59": 348, + "N60": 347, + "N61": 346, + "N62": 345, + "N63": 344, + "N64": 343, + "N65": 342, + "N66": 341, + "N67": 340, + "N68": 339, + "N69": 338, + "N7": 386, + "N70": 337, + "N71": 336, + "N72": 335, + "N73": 334, + "N74": 333, + "N75": 332, + "N76": 331, + "N77": 330, + "N78": 329, + "N79": 328, + "N80": 327, + "N81": 326, + "N82": 325, + "N83": 324, + "N84": 323, + "N85": 322, + "N86": 321, + "N87": 320, + "N88": 319, + "N89": 318, + "N9": 385, + "N90": 317, + "N91": 316, + "N92": 315, + "N96": 314, + "N98": 313 + }, + "fractional_increments_checked": 1438, + "fractional_source_rows_sha256": "8fbf308f3a3e8eaf3f18a8b11f5e06eff3a0c184c7424f30eb897fe68ab7d0d7" + }, + "projection_fractional_N_sources": [ + "N100", + "N18", + "N2", + "N20", + "N27", + "N29", + "N35", + "N36", + "N4", + "N40", + "N44", + "N45", + "N46", + "N48", + "N49", + "N50", + "N54", + "N58", + "N59", + "N64", + "N65", + "N66", + "N7", + "N70", + "N74", + "N75", + "N79", + "N80", + "N81", + "N83", + "N84", + "N85", + "N87", + "N88", + "N89", + "N9", + "N92", + "N98" + ], + "projection_fractional_reads": { + "N": 94, + "Y": 1248 + }, + "projection_source_rows": { + "N_and_Y_normalized_endpoints_restore": true, + "first_N_half_events": { + "N100": 312, + "N18": 380, + "N2": 389, + "N20": 379, + "N27": 376, + "N29": 375, + "N35": 372, + "N36": 371, + "N4": 388, + "N40": 367, + "N44": 363, + "N45": 362, + "N46": 361, + "N48": 359, + "N49": 358, + "N50": 357, + "N54": 353, + "N58": 349, + "N59": 348, + "N64": 343, + "N65": 342, + "N66": 341, + "N7": 386, + "N70": 337, + "N74": 333, + "N75": 332, + "N79": 328, + "N80": 327, + "N81": 326, + "N83": 324, + "N84": 323, + "N85": 322, + "N87": 320, + "N88": 319, + "N89": 318, + "N9": 385, + "N92": 315, + "N98": 313 + }, + "fractional_increments_checked": 1342, + "fractional_source_rows_sha256": "93b709070ce3435797b874df88d10a48b87876725ba67ed44d611783030ecf24" + }, + "qualification": "Both original and changed callers are interpreted on the same strong product domain. The 38 projection N-source count is a read inventory, not a new minimal-domain theorem. Endpoint equality is proved separately.", + "scope": "Common sufficient B9-product entrance under inherited native/B9 covariance; no minimal-domain claim and all initial preparations remain unpaid", + "weak_N100_control": "unadmitted source increment at event 312 from N100", + "weak_Y1_control": "unadmitted source increment at event 1689 from Y1" + }, + "status": "PASS", + "undercharged_profile_control": "comparison rank mass changed" + }, + "native": { + "certificates": { + "X0": { + "exact_anchor_sha256": "a020595c6c87de7c7c5d5bc8c89c93f4bb02a64222793fa292068318f79c9416", + "new": [], + "old": [ + 386 + ], + "rank": 1, + "recipe_sha256": "17b0bc08b0d83c104a9af9edf6830ba61eabd83cae131252b7058f5bbfe260da", + "signed_pauli_sha256": "c5cf1f7e1cef5f17a34a949ae23e496dc66c41e5c3bc5f5e140128dad228b1c7", + "wrappers": { + "left": { + "cycle_length_histogram": { + "1": 2, + "3": 2, + "63": 8 + }, + "cycles": 12, + "direct_gaussian_swaps": 500, + "entries": 512, + "mapping_sha256": "4e95de08b344b30b539dbcfdd18f420f0ded7fb10d955127c99b78cbd2ded8c7", + "nontrivial_phase_entries": 256, + "phase_histogram": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "phase_real_negations": 512, + "phase_real_swaps": 0 + }, + "right": { + "cycle_length_histogram": { + "1": 1, + "511": 1 + }, + "cycles": 2, + "direct_gaussian_swaps": 510, + "entries": 512, + "mapping_sha256": "212674a7fdb9ea023f0bdb49c7faf2a3181a2454438a36c080a7f2d8f76a4239", + "nontrivial_phase_entries": 384, + "phase_histogram": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "phase_real_negations": 512, + "phase_real_swaps": 256 + } + } + }, + "X10": { + "exact_anchor_sha256": "18fb1fd8c5f74134d6513876d2a33d19edc6001e3073eb3389d139d04f2dac3c", + "new": [], + "old": [ + 295 + ], + "rank": 1, + "recipe_sha256": "9c23e9a611edc6fc26186903478a7c3b01e35d2d42761f2ffa94d9d4960f38ec", + "signed_pauli_sha256": "4a49bcf94819d2277f14b535a682412d0127eb86dc11c11cac37c67954de796c", + "wrappers": { + "left": { + "cycle_length_histogram": { + "1": 2, + "217": 2, + "31": 2, + "7": 2 + }, + "cycles": 8, + "direct_gaussian_swaps": 504, + "entries": 512, + "mapping_sha256": "655f5e856b6331bd53c93789ef247ff553f6f31b8e971c4d05c917049a000cf2", + "nontrivial_phase_entries": 256, + "phase_histogram": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "phase_real_negations": 512, + "phase_real_swaps": 0 + }, + "right": { + "cycle_length_histogram": { + "2": 1, + "510": 1 + }, + "cycles": 2, + "direct_gaussian_swaps": 510, + "entries": 512, + "mapping_sha256": "9d9da2a7a5388df23ddca648eeaa387bdb37f974e520de46c33b043765349ab4", + "nontrivial_phase_entries": 384, + "phase_histogram": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "phase_real_negations": 512, + "phase_real_swaps": 256 + } + } + }, + "X101": { + "exact_anchor_sha256": "4eb367b2b1944c251668d9f9c384b389b0f411f0d022fd7eb1f7879f980c4d02", + "new": [], + "old": [ + 439 + ], + "rank": 1, + "recipe_sha256": "35109cad950f6e27268cb5024f22e8174154c8cfaef5411d8e4fdb8d4ee441fc", + "signed_pauli_sha256": "99f256b8bad1372a76f37e274978bb18e7c6955d03fad8990375bcbf12c4c81a", + "wrappers": { + "left": { + "cycle_length_histogram": { + "1": 2, + "105": 2, + "14": 1, + "15": 2, + "2": 1, + "210": 1, + "30": 1, + "7": 2 + }, + "cycles": 12, + "direct_gaussian_swaps": 500, + "entries": 512, + "mapping_sha256": "ec464fa79917180ce3145b5e4748b31b63d0ce52cb248e03d0b9738f3ad76b8d", + "nontrivial_phase_entries": 256, + "phase_histogram": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "phase_real_negations": 512, + "phase_real_swaps": 0 + }, + "right": { + "cycle_length_histogram": { + "1": 1, + "14": 32, + "7": 9 + }, + "cycles": 42, + "direct_gaussian_swaps": 470, + "entries": 512, + "mapping_sha256": "859587aa3b4b629cb7071f06fe1802a307ae18bd710746fdf415fe8f4a409593", + "nontrivial_phase_entries": 384, + "phase_histogram": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "phase_real_negations": 512, + "phase_real_swaps": 256 + } + } + }, + "X102": { + "exact_anchor_sha256": "94020aeb67811b309efdea8cfbf2291d10f0e462d9345915dfe3340bff9bd98d", + "new": [], + "old": [ + 296 + ], + "rank": 1, + "recipe_sha256": "2e599eee0ccf3905a9214c02ff7d29a6d1b0208708824175560d02479e071d34", + "signed_pauli_sha256": "138bd147db98c0ac3aa4c7f0d193a7ddf62dd587a3f6efcfabe4e5307d47d0b0", + "wrappers": { + "left": { + "cycle_length_histogram": { + "1": 2, + "255": 2 + }, + "cycles": 4, + "direct_gaussian_swaps": 508, + "entries": 512, + "mapping_sha256": "e17a8148442d35965755ed0431bcba5f963b34c34593f82cf9d1c18dbf5e46d7", + "nontrivial_phase_entries": 256, + "phase_histogram": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "phase_real_negations": 512, + "phase_real_swaps": 0 + }, + "right": { + "cycle_length_histogram": { + "1": 1, + "511": 1 + }, + "cycles": 2, + "direct_gaussian_swaps": 510, + "entries": 512, + "mapping_sha256": "7234ef532e605a4eb3abc095a0d9f0d2189766cd3f71234543a0f1326e4fdc6e", + "nontrivial_phase_entries": 384, + "phase_histogram": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "phase_real_negations": 512, + "phase_real_swaps": 256 + } + } + }, + "X11": { + "exact_anchor_sha256": "4b06fb8bececfcff7647ad2639bdac1a40bf93c7e0b811b4f906592a6e55c85e", + "new": [], + "old": [ + 309 + ], + "rank": 1, + "recipe_sha256": "132de9babda76efc46df8946f04bad95af1d0860306e29f2b11ada1330b18357", + "signed_pauli_sha256": "c0dd0365bc7f49a87dbf924cfeb141f9ea3d0daab0a776957dfda53eeffd0873", + "wrappers": { + "left": { + "cycle_length_histogram": { + "1": 2, + "126": 1, + "2": 1, + "252": 1, + "4": 1, + "63": 2 + }, + "cycles": 8, + "direct_gaussian_swaps": 504, + "entries": 512, + "mapping_sha256": "841fcd59dddced7e39fd3c54d4ad02ac86b7b0364195a8aaf657b8f5cc16126a", + "nontrivial_phase_entries": 256, + "phase_histogram": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "phase_real_negations": 512, + "phase_real_swaps": 0 + }, + "right": { + "cycle_length_histogram": { + "4": 1, + "508": 1 + }, + "cycles": 2, + "direct_gaussian_swaps": 510, + "entries": 512, + "mapping_sha256": "1e872f1b7ed4f9edbc8bb34f9559c54a2fd21ebdf24dda8610f10e5d49fcad12", + "nontrivial_phase_entries": 384, + "phase_histogram": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "phase_real_negations": 512, + "phase_real_swaps": 256 + } + } + }, + "X12": { + "exact_anchor_sha256": "591fe7fea94b73340fdb742dd8c42e9b32b4f4a2d6eb18cb15aa4f1b1226c341", + "new": [], + "old": [ + 346 + ], + "rank": 1, + "recipe_sha256": "22b8ba52d4ddf4517359d7561ff8b3e2a4958e47a23f2c2c60092fefc978f3fb", + "signed_pauli_sha256": "b122da31a1c1e98212054773542a6e11ac576a14aa4811a255a68019a3963f2a", + "wrappers": { + "left": { + "cycle_length_histogram": { + "1": 2, + "15": 6, + "3": 2, + "30": 12, + "5": 6, + "6": 4 + }, + "cycles": 32, + "direct_gaussian_swaps": 480, + "entries": 512, + "mapping_sha256": "d9c13e185e5e05c431a24d359a3b9e30d913862ba31354f1e228a95885595454", + "nontrivial_phase_entries": 256, + "phase_histogram": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "phase_real_negations": 512, + "phase_real_swaps": 0 + }, + "right": { + "cycle_length_histogram": { + "14": 1, + "2": 1, + "434": 1, + "62": 1 + }, + "cycles": 4, + "direct_gaussian_swaps": 508, + "entries": 512, + "mapping_sha256": "49e5a2c685d95ffc25d5ba594e599a101c9bda0f7c78c1fc695442e808c4e7e0", + "nontrivial_phase_entries": 384, + "phase_histogram": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "phase_real_negations": 512, + "phase_real_swaps": 256 + } + } + }, + "X15": { + "exact_anchor_sha256": "a6722054d13a4ee98195801881fe402db85c81e2f5e2e844f9ca3b4c6065acf9", + "new": [], + "old": [ + 32 + ], + "rank": 1, + "recipe_sha256": "4b40d481e2a8c6bd01fe6a34f39729213ddd8791b1bf29aa8d56fae4215f3661", + "signed_pauli_sha256": "468c59e9ad13fe37967def08944e9b656af1b2552714737870544406d546f236", + "wrappers": { + "left": { + "cycle_length_histogram": { + "1": 16, + "2": 8, + "3": 16, + "6": 72 + }, + "cycles": 112, + "direct_gaussian_swaps": 400, + "entries": 512, + "mapping_sha256": "c319a78b6bc6b889a69bc1f7c8f4c0571dc5e720ea0e367cfbd6f1156844cd4a", + "nontrivial_phase_entries": 256, + "phase_histogram": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "phase_real_negations": 512, + "phase_real_swaps": 0 + }, + "right": { + "cycle_length_histogram": { + "12": 40, + "4": 8 + }, + "cycles": 48, + "direct_gaussian_swaps": 464, + "entries": 512, + "mapping_sha256": "d547c571965a4fc4afc543a609fa9309ed26ce9dcb2cf5c9b7d462a5d69f331f", + "nontrivial_phase_entries": 512, + "phase_histogram": { + "0": 0, + "1": 256, + "2": 0, + "3": 256 + }, + "phase_real_negations": 512, + "phase_real_swaps": 512 + } + } + }, + "X16": { + "exact_anchor_sha256": "06bfdcb6c210b4b704bd485e9d66ad4e6c4538ca259e480ec1a1e80575b8db3c", + "new": [], + "old": [ + 79 + ], + "rank": 1, + "recipe_sha256": "7db3cdc77aec2b64851e0bd226a30408b4f046d303fb5cb7227eaa7a31bb3e88", + "signed_pauli_sha256": "e68ebbc90c2ed9d44a3d6f82b150d00c4668c186a0941ba448e121a06204d3b6", + "wrappers": { + "left": { + "cycle_length_histogram": { + "1": 8, + "21": 24 + }, + "cycles": 32, + "direct_gaussian_swaps": 480, + "entries": 512, + "mapping_sha256": "ee8e676554de631662e006bae6d1b17e0390b045810dc6089640af9cfb7cdc35", + "nontrivial_phase_entries": 256, + "phase_histogram": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "phase_real_negations": 512, + "phase_real_swaps": 0 + }, + "right": { + "cycle_length_histogram": { + "126": 4, + "2": 4 + }, + "cycles": 8, + "direct_gaussian_swaps": 504, + "entries": 512, + "mapping_sha256": "fb717ad6c36ee8309b1114a17b93b4aea3b5076f8bd6d4241fb03682405078ff", + "nontrivial_phase_entries": 384, + "phase_histogram": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "phase_real_negations": 512, + "phase_real_swaps": 256 + } + } + }, + "X17": { + "exact_anchor_sha256": "ca26e28ad12428c9131940d43c92f6a714333c56b689e50f669a9f983a9f01ec", + "new": [], + "old": [ + 93 + ], + "rank": 1, + "recipe_sha256": "f8199326b44a3b47fa01c1c3a0b93d5b91949d39ece280e9d1efbb6863ec5f52", + "signed_pauli_sha256": "8dd7bf70ec7fd9e85218897a3d545f035a08cc54834102c5fe2fda42fdd2ed4f", + "wrappers": { + "left": { + "cycle_length_histogram": { + "1": 8, + "14": 4, + "2": 4, + "28": 12, + "4": 12, + "7": 8 + }, + "cycles": 48, + "direct_gaussian_swaps": 464, + "entries": 512, + "mapping_sha256": "62006ef34dda2bb63d4c2e26ac76e3fedaa32680bb6839d9034295ed907dce22", + "nontrivial_phase_entries": 256, + "phase_histogram": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "phase_real_negations": 512, + "phase_real_swaps": 0 + }, + "right": { + "cycle_length_histogram": { + "8": 64 + }, + "cycles": 64, + "direct_gaussian_swaps": 448, + "entries": 512, + "mapping_sha256": "4ed8f178db03ad9ec1ee5ce9858960069c8d71a0e7c7f367fb67e1ecf57f08f1", + "nontrivial_phase_entries": 384, + "phase_histogram": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "phase_real_negations": 512, + "phase_real_swaps": 256 + } + } + }, + "X21": { + "exact_anchor_sha256": "cdaf6b94b3668d942fce42755c5bcf84aece2a59ff1cfd8472d7369ba8b01e2b", + "new": [], + "old": [ + 26 + ], + "rank": 1, + "recipe_sha256": "f55e672716277a1ae66b0fa8512e1b5da1390cb3a02111a5e196b414ecddb485", + "signed_pauli_sha256": "96d879f035aa55a39ebb654d2d542ee8c24bf410a0e96a9e694a50bcc03dfcaf", + "wrappers": { + "left": { + "cycle_length_histogram": { + "1": 32, + "15": 32 + }, + "cycles": 64, + "direct_gaussian_swaps": 448, + "entries": 512, + "mapping_sha256": "58f4ed5ce258451b8080a3ba5ed7561c236061656609121e0dea2cc3a9fc7f42", + "nontrivial_phase_entries": 256, + "phase_histogram": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "phase_real_negations": 512, + "phase_real_swaps": 0 + }, + "right": { + "cycle_length_histogram": { + "1": 16, + "31": 16 + }, + "cycles": 32, + "direct_gaussian_swaps": 480, + "entries": 512, + "mapping_sha256": "a70ddf2588ae2a7e3bc747654fe78757518059ff52e88f74e0c472dc050bcf00", + "nontrivial_phase_entries": 384, + "phase_histogram": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "phase_real_negations": 512, + "phase_real_swaps": 256 + } + } + }, + "X24": { + "exact_anchor_sha256": "253c983140212d776b2cb33935f9cb1bd927293272844f8f883da360f396fa46", + "new": [], + "old": [ + 223 + ], + "rank": 1, + "recipe_sha256": "b4d0cfb8db40f74af32c66005ee179d29dcc8d74e58846a1925d6d42f872e2d1", + "signed_pauli_sha256": "964860c858bdb096a520e609cf9bf9f8e749a5db1545f7cfe777a0423f9356fd", + "wrappers": { + "left": { + "cycle_length_histogram": { + "1": 4, + "126": 2, + "2": 2, + "63": 4 + }, + "cycles": 12, + "direct_gaussian_swaps": 500, + "entries": 512, + "mapping_sha256": "fe41bd77cefb0f79f0a83cd4fed4791df486c4ee2128e77a6302fec424097662", + "nontrivial_phase_entries": 256, + "phase_histogram": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "phase_real_negations": 512, + "phase_real_swaps": 0 + }, + "right": { + "cycle_length_histogram": { + "1": 2, + "255": 2 + }, + "cycles": 4, + "direct_gaussian_swaps": 508, + "entries": 512, + "mapping_sha256": "f8c068d8336a75c1625ca32fd494338516665115a4da1ca4637dc00592e1bd6f", + "nontrivial_phase_entries": 384, + "phase_histogram": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "phase_real_negations": 512, + "phase_real_swaps": 256 + } + } + }, + "X25": { + "exact_anchor_sha256": "aacf022c78143c0771e37b37f5c6dc3990fbd263c786146ee8e765e1ce269ca6", + "new": [], + "old": [ + 176 + ], + "rank": 1, + "recipe_sha256": "4a9839a9d1629bf03abb41a1c15ebcb0b5343d01bcac4526c1e5a5ad71149bc5", + "signed_pauli_sha256": "30ee72f067653d373516b8767198b31e3c2c9265346e6e3c43ee0c24b0274a50", + "wrappers": { + "left": { + "cycle_length_histogram": { + "1": 4, + "3": 4, + "31": 4, + "93": 4 + }, + "cycles": 16, + "direct_gaussian_swaps": 496, + "entries": 512, + "mapping_sha256": "f9bd1532e242f05397381ab9541e64a34e5cdb50c6daef52cb0a2789bb2df765", + "nontrivial_phase_entries": 256, + "phase_histogram": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "phase_real_negations": 512, + "phase_real_swaps": 0 + }, + "right": { + "cycle_length_histogram": { + "1": 2, + "15": 8, + "3": 2, + "30": 12, + "6": 4 + }, + "cycles": 28, + "direct_gaussian_swaps": 484, + "entries": 512, + "mapping_sha256": "f72e21d182be9b69c5d6da977cf184187afcf1790322e64863107791fb5e93bd", + "nontrivial_phase_entries": 384, + "phase_histogram": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "phase_real_negations": 512, + "phase_real_swaps": 256 + } + } + }, + "X26": { + "exact_anchor_sha256": "66bb561a6b155c7ac260b296aabdb4f3982fb0cdea67efeed7865b88bd5237a2", + "new": [], + "old": [ + 162 + ], + "rank": 1, + "recipe_sha256": "c1e796c2b3ae02b9c232663554dd42c71fb6f63d043f0bdb301422b60591fd63", + "signed_pauli_sha256": "df28828af18fb73f4591bee93855dc19c2ca6de76194ee2bc15daf8e08abb05e", + "wrappers": { + "left": { + "cycle_length_histogram": { + "1": 4, + "12": 30, + "2": 2, + "3": 4, + "4": 6, + "6": 18 + }, + "cycles": 64, + "direct_gaussian_swaps": 448, + "entries": 512, + "mapping_sha256": "ff34685baa857ac228455649795c092e2c06dafb2bbfde1e27653ecd7c515e82", + "nontrivial_phase_entries": 256, + "phase_histogram": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "phase_real_negations": 512, + "phase_real_swaps": 0 + }, + "right": { + "cycle_length_histogram": { + "1": 2, + "12": 40, + "3": 2, + "6": 4 + }, + "cycles": 48, + "direct_gaussian_swaps": 464, + "entries": 512, + "mapping_sha256": "a1aad0e5c1217c84d853dec7d7f97499746adb6123c40827ed8a4c1c7e942893", + "nontrivial_phase_entries": 384, + "phase_histogram": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "phase_real_negations": 512, + "phase_real_swaps": 256 + } + } + }, + "X30": { + "exact_anchor_sha256": "72459b9d115a30eb4d92ac7ad3956fc6db27eefefbe81dd2aa195b29a9a6d252", + "new": [], + "old": [ + 229 + ], + "rank": 1, + "recipe_sha256": "06e961870de3fe7227da5ea3125289d471c4f92f550c6e90f0962a09e08d518b", + "signed_pauli_sha256": "191ce7303797b7162e6c20e83103fadfe06206ff0138f3112d4bb965a47c6733", + "wrappers": { + "left": { + "cycle_length_histogram": { + "1": 4, + "127": 4 + }, + "cycles": 8, + "direct_gaussian_swaps": 504, + "entries": 512, + "mapping_sha256": "90eb9de6897e674f08e00298a1e9cd5e79507d35f19a718d2fba4f312220afe6", + "nontrivial_phase_entries": 256, + "phase_histogram": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "phase_real_negations": 512, + "phase_real_swaps": 0 + }, + "right": { + "cycle_length_histogram": { + "2": 2, + "254": 2 + }, + "cycles": 4, + "direct_gaussian_swaps": 508, + "entries": 512, + "mapping_sha256": "a8cde8ded2be8b78a92d7c0f41926652340b43e6d7264f1155400f01a891817c", + "nontrivial_phase_entries": 384, + "phase_histogram": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "phase_real_negations": 512, + "phase_real_swaps": 256 + } + } + }, + "X31": { + "exact_anchor_sha256": "5d4be6f4de357378010499a93e5fff02db872ce86ae3fb4db258ff5dc3adba78", + "new": [], + "old": [ + 122 + ], + "rank": 1, + "recipe_sha256": "2a1f3077ada83a0b167c2a667c0485d31956896e65cb43380d68baa29b8a2761", + "signed_pauli_sha256": "338408243d370e3ace3f17811df46fb2aab9dc348e20fedc22c3f1e17d617b9a", + "wrappers": { + "left": { + "cycle_length_histogram": { + "1": 8, + "14": 4, + "2": 4, + "21": 8, + "3": 8, + "42": 4, + "6": 4, + "7": 8 + }, + "cycles": 48, + "direct_gaussian_swaps": 464, + "entries": 512, + "mapping_sha256": "e5010faa917f307e07978cf2d2e9b6a9dbb36efbbbde16018ae5824e93698357", + "nontrivial_phase_entries": 256, + "phase_histogram": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "phase_real_negations": 512, + "phase_real_swaps": 0 + }, + "right": { + "cycle_length_histogram": { + "12": 40, + "4": 8 + }, + "cycles": 48, + "direct_gaussian_swaps": 464, + "entries": 512, + "mapping_sha256": "247b65851c547cc6c47ff86e4417e43fad30abdbc9000702ef898102d4cda9de", + "nontrivial_phase_entries": 384, + "phase_histogram": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "phase_real_negations": 512, + "phase_real_swaps": 256 + } + } + }, + "X33": { + "exact_anchor_sha256": "d8264f9284b42ba688a1f67718dfb7be1188d710c9829021ee7f97fccc38d284", + "new": [], + "old": [ + 494 + ], + "rank": 1, + "recipe_sha256": "1e4beed1301e1d34016f6b8f8a0df2b7f81ed00d1c55ee823672d2b26419203d", + "signed_pauli_sha256": "8082a486ffb3ec8ef7707f1515c82a62c3b6b98928a473e0d8d83044fe772434", + "wrappers": { + "left": { + "cycle_length_histogram": { + "1": 2, + "21": 24, + "3": 2 + }, + "cycles": 28, + "direct_gaussian_swaps": 484, + "entries": 512, + "mapping_sha256": "000e400befd38c5a41e53ac696cb30f33fa2ec351caadd454f3f9fcd550c97bc", + "nontrivial_phase_entries": 256, + "phase_histogram": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "phase_real_negations": 512, + "phase_real_swaps": 0 + }, + "right": { + "cycle_length_histogram": { + "1": 1, + "186": 2, + "3": 1, + "31": 1, + "6": 2, + "93": 1 + }, + "cycles": 8, + "direct_gaussian_swaps": 504, + "entries": 512, + "mapping_sha256": "14b2735328ab48aea1069aca5febddfd67554df79a3ba569990ba0241e783bb3", + "nontrivial_phase_entries": 384, + "phase_histogram": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "phase_real_negations": 512, + "phase_real_swaps": 256 + } + } + }, + "X34": { + "exact_anchor_sha256": "a4e6cde9c36f17c81eb1cc7ec16e5fc9daf4864a9fe330a6ea7f295eee6cb84c", + "new": [], + "old": [ + 385 + ], + "rank": 1, + "recipe_sha256": "2ad3475c918ae1de1b5b2a6835d7dc49596ff57aebb9e81c90295e5ff82b7785", + "signed_pauli_sha256": "000ae453f3295b779f2ae0d0f9b2a1b7031c5beb439a3a19ecb2ae6dd668ff8d", + "wrappers": { + "left": { + "cycle_length_histogram": { + "1": 2, + "16": 16, + "2": 1, + "4": 3, + "8": 30 + }, + "cycles": 52, + "direct_gaussian_swaps": 460, + "entries": 512, + "mapping_sha256": "b0b64274a10b6fe90963413b5473978b4e8aef1f34723f802287e7957b7fd01e", + "nontrivial_phase_entries": 256, + "phase_histogram": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "phase_real_negations": 512, + "phase_real_swaps": 0 + }, + "right": { + "cycle_length_histogram": { + "1": 1, + "15": 1, + "31": 1, + "465": 1 + }, + "cycles": 4, + "direct_gaussian_swaps": 508, + "entries": 512, + "mapping_sha256": "e461e0b890fc4b30eec5e68df8148e66f60b575e28a594c9c59f79a0cfdb1b26", + "nontrivial_phase_entries": 384, + "phase_histogram": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "phase_real_negations": 512, + "phase_real_swaps": 256 + } + } + }, + "X37": { + "exact_anchor_sha256": "aa3a76634375b136830cc75687a4ffcdcd103c9721ce8f92cf1ae06863fdaaa8", + "new": [], + "old": [ + 425 + ], + "rank": 1, + "recipe_sha256": "040100b7b3c86521a200811c1db0cfa0d2d74358770002df5d1b39a735308890", + "signed_pauli_sha256": "6aed4509896cafced71a68196d65cafdc64091e0e68ab9f8ea35df0bcb6a8883", + "wrappers": { + "left": { + "cycle_length_histogram": { + "1": 2, + "127": 2, + "2": 1, + "254": 1 + }, + "cycles": 6, + "direct_gaussian_swaps": 506, + "entries": 512, + "mapping_sha256": "228866a3ec7b97065917189980ccc032e7c0d029f76be2cca19a3d9f4090c666", + "nontrivial_phase_entries": 256, + "phase_histogram": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "phase_real_negations": 512, + "phase_real_swaps": 0 + }, + "right": { + "cycle_length_histogram": { + "252": 2, + "4": 2 + }, + "cycles": 4, + "direct_gaussian_swaps": 508, + "entries": 512, + "mapping_sha256": "936733e1afb9bef7fc9db8046f628fe2c49ddf29b41276cfab9071605e505831", + "nontrivial_phase_entries": 384, + "phase_histogram": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "phase_real_negations": 512, + "phase_real_swaps": 256 + } + } + }, + "X38": { + "exact_anchor_sha256": "9c1733540c86270755de86768c4d30c3d496ac0a90c9117ab2c77a0e7727d778", + "new": [], + "old": [ + 454 + ], + "rank": 1, + "recipe_sha256": "0f614c7803e9ce61ce5382145b339fcd48a429a5abe38707b9c2c7d528278c1d", + "signed_pauli_sha256": "c9f9fd258e2423b36d51d227958f4ac2f811d951548c1dfc1bac6e6c28bf2a5f", + "wrappers": { + "left": { + "cycle_length_histogram": { + "1": 2, + "85": 6 + }, + "cycles": 8, + "direct_gaussian_swaps": 504, + "entries": 512, + "mapping_sha256": "d0c2f442858dbbd7e81e162d31c1718bbf06e64fe08988a378565fc4e77c2fe1", + "nontrivial_phase_entries": 256, + "phase_histogram": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "phase_real_negations": 512, + "phase_real_swaps": 0 + }, + "right": { + "cycle_length_histogram": { + "14": 1, + "2": 1, + "434": 1, + "62": 1 + }, + "cycles": 4, + "direct_gaussian_swaps": 508, + "entries": 512, + "mapping_sha256": "4c934a9a4ba3cbb181e93033b2942c66ca2f4ccaa6abe863741d1cd3e82c00b5", + "nontrivial_phase_entries": 384, + "phase_histogram": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "phase_real_negations": 512, + "phase_real_swaps": 256 + } + } + }, + "X39": { + "exact_anchor_sha256": "898a71d7f4f818c60dfbf7d20866d9afd1561e793e1fa62b1af8829344aa2f6b", + "new": [], + "old": [ + 468 + ], + "rank": 1, + "recipe_sha256": "0a2bbe60f1d706f7e2d1b0ef92fb01c29600075dc3d52f134c4ade4efe3f6783", + "signed_pauli_sha256": "e19160d791a969189ffb44ba5acdca2b659d56e835d9fd6743f57d362af1ad8f", + "wrappers": { + "left": { + "cycle_length_histogram": { + "1": 2, + "14": 1, + "2": 1, + "28": 3, + "4": 3, + "56": 6, + "7": 2, + "8": 6 + }, + "cycles": 24, + "direct_gaussian_swaps": 488, + "entries": 512, + "mapping_sha256": "1b43a9b35d8a03b6e39d2fc2e64949178bc528ecb1721b50488014e2a1333453", + "nontrivial_phase_entries": 256, + "phase_histogram": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "phase_real_negations": 512, + "phase_real_swaps": 0 + }, + "right": { + "cycle_length_histogram": { + "4": 1, + "508": 1 + }, + "cycles": 2, + "direct_gaussian_swaps": 510, + "entries": 512, + "mapping_sha256": "48034711ad7abeed24fa30418da1e422cf038f8c6e3b7c0141226621fb78ecf7", + "nontrivial_phase_entries": 384, + "phase_histogram": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "phase_real_negations": 512, + "phase_real_swaps": 256 + } + } + }, + "X41": { + "exact_anchor_sha256": "c7f3c8e098c41555811b06cd3c0c876044d3401bfe8c7024bad06665b262ad72", + "new": [], + "old": [ + 310 + ], + "rank": 1, + "recipe_sha256": "712788b1631ed41b4f4c6fed379eacc25476d8f1e5cbc63aaee60dd97a3084cc", + "signed_pauli_sha256": "5c85dbb66d8ee4025d1650ef526f0f3de8b4018dde27e3bfdc11196340f4bfe5", + "wrappers": { + "left": { + "cycle_length_histogram": { + "1": 2, + "14": 8, + "21": 2, + "3": 2, + "42": 8, + "7": 2 + }, + "cycles": 24, + "direct_gaussian_swaps": 488, + "entries": 512, + "mapping_sha256": "57c4437e7e1bf1151e13d6485236146a8def30783c4f0601e614b055e31d1565", + "nontrivial_phase_entries": 256, + "phase_histogram": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "phase_real_negations": 512, + "phase_real_swaps": 0 + }, + "right": { + "cycle_length_histogram": { + "102": 5, + "2": 1 + }, + "cycles": 6, + "direct_gaussian_swaps": 506, + "entries": 512, + "mapping_sha256": "6a69bd8cbfeb4a7fda057ebf0dcd5f5d4cc1e12c3102b5734ee2c9cca7bfbd27", + "nontrivial_phase_entries": 384, + "phase_histogram": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "phase_real_negations": 512, + "phase_real_swaps": 256 + } + } + }, + "X42": { + "exact_anchor_sha256": "a591161fab87e2ee59cabdb6ad93471acb917dc7079908505279cdd6cd7dc0c9", + "new": [], + "old": [ + 345 + ], + "rank": 1, + "recipe_sha256": "22ac822b2002310d18b31cfd8785e8d15f8fd3a2f1a525e984a44ed86e8a4d98", + "signed_pauli_sha256": "5a2adc0185195417cda02dd401fc7211caefb53ddce03d3458eb3c62e8ae4b5e", + "wrappers": { + "left": { + "cycle_length_histogram": { + "1": 2, + "127": 2, + "2": 1, + "254": 1 + }, + "cycles": 6, + "direct_gaussian_swaps": 506, + "entries": 512, + "mapping_sha256": "48ee8eb5d697d80fb28a27dcf12a3844ea3ad6975c906216f9289cf373a28744", + "nontrivial_phase_entries": 256, + "phase_histogram": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "phase_real_negations": 512, + "phase_real_swaps": 0 + }, + "right": { + "cycle_length_histogram": { + "252": 2, + "4": 2 + }, + "cycles": 4, + "direct_gaussian_swaps": 508, + "entries": 512, + "mapping_sha256": "63cd7797df1d198baaec92c702b9dbfdc2ec0ebb8ce2d09f478d61925b35a558", + "nontrivial_phase_entries": 384, + "phase_histogram": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "phase_real_negations": 512, + "phase_real_swaps": 256 + } + } + }, + "X43": { + "exact_anchor_sha256": "039dea04fa8e535e425a0ec6f5241bd69ac90443e54b1dc7ff255347278b2fc1", + "new": [], + "old": [ + 331 + ], + "rank": 1, + "recipe_sha256": "00dad377a45851d1ac36d24b6c8d69873c474fb9cf234862bfd0a171574bcc39", + "signed_pauli_sha256": "3b04e97372144e3046a071292a7d4591d278dc411fe7d8b583bfed444defa883", + "wrappers": { + "left": { + "cycle_length_histogram": { + "1": 2, + "255": 2 + }, + "cycles": 4, + "direct_gaussian_swaps": 508, + "entries": 512, + "mapping_sha256": "72fb9887b4857db5bd2b49d281e409f796d7160630b2139cb06f91cb0153826a", + "nontrivial_phase_entries": 256, + "phase_histogram": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "phase_real_negations": 512, + "phase_real_swaps": 0 + }, + "right": { + "cycle_length_histogram": { + "14": 1, + "2": 1, + "434": 1, + "62": 1 + }, + "cycles": 4, + "direct_gaussian_swaps": 508, + "entries": 512, + "mapping_sha256": "e5be9855c866cce9fd629839bfa3252699c7dec1c7d80c95e27386edfa25529b", + "nontrivial_phase_entries": 384, + "phase_histogram": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "phase_real_negations": 512, + "phase_real_swaps": 256 + } + } + }, + "X47": { + "exact_anchor_sha256": "9a2b5b488412f0ba0f359e3d32bf180bfb9dd9ec3fee2a66e44bef747b67998f", + "new": [], + "old": [ + 94 + ], + "rank": 1, + "recipe_sha256": "320ca8e6651ffbb52430852434dcf863e960a2437ef9fea209c6db454091960e", + "signed_pauli_sha256": "1ce2643f5e8257ca73d4c2ac8dd1cfcf4496ea1a13a6f5ef4bb6ed05929ad9fb", + "wrappers": { + "left": { + "cycle_length_histogram": { + "1": 8, + "12": 32, + "3": 8, + "6": 16 + }, + "cycles": 64, + "direct_gaussian_swaps": 448, + "entries": 512, + "mapping_sha256": "bb4d2f1a35c3355b67978cb470d63b1f842ca5c9d745d1641070808459ebc410", + "nontrivial_phase_entries": 256, + "phase_histogram": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "phase_real_negations": 512, + "phase_real_swaps": 0 + }, + "right": { + "cycle_length_histogram": { + "2": 4, + "30": 16, + "6": 4 + }, + "cycles": 24, + "direct_gaussian_swaps": 488, + "entries": 512, + "mapping_sha256": "acd0224f48c91e31e21d45d3043ee3384c1ce75bf107cb58c574d9df5a913d39", + "nontrivial_phase_entries": 384, + "phase_histogram": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "phase_real_negations": 512, + "phase_real_swaps": 256 + } + } + }, + "X5": { + "exact_anchor_sha256": "bd9097df9aa73f33782415d0146087d7bdb615e47ae302d79b272a27bcd80ec3", + "new": [], + "old": [ + 440 + ], + "rank": 1, + "recipe_sha256": "9ccc7490a2ae1517ff9e4d0cc791097c9a49445302ca1f202b6720ce84899cfe", + "signed_pauli_sha256": "53089d1410eedd4a1797a36c1cc863ca78815e213c22a249bd6f2d1a9d1a090f", + "wrappers": { + "left": { + "cycle_length_histogram": { + "1": 2, + "127": 2, + "2": 1, + "254": 1 + }, + "cycles": 6, + "direct_gaussian_swaps": 506, + "entries": 512, + "mapping_sha256": "2e1894ad843cd6fec837d1647f0262370c5d5d94463e434930d97846f97a53e2", + "nontrivial_phase_entries": 256, + "phase_histogram": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "phase_real_negations": 512, + "phase_real_swaps": 0 + }, + "right": { + "cycle_length_histogram": { + "4": 1, + "508": 1 + }, + "cycles": 2, + "direct_gaussian_swaps": 510, + "entries": 512, + "mapping_sha256": "e240d78ed6cebe7c5ea47b1b510f00362ff91141df873948a035f552f18d46e6", + "nontrivial_phase_entries": 384, + "phase_histogram": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "phase_real_negations": 512, + "phase_real_swaps": 256 + } + } + }, + "X51": { + "exact_anchor_sha256": "e113b06efb1151d75cf50e0eb420848a4e34152147c2a6ba8b379c693c01d774", + "new": [], + "old": [ + 25 + ], + "rank": 1, + "recipe_sha256": "7d0b42a1a88f8238e4c318e699970185ce830e214bba5482e4c1d414ad3fdae1", + "signed_pauli_sha256": "622f6fe2c3766014adf0bb62937ee47dbb07d33039bf29cddd72fc154202785e", + "wrappers": { + "left": { + "cycle_length_histogram": { + "1": 32, + "2": 16, + "4": 48, + "8": 32 + }, + "cycles": 128, + "direct_gaussian_swaps": 384, + "entries": 512, + "mapping_sha256": "b3c184b232aa37ba066ed60ac069998e91ba5ea4fc8a05c17554712059ebe0e6", + "nontrivial_phase_entries": 256, + "phase_histogram": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "phase_real_negations": 512, + "phase_real_swaps": 0 + }, + "right": { + "cycle_length_histogram": { + "1": 16, + "31": 16 + }, + "cycles": 32, + "direct_gaussian_swaps": 480, + "entries": 512, + "mapping_sha256": "9cffe595e67d0a78a44a30ece85c5f80d6c51642ad8545e045711d13e5c59f7e", + "nontrivial_phase_entries": 384, + "phase_histogram": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "phase_real_negations": 512, + "phase_real_swaps": 256 + } + } + }, + "X52": { + "exact_anchor_sha256": "a9bf7c518f7aaf894812f250d3356f8b3a172a99e58b03467b12ef02dbcfe356", + "new": [], + "old": [ + 11 + ], + "rank": 1, + "recipe_sha256": "e76f3340a9ab6141273f9d3d30acf095e7b90fa480f11b749fe15fe41f92f8db", + "signed_pauli_sha256": "3c21eacf210bb907518051f5f8c56ca81528f89dd7d1ee4db5c95138b8e2d53e", + "wrappers": { + "left": { + "cycle_length_histogram": { + "1": 64, + "7": 64 + }, + "cycles": 128, + "direct_gaussian_swaps": 384, + "entries": 512, + "mapping_sha256": "a93de6088410d126ac276621e75db79393b53fb5c707391ece3cbf20f4ec8081", + "nontrivial_phase_entries": 256, + "phase_histogram": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "phase_real_negations": 512, + "phase_real_swaps": 0 + }, + "right": { + "cycle_length_histogram": { + "1": 32, + "15": 32 + }, + "cycles": 64, + "direct_gaussian_swaps": 448, + "entries": 512, + "mapping_sha256": "19103112b0d48d15124308665cdf6d5c98d583e995e006cb773dbf4ec462de11", + "nontrivial_phase_entries": 384, + "phase_histogram": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "phase_real_negations": 512, + "phase_real_swaps": 256 + } + } + }, + "X53": { + "exact_anchor_sha256": "59e50a991f54dae17d30e18c10f883c69c921028ee1fbd32b32ddb8e2d34c6fd", + "new": [], + "old": [ + 100 + ], + "rank": 1, + "recipe_sha256": "602661ba6b08586e89421bb8c9d437d09a7ef0056484b8893430134ca239a340", + "signed_pauli_sha256": "072efe13da6a8f43e29a725faf1fc63705b662814ea90eb4c51c6758dcad625f", + "wrappers": { + "left": { + "cycle_length_histogram": { + "1": 8, + "2": 4, + "31": 8, + "62": 4 + }, + "cycles": 24, + "direct_gaussian_swaps": 488, + "entries": 512, + "mapping_sha256": "82d6793e22fd8b6703a6791f5338fc758275ccfa13337c8ff3ea1b7887f1d04d", + "nontrivial_phase_entries": 256, + "phase_histogram": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "phase_real_negations": 512, + "phase_real_swaps": 0 + }, + "right": { + "cycle_length_histogram": { + "1": 4, + "127": 4 + }, + "cycles": 8, + "direct_gaussian_swaps": 504, + "entries": 512, + "mapping_sha256": "144885f11ea23a573effc888b271b1aa127b5553ddc5347bb863522d82f3edc3", + "nontrivial_phase_entries": 384, + "phase_histogram": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "phase_real_negations": 512, + "phase_real_swaps": 256 + } + } + }, + "X55": { + "exact_anchor_sha256": "c44352a46e7a99869876ddc3788263c640c6d754b6a5c8c99c1595745363c23c", + "new": [], + "old": [ + 134 + ], + "rank": 1, + "recipe_sha256": "6504b17619611c81dc06790b9386753a8ca4a366c4e4c3612f448dd7697abf11", + "signed_pauli_sha256": "fa935cea6d3950ec976d1e66122c3f5bea17fcaefc98b1285e2ebc95446783fa", + "wrappers": { + "left": { + "cycle_length_histogram": { + "1": 4, + "3": 4, + "31": 4, + "93": 4 + }, + "cycles": 16, + "direct_gaussian_swaps": 496, + "entries": 512, + "mapping_sha256": "40ec5caf20249089b699c58701f0df231666f41b413deb25d25b502c19f93303", + "nontrivial_phase_entries": 256, + "phase_histogram": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "phase_real_negations": 512, + "phase_real_swaps": 0 + }, + "right": { + "cycle_length_histogram": { + "1": 2, + "15": 8, + "3": 2, + "30": 12, + "6": 4 + }, + "cycles": 28, + "direct_gaussian_swaps": 484, + "entries": 512, + "mapping_sha256": "c634c3af732719554637055c9a728e76a544a495d943369c2c8dd1a9d836e2b2", + "nontrivial_phase_entries": 384, + "phase_histogram": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "phase_real_negations": 512, + "phase_real_swaps": 256 + } + } + }, + "X56": { + "exact_anchor_sha256": "4764d052ece70d12f9a8348e160f0ca98b168af56e03c1c332cccd7ca28b9b23", + "new": [], + "old": [ + 148 + ], + "rank": 1, + "recipe_sha256": "919d660bcfb1f0630355fcdb6a050b51957fa0f856557d7a312045755fb47cb3", + "signed_pauli_sha256": "d680482cbfc4ce62e6113e814d2a94c6e0a527c27d1c0687d324cfa2d041cac9", + "wrappers": { + "left": { + "cycle_length_histogram": { + "1": 4, + "10": 6, + "15": 12, + "2": 2, + "3": 4, + "30": 6, + "5": 12, + "6": 2 + }, + "cycles": 48, + "direct_gaussian_swaps": 464, + "entries": 512, + "mapping_sha256": "8f19ae225f7e2846a5ab229b29e281b6951368ee157a510354c1e93d2b7adadc", + "nontrivial_phase_entries": 256, + "phase_histogram": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "phase_real_negations": 512, + "phase_real_swaps": 0 + }, + "right": { + "cycle_length_histogram": { + "1": 2, + "15": 2, + "30": 16 + }, + "cycles": 20, + "direct_gaussian_swaps": 492, + "entries": 512, + "mapping_sha256": "485a8088095edc19feaa95b07303d032050e8c71e197002e2c321048c58d601e", + "nontrivial_phase_entries": 384, + "phase_histogram": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "phase_real_negations": 512, + "phase_real_swaps": 256 + } + } + }, + "X57": { + "exact_anchor_sha256": "1306a9c100b2e4a27dae0129a65a32840db0e688bcbb2b07669a57efa0c13408", + "new": [], + "old": [ + 251 + ], + "rank": 1, + "recipe_sha256": "99d324f3f4d10eeaeec29bec669d1a3b6f301f51eb98552eed95ac2638815936", + "signed_pauli_sha256": "83c87fdc57ffaec5c4bdafb51e6b6cb2cb7d0bb95b2508eceda3a255328cd1e7", + "wrappers": { + "left": { + "cycle_length_histogram": { + "1": 4, + "105": 4, + "15": 4, + "7": 4 + }, + "cycles": 16, + "direct_gaussian_swaps": 496, + "entries": 512, + "mapping_sha256": "adeb61904be223e4be53a9138b263fc8a9734049d0ce43e80a7fa3d1c3463180", + "nontrivial_phase_entries": 256, + "phase_histogram": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "phase_real_negations": 512, + "phase_real_swaps": 0 + }, + "right": { + "cycle_length_histogram": { + "1": 2, + "255": 2 + }, + "cycles": 4, + "direct_gaussian_swaps": 508, + "entries": 512, + "mapping_sha256": "777fd932a1e9818a0d394b1b94db31dac4c3661baf725982936f8ebdfe11183b", + "nontrivial_phase_entries": 384, + "phase_histogram": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "phase_real_negations": 512, + "phase_real_swaps": 256 + } + } + }, + "X6": { + "exact_anchor_sha256": "670066e9f06957afd414b4efae93f5c60bb6cba720d6fd3453bef6c9686fd590", + "new": [], + "old": [ + 426 + ], + "rank": 1, + "recipe_sha256": "66298583c93b39d6dec40f420877d37a25ac9c9efc54f092f5ef474f9bb384cb", + "signed_pauli_sha256": "6beaef28666c312cc78fe80225de69e398843fde2c70452a8c72d64dd0bfe802", + "wrappers": { + "left": { + "cycle_length_histogram": { + "1": 2, + "217": 2, + "31": 2, + "7": 2 + }, + "cycles": 8, + "direct_gaussian_swaps": 504, + "entries": 512, + "mapping_sha256": "99e73a4ad55f7535d880f69f5eed44a7215e6191bac50ae69811179b54e18c18", + "nontrivial_phase_entries": 256, + "phase_histogram": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "phase_real_negations": 512, + "phase_real_swaps": 0 + }, + "right": { + "cycle_length_histogram": { + "2": 1, + "510": 1 + }, + "cycles": 2, + "direct_gaussian_swaps": 510, + "entries": 512, + "mapping_sha256": "55ca5cd78e99aa98d4d8727afba8da7047f9ab12e4892c2f84bc663901473099", + "nontrivial_phase_entries": 384, + "phase_histogram": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "phase_real_negations": 512, + "phase_real_swaps": 256 + } + } + }, + "X60": { + "exact_anchor_sha256": "a53e8c4471decf95be4f8249c3ce94cc8c8053b47ae1a79c9bd4625c97ee3aea", + "new": [], + "old": [ + 211 + ], + "rank": 1, + "recipe_sha256": "bebacdcd360dcd71c1b1efbc5c40257945c348561bb3e4d176a4d3206b05f13a", + "signed_pauli_sha256": "f2712b3d3112f029751d71606fba5cc8481cdeb880fba7069649ffbacca11b97", + "wrappers": { + "left": { + "cycle_length_histogram": { + "1": 4, + "127": 4 + }, + "cycles": 8, + "direct_gaussian_swaps": 504, + "entries": 512, + "mapping_sha256": "2467faf36bc6b17cc09fa5f360edb6dc8026ea4b7efbd10cc1a93c91424cd461", + "nontrivial_phase_entries": 256, + "phase_histogram": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "phase_real_negations": 512, + "phase_real_swaps": 0 + }, + "right": { + "cycle_length_histogram": { + "2": 2, + "254": 2 + }, + "cycles": 4, + "direct_gaussian_swaps": 508, + "entries": 512, + "mapping_sha256": "29e69d30fbb148d69e633fabf0bd9e9c2d3d12d907a5b66fa0328e0e98e4f927", + "nontrivial_phase_entries": 384, + "phase_histogram": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "phase_real_negations": 512, + "phase_real_swaps": 256 + } + } + }, + "X61": { + "exact_anchor_sha256": "7ba05337ab964510c81b27d8eefd07e6b9a16dd0d2d2d6eb8a1e5275857a7a0b", + "new": [], + "old": [ + 188 + ], + "rank": 1, + "recipe_sha256": "41d9da1779810d2988e182d0c01ae72bdd01db1b6d4d0d589788bacf30433a4c", + "signed_pauli_sha256": "92da8ce6dfcc1ced27b59ca1673c09a952cd6e89e5d06dbed6b212a47262afa1", + "wrappers": { + "left": { + "cycle_length_histogram": { + "1": 4, + "124": 2, + "2": 2, + "31": 4, + "4": 2, + "62": 2 + }, + "cycles": 16, + "direct_gaussian_swaps": 496, + "entries": 512, + "mapping_sha256": "993f3a1d2a8f1019ffd21c33256947cfd812b28d7aacbd94cfc152ec0f5be030", + "nontrivial_phase_entries": 256, + "phase_histogram": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "phase_real_negations": 512, + "phase_real_swaps": 0 + }, + "right": { + "cycle_length_histogram": { + "252": 2, + "4": 2 + }, + "cycles": 4, + "direct_gaussian_swaps": 508, + "entries": 512, + "mapping_sha256": "7eca518c177e7769c1da9b167999babea46777401b4ebdcf819881ad138dacb3", + "nontrivial_phase_entries": 384, + "phase_histogram": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "phase_real_negations": 512, + "phase_real_swaps": 256 + } + } + }, + "X62": { + "exact_anchor_sha256": "597f80a9353da134f96e538474d6fd1caf126b4a4a57c441da67bdc2acda6f72", + "new": [], + "old": [ + 174 + ], + "rank": 1, + "recipe_sha256": "1cba1735bff74bd0058d32bab252e9360d0566739a8a9bf032f2c151afabc28e", + "signed_pauli_sha256": "f15f73b7c6e4a1dfdb28c4566f425acbb19fb131674219aa8f61ad847b0353ed", + "wrappers": { + "left": { + "cycle_length_histogram": { + "1": 4, + "127": 4 + }, + "cycles": 8, + "direct_gaussian_swaps": 504, + "entries": 512, + "mapping_sha256": "d363d0e51f4e166f12eb4a9a68e9968a27ad75f22c02144403f8863ddce2e8b9", + "nontrivial_phase_entries": 256, + "phase_histogram": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "phase_real_negations": 512, + "phase_real_swaps": 0 + }, + "right": { + "cycle_length_histogram": { + "2": 2, + "254": 2 + }, + "cycles": 4, + "direct_gaussian_swaps": 508, + "entries": 512, + "mapping_sha256": "9d77db2d24899188adc40fd5d9527b149ab210604665b21c29c4af1e2effdb92", + "nontrivial_phase_entries": 384, + "phase_histogram": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "phase_real_negations": 512, + "phase_real_swaps": 256 + } + } + }, + "X63": { + "exact_anchor_sha256": "d3f6acc5a0c9e80922a0b341f42f46dde9800c2e5999ad63deacd496105c5e27", + "new": [], + "old": [ + 161 + ], + "rank": 1, + "recipe_sha256": "9a7cd1e8fc576e3d44a58e8140864f2782687767a595d0cc196de1585edf5864", + "signed_pauli_sha256": "3bd2cb0d6e61fd85d12a4b457a0ce4e87af83b83e757a5fe59cc2ed37549a15a", + "wrappers": { + "left": { + "cycle_length_histogram": { + "1": 4, + "127": 4 + }, + "cycles": 8, + "direct_gaussian_swaps": 504, + "entries": 512, + "mapping_sha256": "721bcf67112de8b13e430f69bc1209fff2a3fbc9ca613f9fd5a5bbad2a187f08", + "nontrivial_phase_entries": 256, + "phase_histogram": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "phase_real_negations": 512, + "phase_real_swaps": 0 + }, + "right": { + "cycle_length_histogram": { + "1": 2, + "255": 2 + }, + "cycles": 4, + "direct_gaussian_swaps": 508, + "entries": 512, + "mapping_sha256": "9b5838cd40320e030b6fb2bfd12be20c05a5ee93d4d1ea55a45ec08d1d6ceba7", + "nontrivial_phase_entries": 384, + "phase_histogram": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "phase_real_negations": 512, + "phase_real_swaps": 256 + } + } + }, + "X67": { + "exact_anchor_sha256": "bd678e5d16d459ffc8d7913480a3c1ff3a9cc357aa5a005cec6363103c97d67b", + "new": [], + "old": [ + 230 + ], + "rank": 1, + "recipe_sha256": "7325fbe687c3457291dbf2a3823c5eeb4a83caa5d34a5e76133414131da41efd", + "signed_pauli_sha256": "454702460126e395dbd9d72c900b18991779c249871d19d7674571fb06bc137e", + "wrappers": { + "left": { + "cycle_length_histogram": { + "1": 4, + "14": 2, + "2": 2, + "28": 6, + "4": 6, + "56": 4, + "7": 4, + "8": 4 + }, + "cycles": 32, + "direct_gaussian_swaps": 480, + "entries": 512, + "mapping_sha256": "99e3aeacdfa785ac3a9949291fa7646ed8de09a32c6be72ca586954b8f033901", + "nontrivial_phase_entries": 256, + "phase_histogram": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "phase_real_negations": 512, + "phase_real_swaps": 0 + }, + "right": { + "cycle_length_histogram": { + "28": 18, + "4": 2 + }, + "cycles": 20, + "direct_gaussian_swaps": 492, + "entries": 512, + "mapping_sha256": "e025ffa28be0b4bc2431b6c9d12150ffab6b927059cb26c6ef323ac5e096a1f0", + "nontrivial_phase_entries": 384, + "phase_histogram": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "phase_real_negations": 512, + "phase_real_swaps": 256 + } + } + }, + "X68": { + "exact_anchor_sha256": "4eec0efd0fe0af7e1e271b8b0a40da3f3b07da369f0c7f49e48c11c940586a89", + "new": [], + "old": [ + 244 + ], + "rank": 1, + "recipe_sha256": "0bed05b1efa51d1ebd1378ed9ae93e3acedddc72e5124e0260f111bed01aa410", + "signed_pauli_sha256": "f2a48863efb527d45dcbbd94fc43af80e4ffb6e8158fa92aeeaa40704635c7ee", + "wrappers": { + "left": { + "cycle_length_histogram": { + "1": 4, + "127": 4 + }, + "cycles": 8, + "direct_gaussian_swaps": 504, + "entries": 512, + "mapping_sha256": "5e9745a4fc2ed30aa65bd5bea7b6bb00007839cf48d74803fee4617133f6f511", + "nontrivial_phase_entries": 256, + "phase_histogram": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "phase_real_negations": 512, + "phase_real_swaps": 0 + }, + "right": { + "cycle_length_histogram": { + "14": 2, + "2": 2, + "210": 2, + "30": 2 + }, + "cycles": 8, + "direct_gaussian_swaps": 504, + "entries": 512, + "mapping_sha256": "192a07af81b950950bc33732c5ff0d16a2a6d0ff7261d67f676abdd145a77218", + "nontrivial_phase_entries": 384, + "phase_histogram": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "phase_real_negations": 512, + "phase_real_swaps": 256 + } + } + }, + "X69": { + "exact_anchor_sha256": "ae7e236fe18a1b6da571f50f6fce9ceeb14af6b2c4ce71c442d025041fceb071", + "new": [], + "old": [ + 155 + ], + "rank": 1, + "recipe_sha256": "c3167bd4dd9bfde0103dfe79ccf3bf38b9f888394cdb339338a464a99dece042", + "signed_pauli_sha256": "53a27870d2ef4a2a35956985f06b09b33baf90435c4bf8ba9fe49f0f89231320", + "wrappers": { + "left": { + "cycle_length_histogram": { + "1": 4, + "126": 2, + "2": 2, + "63": 4 + }, + "cycles": 12, + "direct_gaussian_swaps": 500, + "entries": 512, + "mapping_sha256": "a130145ed6fc7635467ecc6e9ce10cb08695a2bb0e15e0339c2dddc66dfde809", + "nontrivial_phase_entries": 256, + "phase_histogram": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "phase_real_negations": 512, + "phase_real_swaps": 0 + }, + "right": { + "cycle_length_histogram": { + "252": 2, + "4": 2 + }, + "cycles": 4, + "direct_gaussian_swaps": 508, + "entries": 512, + "mapping_sha256": "a832c85cc22b81d57cb6d03864d8a7ee80556b34a3ed224eae5738a0a9ac0ef4", + "nontrivial_phase_entries": 384, + "phase_histogram": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "phase_real_negations": 512, + "phase_real_swaps": 256 + } + } + }, + "X71": { + "exact_anchor_sha256": "6826cb93085e25d306e6646303a4ed1a1504fcad2298323afe9ab6e85dbbb507", + "new": [], + "old": [ + 121 + ], + "rank": 1, + "recipe_sha256": "d1d40690687650a60ad42f6ed0909f23e802dc8e25638d25ce44bbbbec438dc5", + "signed_pauli_sha256": "ce807262f8f03e175f0d91c30e4710e48a346d02e55c54b02d711d0568733055", + "wrappers": { + "left": { + "cycle_length_histogram": { + "1": 8, + "14": 32, + "7": 8 + }, + "cycles": 48, + "direct_gaussian_swaps": 464, + "entries": 512, + "mapping_sha256": "a370ae0a59848ceefd6e75c7b9c82f2ade47134dc4f98be202c71f13abdf6e21", + "nontrivial_phase_entries": 256, + "phase_histogram": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "phase_real_negations": 512, + "phase_real_swaps": 0 + }, + "right": { + "cycle_length_histogram": { + "14": 36, + "2": 4 + }, + "cycles": 40, + "direct_gaussian_swaps": 472, + "entries": 512, + "mapping_sha256": "278455ad7d96deda5d9d2043c3a42923b4037e09fbb5fb4e98a032fdc5ab71c1", + "nontrivial_phase_entries": 384, + "phase_histogram": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "phase_real_negations": 512, + "phase_real_swaps": 256 + } + } + }, + "X72": { + "exact_anchor_sha256": "57afd723b7902d157fa59c1c6145ffcba810ccb1d0354bc25db8fbecb3768b17", + "new": [], + "old": [ + 107 + ], + "rank": 1, + "recipe_sha256": "84d6827852b8a4ce53b58003813f2cf5c3adc48610d653760113207c814cf9d8", + "signed_pauli_sha256": "d5f93aae00fd761b04fdf9714dd81bd4a01a388c02b9b6c983da29577f89f6a1", + "wrappers": { + "left": { + "cycle_length_histogram": { + "1": 8, + "2": 4, + "31": 8, + "62": 4 + }, + "cycles": 24, + "direct_gaussian_swaps": 488, + "entries": 512, + "mapping_sha256": "b9289109e68cdc48cc41692c87e8e3ccb66f056e6f23d8078fa74e64d8154a43", + "nontrivial_phase_entries": 256, + "phase_histogram": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "phase_real_negations": 512, + "phase_real_swaps": 0 + }, + "right": { + "cycle_length_histogram": { + "4": 8, + "60": 8 + }, + "cycles": 16, + "direct_gaussian_swaps": 496, + "entries": 512, + "mapping_sha256": "b4d3fc0305406f3180781a050b04871fac10ce15747b7ffdeac40c53491e1409", + "nontrivial_phase_entries": 384, + "phase_histogram": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "phase_real_negations": 512, + "phase_real_swaps": 256 + } + } + }, + "X73": { + "exact_anchor_sha256": "4e7e6905ed0724da11f6e407bac426e8a7cc7ee9c6811919ff778634aa0cf0f5", + "new": [], + "old": [ + 4 + ], + "rank": 1, + "recipe_sha256": "98147c2a410655f3804a3217462a6b3750e4aaa0aff8295d1077486bcaed752e", + "signed_pauli_sha256": "28816e0939a81a21b76535dc1bf81dc3c27b0a85e07f2b94eee3a1caeb8b3ca6", + "wrappers": { + "left": { + "cycle_length_histogram": { + "1": 128, + "3": 128 + }, + "cycles": 256, + "direct_gaussian_swaps": 256, + "entries": 512, + "mapping_sha256": "5dd2d2beec08eef6f3a87c7fbcfeb097515da92e363d9c360db59840ff761d70", + "nontrivial_phase_entries": 256, + "phase_histogram": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "phase_real_negations": 512, + "phase_real_swaps": 0 + }, + "right": { + "cycle_length_histogram": { + "2": 64, + "6": 64 + }, + "cycles": 128, + "direct_gaussian_swaps": 384, + "entries": 512, + "mapping_sha256": "c460609e3d69faa5ee94010957127e1e67bd7354e934bdecab63645e17daacf5", + "nontrivial_phase_entries": 512, + "phase_histogram": { + "0": 0, + "1": 256, + "2": 0, + "3": 256 + }, + "phase_real_negations": 512, + "phase_real_swaps": 512 + } + } + }, + "X76": { + "exact_anchor_sha256": "08ece12af138044f80af7504ac1f5572f4531e2e3dfbb25ac3fb0ebca22f7dc0", + "new": [], + "old": [ + 44 + ], + "rank": 1, + "recipe_sha256": "fb1f278024e3498ccdcbad8f1eff668b67e4edb957b9dc7325c21bf7deb296da", + "signed_pauli_sha256": "6508f2689163f16991a394ed11838ca80bf977cfb85fcd527c99c3ac8840c713", + "wrappers": { + "left": { + "cycle_length_histogram": { + "1": 16, + "31": 16 + }, + "cycles": 32, + "direct_gaussian_swaps": 480, + "entries": 512, + "mapping_sha256": "9f4dd4a23a3f0afd84af31cb363817f68440ff71e933bb9e9a2e2362754d8b70", + "nontrivial_phase_entries": 256, + "phase_histogram": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "phase_real_negations": 512, + "phase_real_swaps": 0 + }, + "right": { + "cycle_length_histogram": { + "1": 8, + "21": 24 + }, + "cycles": 32, + "direct_gaussian_swaps": 480, + "entries": 512, + "mapping_sha256": "754ba87392bd132186fcda5eec6e4d82f465c03569cb784a981db5329988c9f4", + "nontrivial_phase_entries": 384, + "phase_histogram": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "phase_real_negations": 512, + "phase_real_swaps": 256 + } + } + }, + "X77": { + "exact_anchor_sha256": "db2da22197e3bc4de2a75b549cdbdc6b4f180105a7b744635ce9d1f9a76ab5b7", + "new": [], + "old": [ + 67 + ], + "rank": 1, + "recipe_sha256": "9c253bd4cf3c8a3a834f8e618705758560a8b91a235d1d5fe4e868dac3fd7765", + "signed_pauli_sha256": "eb7302bab29737c2e98b93ffe70975ccbd2d9f6749d1c68593d58490a062563d", + "wrappers": { + "left": { + "cycle_length_histogram": { + "1": 8, + "15": 8, + "2": 4, + "30": 4, + "4": 4, + "60": 4 + }, + "cycles": 32, + "direct_gaussian_swaps": 480, + "entries": 512, + "mapping_sha256": "10799c21c65967d8b732d37e86ef364313005043a4e75f195e5dad9726853728", + "nontrivial_phase_entries": 256, + "phase_histogram": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "phase_real_negations": 512, + "phase_real_swaps": 0 + }, + "right": { + "cycle_length_histogram": { + "1": 4, + "127": 4 + }, + "cycles": 8, + "direct_gaussian_swaps": 504, + "entries": 512, + "mapping_sha256": "0bfdb3a26121adc379af29d94a462dd062fab6505f72bd0c727c76f9df07f068", + "nontrivial_phase_entries": 384, + "phase_histogram": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "phase_real_negations": 512, + "phase_real_swaps": 256 + } + } + }, + "X78": { + "exact_anchor_sha256": "f67415c57c1b3f73f0ac48c66d17d5112cc42907366a06731d1637ae3689315d", + "new": [], + "old": [ + 81 + ], + "rank": 1, + "recipe_sha256": "a6811cba0e30cdf308e35c1586b5e4d5e0426997ad2a01cc390b3d086ab6b55c", + "signed_pauli_sha256": "ea836742c995df707bb2d0b85708f377cf2f81907ad862ff4480492b92062058", + "wrappers": { + "left": { + "cycle_length_histogram": { + "1": 8, + "63": 8 + }, + "cycles": 16, + "direct_gaussian_swaps": 496, + "entries": 512, + "mapping_sha256": "143af8ec569885a54bc9fa4f3a907eed19bd57644a62e1cb6bf54318d93ad875", + "nontrivial_phase_entries": 256, + "phase_histogram": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "phase_real_negations": 512, + "phase_real_swaps": 0 + }, + "right": { + "cycle_length_histogram": { + "1": 4, + "127": 4 + }, + "cycles": 8, + "direct_gaussian_swaps": 504, + "entries": 512, + "mapping_sha256": "04b642327be3d0f080a75ff022b90ce95a54fbd15ea6c8a4d2d264979c61850d", + "nontrivial_phase_entries": 384, + "phase_histogram": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "phase_real_negations": 512, + "phase_real_swaps": 256 + } + } + }, + "X82": { + "exact_anchor_sha256": "c62edb2b5660abca8c989e7a936325b09f66900981159a45a25ce8c6d4414929", + "new": [], + "old": [ + 324 + ], + "rank": 1, + "recipe_sha256": "74065f5ac928576354b6e92f9d7173870e716e02ef09175af5942cb5aab93fdf", + "signed_pauli_sha256": "5039ef632628b31392933f43ef42c40c268630a97544ff21ef8437159ffe1ac5", + "wrappers": { + "left": { + "cycle_length_histogram": { + "1": 2, + "255": 2 + }, + "cycles": 4, + "direct_gaussian_swaps": 508, + "entries": 512, + "mapping_sha256": "532e94a823e44519ac9ee963ac43441459e9003936f7ebbd3c38a379ad34d2a5", + "nontrivial_phase_entries": 256, + "phase_histogram": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "phase_real_negations": 512, + "phase_real_swaps": 0 + }, + "right": { + "cycle_length_histogram": { + "1": 1, + "63": 8, + "7": 1 + }, + "cycles": 10, + "direct_gaussian_swaps": 502, + "entries": 512, + "mapping_sha256": "d608e34f2d28af88871be9223b97272e72c89cc56650db670bb1f98effea120a", + "nontrivial_phase_entries": 384, + "phase_histogram": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "phase_real_negations": 512, + "phase_real_swaps": 256 + } + } + }, + "X86": { + "exact_anchor_sha256": "d38309b06558672c35577d7f544df5974b48076635890475688d53f35f0090dc", + "new": [], + "old": [ + 475 + ], + "rank": 1, + "recipe_sha256": "15df626c51cdaae9980cbfb092426812a99521c837576f8527eaf8fe0e2f3327", + "signed_pauli_sha256": "b6a7627888a925596205caf0e21859de06a9d9ecaab6cfb9d863814d42ded5ff", + "wrappers": { + "left": { + "cycle_length_histogram": { + "1": 2, + "18": 7, + "2": 1, + "36": 7, + "4": 1, + "9": 14 + }, + "cycles": 32, + "direct_gaussian_swaps": 480, + "entries": 512, + "mapping_sha256": "eb386af7fe5eb49ed59cd29d96bcb7aea22a6f1d0ce75ddee8a59fc596e48c99", + "nontrivial_phase_entries": 256, + "phase_histogram": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "phase_real_negations": 512, + "phase_real_swaps": 0 + }, + "right": { + "cycle_length_histogram": { + "1": 1, + "511": 1 + }, + "cycles": 2, + "direct_gaussian_swaps": 510, + "entries": 512, + "mapping_sha256": "7e5c27959ba1996b4e6376518e9f46982650f23b696174832ae408b4a2f37d9e", + "nontrivial_phase_entries": 384, + "phase_histogram": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "phase_real_negations": 512, + "phase_real_swaps": 256 + } + } + }, + "X90": { + "exact_anchor_sha256": "6c739dfb485555f57c1958354d2293391a19896ad6bdce982edd8ae770e0cc19", + "new": [], + "old": [ + 398 + ], + "rank": 1, + "recipe_sha256": "e9b9a9935d805c3fcfd95718e02380418cd9ff152fb7d99a1a0d8bc43d0ddd59", + "signed_pauli_sha256": "c912d4cee4e875b2562bc0c20d43b3a6366686cc0a802a2753c163e05966ff0d", + "wrappers": { + "left": { + "cycle_length_histogram": { + "1": 2, + "2": 1, + "21": 6, + "4": 1, + "42": 3, + "84": 3 + }, + "cycles": 16, + "direct_gaussian_swaps": 496, + "entries": 512, + "mapping_sha256": "f7d729a2392548a712ba21de22d85a9df4904377c9a95f0224016c856598ea60", + "nontrivial_phase_entries": 256, + "phase_histogram": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "phase_real_negations": 512, + "phase_real_swaps": 0 + }, + "right": { + "cycle_length_histogram": { + "248": 2, + "8": 2 + }, + "cycles": 4, + "direct_gaussian_swaps": 508, + "entries": 512, + "mapping_sha256": "accd0fa9c9681e6c3b6f82d1231b34246323d62ab3cd86a88c8fb0c305ea3af6", + "nontrivial_phase_entries": 384, + "phase_histogram": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "phase_real_negations": 512, + "phase_real_swaps": 256 + } + } + }, + "X91": { + "exact_anchor_sha256": "b532b875766654c88361ec7738346f40f08c5c84f4cef89fde7e109073609f51", + "new": [], + "old": [ + 481 + ], + "rank": 1, + "recipe_sha256": "3171f29d6e756709f818a949182e53bde0e79dd8dfba22b3ac959cde430279d3", + "signed_pauli_sha256": "4cbb9ef509c8a774c778a603df580c294a07953cead0f1247462a38b53a6d335", + "wrappers": { + "left": { + "cycle_length_histogram": { + "1": 2, + "15": 2, + "30": 16 + }, + "cycles": 20, + "direct_gaussian_swaps": 492, + "entries": 512, + "mapping_sha256": "3b47618b71aec9241b15a5b8b58c355d4329b393661b7d11cf78c6bd57c6b008", + "nontrivial_phase_entries": 256, + "phase_histogram": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "phase_real_negations": 512, + "phase_real_swaps": 0 + }, + "right": { + "cycle_length_histogram": { + "2": 1, + "510": 1 + }, + "cycles": 2, + "direct_gaussian_swaps": 510, + "entries": 512, + "mapping_sha256": "c823d998733ea7fc33394126c50108fb218776185cb660aad5deab372f4489de", + "nontrivial_phase_entries": 384, + "phase_histogram": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "phase_real_negations": 512, + "phase_real_swaps": 256 + } + } + }, + "X93": { + "exact_anchor_sha256": "43bae01539b6224c779d8166de0524adc099f47335fdf726d6f59c806dbd6105", + "new": [], + "old": [ + 82 + ], + "rank": 1, + "recipe_sha256": "2d1143a049b70040de268d99a29a3565e502982d54be22f2194627d3d87ad8de", + "signed_pauli_sha256": "cc83df9fd4f42071075a9bcce44f76291a08531028e4953d47b20b67623a97df", + "wrappers": { + "left": { + "cycle_length_histogram": { + "1": 8, + "10": 12, + "2": 4, + "20": 12, + "4": 4, + "5": 24 + }, + "cycles": 64, + "direct_gaussian_swaps": 448, + "entries": 512, + "mapping_sha256": "b5fb22796153e83c3d90e3c99834cfcd080f0093524a34766e6b4e19395de5b6", + "nontrivial_phase_entries": 256, + "phase_histogram": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "phase_real_negations": 512, + "phase_real_swaps": 0 + }, + "right": { + "cycle_length_histogram": { + "1": 4, + "127": 4 + }, + "cycles": 8, + "direct_gaussian_swaps": 504, + "entries": 512, + "mapping_sha256": "dac35ba47bbfe8f1e36a42a593c8da7d35f17e99bf676e1d42007c5b4dc5669d", + "nontrivial_phase_entries": 384, + "phase_histogram": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "phase_real_negations": 512, + "phase_real_swaps": 256 + } + } + }, + "X96": { + "exact_anchor_sha256": "fe32131dadba0551c9bd65897e7b293f28292f8f4eef44cc821292e3147e3e32", + "new": [], + "old": [ + 397 + ], + "rank": 1, + "recipe_sha256": "783e4bb693e26b5f0c29b99d5d8195393c95ba228de70d56cbb65ed51f951932", + "signed_pauli_sha256": "bc411f0bed8d7f8278083f5f8e3af20e53866e224f9727cc07b1c8428fdfb365", + "wrappers": { + "left": { + "cycle_length_histogram": { + "1": 2, + "217": 2, + "31": 2, + "7": 2 + }, + "cycles": 8, + "direct_gaussian_swaps": 504, + "entries": 512, + "mapping_sha256": "302a44c2ee52a464e7b6d30c72ac7c430134f8324b405685f6dc34215e17fe50", + "nontrivial_phase_entries": 256, + "phase_histogram": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "phase_real_negations": 512, + "phase_real_swaps": 0 + }, + "right": { + "cycle_length_histogram": { + "170": 3, + "2": 1 + }, + "cycles": 4, + "direct_gaussian_swaps": 508, + "entries": 512, + "mapping_sha256": "ee0d5e228c94721fe6afeeafe7cab06903b9ca21653f7c1e774fe8ed5d34ef6f", + "nontrivial_phase_entries": 384, + "phase_histogram": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "phase_real_negations": 512, + "phase_real_swaps": 256 + } + } + }, + "X97": { + "exact_anchor_sha256": "74425f2a367390fcf5f219443ad3043048ccf5579336a7af925f8ecd52813635", + "new": [], + "old": [ + 482 + ], + "rank": 1, + "recipe_sha256": "4f2c361f3f2e2dc8e4bb675be5884a904fa36d0401f9c6ad22fa97b29fcb3b9d", + "signed_pauli_sha256": "6048b25b5e9071864a717ecb34765ae690da57d17bc7487b2faba4a78a19a67a", + "wrappers": { + "left": { + "cycle_length_histogram": { + "1": 2, + "127": 2, + "2": 1, + "254": 1 + }, + "cycles": 6, + "direct_gaussian_swaps": 506, + "entries": 512, + "mapping_sha256": "e2bed1a8744d1185260e47d6879448daa521e5f670f7f49f76a1b4e1853dae6d", + "nontrivial_phase_entries": 256, + "phase_histogram": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "phase_real_negations": 512, + "phase_real_swaps": 0 + }, + "right": { + "cycle_length_histogram": { + "28": 18, + "4": 2 + }, + "cycles": 20, + "direct_gaussian_swaps": 492, + "entries": 512, + "mapping_sha256": "0d1f8ff278bb9f05af0a3b3ecd8f3527fdc799308a2703a80eee0efa55c26b78", + "nontrivial_phase_entries": 384, + "phase_histogram": { + "0": 128, + "1": 128, + "2": 128, + "3": 128 + }, + "phase_real_negations": 512, + "phase_real_swaps": 256 + } + } + }, + "empty_to_full": { + "exact_anchor_sha256": "7731a10101f9c8ba9b9b92fda1ac936c1caee707e8152490fda3999ec428c35f", + "new": [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ], + "old": [], + "rank": 9, + "recipe_sha256": "03501bf33e7a0f5d4833aba0e0f3969e3dd08aaee1c0f51e45e7b5dce49e063b", + "signed_pauli_sha256": "7645a2b76e8546a75f2f4f0acc4fa2ca71c3af46cd93f6896e3b29add2eeb95f", + "wrappers": { + "left": { + "cycle_length_histogram": { + "1": 512 + }, + "cycles": 512, + "direct_gaussian_swaps": 0, + "entries": 512, + "mapping_sha256": "814fa0bfeb8a09115f08d2b84a769a2aebeaf6d04f2cbd801b27d9810b4eaac3", + "nontrivial_phase_entries": 256, + "phase_histogram": { + "0": 256, + "1": 0, + "2": 256, + "3": 0 + }, + "phase_real_negations": 512, + "phase_real_swaps": 0 + }, + "right": { + "cycle_length_histogram": { + "1": 512 + }, + "cycles": 512, + "direct_gaussian_swaps": 0, + "entries": 512, + "mapping_sha256": "831dee8c5ecfd06657f4b84cb39f4fc17f78137519623941dddbdb058b178230", + "nontrivial_phase_entries": 512, + "phase_histogram": { + "0": 0, + "1": 256, + "2": 0, + "3": 256 + }, + "phase_real_negations": 512, + "phase_real_swaps": 512 + } + } + } + }, + "distinct_recipes": 53, + "exact_anchor_entries_per_recipe": 512, + "monomial_maps_checked_by_separate_kernel": 210, + "proposed_native_calls": 145, + "proposed_native_pair_count": 227584, + "proposed_native_rank_mass": 889, + "proposed_occurrence_profile": { + "1": 52, + "9": 93 + }, + "recipes_sha256": "f3c6320a2efd3a513a3ce41507598137eeb73ecf5a7ab494d27911e64c8326c3", + "schema_version": 1, + "scope": "53 new exact maps; historical native classes not replayed", + "signed_paulis_per_recipe": 18, + "singleton_frames_sha256": "186cf8613a20c1ae5a2f3e4aec0a4fd1dc912c266e39213f440ed60314631a57", + "wrapper_occurrence_counts": { + "cycle_length_histogram": { + "1": 95809, + "10": 18, + "102": 5, + "105": 6, + "12": 182, + "124": 2, + "126": 9, + "127": 44, + "14": 125, + "15": 117, + "16": 16, + "170": 3, + "18": 7, + "186": 2, + "2": 162, + "20": 12, + "21": 88, + "210": 3, + "217": 6, + "248": 2, + "252": 9, + "254": 10, + "255": 12, + "28": 57, + "3": 191, + "30": 97, + "31": 84, + "36": 7, + "4": 130, + "42": 15, + "434": 3, + "465": 1, + "5": 42, + "508": 3, + "510": 3, + "511": 3, + "56": 10, + "6": 198, + "60": 12, + "62": 13, + "63": 34, + "7": 118, + "8": 138, + "84": 3, + "85": 6, + "9": 14, + "93": 9 + }, + "cycles": 97840, + "direct_gaussian_swaps": 50640, + "entries": 148480, + "nontrivial_phase_entries": 104960, + "phase_histogram": { + "0": 43520, + "1": 30720, + "2": 43520, + "3": 30720 + }, + "phase_real_negations": 148480, + "phase_real_swaps": 61440, + "wrappers": 290 + }, + "x_names": [ + "X0", + "X10", + "X101", + "X102", + "X11", + "X12", + "X15", + "X16", + "X17", + "X21", + "X24", + "X25", + "X26", + "X30", + "X31", + "X33", + "X34", + "X37", + "X38", + "X39", + "X41", + "X42", + "X43", + "X47", + "X5", + "X51", + "X52", + "X53", + "X55", + "X56", + "X57", + "X6", + "X60", + "X61", + "X62", + "X63", + "X67", + "X68", + "X69", + "X71", + "X72", + "X73", + "X76", + "X77", + "X78", + "X82", + "X86", + "X90", + "X91", + "X93", + "X96", + "X97" + ] + }, + "physical": { + "actual_fields_sha256": "693dd68a02f23c74fb5f253af7062393efce832cd546769f61192b511abfb817", + "array_equality": { + "Gaussian_coordinates_per_field": 512, + "all_dirty_offsets_preserved": true, + "full_Gaussian_entries_compared": 100864, + "local_outputs": 93, + "restored_Y": 104 + }, + "basis_X": [ + "X0", + "X33", + "X101", + "X102", + "X11", + "X12", + "X15", + "X24" + ], + "canonical_oracle": "Greedy binary-basis enumeration;Q=I+A^T A;H phases;J_W=H^-1 C^-1 H;canonical empty/full cases.", + "controls": { + "boolean_native_phase": "native constant phase", + "inside_2B9_outside_required_4B9": "outside 4B9", + "native_constant_phase_mutation": { + "address": 0, + "change": "phase + 1 modulo 4", + "expected": [ + 1, + 0 + ], + "mutated_wrapper": "left", + "observed": [ + 0, + 1 + ] + }, + "nonintegral_ideal_pair": "nonintegral ideal native pair", + "odd_source_half": "nonintegral source half at 0", + "outside_B9": "outside B9 at Newton mask 1", + "signed_phase_cycle_and_exact_negative_half": "PASS" + }, + "direct_scalar_real_primitives": { + "ADD_SUB": 908288, + "double": 105472, + "exact_half": 105472 + }, + "endpoint_frames_sha256": "a951d115e9dfd769f7e01440e951a93e225eb9692495f95de0d8cdccfd1c73a6", + "expected_fields_sha256": "693dd68a02f23c74fb5f253af7062393efce832cd546769f61192b511abfb817", + "fixture_role_order": [ + "G2", + "G3", + "G9", + "N5", + "N10", + "N12", + "N15", + "N17", + "N24", + "N26", + "N37", + "N38", + "N39", + "N41", + "N42", + "N43", + "N47", + "N51", + "N52", + "N53", + "N55", + "N56", + "N57", + "N60", + "N61", + "N62", + "N63", + "N67", + "N68", + "N69", + "N71", + "N72", + "N73", + "N76", + "N77", + "N78", + "N82", + "N86", + "N90", + "N91", + "N96", + "X0", + "X5", + "X6", + "X10", + "X11", + "X12", + "X15", + "X16", + "X17", + "X21", + "X24", + "X25", + "X26", + "X30", + "X31", + "X33", + "X34", + "X37", + "X38", + "X39", + "X41", + "X42", + "X43", + "X47", + "X51", + "X52", + "X53", + "X55", + "X56", + "X57", + "X60", + "X61", + "X62", + "X63", + "X67", + "X68", + "X69", + "X71", + "X72", + "X73", + "X76", + "X77", + "X78", + "X82", + "X86", + "X90", + "X91", + "X93", + "X96", + "X97", + "X101", + "X102", + "Y0", + "Y1", + "Y2", + "Y3", + "Y4", + "Y5", + "Y6", + "Y7", + "Y8", + "Y9", + "Y10", + "Y11", + "Y12", + "Y13", + "Y14", + "Y15", + "Y16", + "Y17", + "Y18", + "Y19", + "Y20", + "Y21", + "Y22", + "Y23", + "Y24", + "Y25", + "Y26", + "Y27", + "Y28", + "Y29", + "Y30", + "Y31", + "Y32", + "Y33", + "Y34", + "Y35", + "Y36", + "Y37", + "Y38", + "Y39", + "Y40", + "Y41", + "Y42", + "Y43", + "Y44", + "Y45", + "Y46", + "Y47", + "Y48", + "Y49", + "Y50", + "Y51", + "Y52", + "Y53", + "Y54", + "Y55", + "Y56", + "Y57", + "Y58", + "Y59", + "Y60", + "Y61", + "Y62", + "Y63", + "Y64", + "Y65", + "Y66", + "Y67", + "Y68", + "Y69", + "Y70", + "Y71", + "Y72", + "Y73", + "Y74", + "Y75", + "Y76", + "Y77", + "Y78", + "Y79", + "Y80", + "Y81", + "Y82", + "Y83", + "Y84", + "Y85", + "Y86", + "Y87", + "Y88", + "Y89", + "Y90", + "Y91", + "Y92", + "Y93", + "Y94", + "Y95", + "Y96", + "Y97", + "Y98", + "Y99", + "Y100", + "Y101", + "Y102", + "Y103" + ], + "initial_fields_sha256": "1fdea7a8682f92921f855c298724a0ee68c56de5c03ed947ed209d06e0f3b67f", + "initial_fixture": "dense_E9_formula_v1", + "initial_local_domain": "93 physical dirty fields in B9;104 physical Y fields in4B9.", + "input_component_magnitude_bits_limit": 8192, + "literal_program_counts": { + "add": 887, + "double": 103, + "half": 103, + "native": 145 + }, + "native_counts": { + "actual_phase_applications": 148480, + "actual_wrappers": 290, + "completed_floor_pairs": 227584, + "native_calls": 145, + "native_rank_mass": 889 + }, + "native_oracle": "Actual right wrapper, literal signed-floor C pairs with integral ideal comparison, actual left wrapper.", + "observed_peak_component_magnitude": 11232, + "observed_peak_component_magnitude_bits": 14, + "observed_peak_sampling": "Stored fields after complete serialized operations; native-pair internal temporaries are not sampled.", + "program_sha256": "e78b42372973e9f794b17cd0ff9dca0bd444b8af63ad28b4ddad1154a1dc67d2", + "scope": "One complete dense local physical fixture, exact primitive controls, and supplied schedule binding. Universal recipe covariance and B9 invariance are separate proof inputs. No full-WORD arbitrary-input admission, register-owner, routing, total width/cost or frontier claim.", + "source_object_sha256": { + "completion": "4eca9be38c194b8bcc9fe984ac4a5eb6e58503e204574d56f35a0a4b85ce9212", + "empty_to_full": "701ea529d1e7b171655c05debd974b1aa7e0a0cff2fb8e0a9a0753dd9c11ea9c", + "word": "c00db0d99b75817e7805b254f8b33af37d534bd11f0612aca80e16f140159315", + "x_to_empty": "05b5ee6a5e7069915ab756b612fa7abc8e3b486ccd9b4a247782a146b3aa6d5c" + }, + "status": "PASS_INDEPENDENT_LOCAL_PHYSICAL_INPLACE_COMPLETION", + "width_convention": "H_Y denotes actual unhalved common-frame Y. The 8H_X+95H_Y row attains the equal-bound peak103H; it is not a uniform two-parameter bound. Use the primary Pareto envelope for independent H_X,H_Y. Native adapters and temporaries are additional.", + "work_component_magnitude_bits_limit": 8224 + }, + "primary": { + "common_sufficient_admission": { + "N_in_2B9": 78, + "Y_in_4B9": 104, + "all_scalar_increments_module_integral": true, + "minimality_claimed": false, + "native_and_chart_module_lemmas": "Pinned PR3382 and PR3416 proofs, not re-proved by this matrix check.", + "other_in_B9": 176 + }, + "controls": { + "omit_Y0_redoubling": "complete Y source restoration", + "weaken_N100_to_B9": "non-module increment at 312" + }, + "endpoint_matrix_sha256": "8e738751d18e85e1395fa0a7affa2a81d283e41a1e7bdaa8a58b05b97d111e7d", + "entrance": { + "convex_reduced_scalar_envelope": [ + { + "after_prelude_operation": 929, + "bank": "X17", + "twice_y_weight": 190, + "x_weight": 8 + }, + { + "after_prelude_operation": 926, + "bank": "X17", + "twice_y_weight": 128, + "x_weight": 11 + }, + { + "after_prelude_operation": 925, + "bank": "X17", + "twice_y_weight": 98, + "x_weight": 12 + }, + { + "after_prelude_operation": 90, + "bank": "X17", + "twice_y_weight": 0, + "x_weight": 14 + } + ], + "operations": { + "add": 887, + "double": 103, + "half": 103, + "native": 145 + }, + "scalar_peak_after_entering_empty_frame": { + "after_prelude_operation": 929, + "bank": "X17", + "twice_equal_bound": 206, + "twice_y_weight": 190, + "x_weight": 8 + }, + "two_bound_scalar_envelope": [ + { + "after_prelude_operation": 929, + "bank": "X17", + "twice_y_weight": 190, + "x_weight": 8 + }, + { + "after_prelude_operation": 928, + "bank": "X17", + "twice_y_weight": 156, + "x_weight": 9 + }, + { + "after_prelude_operation": 926, + "bank": "X17", + "twice_y_weight": 128, + "x_weight": 11 + }, + { + "after_prelude_operation": 925, + "bank": "X17", + "twice_y_weight": 98, + "x_weight": 12 + }, + { + "after_prelude_operation": 924, + "bank": "X17", + "twice_y_weight": 49, + "x_weight": 13 + }, + { + "after_prelude_operation": 90, + "bank": "X17", + "twice_y_weight": 0, + "x_weight": 14 + } + ], + "width_interpretation": "Maximum of the displayed x_weight*H_X + twice_y_weight*H_Y/2 rows;103H when H_X=H_Y=H. H_X is after entrance conversion and H_Y is unhalved. Native conversions/temporaries are additional." + }, + "native_occurrences_bound": 2070, + "new_program_sha256": "e78b42372973e9f794b17cd0ff9dca0bd444b8af63ad28b4ddad1154a1dc67d2", + "normalised_endpoint_fields_checked": 358, + "normalised_matrix_entries_checked": 128164, + "original_opcode_counts": { + "add": 3104, + "erase": 8, + "sign": 208, + "transport": 2070, + "zero": 8 + }, + "projection_event_sha256": "66113bcd513a17eac24f43944a8759bdae1bb2a85e2b9900122f281c5c676dc8", + "projection_never_reads_or_writes_omitted": true, + "residual_nonzero_coefficients": 2500, + "residual_nonzero_rows": 52, + "retained_opcode_counts": { + "add": 2310, + "erase": 8, + "sign": 104, + "transport": 1597, + "zero": 8 + }, + "status": "PASS_SOURCE_BOUND_ENTRANCE_MATRIX_AND_ADMISSION" + }, + "schema_version": 1, + "scope": "An actual local in-place entrance completion, a source-bound all358 endpoint/module implication, one independent dense literal prefix, and a conditional rejected consumer budget. No global owner, full physical bill, all-size supplier, or new selected saving.", + "status": "PASS_P104_INPLACE_ENTRANCE", + "typed_receipt_control": "Boolean true is distinct from integer1." +} diff --git a/research/p104-inplace-entrance/SOURCES.json b/research/p104-inplace-entrance/SOURCES.json new file mode 100644 index 0000000000..5cd27fb5d5 --- /dev/null +++ b/research/p104-inplace-entrance/SOURCES.json @@ -0,0 +1,393 @@ +{ + "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" + }, + { + "path": "research/gmx-t74-borrow43-handoff/new/fastnative/vendor/native/new/code/borrow/vendor/clifford/clifford_exact.py", + "usage": "input", + "git_blob": "166841a037f069249f6f7f6dedb89248812f59e2", + "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962", + "author_credit": "Retained Gaussian Clifford compiler and credited containing-package lineage. Exact executable authorship is not inferred from directory ownership.", + "role": "Unchanged compiler used only to synthesize the 53 new maps. Its own execution object is not the independent endpoint oracle.", + "retention": "Unchanged bytes at base_commit; SHA256 and Git blob are pinned above." + }, + { + "path": "research/p104-consumer-budget-audit/README.md", + "usage": "input", + "git_blob": "7317fa775e5942e66237b9053aa5e0ed8dc6b1a3", + "sha256": "13694215d0c1a245b392f7155e8395b9c4bad9c5db3558833c784d9449616417", + "author_credit": "Jose Manuel / jmbarrancoml (original observation), then Vasek / flyingviper (PR2744 audit)", + "role": "Frozen five-forward/four-dual coverage hypotheses. The present invoice substitutes a new realized profile; the old theorem is not misapplied as an unchanged-profile result.", + "retention": "Unchanged bytes at base_commit; SHA256 and Git blob are pinned above." + }, + { + "path": "research/p104-omitted-completion/CERTIFICATE.json", + "usage": "input", + "git_blob": "2893b15a23100beba7a46595afe181a551a7e39c", + "sha256": "f68a2e6f3bd771b9692772909df200102350a80deda35532f3cc348b75d0c044", + "author_credit": "Nick Petalas / petalas", + "role": "PR3462 rank-eight R=CA/2 factor, identity pivot block and exact projection digest; retained unchanged.", + "retention": "Unchanged bytes at base_commit; SHA256 and Git blob are pinned above." + }, + { + "path": "research/p104-omitted-frame-adapters/ADAPTERS.json", + "usage": "input", + "git_blob": "be3da1fa244260cf32d7c8f795af53b85965f2e0", + "sha256": "db424edfb316f06f4913946b2b0cafa2f200b75392cacb35244b8705db02387c", + "author_credit": "Nick Petalas / petalas", + "role": "PR3469 omitted-bank inventory, original transport profile and retained full-frame native certificate. Isolated-adapter optimality does not cover scalar interleaving.", + "retention": "Unchanged bytes at base_commit; SHA256 and Git blob are pinned above." + }, + { + "path": "research/p104-omitted-frame-adapters/inputs/ORIGINS.json", + "usage": "input", + "git_blob": "f719b868db77df71dbf62b05e7a8e9e65a1afbaf", + "sha256": "c28888fb28c6c4defab5dd4b17150001d7435a6e7346a705ca0a266b67e1598c", + "author_credit": "Nick Petalas / petalas", + "role": "Authenticates the retained PR3416 checker origin.", + "retention": "Unchanged bytes at base_commit; SHA256 and Git blob are pinned above." + }, + { + "path": "research/p104-omitted-frame-adapters/inputs/PR3416_verify.py", + "usage": "input", + "git_blob": "d47b804ad8fa9b722d18d4f518e3f8532ca18e3b", + "sha256": "d9fa70e7feb0032048b84b7a3e63628d56b206030b2f6b6a5c001b470bb9d049", + "author_credit": "Nick Petalas / petalas", + "role": "Unchanged separate signed-Pauli/global-phase checker. Only the new-map APIs are called; its historical census entry point is not run.", + "retention": "Unchanged bytes at base_commit; SHA256 and Git blob are pinned above." + }, + { + "path": "research/p104-rounded-collector/inputs/NATIVE.json.gz", + "usage": "input", + "git_blob": "04f2877aa5444948b7ae37efd267745af82cb34d", + "sha256": "ab91c78835c3e10cf3b2cb8a5d4e0b7cfc3df1ae5a811298d27842f2193e1e3d", + "author_credit": "ywz65, retained by Arham Tahir / PR2665", + "role": "Original PR2586 native archive, bound to the actual WORD occurrences; the 1,245-class historical covariance theorem is inherited, not rerun.", + "retention": "Unchanged bytes at base_commit; SHA256 and Git blob are pinned above." + }, + { + "path": "research/p104-rounded-collector/inputs/WORD.json", + "usage": "input", + "git_blob": "93acaabc0a523789ef2f1b06f6eeeefed5551397", + "sha256": "cec1fb3fbd0067b500ad5119a62ba60685be718e769374d7ec8abdd2beaa7e50", + "author_credit": "ywz65, retained by Arham Tahir / PR2665", + "role": "Actual 5,398-event physical corrected-dual WORD, with 358 public input/output frame contracts.", + "retention": "Unchanged bytes at base_commit; SHA256 and Git blob are pinned above." + }, + { + "path": "research/p104-stagewise-entrance/inputs/PR3382_PROOF.md", + "usage": "input", + "git_blob": "10b3202c788b5b03188eed91181441dfd793ff7f", + "sha256": "1ca8c0e7e78f0f39de6cff7accc68ccd3901bfb50759bf7a2e2896bcf63bf081", + "author_credit": "Clear1nsight with substantial OpenAI assistance", + "role": "Unchanged inherited B9 module/codec definition, automorphisms and integral ideal-pair iff exact signed-floor criterion.", + "retention": "Unchanged bytes at base_commit; SHA256 and Git blob are pinned above." + }, + { + "path": "research/p104-stagewise-entrance/inputs/PR3416_PROOF.md", + "usage": "input", + "git_blob": "276f61cb64d253f6d43e1ec7e8230df551ad02cd", + "sha256": "0dc1c35158902299fc8748c8baf89205483562f041e9050580e6579c331ebeb5", + "author_credit": "Nick Petalas / petalas", + "role": "Unchanged inherited complete native covariance, including phase, for the original WORD.", + "retention": "Unchanged bytes at base_commit; SHA256 and Git blob are pinned above." + }, + { + "path": "LICENSE", + "usage": "input", + "git_blob": "261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64", + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "bytes": 11357, + "role": "Documentary runtime-authenticated input retained in standalone exports; no executable import. Preserve repository licensing and source-specific predecessor attribution unchanged." + }, + { + "path": "NOTICE", + "usage": "input", + "git_blob": "59d8e0cf3102e15bd11db430838365531e2d7f18", + "sha256": "b49022cb4104d90b182e4c335f670faf45529025b15db77bf0291835083c28bd", + "bytes": 24973, + "role": "Documentary runtime-authenticated input retained in standalone exports; no executable import. Preserve repository licensing and source-specific predecessor attribution unchanged." + }, + { + "path": "research/p104-native-channel/notices/FRAME-SA504-NOTICE.md", + "usage": "input", + "git_blob": "f7a8f861be860edd5a78114c5225dec90effa029", + "sha256": "a92f49c5ced455160fbedcc8954e3c9255e3605e88ad12ae5a84f1c4302986f1", + "bytes": 1451, + "role": "Documentary runtime-authenticated input retained in standalone exports; no executable import. Preserve repository licensing and source-specific predecessor attribution unchanged." + }, + { + "path": "research/p104-native-channel/notices/PR1862-NOTICE.md", + "usage": "input", + "git_blob": "24461eddc12e01eb817fd916debafdadfde8a63e", + "sha256": "d86f31a4c0bafd4271fe0c0e087a7fc1cd72d5b705e3739c4ba3e9241b7ba3f9", + "bytes": 3173, + "role": "Documentary runtime-authenticated input retained in standalone exports; no executable import. Preserve repository licensing and source-specific predecessor attribution unchanged." + }, + { + "path": "research/p104-native-channel/notices/PR1972-NOTICE.md", + "usage": "input", + "git_blob": "eb4ac7c07f10e754657acaefddb0937aacd71381", + "sha256": "2d9c60fdeda14a8609f2b210fe0873ee0318788130637db9e5e79d487243ab7d", + "bytes": 817, + "role": "Documentary runtime-authenticated input retained in standalone exports; no executable import. Preserve repository licensing and source-specific predecessor attribution unchanged." + }, + { + "path": "research/gmx-t74-borrow43-handoff/new/fastnative/NATIVE-LINEAGE-NOTICE", + "usage": "input", + "git_blob": "380e979f0e84e00a22bd890615d87cc4684ad740", + "sha256": "ee0c73ca35877aad0e0b6adc560a3881cb82276dba4cf2d4fc58cd19e57cc420", + "bytes": 2456, + "role": "Exact containing native-package notice, retained and authenticated for standalone export. It credits the Rohan Arun/Tekalign derivative and original Jeremy Kothe/Cinna Davis and other local/native lineage; exact authorship of the Clifford executable is not inferred." + } + ], + "repository": "CrocSwap/integer-mult-bounds", + "source_policy": "All files rows resolve at the exact base_commit. Existing scientific inputs remain byte-for-byte unchanged. The 16 input rows include six documentary license/notice files for export retention; only two retained Python files are executed. Source/history equality is provenance, not independent mathematical acceptance.", + "new_work_license": "Apache-2.0, under the retained repository LICENSE. Existing source-specific notices and historical assistance disclosures remain in force.", + "notice_inputs": [ + "LICENSE", + "NOTICE", + "research/p104-native-channel/notices/FRAME-SA504-NOTICE.md", + "research/p104-native-channel/notices/PR1862-NOTICE.md", + "research/p104-native-channel/notices/PR1972-NOTICE.md", + "research/gmx-t74-borrow43-handoff/new/fastnative/NATIVE-LINEAGE-NOTICE" + ], + "source_origins": [ + { + "source_path": "research/p104-omitted-completion/CERTIFICATE.json", + "pull_request": 3462, + "author": "Nick Petalas / petalas", + "head": "7f0706bf7e7d6fce317d353d513157ebb368beb6", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3462" + }, + { + "source_path": "research/p104-omitted-frame-adapters/ADAPTERS.json", + "pull_request": 3469, + "author": "Nick Petalas / petalas", + "head": "f42cc424aad37f5734fd1c893ecdadd8cc53e1c1", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3469" + }, + { + "source_path": "research/p104-omitted-frame-adapters/inputs/PR3416_verify.py", + "pull_request": 3416, + "author": "Nick Petalas / petalas", + "head": "f1112560883a5e81b1a29c37c81a79a20be31fe3", + "origin_path": "research/p104-native-covariance/verify.py", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3416" + }, + { + "source_path": "research/p104-stagewise-entrance/inputs/PR3382_PROOF.md", + "pull_request": 3382, + "author": "Clear1nsight with substantial OpenAI assistance", + "head": "2834523b1cd4ea83ba7a043e2e2f5f3332cf9909", + "origin_path": "research/p104-clifford-exactness/PROOF.md", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3382" + }, + { + "source_path": "research/p104-stagewise-entrance/inputs/PR3416_PROOF.md", + "pull_request": 3416, + "author": "Nick Petalas / petalas", + "head": "f1112560883a5e81b1a29c37c81a79a20be31fe3", + "origin_path": "research/p104-native-covariance/PROOF.md", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3416" + }, + { + "source_paths": [ + "research/p104-rounded-collector/inputs/WORD.json", + "research/p104-rounded-collector/inputs/NATIVE.json.gz" + ], + "pull_request": 2586, + "author": "ywz65", + "head": "7953c9a8f788a8de5cf2ced63d9a61b67c22c6f1", + "retained_by": "Arham Tahir / PR2665; current canonical paths are independently pinned in files.", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2586" + }, + { + "source_path": "research/p104-consumer-budget-audit/README.md", + "pull_request": 2744, + "author": "Vasek / flyingviper", + "head": "0166260409f55a56e7fefa48d859f7dd5b42b300", + "prior_observation_credit": "Jose Manuel / jmbarrancoml", + "prior_observation_url": "https://github.com/CrocSwap/integer-mult-bounds/discussions/2619#discussioncomment-18955566", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2744" + } + ], + "context_sources": [ + { + "path": "research/p104-omitted-completion/PROOF.md", + "origin_commit": "7f0706bf7e7d6fce317d353d513157ebb368beb6", + "url": "https://github.com/CrocSwap/integer-mult-bounds/blob/7f0706bf7e7d6fce317d353d513157ebb368beb6/research/p104-omitted-completion/PROOF.md", + "sha256": "d77dfddc22ec31b24b75f00bb0e78034e8d1abd37972651c80458a4339904961", + "git_blob": "7cf8c7ee0eebb11ab024b8326e59c376cbd43701", + "bytes": 8992, + "usage": "read-only contextual proof/credit; not an executable replay input" + }, + { + "path": "research/p104-omitted-completion/README.md", + "origin_commit": "7f0706bf7e7d6fce317d353d513157ebb368beb6", + "url": "https://github.com/CrocSwap/integer-mult-bounds/blob/7f0706bf7e7d6fce317d353d513157ebb368beb6/research/p104-omitted-completion/README.md", + "sha256": "2d49ed6d8676a8f24dc453437ec320b23735dc3d979660a7d24fde71d34a9556", + "git_blob": "d375a6ef314eb76a313145aee12d57ec0e8c560f", + "bytes": 5833, + "usage": "read-only contextual proof/credit; not an executable replay input" + }, + { + "path": "research/p104-omitted-frame-adapters/PROOF.md", + "origin_commit": "f42cc424aad37f5734fd1c893ecdadd8cc53e1c1", + "url": "https://github.com/CrocSwap/integer-mult-bounds/blob/f42cc424aad37f5734fd1c893ecdadd8cc53e1c1/research/p104-omitted-frame-adapters/PROOF.md", + "sha256": "f0ffae7c84f27bc0f4ae674335e639f79e73ec3c1c8f94ce7e18ec2e3d2aaf2b", + "git_blob": "7b994b1a229d26f7f4f0dc0fc456b2f7837f8fa9", + "bytes": 8832, + "usage": "read-only contextual proof/credit; not an executable replay input" + }, + { + "path": "research/p104-external-port-closure/README.md", + "origin_commit": "886222c1d3e2c2d878b263dc8d165ef03d5bac7f", + "url": "https://github.com/CrocSwap/integer-mult-bounds/blob/886222c1d3e2c2d878b263dc8d165ef03d5bac7f/research/p104-external-port-closure/README.md", + "sha256": "b09dbbe2631df90ecc2752a476be50932b9df3f88b14e58869441ce7652f754a", + "git_blob": "4d897e52dfc6d04caf67860c4689d567cfa1ddaf", + "bytes": 9067, + "usage": "read-only contextual proof/credit; not an executable replay input" + }, + { + "path": "research/direct584-commuting-retiming-cover/README.md", + "origin_commit": "e3dc9c1660bfec0501dd7522f44a21746f9b89e2", + "url": "https://github.com/CrocSwap/integer-mult-bounds/blob/e3dc9c1660bfec0501dd7522f44a21746f9b89e2/research/direct584-commuting-retiming-cover/README.md", + "sha256": "6e05368b1f78c11676a467504bcd8d48d8a4b6633238994fb5575e35014b666a", + "git_blob": "c070870a491169c29b61e1dc77a1000488d57641", + "bytes": 5604, + "usage": "read-only contextual proof/credit; not an executable replay input" + }, + { + "title": "In-place accumulation of fast multiplication formulae", + "authors": [ + "Jean-Guillaume Dumas", + "Bruno Grenet" + ], + "version": "arXiv:2307.12712v3", + "version_date": "2024-07-01", + "venue": "ISSAC 2024", + "url": "https://arxiv.org/abs/2307.12712v3", + "published_doi": "10.1145/3666000.3669671", + "usage": "General in-place accumulation principle and temporarily modified/restored input model; credited mathematical precedent. No paper source/code is copied or executed; the P104 construction is derived in PROOF.md.", + "license_scope": "Citation only; no relicensing of the external paper." + } + ], + "mathematical_dependencies": [ + { + "source": "PR3382", + "statement": "The stated B9 Gaussian Newton module is preserved by the admitted monomials/native coordinate stages; ideal integral pairs coincide with the literal signed-floor implementation.", + "status": "Inherited written theorem, retained unchanged; not independently formalized here." + }, + { + "source": "PR3416", + "statement": "Original native recipes equal the complete Delta_new Delta_old^-1 chart map, including global phase.", + "status": "Historical 1,245-class covariance theorem inherited. The 53 newly synthesized maps are separately certified by the retained checker in this package." + }, + { + "source": "PR3446", + "statement": "The released retained event set supplies the 4,027-event projection and identifies 93 omitted banks.", + "status": "Both graph and bitset closure reconstructions, no omitted-bank access, full endpoint comparison and exact digest binding are new checks here." + }, + { + "source": "PR3462 and PR3469", + "statement": "The residual CA/2 factor and isolated endpoint-adapter data are retained.", + "status": "Rank 8/factorization and isolated adapter optimality are predecessor results. New work supplies the actual entrance placement, dirty-output/source-return word and its realized native profile." + }, + { + "source": "Jose Manuel observation and PR2744", + "statement": "Frozen m=73/W=832, five-forward/four-dual, persistent-credit and paid-coverage hypotheses.", + "status": "The new profile is substituted explicitly. Neither old-profile stopping results nor archival intake automatically establish this new conditional comparison." + } + ], + "credit": [ + { + "author": "Hiroki Kumazaki / kumagi", + "pull_request": 3446, + "head": "886222c1d3e2c2d878b263dc8d165ef03d5bac7f", + "contribution": "External-port closure, retained projection and released omitted-recipient handoff." + }, + { + "author": "Nick Petalas / petalas", + "pull_requests": [ + 3462, + 3469, + 3416 + ], + "contribution": "Rank-eight omitted factor, isolated adapters, native covariance and their precise remaining frame/phase obligations; exact heads are in source_origins." + }, + { + "author": "ywz65", + "pull_request": 2586, + "head": "7953c9a8f788a8de5cf2ced63d9a61b67c22c6f1", + "contribution": "Actual corrected physical dual, logical/physical WORD and native lineage." + }, + { + "author": "Arham Tahir", + "pull_request": 2665, + "contribution": "Unchanged rounded-collector retention and source binding of the actual WORD/native inputs." + }, + { + "author": "Clear1nsight with substantial OpenAI assistance", + "pull_requests": [ + 3382, + 3423, + 3467, + 3554, + 3577 + ], + "contribution": "Newton exactness and prior producer/caller/consumer boundaries; these older results are not republished as the new entrance completion." + }, + { + "author": "Jean-Guillaume Dumas and Bruno Grenet", + "contribution": "General in-place accumulation with mutable/restored inputs, cited above; no priority claim for that method." + }, + { + "author": "Jose Manuel / jmbarrancoml, then Vasek / flyingviper", + "pull_request": 2744, + "contribution": "Original consumer-budget insight first, then the source/coverage audit retaining its exact assumptions." + }, + { + "author": "Ross Richardson", + "pull_requests": [ + 2445, + 2458, + 3594 + ], + "contribution": "Retained forward/word and fixed-profile context; the current different four-read retiming scope is credited and not repeated." + }, + { + "author": "Jeremy Kothe / jeremykothe2", + "contribution": "Containing local-supplier and gmx-t74-borrow43-handoff lineage, as credited in PR3469. This does not attribute authorship of the exact retained Clifford executable." + }, + { + "author": "Tekalign / tekuuu", + "pull_requests": [ + 3025, + 3218 + ], + "contribution": "Literal signed-floor/wrapper conventions and the phase-sensitive Pauli-plus-anchor criterion." + }, + { + "author": "Earlier source-specific contributors, including DreamingOfClouds, icekylinx, Vasek, Douglas Colkitt, Rohan Arun, Adam Gall, Josie Elliston, Ali Romman, themilkman216, GamingPuzzled / Joel Pulikkan, Hao Yan and Chafik Boukhalfa", + "contribution": "Retained geometry, channel, compiler, source/target compensation, LemmaG and original manuscript lineage. Documentary input files preserve their notices and historical assistance disclosures, including the containing native-package lineage." + }, + { + "author": "Rohan Arun, Tekalign / tekuuu, Cinna Davis / 1337isnot1337 and all contributors named in NATIVE-LINEAGE-NOTICE", + "contribution": "Containing native-package derivative and anticipatory dirty-borrowing lineage, retained as exact documentary input. These source notices do not by themselves identify the author of every vendored executable." + } + ], + "scope_limit": "No new rank-eight factorization or lattice classification, no historical full-census replay, no complete physical owner/bill, no all-size supplier admission, no frontier change and no new kappa." +} diff --git a/research/p104-inplace-entrance/TASK.json b/research/p104-inplace-entrance/TASK.json new file mode 100644 index 0000000000..76525ef6b2 --- /dev/null +++ b/research/p104-inplace-entrance/TASK.json @@ -0,0 +1,379 @@ +{ + "schema_version": 1, + "task_id": "p104-side-correction", + "priority_revision": 6, + "base_commit": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "scope_status": "changed", + "actual_scope": "Construct and certify one in-place omitted-bank completion at the actual entrance of the pinned 5,398-event P104 physical dual, then execute the unchanged 4,027-event projection. Use the eight identity-block X outputs as dirty accumulators, restore temporary Y source writes, deliver all omitted final frames, and substitute the realized profile into the named complete consumer screen.", + "scope_change_reason": "CHANGED from the drawn joint-flag question to the released PR3446/3462/3469 common-frame acquisition obligation. This changes the scalar network and chronological placement, supplies an actual restored-source word, and prices that word; it is not another static flag cover, isolated adapter census, correlated-entrance classification or fixed four-read retiming test.", + "bottleneck_link": "The predecessor CA/2 completion had not supplied the simultaneous Y-frame access needed by its physical caller. At the actual WORD entrance all Y fields have the empty frame. The new dirty-output schedule computes the missing map there, restores retained fields before the projection, and replaces the 473 omitted native occurrences by 145 realized occurrences of equal rank mass. The updated complete consumer screen still fails, so the deliverable is a local interface and a model-specific stopping decision.", + "budget_minutes": null, + "stop_rule": "NARROW to this exact local entrance result. Pause dependent owner, supplier and all-size construction aimed at the selected target under the retained m=73, W=832, five-forward/four-dual coverage law: even favorable rank forgiveness with the newly realized dual profile gives a moment greater than one at the selected benchmark. Reopen only for a concrete changed complete consumer, coverage law or realized scalar/native network with a new fully charged favorable screen. Do not infer a universal P104 obstruction.", + "outcome": "partial", + "evidence": "PROOF.md establishes the dirty-output chronology, common sufficient B9-domain implication and physical endpoint interpretation. PROGRAM.json and NATIVE.json serialize the actual prelude and 53 maps. primary.py compares all 128,164 scalar coefficients and 358 final frames; native.py certifies new signed Pauli actions and exact phase; physical.py supplies an independent dense literal prefix comparison; invoice.py independently reconstructs the projection and derives exact arithmetic/native inventories and the rational consumer stop. controls.py exercises omitted/late preconditioning. Component evidence has been inspected; final registered normal/optimized replay, committed export/source-history and hosted CI remain publication gates at this metadata freeze.", + "author": "Clear1nsight", + "ai_assistance": "Substantial OpenAI assistance from a root agent and three concurrent specialist agents in mathematics, implementation, independent finite checks, source/overlap audit and publication preparation. Separate same-session implementations and cross-review are described by their actual coverage; no independent human acceptance, formal-kernel proof or OpenAI endorsement is claimed.", + "open_questions": [ + { + "question": "Can a changed complete consumer or coverage law use this local word and pass its own favorable cost screen?", + "why_it_matters": "The realized local gain still fails the retained five-forward/four-dual model; extra owner/supplier engineering cannot repair that stated optimistic failure.", + "first_step": "Identify one failed assumption that changes, state the actual upstream/downstream contract, and give a rational whole-bill screen including its replacement cost before implementation expansion.", + "blocked_by": "Actual owners, idle coverage, finite widths, source preparation and the absence of a favorable changed complete bill." + }, + { + "question": "Can a realized changed scalar/native network reduce the remaining full dual tariff enough to change the decision?", + "why_it_matters": "A more concentrated abstract profile is not an executable replacement, and unchanged forward calls and cleanup may erase a local gain.", + "first_step": "Publish one exact network delta with source acquisition, native frames/phases, return maps, unchanged forward charges and a full conditional moment comparison.", + "blocked_by": "No cheaper realized network with a favorable complete screen; isolated histogram optimization is insufficient." + }, + { + "question": "Is there an independently specified caller that benefits after width, routing and monomial costs?", + "why_it_matters": "The WORD entrance is a concrete local caller, but its identity does not establish global ownership or an all-size physical supplier.", + "first_step": "Name the physical banks, entrance frames, allowed temporary source writes and required observables, then bound every width and machine charge in that caller.", + "blocked_by": "Unpriced source admission, temporary headroom, routing/controller cost, legal ownership and recursive transfer." + } + ], + "budget_note": "The user explicitly removed the session time cap for this continuation. The scientific scope remains bounded to this one completion and its verification. Successful local checks do not themselves reopen the paused consumer route.", + "claim_url": "https://github.com/CrocSwap/integer-mult-bounds/discussions/2750#discussioncomment-19014226", + "claim_status_at_metadata_freeze": "Active scoped claim; the latest loaded body has no replies. Result/handoff publication and claim release follow final gates.", + "metadata_frozen_at_utc": "2026-10-18T08:30:21Z", + "selection": { + "mode": "Handoff-first continuation under the preserved p104-side-correction catalogue card; no reroll of the original card.", + "starting_obligation": "PR3462/3469 actual common-frame source acquisition for the omitted completion of PR3446.", + "original_card_preserved": true + }, + "scientific_boundary": { + "word_events": 5398, + "public_banks": 358, + "projection_events": 4027, + "projection_event_sha256": "66113bcd513a17eac24f43944a8759bdae1bb2a85e2b9900122f281c5c676dc8", + "entrance_operations": 1238, + "omitted_banks": 93, + "pivot_X_banks": [ + "X0", + "X33", + "X101", + "X102", + "X11", + "X12", + "X15", + "X24" + ], + "local_domain": "93 omitted physical dirty fields in B9 and all 104 Y in 4B9, with the actual prescribed entrance frames and temporarily writable/restored Y access.", + "common_full_word_domain": "All 104 Y in 4B9, all 78 N in 2B9, and the other 176 public fields in B9. This sufficient product domain is not claimed minimal.", + "physical_target": "The complete endpoint of the canonical ordinary inverse-transpose of the two-target-corrected P104 shear, in the retained Delta=conjugate(Gamma)=Gamma^-T charts. The remaining 102 forward rows are still Gram/2.", + "restoration": "All Y fields return to their identical entrance values and frames before the projection. The 93 omitted outputs reach their required final full frames. The eight pivot X banks are required updated outputs, not borrowed helpers required to return unchanged.", + "storage": "No added Gaussian bank in the new prelude; all eight original private-C zero/erase lifetimes remain in the unchanged projection. Component scratch, wrappers, widths, owners and machine routing are additional obligations." + }, + "family_decision": { + "decision": "narrow", + "gate": "docs/research/research-family-status.md at the frozen base", + "positive_result": "An actual common-frame entrance word with arbitrary admitted dirty offsets, source return and all final endpoint frames, plus a strict local concave-native tariff gain.", + "unfavorable_complete_screen": "New full native profile (1316,61,74,86,33,25,46,8,93), mass 3542. Under the explicit five-forward/four-dual coverage assumptions and 416 rank units forgiven per dual, the new rational slope is 75068 and M_B(a)>1+(75068a-104)/(73(832+B)) for finite fully paid B and 0" + ], + "searched_at": "2026-10-18T07:32:06.788178+00:00", + "cache_fetched_at": "2026-10-18T07:23:06Z", + "cache_placeholder": "The portable placeholder denotes the recorded complete 315-body entry snapshot, not a committed mathematical input." + } + }, + "finding": "No equivalent actual entrance/in-place CA/2 completion found in those bodies and the exact PR3462/PR3469 proofs. This is bounded overlap evidence, not a universal novelty guarantee." + }, + { + "kind": "presubmission", + "canonical_fetch_utc": "2026-10-18T08:18:06Z", + "canonical_main": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "priority_revision": 6, + "main_path_delta": [], + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129", + "catalogue_sha256": "47b42433f5a85809a3aadd29c2c339da2c6ed728e4f7762df6b88bccb7874cf0", + "guidance": "Root reread current AGENTS.md, autoresearch.md, CONTRIBUTING.md and the family gate; all retained source/guidance bytes remain unchanged.", + "open_PR_delta": { + "checked_at": "2026-10-18T08:18:06Z", + "method": "Delta of all open PR bodies updated since complete 315-body snapshot 2026-10-18T07:23:06Z. First 100 sorted-updated includes oldest 2026-10-16T12:33:12Z, so all updates in interval covered.", + "updated_records": [ + { + "number": 3603, + "head": "dd2796bf53d0db44a1e1050c18f3f0bad7141267", + "updated_at": "2026-10-18T08:14:59Z" + }, + { + "number": 3602, + "head": "f7a987e11007685bd88d7ac9693d26b4d604938d", + "updated_at": "2026-10-18T08:07:48Z" + }, + { + "number": 3599, + "head": "72df81b8cee17ffd990fc18b2d54024f65971556", + "updated_at": "2026-10-18T07:52:12Z" + }, + { + "number": 3601, + "head": "26394881f0a183ca0df3d986ec58aa56900ada6c", + "updated_at": "2026-10-18T07:44:08Z" + }, + { + "number": 3594, + "head": "e3dc9c1660bfec0501dd7522f44a21746f9b89e2", + "updated_at": "2026-10-18T07:28:14Z" + }, + { + "number": 3600, + "head": "a101c4e42c5df705f9a3e8cf191e379dafcc7be7", + "updated_at": "2026-10-18T07:28:00Z" + } + ], + "material_comparison": "PR3601 concerns flag 43/Y59 at a different co-hosted cut; PR3603 concerns owner/common-view direction on the T74 contract; PR3594 remains the fixed four-read commuting-retiming family at e3dc9c1660bfec0501dd7522f44a21746f9b89e2. No new same entrance completion was found in the reviewed update bodies." + }, + "discussion_read_utc": "2026-10-18T08:19:00Z", + "discussion_coverage": { + "2750": "Newest loaded body remains scoped claim 19014226, with 0 replies.", + "1166": "Newest loaded handoff is 19013929 pointing to PR3596.", + "1167": "Newest loaded mechanism pointer is 19013932 pointing to PR3594.", + "limits": "Fresh loaded bodies and visible replies only; hidden/global Discussion pagination is not claimed." + }, + "decision": "Continue to final verification/publication of the frozen local result; preserve all source pins and the conditional NARROW/stop decision." + } + ], + "orientation_baseline": { + "command": "python3.12 -B scripts/research_baseline.py", + "status": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "checked_at_utc": "2026-10-18T08:18:50Z", + "scope": "Current-round source-binding and arithmetic orientation only. The initial sparse-worktree attempt failed because the selected ASSEMBLY source was not materialized; root then ran the same command read-only in the retained canonical source checkout with identical selected bytes. No full selected mathematical replay was run." + }, + "predecessor_evidence_status": { + "central_ledger_at_base": [ + { + "current_head": "886222c1d3e2c2d878b263dc8d165ef03d5bac7f", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "number": 3446, + "review_completion": { + "changed_file_coverage": true, + "published": true, + "required_execution_complete": false, + "scoped_mechanism_review": false + }, + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa." + }, + { + "current_head": "7f0706bf7e7d6fce317d353d513157ebb368beb6", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "number": 3462, + "review_completion": { + "changed_file_coverage": true, + "published": true, + "required_execution_complete": false, + "scoped_mechanism_review": false + }, + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa." + }, + { + "current_head": "4e4b08c689242f7f3be2e5e08dc1ae8d728ff920", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "number": 3467, + "review_completion": { + "changed_file_coverage": true, + "published": true, + "required_execution_complete": false, + "scoped_mechanism_review": false + }, + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa." + }, + { + "current_head": "f42cc424aad37f5734fd1c893ecdadd8cc53e1c1", + "disposition": "partially_reviewed", + "github_state": "MERGED", + "number": 3469, + "review_completion": { + "changed_file_coverage": true, + "published": true, + "required_execution_complete": false, + "scoped_mechanism_review": false + }, + "unresolved_question": "Independent scientific review and source-bound replay remain open. Archival publication does not admit a supplier, outer theorem or improved kappa." + } + ], + "qualification": "Source archival intake is not scientific replay or supplier acceptance. The full historical native census and older claimed complete physical bills are inherited only to the precise extent stated in SOURCES.json and PROOF.md." + }, + "verification_at_metadata_freeze": { + "registered_commands": "Ready and pending final execution; command registration is not a PASS claim.", + "completed_review": "Exact source SHA256/Git-blob checks against the canonical tree; separate scalar and invoice component checks; read-only proof/cost review. Root has reported the new full symbolic/native/physical component evidence.", + "remaining_gates": [ + "Final registered normal and optimized replay with the same deterministic receipt.", + "Committed-byte/source-history and source-complete exported replay.", + "Exact public-head/CI checks and canonical result handoff." + ] + }, + "original_card": { + "id": "p104-side-correction", + "question": "Can the proposed P104 joint endpoint flags be realized by a chronological correction program with coefficients, dirty restoration and an affordable complete bill?", + "starting_points": [ + "docs/research/research-family-status.md", + "research/p104-native-channel/README.md", + "research/p104-native-channel/PROOF.md", + "docs/research/community-efficient1000-review.md", + "research/p104-joint-unit-flags/README.md" + ], + "methods": [ + "Construct one side-correction word at an explicit chronological cut with the needed frames still available.", + "Derive a lower bound on the side correction and hosting costs that decides whether this channel can beat the selected budget." + ], + "acceptance_gate": "An exact arbitrary-input identity, source/target frame availability and restoration at the chosen cut, plus the complete channel+correction+idle/hosting bill or an explicit favorable bound. The native channel alone is not a supplier. A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read the revision-6 family record and #2981 static joint flags, alongside the reviewed #1991 channel. #2981 is an author-checked source archive, not an independently validated executable correction or a refutation of program-level lifetime floors.", + "scope": "Source-bound orientation only. Read the named package and review before relying on its local evidence; this command is not its replay or supplier admission." + }, + "first_experiment": "After checking live handoffs, pin one named collection from #2981 and attach acquisition/delivery times, source dependencies and coefficient requirements. Test legal access and arbitrary dirty restoration; price any completion against the full channel/endpoint/hosting allowance. Stop with the exact missing implication or a scoped counterexample rather than expanding the static cover census.", + "bottleneck_link": "Completing an already realized changed channel tests a concrete construction opportunity, instead of refining the incumbent packing. A positive local result still needs global and all-size admission.", + "allowed_variations": [ + "One correction factorization, one chronological cut, or one explicit hosting obstruction.", + "A changed correction schedule with an updated full bill and native frame contract." + ], + "scope_change_triggers": [ + "Recompiling the already certified low-rank channel without closing a new obligation.", + "Treating a pending ancestor, local histogram or unpriced side correction as an admitted global supplier.", + "Repeating a correction or physical conversion already supplied by a pending follow-up without adding independent coverage or a different unresolved obligation.", + "Repeating the 208-flag static matching or calling a static nested cover a chronological correction program. Independent audit of that certificate is distinct and remains useful." + ], + "overlap_terms": [ + "P104", + "I-G/2", + "side correction", + "native channel", + "1972", + "1991", + "2586", + "endpoint transport", + "physical dual", + "relay composition", + "2981", + "joint unit flags", + "acquisition delivery", + "static nesting" + ], + "existing_checks": [ + { + "scope": "PR #2981 reports static joint endpoint flags and a matching of 208 departure and arrival flags; archival intake is not independent verification.", + "evidence": "research/p104-joint-unit-flags/README.md", + "remaining": "Independent flag check and a chronological coefficient program with dirty restoration and a complete cost.", + "status": "author-checked", + "source_commit": "3d24b92d8ba057b57cb2d480170ec407520e6882", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + } + ] + }, + "parallel_finding": "https://github.com/CrocSwap/integer-mult-bounds/pull/3577#issuecomment-6247605048" +} diff --git a/research/p104-inplace-entrance/VERIFY.json b/research/p104-inplace-entrance/VERIFY.json new file mode 100644 index 0000000000..a48dd2522e --- /dev/null +++ b/research/p104-inplace-entrance/VERIFY.json @@ -0,0 +1,49 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/gmx-t74-borrow43-handoff/new/fastnative/vendor/native/new/code/borrow/vendor/clifford/clifford_exact.py", + "research/p104-consumer-budget-audit/README.md", + "research/p104-omitted-completion/CERTIFICATE.json", + "research/p104-omitted-frame-adapters/ADAPTERS.json", + "research/p104-omitted-frame-adapters/inputs/ORIGINS.json", + "research/p104-omitted-frame-adapters/inputs/PR3416_verify.py", + "research/p104-rounded-collector/inputs/NATIVE.json.gz", + "research/p104-rounded-collector/inputs/WORD.json", + "research/p104-stagewise-entrance/inputs/PR3382_PROOF.md", + "research/p104-stagewise-entrance/inputs/PR3416_PROOF.md", + "LICENSE", + "NOTICE", + "research/p104-native-channel/notices/FRAME-SA504-NOTICE.md", + "research/p104-native-channel/notices/PR1862-NOTICE.md", + "research/p104-native-channel/notices/PR1972-NOTICE.md", + "research/gmx-t74-borrow43-handoff/new/fastnative/NATIVE-LINEAGE-NOTICE" + ], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 180, + "checks": "Authenticate scientific and documentary inputs; verify typed serialized PROGRAM/NATIVE artifacts; compare the full 358-field endpoint matrix and all frames; certify 53 new native maps including phase; compare full independent dense physical arrays and literal floor pairs; execute dirty-order/source/divisibility controls; derive exact native/scalar invoices and the conditional consumer stop; require the unchanged deterministic receipt." + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 180, + "checks": "Repeat the same authenticated complete package replay with optimization enabled. Explicit source, typed-artifact, endpoint, phase, full-array, dirty-order, source-return, divisibility and rational-cost checks must remain active and produce the identical deterministic receipt." + } + ], + "registration_scope": "Commands are registered for final local, exported-source and hosted replay. Ready denotes complete metadata, not evidence that these final commands have already run.", + "execution_boundary": "Python 3.12 standard library only. Captured predecessor compiler/checker bytes are reused explicitly; physical and invoice engines import no predecessor executable. The historical native census, full selected replay, physical owner/controller payload and formal proofs are outside these commands." +} diff --git a/research/p104-inplace-entrance/controls.py b/research/p104-inplace-entrance/controls.py new file mode 100644 index 0000000000..829238d2f0 --- /dev/null +++ b/research/p104-inplace-entrance/controls.py @@ -0,0 +1,81 @@ +"""Source-program scalar ordering controls; no physical/frame verifier imported. + +Clear1nsight, with substantial OpenAI assistance. Apache-2.0. +""" +from fractions import Fraction + + +def scalar_controls(program, C, A): + """Interpret all 1,238 operations on multiples of one normalized B9 vector u. + + Native operations preserve normalized coordinates and are skipped here. + This does not assert native phase, physical width, or admission of other inputs. + """ + def need(ok, message): + if not ok: + raise ValueError(message) + + basis = ('X0', 'X33', 'X101', 'X102', 'X11', 'X12', 'X15', 'X24') + need(len(program) == 1238 and len(A) == 8 and len(C) == 52, 'source shape') + first = next(i for i, op in enumerate(program) if op[0] == 'half') + last = max(i for i, op in enumerate(program) if op[0] == 'double') + need(first == 299 and last == 897, 'source phase boundaries') + enter, pre = program[:52], program[52:first] + gather, tail = program[first:last + 1], program[last + 1:] + need(all(op[0] == 'native' for op in enter), 'initial native block') + need(len(pre) == 247 and all(op[0] == 'add' for op in pre), 'precondition block') + names = set(C) | {'Y' + str(i) for i in range(104)} + names.update(op[1] for op in program) + names.update(op[2] for op in program if op[0] == 'add') + + def execute(ops, initial): + state = {b: Fraction(initial.get(b, 0)) for b in names} + for op in ops: + kind, target = op[:2] + if kind == 'native': + continue + if kind == 'add': + source, sign = op[2:] + need(sign in (-1, 1), 'unit ADD required') + state[target] += sign * state[source] + else: + need(kind in ('half', 'double'), 'unexpected scalar operation') + state[target] *= Fraction(1, 2) if kind == 'half' else 2 + need(state[target].denominator == 1, 'witness lost scalar integrality') + return state + + def expected(initial): + out = {b: Fraction(initial.get(b, 0)) for b in names} + delta = [sum(Fraction(v * initial.get(y, 0), 2) for y, v in row.items()) + for row in A] + for x, row in C.items(): + out[x] += sum(row[j] * delta[j] for j in range(8)) + return out + + need(C['X5'][basis.index('X11')] == 1, 'dirty witness source binding') + need(sum(C['X5'][j] * A[j].get('Y3', 0) for j in range(8)) == -1, + 'signal witness source binding') + fixtures = [('omit_precondition', {'X11': 1}, enter + gather + tail, 0, 1), + ('late_precondition', {'Y3': 4}, enter + gather + pre + tail, -2, 0)] + controls = [] + for label, initial, mutated, target_expected, target_observed in fixtures: + want = expected(initial) + good, bad = execute(program, initial), execute(mutated, initial) + need(good == want, label + ': original program failed full-bank oracle') + need(bad != want, label + ': mutation was not detected by its output') + need(want['X5'] == target_expected and bad['X5'] == target_observed, + label + ': exact X5 witness differs') + need(all(bad[y] == want[y] for y in names if y.startswith('Y')), + label + ': source-return confounder') + differences = [{'bank': b, 'expected_multiple_of_u': str(want[b]), + 'observed_multiple_of_u': str(bad[b])} + for b in sorted(names) if bad[b] != want[b]] + controls.append({'control': label, 'status': 'REJECTED_BY_OUTPUT', + 'input_multiples_of_u': initial, + 'executed_program_operations': len(mutated), + 'differing_banks': differences, 'all_Y_restored': True}) + return {'status': 'PASS', 'original_program_operations': len(program), + 'compared_banks': len(names), 'precondition_ADDs': len(pre), + 'oracle': 'X_initial + C*A*Y_initial/2; all other banks unchanged', + 'interpretation': 'Normalized multiples of one B9 vector u; native charts omitted', + 'original_full_bank_oracle_matches': 2, 'controls': controls} diff --git a/research/p104-inplace-entrance/invoice.py b/research/p104-inplace-entrance/invoice.py new file mode 100644 index 0000000000..ea88f0355f --- /dev/null +++ b/research/p104-inplace-entrance/invoice.py @@ -0,0 +1,380 @@ +"""Independent structural and conditional cost audit for entrance completion. + +Clear1nsight, with substantial OpenAI assistance. Apache-2.0. +No predecessor executable is imported. The caller authenticates source bytes; +this module independently derives their closure, coefficient and rank invoice. +The consumer hypotheses retain Jose Manuel's observation and Vasek's PR2744 +audit, including the credited Ross Richardson forward profile. +""" +from collections import Counter +from fractions import Fraction +import hashlib +import json + +BASIS = ('X0', 'X33', 'X101', 'X102', 'X11', 'X12', 'X15', 'X24') +FORWARD = {1: 1216, 2: 74, 3: 86, 4: 104, 5: 48, 6: 42, 7: 68, 8: 8} +KAPPA = Fraction(836330098538459, 500000000000000000) + + +def require(condition, message): + if not condition: + raise ValueError(message) + + +def digest(value): + raw = json.dumps(value, sort_keys=True, separators=(',', ':')).encode() + return hashlib.sha256(raw).hexdigest() + + +def native_binding(word, native): + """Bind every literal occurrence; this is not a Pauli/phase proof.""" + occurrence = {} + for item in native['transports']: + for event in item['events']: + require(event not in occurrence, 'duplicate native event') + occurrence[event] = item + frames = {name: list(frame) for name, frame in word['initial_frames'].items()} + count = 0 + for index, event in enumerate(word['program']): + op, target = event[:2] + if op == 'zero': + require(target not in frames, 'private allocation collision') + frames[target] = event[2] + elif op == 'erase': + require(frames.pop(target) == event[2], 'erase frame') + elif op == 'transport': + item = occurrence[index] + require(type(event[4]) is int and 1 <= event[4] <= 9, 'native rank') + require(frames[target] == event[2] == item['old'], 'native old frame') + require(event[3] == item['new'], 'native new frame') + require(event[4] == item['recipe']['rank'], 'native rank binding') + frames[target] = event[3] + count += 1 + elif op == 'add': + require(frames[target] == frames[event[2]] == event[4], 'ADD common frame') + elif op == 'sign': + require(frames[target] == event[3], 'sign frame') + require(Fraction(event[2]) == -1, 'sign coefficient') + else: + raise ValueError('unknown word opcode') + require(frames == word['final_frames'], 'full final frame bindings') + require(count == len(occurrence) == 2070, 'native coverage') + return count + + +def history_graph(word): + """State-version provenance uses disjoint bits for events and inputs.""" + program = word['program'] + initial = sorted(word['initial_frames']) + offset = len(program) + histories = {name: 1 << (offset+j) for j, name in enumerate(initial)} + local = {f'Y{x}' for x in range(22, 33)} | {f'Y{x}' for x in range(63, 104)} + local |= {f'{p}{x}' for p in ('D', 'G') for x in range(27, 32)} | {'Q7'} + ports, recipients, starts, cleanup = [], set(), {}, {} + for index, event in enumerate(program): + op, target = event[:2] + bit = 1 << index + if op == 'zero': + require(target not in histories, 'private history collision') + histories[target], starts[target] = bit, index + elif op == 'erase': + cleanup[starts.pop(target)] = histories.pop(target) | bit + elif op in ('transport', 'sign'): + histories[target] |= bit + elif op == 'add': + source = event[2] + histories[target] |= histories[source] | bit + if index <= 4516 and source in local and target not in local and target != 'C': + ports.append(histories[target]) + recipients.add(target) + else: + raise ValueError('history opcode') + require(not starts and len(cleanup) == 8, 'private history lifetimes') + return initial, histories, local, ports, recipients, cleanup + + +def derive_projection(word): + initial, histories, local, ports, recipients, cleanup = history_graph(word) + offset = len(word['program']) + required = 0 + for history in ports: + required |= history + for name in local | recipients: + required |= histories[name] + for _ in range(len(initial)+len(cleanup)+1): + before = required + dependencies = required >> offset + for j, name in enumerate(initial): + if (dependencies >> j) & 1: + required |= histories[name] + for first, history in cleanup.items(): + if (required >> first) & 1: + required |= history + if before == required: + break + else: + raise ValueError('closure did not stabilize') + events = [i for i in range(offset) if (required >> i) & 1] + inputs = [name for j, name in enumerate(initial) if (required >> (offset+j)) & 1] + omitted = set(initial) - set(inputs) + for i in events: + event = word['program'][i] + require(event[1] not in omitted, 'projection writes omitted bank') + require(event[0] != 'add' or event[2] not in omitted, 'projection reads omitted bank') + require(len(events) == 4027 and len(inputs) == 265 and len(ports) == 675, 'closure size') + return events, inputs, sorted(omitted) + + +def inventory(program, indices): + native, operations, coefficients = Counter(), Counter(), Counter() + unit_adds = half_passes = 0 + for index in indices: + event = program[index] + operations[event[0]] += 1 + if event[0] == 'transport': + native[event[4]] += 1 + elif event[0] == 'add': + coefficient = Fraction(event[3]) + coefficients[str(coefficient)] += 1 + denominator = coefficient.denominator + require(denominator in (1, 2, 4), 'scalar denominator') + unit_adds += abs(coefficient.numerator) + half_passes += denominator.bit_length()-1 + mass = sum(rank*count for rank, count in native.items()) + return {'operations': dict(sorted(operations.items())), + 'native_profile': dict(sorted(native.items())), 'native_calls': sum(native.values()), + 'native_rank_mass': mass, 'coordinate_C_pairs': 256*mass, + 'weighted_ADD_coefficients': dict(sorted(coefficients.items())), + 'scalar_unit_Gaussian_bank_ADDs': unit_adds, + 'scalar_real_ADDs': 1024*unit_adds, + 'scalar_exact_half_bank_passes': half_passes, + 'scalar_exact_real_halves': 1024*half_passes, + 'scalar_source_restoring_real_doublings': 1024*half_passes} + + +def factor_invoice(completion): + A, C = completion['factor']['A'], completion['factor']['C'] + require(len(A) == 8 and len(C) == 52, 'factor dimensions') + require(all(C[name] == [int(i == j) for j in range(8)] + for i, name in enumerate(BASIS)), 'C basis block is not identity') + a = [value for row in A for value in row.values()] + c = [value for name, row in C.items() if name not in BASIS for value in row if value] + require(all(type(v) is int and v for v in a+c), 'integer nonzero factor entries') + active = sorted({name for row in A for name in row}) + require(set(active) == {f'Y{i}' for i in range(104)}-{'Y1'}, 'active Y columns') + require(len(a) == 385 and len(c) == 201, 'factor nonzero counts') + units = sum(map(abs, a)) + 2*sum(map(abs, c)) + require(units == 887, 'strict factor ADD invoice') + return {'basis': list(BASIS), 'basis_identity_checked': True, + 'A_nonzeros': len(a), 'A_l1': sum(map(abs, a)), + 'C_nonbasis_nonzeros': len(c), 'C_nonbasis_l1': sum(map(abs, c)), + 'weighted_ADDs': len(a)+2*len(c), 'unit_Gaussian_bank_ADDs': units, + 'real_ADDs': 1024*units, 'temporarily_halved_restored_Y_banks': len(active), + 'inactive_Y': ['Y1'], 'exact_real_halves': 1024*len(active), + 'exact_real_doublings': 1024*len(active), + 'native_profile': {1: 52, 9: 93}, 'native_calls': 145, 'native_rank_mass': 889, + 'new_private_Gaussian_banks': 0, + 'schedule': 'Xnonbasis-=C_N*Xbasis; Xbasis+=A*Y/2 by source columns; Xnonbasis+=C_N*Xbasis'} + + +def fractional_sources(program, indices): + found = {'N': set(), 'Y': set()} + counts = Counter() + for i in indices: + event = program[i] + if event[0] != 'add' or Fraction(event[3]).denominator == 1: + continue + family = event[2][0] + require(family in found, 'unexpected fractional source family') + require(Fraction(event[3]).denominator == {'N': 2, 'Y': 4}[family], 'fractional source denominator') + found[family].add(event[2]) + counts[family] += 1 + return found, dict(counts) + + +def source_row_audit(word, indices, weights): + """Only N/Y source rows are needed; all Y writes are native transports.""" + rows = {name: {name: Fraction(1)} for name in word['initial_frames'] if name.startswith(('N', 'Y'))} + first_n, checked, row_digests = {}, 0, [] + for index in indices: + event = word['program'][index] + op, target = event[:2] + if target.startswith('Y'): + require(op == 'transport', 'Y numeric mutation in projection') + if op != 'add': + continue + source, coefficient = event[2], Fraction(event[3]) + if coefficient.denominator != 1: + require(source in rows, 'fractional source row absent') + for name, value in rows[source].items(): + require((coefficient*value*weights[name]).denominator == 1, + f'unadmitted source increment at event {index} from {name}') + checked += 1 + row_digests.append([index, {name: str(value) for name, value in rows[source].items()}]) + if source.startswith('N') and source not in first_n: + require(rows[source] == {source: 1} and event[4] == [], 'first N half boundary') + first_n[source] = index + if target.startswith('N'): + require(source in rows, 'N row update alphabet') + updated = dict(rows[target]) + for name, value in rows[source].items(): + updated[name] = updated.get(name, 0)+coefficient*value + rows[target] = {name: value for name, value in updated.items() if value} + require(all(row == {name: 1} for name, row in rows.items()), 'N/Y source endpoint restoration') + return {'fractional_increments_checked': checked, 'fractional_source_rows_sha256': digest(row_digests), + 'first_N_half_events': first_n, + 'N_and_Y_normalized_endpoints_restore': all(row == {name: 1} for name, row in rows.items())} + + +def expected_rejection(function): + try: + function() + except ValueError as error: + return str(error) + raise ValueError('required rejection was accepted') + + +def domain_audit(word, selected): + program = word['program'] + full_ids = list(range(len(program))) + full, full_counts = fractional_sources(program, full_ids) + part, part_counts = fractional_sources(program, selected) + require(len(full['N']) == 78 and len(part['N']) == 38, 'N domain inventory') + require(full['Y'] == part['Y'] == {f'Y{i}' for i in range(104)}, 'Y domain inventory') + require(all(frame == [] for name, frame in word['initial_frames'].items() if name.startswith('Y')), 'Y entrance chart') + def scales(n_sources): + return {name: (4 if name.startswith('Y') else 2 if name in n_sources else 1) + for name in word['initial_frames']} + full_result = source_row_audit(word, full_ids, scales(full['N'])) + part_weights = scales(full['N']) + part_result = source_row_audit(word, selected, part_weights) + weak_n = dict(part_weights) + weak_n['N100'] = 1 + weak_y = dict(part_weights) + weak_y['Y1'] = 2 + return {'scope': 'Common sufficient B9-product entrance under inherited native/B9 covariance; no minimal-domain claim and all initial preparations remain unpaid', + 'common_original_and_new_caller': {'Y_4B9': 104, 'N_2B9': sorted(full['N']), 'other_B9': 176}, + 'projection_fractional_N_sources': sorted(part['N']), + 'full_fractional_reads': full_counts, 'projection_fractional_reads': part_counts, + 'full_source_rows': full_result, 'projection_source_rows': part_result, + 'weak_N100_control': expected_rejection(lambda: source_row_audit(word, selected, weak_n)), + 'weak_Y1_control': expected_rejection(lambda: source_row_audit(word, selected, weak_y)), + 'qualification': 'Both original and changed callers are interpreted on the same strong product domain. The 38 projection N-source count is a read inventory, not a new minimal-domain theorem. Endpoint equality is proved separately.'} + + +def profile_comparison(old, new): + old = {int(k): v for k, v in old.items()} + new = {int(k): v for k, v in new.items()} + count = sum(old.values()) + mass = sum(rank*n for rank, n in old.items()) + require(all(type(r) is int and 1 <= r <= 9 and type(n) is int and n >= 0 + for r, n in old.items()), 'chord rank/count domain') + require(sum(r*n for r, n in new.items()) == mass, 'comparison rank mass changed') + require(count == 473 and mass == 889 and new == {1: 52, 9: 93}, 'comparison profile') + old_sorted = sorted((r for r, n in old.items() for _ in range(n)), reverse=True) + new_sorted = sorted((r for r, n in new.items() for _ in range(n)), reverse=True) + new_sorted += [0]*(len(old_sorted)-len(new_sorted)) + prefix, differences = 0, [] + for old_rank, new_rank in zip(old_sorted, new_sorted): + prefix += new_rank-old_rank + require(prefix >= 0, 'majorization prefix fails') + differences.append(prefix) + require(prefix == 0, 'majorization total fails') + chord_one, chord_nine = Fraction(9*count-mass, 8), Fraction(mass-count, 8) + require((chord_one, chord_nine) == (421, 52), 'chord weights') + return {'equal_mass': mass, 'old_calls': count, 'new_calls': sum(new.values()), + 'majorization_prefixes_checked': len(differences), + 'prefix_difference_sha256': digest(differences), + 'old_tariff_lower_bound': '421 + 52*9^s', + 'new_tariff': '52 + 93*9^s', + 'old_minus_new_lower_bound': '41*(9-9^s)', + 'scope': 'Strict improvement for 0<=s<1; equality at s=1; native-only profile tariff, with monomials and all physical/outer charges separate', + 'positive_sqrt_chord_control': {'s': '1/2', 'old_lower': 577, 'new_exact': 331, 'certified_gain_at_least': 246}} + + +def exp_upper(value, terms): + require(value >= 0 and value < terms+2, 'exponential tail ratio') + term = total = Fraction(1) + for k in range(1, terms+1): + term = term*value/k + total += term + next_term = term*value/(terms+1) + return total+next_term/(1-value/Fraction(terms+2)) + + +def consumer_stop(new_profile): + new = {int(k): v for k, v in new_profile.items()} + require(sum(r*n for r, n in FORWARD.items()) == 3070, 'forward mass') + require(sum(r*n for r, n in new.items()) == 3542 and max(new) == 9, 'new dual mass/rank') + profile = {r: 5*FORWARD.get(r, 0)+4*new.get(r, 0) for r in set(FORWARD)|set(new)} + profile[1] -= 4*416 + mass = sum(r*n for r, n in profile.items()) + require(profile[1] == 9680 and mass == 27854, 'forgiven profile') + m, families, persistent = 73, 832, 3014 + remainder = 72*families-9*persistent + require(remainder == 32778, 'coverage remainder') + slope = 4*profile[1]+2*(mass-profile[1]) + require(slope == 75068, 'new-profile slope') + e4, e2 = exp_upper(Fraction(4), 16), exp_upper(Fraction(2), 12) + require(e4 < 73 and e2 < Fraction(73, 9), 'rational logarithm bounds') + excess = slope*KAPPA-104 + require(excess > 0, 'selected target not excluded') + return {'scope': 'Conditional new fixed-profile substitution under the retained PR2744 five-forward/four-dual coverage assumptions; not a universal P104 barrier', + 'm': m, 'W': families, 'forward_calls': 5, 'dual_calls': 4, + 'persistent_credit_per_call': persistent, 'remaining_coverage_mass': remainder, + 'rank_forgiveness_per_dual': 416, 'forgiven_profile': dict(sorted(profile.items())), + 'forgiven_rank_mass': mass, 'linear_lower_slope': slope, + 'kappa': str(KAPPA), 'slope_times_kappa_minus_104': str(excess), + 'no_bank_selected_lower_bound': str(1+excess/(m*families)), + 'fully_paid_B_lower_bound': '1 + (75068*a-104)/(73*(832+B))', + 'auxiliary_bank_scope': 'every finite B>=0; fixed m, fully paid 73 units per added bank', + 'unforgiven_zero_saving_bound': str(Fraction(5*3070+4*3542+remainder, m*families)), + 'forgiven_zero_saving_bound': str(Fraction(mass+remainder, m*families)), + 'exp4_rational_upper': str(e4), 'exp2_rational_upper': str(e2), + 'remaining_hypotheses': ['unchanged forward profile', 'new dual decomposition fixed apart from allowed rank deletion', + 'all other positive children rank<=73', 'coverage law and endpoint credit unchanged', + 'all other charges nonnegative; source admission and ownership not supplied']} + + +def analyze(word, native, completion, adapters, selected_events): + """Return JSON-compatible exact evidence without mutating inputs.""" + require(len(word['program']) == 5398 and len(word['initial_frames']) == 358, 'word size') + native_count = native_binding(word, native) + selected, inputs, omitted_banks = derive_projection(word) + require(list(selected_events) == selected, 'external selected-event list differs') + require(digest(selected) == adapters['projection_event_sha256'] == completion['closure']['events_sha256'], 'projection digest') + selected_set = set(selected) + removed = [i for i in range(len(word['program'])) if i not in selected_set] + full = inventory(word['program'], range(len(word['program']))) + projection = inventory(word['program'], selected) + omitted = inventory(word['program'], removed) + require({str(r): n for r, n in omitted['native_profile'].items()} == adapters['omitted_original_transport_profile'], 'old omitted profile') + factor = factor_invoice(completion) + require(set(completion['factor']['C']) == {name for name in omitted_banks if name.startswith('X')}, 'omitted X target binding') + require(all(len(word['initial_frames'][name]) == (1 if name.startswith('X') else 0) + and word['final_frames'][name] == [256,128,64,32,16,8,4,2,1] for name in omitted_banks), 'omitted adapter frames') + new = Counter(projection['native_profile'])+Counter(factor['native_profile']) + require(sum(new.values()) == 1742 and sum(r*n for r, n in new.items()) == 3542, 'new full profile') + comparison = profile_comparison(omitted['native_profile'], factor['native_profile']) + bad_profile = {1: 52, 8: 1, 9: 92} + undercharge = expected_rejection(lambda: profile_comparison(omitted['native_profile'], bad_profile)) + scalar_adds = projection['scalar_real_ADDs']+factor['real_ADDs'] + scalar_halves = projection['scalar_exact_real_halves']+factor['exact_real_halves'] + return {'schema_version': 1, 'status': 'PASS', 'native_occurrences_bound': native_count, + 'closure': {'events': len(selected), 'inputs': len(inputs), 'omitted_banks': len(omitted_banks), + 'event_sha256': digest(selected), 'projection_reads_or_writes_omitted': False}, + 'original_full': full, 'projection': projection, 'removed_program': omitted, + 'entrance_completion': factor, + 'changed_full': {'native_profile': dict(sorted(new.items())), 'native_calls': sum(new.values()), + 'native_rank_mass': sum(r*n for r, n in new.items()), 'coordinate_C_pairs': 256*3542, + 'scalar_real_ADDs': scalar_adds, 'scalar_exact_real_halves': scalar_halves, + 'scalar_real_doublings': scalar_halves, 'original_private_C_lifetimes': 8, 'new_private_C_lifetimes': 0, + 'scalar_real_ADD_change': scalar_adds-full['scalar_real_ADDs'], + 'scalar_exact_half_and_double_change_each': scalar_halves-full['scalar_exact_real_halves']}, + 'source_domain': domain_audit(word, selected), 'native_concavity_gain': comparison, + 'undercharged_profile_control': undercharge, 'conditional_consumer_stop': consumer_stop(new), + 'scalar_invoice_contract': 'Integer weighted ADDs repeat unit Gaussian ADDs. Each original fractional ADD temporarily divides its mutable source, performs its signed unit ADD, and restores the source by doubling before the next original event. The source-row audit proves exact divisibility at those reads. No new Gaussian workspace is used by the entrance completion.', + 'not_priced': ['actual source preparation', 'monomial swaps and phases', 'native-pair temporary implementation', + 'global ownership and routing', 'caller heights and widths', 'idle packing realization', + 'recursive/all-size transfer', 'actual physical-machine runtime'], + 'evidence_limits': 'Exact symbolic structure, coefficient and rational tariff checks; no native matrix/rounded replay or full-word endpoint proof is performed by this module.'} diff --git a/research/p104-inplace-entrance/native.py b/research/p104-inplace-entrance/native.py new file mode 100644 index 0000000000..dca76a80a6 --- /dev/null +++ b/research/p104-inplace-entrance/native.py @@ -0,0 +1,299 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Certify the new entrance maps for the in-place P104 completion. + +Clear1nsight, with substantial OpenAI assistance. The Gaussian Clifford +compiler and the separately written PR3416 checker retain their authorship. +PR3462 supplies the omitted X list; PR3469 supplies the endpoint convention. + +The caller authenticates WORD and both executable sources before calling +``synthesize`` and reconciles X_NAMES with its authenticated completion C. +This module neither imports nor rereplays the 1,245 historical native classes. +It certifies 52 singleton-to-empty maps and one empty-to-full map. These +are exact complex-linear maps; literal integer admission is a separate gate. +""" + +import hashlib +import json +from collections import Counter + + +BITS = 9 +SIZE = 1 << BITS +FULL = [256, 128, 64, 32, 16, 8, 4, 2, 1] +X_NAMES = ( + "X0", "X10", "X101", "X102", "X11", "X12", "X15", "X16", + "X17", "X21", "X24", "X25", "X26", "X30", "X31", "X33", + "X34", "X37", "X38", "X39", "X41", "X42", "X43", "X47", + "X5", "X51", "X52", "X53", "X55", "X56", "X57", "X6", + "X60", "X61", "X62", "X63", "X67", "X68", "X69", "X71", + "X72", "X73", "X76", "X77", "X78", "X82", "X86", "X90", + "X91", "X93", "X96", "X97", +) + + +class NativeError(ValueError): + """A new-map, frame or native-certificate obligation failed.""" + + +def require(condition, message): + if not condition: + raise NativeError(message) + + +def canonical(value): + return json.dumps(value, sort_keys=True, separators=(",", ":")).encode() + + +def digest(value): + return hashlib.sha256(canonical(value)).hexdigest() + + +def binary_rank(columns): + """Independent elimination on the requested map's nine B columns.""" + require(type(columns) in (list, tuple) and len(columns) <= BITS, + "binary-rank capacity") + pivots = {} + for original in columns: + require(type(original) is int and 0 <= original < SIZE, + "binary-rank column") + value = original + while value: + bit = value.bit_length() - 1 + if bit in pivots: + value ^= pivots[bit] + else: + pivots[bit] = value + break + return len(pivots) + + +def check_wrapper_shape(record): + require(type(record) is dict and set(record) == { + "matrix_rows", "offset", "phase", "linear_Z4", "quadratic_rows" + }, "wrapper fields") + for name in ("matrix_rows", "quadratic_rows", "linear_Z4"): + require(type(record[name]) in (list, tuple) + and len(record[name]) == BITS, "wrapper vector width") + for name in ("matrix_rows", "quadratic_rows"): + require(all(type(x) is int and 0 <= x < SIZE for x in record[name]), + "wrapper binary coefficients") + require(all(type(x) is int and 0 <= x < 4 for x in record["linear_Z4"]), + "wrapper linear phases") + require(type(record["offset"]) is int and 0 <= record["offset"] < SIZE, + "wrapper offset") + require(type(record["phase"]) is int and 0 <= record["phase"] < 4, + "wrapper scalar phase") + require(binary_rank(record["matrix_rows"]) == BITS, + "wrapper invertible address map") + quadratic = record["quadratic_rows"] + for j in range(BITS): + require((record["linear_Z4"][j] & 1) == ((quadratic[j] >> j) & 1), + "wrapper diagonal parity") + for k in range(j): + require(((quadratic[j] >> k) & 1) == ((quadratic[k] >> j) & 1), + "wrapper quadratic symmetry") + + +def wrapper_mapping(record): + """Enumerate address and phase directly, independently of kernel.wrapper.""" + check_wrapper_shape(record) + mapping = [] + for source in range(SIZE): + target = record["offset"] + for j, row in enumerate(record["matrix_rows"]): + target ^= ((row & source).bit_count() & 1) << j + phase = record["phase"] + active = [j for j in range(BITS) if (source >> j) & 1] + for j in active: + phase += record["linear_Z4"][j] + for k in active: + if k > j: + phase += 2 * ((record["quadratic_rows"][j] >> k) & 1) + mapping.append((target, phase % 4)) + require({target for target, _ in mapping} == set(range(SIZE)), + "wrapper address bijection") + return tuple(mapping) + + +def wrapper_counts(mapping): + """Count a direct cycle permutation and then Gaussian unit rotations. + + A cycle of length l uses l-1 direct Gaussian SWAPs. This counts an + abstract in-place permutation, not the old l+1 clean-scratch algorithm. + A physical lowering must pay its actual scalar SWAP/sign implementation. + """ + require(type(mapping) is tuple and len(mapping) == SIZE, + "wrapper-map capacity") + require({target for target, _ in mapping} == set(range(SIZE)), + "wrapper-map permutation") + seen, cycles = set(), Counter() + for start in range(SIZE): + if start in seen: + continue + value, length = start, 0 + while value not in seen: + seen.add(value) + length += 1 + value = mapping[value][0] + require(value == start and length > 0, "closed permutation cycle") + cycles[length] += 1 + phase = Counter(p for _, p in mapping) + require(all(type(p) is int and 0 <= p < 4 for p in phase), + "wrapper-map phases") + count = sum(cycles.values()) + return { + "mapping_sha256": digest(mapping), + "entries": SIZE, + "cycles": count, + "cycle_length_histogram": {str(k): cycles[k] for k in sorted(cycles)}, + "direct_gaussian_swaps": SIZE - count, + "phase_histogram": {str(k): phase[k] for k in range(4)}, + "nontrivial_phase_entries": SIZE - phase[0], + "phase_real_swaps": phase[1] + phase[3], + "phase_real_negations": phase[1] + 2 * phase[2] + phase[3], + } + + +def certify_record(record, kernel, cache=None): + """Prove one proposed native map, including its global scalar phase.""" + require(type(record) is dict and set(record) == {"old", "new", "recipe"}, + "new native record fields") + old, new, recipe = record["old"], record["new"], record["recipe"] + require(type(old) is list and type(new) is list, "native frame types") + require(type(recipe) is dict and set(recipe) == {"rank", "left", "right"}, + "native recipe fields") + require(type(recipe["rank"]) is int and 1 <= recipe["rank"] <= BITS, + "positive native rank") + if cache is None: + cache = {} + wrappers = {} + for side in ("right", "left"): + mapping = wrapper_mapping(recipe[side]) + require(mapping == kernel["wrapper"](recipe[side]), + "independent wrapper address/phase mismatch") + wrappers[side] = wrapper_counts(mapping) + actual = kernel["recipe_program"](recipe) + expected = kernel["adjoint"](kernel["chart"](old)) + kernel["chart"](new) + tableau, anchor = kernel["equal_certificate"](actual, expected, cache) + requested_table = kernel["program_table"](expected, cache) + require(len(requested_table) == 2 * BITS, "requested signed Pauli width") + rank = binary_rank([x for _, x, _ in requested_table[BITS:]]) + require(recipe["rank"] == rank, "minimal requested native rank") + return { + "old": list(old), "new": list(new), "rank": rank, + "recipe_sha256": digest(recipe), + "signed_pauli_sha256": tableau, + "exact_anchor_sha256": anchor, + "wrappers": wrappers, + } + + +def build_record(old, new, compiler, kernel, cache): + before = compiler["canonical_frame"](BITS, old) + after = compiler["canonical_frame"](BITS, new) + operation = before.then(after.adjoint()) + recipe, _unused_execution = compiler["lower_child"](operation) + # The compiler's own execution object is deliberately not an oracle. + recipe = json.loads(canonical(recipe)) + record = {"old": list(old), "new": list(new), "recipe": recipe} + return record, certify_record(record, kernel, cache) + + +def aggregate_wrappers(certificates, multiplicities): + require(set(certificates) == set(multiplicities), "wrapper multiplicities") + total = Counter() + phases, cycle_lengths = Counter(), Counter() + for name, certificate in certificates.items(): + multiplicity = multiplicities[name] + require(type(multiplicity) is int and 1 <= multiplicity <= 93, + "positive native multiplicity") + for record in certificate["wrappers"].values(): + total["wrappers"] += multiplicity + for key in ("entries", "cycles", "direct_gaussian_swaps", + "nontrivial_phase_entries", "phase_real_swaps", + "phase_real_negations"): + total[key] += multiplicity * record[key] + for key, value in record["phase_histogram"].items(): + phases[key] += multiplicity * value + for key, value in record["cycle_length_histogram"].items(): + cycle_lengths[key] += multiplicity * value + total["phase_histogram"] = {str(k): phases[str(k)] for k in range(4)} + total["cycle_length_histogram"] = { + key: cycle_lengths[key] for key in sorted(cycle_lengths, key=int) + } + require(total["entries"] == total["wrappers"] * SIZE, + "complete wrapper entry count") + require(total["direct_gaussian_swaps"] == total["entries"] - total["cycles"], + "direct wrapper permutation count") + return dict(total) + + +def check_word_boundary(word): + require(type(word) is dict and word.get("chart") == + "Delta_W = conjugate(Gamma_W) = Gamma_W^(-T)", "source chart") + require(type(word.get("program")) is list and len(word["program"]) == 5398, + "source event count") + for field in ("initial_frames", "final_frames"): + require(type(word.get(field)) is dict and len(word[field]) == 358, + "source public bank count") + require(len(X_NAMES) == len(set(X_NAMES)) == 52, "frozen omitted X list") + old_frames = [] + for name in X_NAMES: + old = word["initial_frames"].get(name) + require(type(old) is list and len(old) == 1 and type(old[0]) is int + and 0 < old[0] < SIZE, "actual singleton X entrance") + require(word["final_frames"].get(name) == FULL, "actual full X endpoint") + old_frames.append(old[0]) + require(len(set(old_frames)) == 52, "distinct singleton X entrances") + return old_frames + + +def synthesize(word, compiler, kernel): + """Return (x_to_empty, empty_to_full, deterministic new-map receipt). + + Each returned map record has exactly {old, new, recipe}. The common + empty-to-full record occurs on the 52 X and the 41 omitted N/G roles in + the proposed prefix. The caller binds these roles and executes the + complete scalar and chronological program separately. + """ + old_frames = check_word_boundary(word) + require(type(compiler) is dict and type(kernel) is dict, "engine namespaces") + require(all(callable(compiler.get(k)) for k in ("canonical_frame", "lower_child")), + "compiler API") + require(all(callable(kernel.get(k)) for k in ( + "wrapper", "recipe_program", "adjoint", "chart", "equal_certificate", + "program_table" + )), "separate checker API") + cache, records, certificates = {}, {}, {} + for name in X_NAMES: + record, certificate = build_record(word["initial_frames"][name], [], + compiler, kernel, cache) + require(certificate["rank"] == 1, "singleton-to-empty rank one") + records[name], certificates[name] = record, certificate + full_record, full_certificate = build_record([], FULL, compiler, kernel, cache) + require(full_certificate["rank"] == BITS, "empty-to-full rank nine") + certificates["empty_to_full"] = full_certificate + multiplicities = {name: 1 for name in X_NAMES} + multiplicities["empty_to_full"] = 93 + wrapper_total = aggregate_wrappers(certificates, multiplicities) + require(wrapper_total["wrappers"] == 290, "new wrapper occurrence count") + receipt = { + "schema_version": 1, + "scope": "53 new exact maps; historical native classes not replayed", + "x_names": list(X_NAMES), + "singleton_frames_sha256": digest(old_frames), + "recipes_sha256": digest({"x_to_empty": records, + "empty_to_full": full_record}), + "distinct_recipes": len(certificates), + "signed_paulis_per_recipe": 2 * BITS, + "exact_anchor_entries_per_recipe": SIZE, + "monomial_maps_checked_by_separate_kernel": len(cache), + "proposed_occurrence_profile": {"1": 52, "9": 93}, + "proposed_native_calls": 145, + "proposed_native_rank_mass": 889, + "proposed_native_pair_count": 889 * (SIZE // 2), + "wrapper_occurrence_counts": wrapper_total, + "certificates": certificates, + } + return records, full_record, receipt diff --git a/research/p104-inplace-entrance/physical.py b/research/p104-inplace-entrance/physical.py new file mode 100644 index 0000000000..520df6ff75 --- /dev/null +++ b/research/p104-inplace-entrance/physical.py @@ -0,0 +1,561 @@ +#!/usr/bin/env python3 +"""Independent local physical audit of the dirty-basis P104 entrance schedule. + +Clear1nsight, with substantial OpenAI assistance. Apache-2.0. + +No candidate or predecessor executable is imported. The canonical chart is +reconstructed from the retained PR3416 definition; the candidate is executed +from its explicit native recipes and serialized primitive program. This is a +finite 512-coordinate local comparison, not a new universal covariance proof, +a whole-WORD admission theorem, or a physical owner/routing/cost certificate. + +verify_physical(word, completion, x_to_empty, empty_to_full, + initial_fields=None, program=None) +returns actual_fields, expected_fields, initial_fields, endpoint frames, and a +compact receipt. Default inputs are the named dense fixture below. Every local +dirty field must be in B9 and every Y in 4B9. Arbitrary valid zero inputs are +accepted; primitive controls use separate fixed witnesses. +""" + +import argparse +from collections import Counter +import hashlib +import json +from pathlib import Path + + +N = 512 +RANK = 9 +FULL = (256, 128, 64, 32, 16, 8, 4, 2, 1) +INPUT_BITS = 8192 +WORK_BITS = INPUT_BITS + 32 +WORD_PIN = 'cec1fb3fbd0067b500ad5119a62ba60685be718e769374d7ec8abdd2beaa7e50' +COMPLETION_PIN = 'f68a2e6f3bd771b9692772909df200102350a80deda35532f3cc348b75d0c044' + + +def need(condition, message): + if not condition: + raise ValueError(message) + + +def canonical(value): + return json.dumps(value, sort_keys=True, separators=(',', ':')).encode() + + +def digest(value): + return hashlib.sha256(canonical(value)).hexdigest() + + +def order(name): + need(type(name) is str and len(name) >= 2 and name[0] in 'GNXY' + and name[1:].isdigit() and str(int(name[1:])) == name[1:], 'bank name') + return name[0], int(name[1:]) + + +def integer(value, low, high, message): + need(type(value) is int and low <= value <= high, message) + return value + + +def vector(value, bits=WORK_BITS): + need(isinstance(value, (list, tuple)) and len(value) == N, 'Gaussian field length') + result = [] + for pair in value: + need(isinstance(pair, (list, tuple)) and len(pair) == 2, 'Gaussian pair shape') + need(all(type(v) is int and abs(v).bit_length() <= bits for v in pair), + 'Gaussian integer component bound') + result.append((pair[0], pair[1])) + return result + + +def phase(value, exponent): + integer(exponent, 0, 3, 'phase exponent') + a, b = value + return ((a, b), (-b, a), (-a, -b), (b, -a))[exponent] + + +def add(left, right, sign=1): + return [(a + sign*c, b + sign*d) for (a, b), (c, d) in zip(left, right)] + + +def scale(value, coefficient): + return [(coefficient*a, coefficient*b) for a, b in value] + + +def half(value): + for address, (a, b) in enumerate(value): + need(a % 2 == b % 2 == 0, 'nonintegral source half at ' + str(address)) + return [(a//2, b//2) for a, b in value] + + +def encode(coefficients): + result = vector(coefficients) + for bit in range(RANK): + mask = 1 << bit + for low in range(N): + if low & mask: + continue + a, b = result[low] + c, d = result[low | mask] + result[low | mask] = (a + c-d, b + c+d) + return vector(result) + + +def newton(value): + result = vector(value) + for bit in range(RANK): + mask = 1 << bit + for high in range(N): + if high & mask: + a, b = result[high] + c, d = result[high ^ mask] + result[high] = (a-c, b-d) + for address, (a, b) in enumerate(result): + for _ in range(address.bit_count()): + need((a+b) % 2 == (b-a) % 2 == 0, + 'outside B9 at Newton mask ' + str(address)) + a, b = (a+b)//2, (b-a)//2 + result[address] = (a, b) + return vector(result) + + +def domain(value, multiplier): + coefficients = newton(value) + need(all(a % multiplier == b % multiplier == 0 for a, b in coefficients), + 'outside ' + str(multiplier) + 'B9') + return coefficients + + +def frame(value): + need(isinstance(value, (list, tuple)) and len(value) <= RANK, 'frame dimension') + span = {0} + result = [] + for direction in value: + integer(direction, 1, N-1, 'frame direction') + need(direction not in span, 'dependent frame') + span |= {x ^ direction for x in span} + result.append(direction) + return tuple(result) + + +def ideal_pair(left, right, inverse=False): + a, b = left + c, d = right + dr, di = a-c, b-d + tr, ti = ((di, -dr) if inverse else (-di, dr)) + numerators = (a+c+tr, b+d+ti, a+c-tr, b+d-ti) + need(all(v % 2 == 0 for v in numerators), 'nonintegral ideal native pair') + return (numerators[0]//2, numerators[1]//2), (numerators[2]//2, numerators[3]//2) + + +def literal_pair(left, right, inverse=False): + expected = ideal_pair(left, right, inverse) + a, b = left + c, d = right + dr, di = a-c, b-d + tr, ti = ((di, -dr) if inverse else (-di, dr)) + mr, mi = c + dr//2, d + di//2 + second = (mr - tr//2, mi - ti//2) + first = (second[0] + tr, second[1] + ti) + need((first, second) == expected, 'literal/ideal native pair disagreement') + return first, second + + +def coordinate(value, bit, inverse=False, literal=False): + result = list(value) + operation = literal_pair if literal else ideal_pair + mask = 1 << bit + for low in range(N): + if not low & mask: + result[low], result[low | mask] = operation(value[low], value[low | mask], inverse) + return result + + +def monomial(value, permutation, phases, inverse=False): + result = [(0, 0)] * N + for source, target in enumerate(permutation): + if inverse: + result[source] = phase(value[target], (-phases[source]) % 4) + else: + result[target] = phase(value[source], phases[source]) + return result + + +class ChartOracle: + """Direct canonical H_W^-1 C^-1 H_W, not an archived native recipe.""" + + def __init__(self): + self.plans = {} + + def plan(self, directions): + directions = frame(directions) + if directions in self.plans: + return self.plans[directions] + columns = list(directions) + span = {0} + for column in columns: + span |= {x ^ column for x in span} + for bit in range(RANK): + column = 1 << bit + if column not in span: + columns.append(column) + span |= {x ^ column for x in span} + need(len(columns) == RANK and len(span) == N, 'completed canonical binary basis') + inverse = [None] * N + for mask in range(N): + address = 0 + for bit, column in enumerate(columns): + if (mask >> bit) & 1: + address ^= column + need(inverse[address] is None, 'canonical basis bijection') + inverse[address] = mask + # Columns of A=G^-1, recovered by complete binary enumeration. + a_columns = [inverse[1 << bit] for bit in range(RANK)] + q = [[int(j == k) ^ ((a_columns[j] & a_columns[k]).bit_count() & 1) + for k in range(RANK)] for j in range(RANK)] + phases = [] + for address in range(N): + bits = [j for j in range(RANK) if (address >> j) & 1] + exponent = sum(q[j][j] for j in bits) + exponent += 2*sum(q[j][k] for j in bits for k in bits if j < k) + phases.append(exponent % 4) + self.plans[directions] = (inverse, phases) + return inverse, phases + + def apply(self, value, directions, inverse=False): + directions = frame(directions) + result = list(value) + if not directions: + return result + if len(directions) < RANK: + permutation, phases = self.plan(directions) + result = monomial(result, permutation, phases) + for bit in range(len(directions)): + result = coordinate(result, bit, inverse=not inverse) + if len(directions) < RANK: + result = monomial(result, permutation, phases, inverse=True) + return vector(result) + + +def wrapper_plan(record): + need(type(record) is dict and set(record) == + {'matrix_rows', 'offset', 'quadratic_rows', 'linear_Z4', 'phase'}, 'native wrapper schema') + rows, quadratic, linear = record['matrix_rows'], record['quadratic_rows'], record['linear_Z4'] + need(all(type(a) is list and len(a) == RANK for a in (rows, quadratic, linear)), 'native wrapper dimensions') + for a in rows + quadratic: + integer(a, 0, N-1, 'native binary row') + for a in linear: + integer(a, 0, 3, 'native linear phase') + offset = integer(record['offset'], 0, N-1, 'native address offset') + constant = integer(record['phase'], 0, 3, 'native constant phase') + permutation, phases = [], [] + for address in range(N): + target = offset + for bit, row in enumerate(rows): + target ^= ((row & address).bit_count() & 1) << bit + exponent = constant + sum(linear[j] for j in range(RANK) if (address >> j) & 1) + # The retained convention uses only strict upper-triangular entries. + exponent += 2*sum(1 for j in range(RANK) for k in range(j+1, RANK) + if (address >> j) & 1 and (address >> k) & 1 and (quadratic[j] >> k) & 1) + permutation.append(target) + phases.append(exponent % 4) + need(len(set(permutation)) == N, 'nonbijective native wrapper') + return permutation, phases + + +class LiteralNative: + def __init__(self): + self.plans = {} + self.counts = Counter() + + def apply(self, value, recipe): + need(type(recipe) is dict and set(recipe) == {'rank', 'left', 'right'}, 'native recipe schema') + rank = integer(recipe['rank'], 1, RANK, 'native rank') + key = digest(recipe) + if key not in self.plans: + self.plans[key] = (wrapper_plan(recipe['right']), wrapper_plan(recipe['left'])) + right, left = self.plans[key] + result = monomial(value, *right) + for bit in range(rank): + result = coordinate(result, bit, literal=True) + self.counts['completed_floor_pairs'] += N//2 + result = monomial(result, *left) + self.counts['native_calls'] += 1 + self.counts['native_rank_mass'] += rank + self.counts['actual_wrappers'] += 2 + self.counts['actual_phase_applications'] += 2*N + return vector(result) + + +def source_spec(word, completion): + need(type(word) is dict and type(completion) is dict, 'source object schemas') + A, C = completion['factor']['A'], completion['factor']['C'] + basis = completion['residual']['minor_rows'] + xs = sorted(C, key=order) + ys = ['Y' + str(j) for j in range(104)] + omitted = sorted(completion['unfilled_physical_frame_gaps'], key=order) + ng = [name for name in omitted if name not in xs] + need(len(A) == len(basis) == 8 and len(xs) == 52 and len(omitted) == 93 and len(ng) == 41, + 'actual local dimensions') + need(len(set(basis)) == 8 and set(basis) <= set(xs), 'actual basis roles') + need([C[b] for b in basis] == [[int(i == j) for j in range(8)] for i in range(8)], 'C basis identity') + need(all(type(row) is dict and set(row) <= set(ys) + and all(type(v) is int and -2 <= v <= 2 for v in row.values()) for row in A), 'integer A') + need(all(type(row) is list and len(row) == 8 + and all(type(v) is int and -4 <= v <= 4 for v in row) for row in C.values()), 'integer C') + need(all(name.startswith('X') for name in xs) and all(name[0] in 'NG' for name in ng), 'local role partition') + need(not (set(omitted) & set(ys)), 'source/output role alias') + for name in omitted: + old, new = completion['unfilled_physical_frame_gaps'][name] + need(frame(old) == frame(word['initial_frames'][name]), 'bound entrance frame ' + name) + need(frame(new) == frame(word['final_frames'][name]) == FULL, 'bound endpoint frame ' + name) + need(len(frame(old)) == (1 if name in xs else 0), 'entrance dimension ' + name) + need(all(frame(word['initial_frames'][name]) == () for name in ys), 'common Y entrance frame') + return A, C, basis, xs, ys, omitted, ng + + +def make_program(A, C, basis, xs, ys, ng): + other = [x for x in xs if x not in basis] + program = [['native', name, 'enter'] for name in xs] + for target in other: + for j, source in enumerate(basis): + coefficient = -C[target][j] + program += [['add', target, source, 1 if coefficient > 0 else -1]] * abs(coefficient) + for source in ys: + if not any(row.get(source, 0) for row in A): + continue + program.append(['half', source]) + for j, target in enumerate(basis): + coefficient = A[j].get(source, 0) + program += [['add', target, source, 1 if coefficient > 0 else -1]] * abs(coefficient) + program.append(['double', source]) + for target in other: + for j, source in enumerate(basis): + coefficient = C[target][j] + program += [['add', target, source, 1 if coefficient > 0 else -1]] * abs(coefficient) + program += [['native', name, 'finish'] for name in xs + ng] + return program + + +def dense_fields(roles, ys): + result = {} + for slot, name in enumerate(roles): + coefficients = [(((37*slot + 17*k + 3*k.bit_count()) % 11)-5, + ((19*slot + 29*k + 5*k.bit_count()) % 13)-6) for k in range(N)] + result[name] = scale(encode(coefficients), 4 if name in ys else 1) + return result + + +def primitive_controls(empty_to_full): + controls = {} + need([phase((-3, 5), exponent) for exponent in range(4)] == + [(-3, 5), (-5, -3), (3, -5), (5, 3)], 'signed phase primitive') + need(half([(-6, -10)]*N) == [(-3, -5)]*N, 'signed exact-half primitive') + controls['signed_phase_cycle_and_exact_negative_half'] = 'PASS' + + def reject(name, operation, prefix): + try: + operation() + except ValueError as error: + need(str(error).startswith(prefix), 'wrong rejection for ' + name) + controls[name] = str(error) + else: + raise ValueError('accepted negative control ' + name) + + reject('odd_source_half', lambda: half([(-3, 4)]*N), 'nonintegral source half') + reject('nonintegral_ideal_pair', lambda: literal_pair((0, 0), (1, 0)), 'nonintegral ideal native pair') + reject('outside_B9', lambda: domain([(1, 0)] + [(0, 0)]*(N-1), 1), 'outside B9') + reject('inside_2B9_outside_required_4B9', lambda: domain([(2, 0)]*N, 4), 'outside 4B9') + bad = json.loads(canonical(empty_to_full['recipe'])) + bad['left']['phase'] = True + reject('boolean_native_phase', lambda: LiteralNative().apply([(1, 0)]*N, bad), 'native constant phase') + probe = [(1, 0)]*N + good = LiteralNative().apply(probe, empty_to_full['recipe']) + wrong = json.loads(canonical(empty_to_full['recipe'])) + wrong['left']['phase'] = (wrong['left']['phase'] + 1) % 4 + changed = LiteralNative().apply(probe, wrong) + expected = ChartOracle().apply(probe, FULL) + need(good == expected and changed != expected, 'native phase endpoint control') + first = next(k for k in range(N) if changed[k] != expected[k]) + controls['native_constant_phase_mutation'] = { + 'address': first, 'observed': changed[first], 'expected': expected[first], + 'mutated_wrapper': 'left', 'change': 'phase + 1 modulo 4', + } + return controls + + +def verify_physical(word, completion, x_to_empty, empty_to_full, + initial_fields=None, program=None): + """Run one exact local fixture; whole-source authentication belongs to caller. + + The canonical dirty variable x is J_initial^-1 of the supplied physical X. + H_Y in scalar row bounds means the actual, unhalved common-frame Y field. + Each supplied native record is {old, new, recipe}; extra certificate keys + are allowed at record level but never in executable recipe/wrapper schemas. + A serialized program is executed exactly as supplied and additionally bound + to this fixed ordered schedule, including all source returns. + """ + input_digests = [digest(value) for value in (word, completion, x_to_empty, empty_to_full)] + A, C, basis, xs, ys, omitted, ng = source_spec(word, completion) + roles = sorted(omitted + ys, key=order) + need(type(x_to_empty) is dict and set(x_to_empty) == set(xs), 'all52 entrance native records') + need(type(empty_to_full) is dict and frame(empty_to_full['old']) == () + and frame(empty_to_full['new']) == FULL and empty_to_full['recipe']['rank'] == 9, + 'common full-frame native record') + for name in xs: + record = x_to_empty[name] + need(type(record) is dict and frame(record['old']) == frame(word['initial_frames'][name]) + and frame(record['new']) == () and record['recipe']['rank'] == 1, + 'actual singleton entrance native record ' + name) + fixed_program = make_program(A, C, basis, xs, ys, ng) + if program is None: + program = fixed_program + need(type(program) is list and len(program) == 1238, 'serialized program length') + need(canonical(program) == canonical(fixed_program), 'serialized fixed schedule mismatch') + program_hash = digest(program) + supplied_hash = digest(initial_fields) if initial_fields is not None else None + if initial_fields is None: + initial_fields = dense_fields(roles, ys) + need(type(initial_fields) is dict and set(initial_fields) == set(roles), 'exact local initial bank set') + initial = {name: vector(initial_fields[name], INPUT_BITS) for name in roles} + for name in roles: + domain(initial[name], 4 if name in ys else 1) + + oracle = ChartOracle() + normalized_x = {name: oracle.apply(initial[name], word['initial_frames'][name], inverse=True) for name in xs} + half_y = {name: half(initial[name]) for name in ys} + readouts = [[(0, 0)]*N for _ in range(8)] + for j, row in enumerate(A): + for name in ys: + coefficient = row.get(name, 0) + if coefficient: + readouts[j] = add(readouts[j], scale(half_y[name], coefficient)) + expected = {name: list(initial[name]) for name in ys} + for name in xs: + value = normalized_x[name] + for j, coefficient in enumerate(C[name]): + if coefficient: + value = add(value, scale(readouts[j], coefficient)) + expected[name] = oracle.apply(value, FULL) + for name in ng: + expected[name] = oracle.apply(initial[name], FULL) + + state = {name: list(initial[name]) for name in roles} + frames = {name: frame(word['initial_frames'][name]) for name in roles} + native = LiteralNative() + counts = Counter() + pending_halves = set() + entered, finished = set(), set() + peak = max(abs(v) for value in state.values() for pair in value for v in pair) + for step, op in enumerate(program): + need(type(op) is list and len(op) in (2, 3, 4), 'program operation shape') + kind, target = op[:2] + need(target in state, 'program target role') + if kind == 'native': + need(len(op) == 3 and op[2] in ('enter', 'finish'), 'native operation shape') + stage = op[2] + if stage == 'enter': + need(target in xs and target not in entered and target not in finished, + 'entrance native lifetime') + record = x_to_empty[target] + entered.add(target) + else: + need(target in omitted and target not in finished and not pending_halves, + 'finish native lifetime') + record = empty_to_full + finished.add(target) + need(frames[target] == frame(record['old']), 'native old-frame mismatch') + domain(state[target], 1) + state[target] = native.apply(state[target], record['recipe']) + frames[target] = frame(record['new']) + domain(state[target], 1) + elif kind == 'add': + need(len(op) == 4 and target in xs and op[2] in xs + ys + and op[2] != target and type(op[3]) is int and op[3] in (-1, 1), 'unit ADD roles/alias/sign') + source, sign = op[2:] + need(frames[target] == frames[source] == (), 'unit ADD common frame') + need(source not in ys or source in pending_halves, 'gather source half lifetime') + state[target] = vector(add(state[target], state[source], sign)) + elif kind == 'half': + need(len(op) == 2 and target in ys and target not in pending_halves and frames[target] == (), + 'temporary source half lifetime') + domain(state[target], 4) + state[target] = half(state[target]) + pending_halves.add(target) + else: + need(kind == 'double' and len(op) == 2 and target in pending_halves and frames[target] == (), + 'source restoration lifetime') + state[target] = vector(scale(state[target], 2)) + pending_halves.remove(target) + need(state[target] == initial[target], 'immediate source restoration') + counts[kind] += 1 + peak = max(peak, max(abs(v) for pair in state[target] for v in pair)) + need(not pending_halves and entered == set(xs) and finished == set(omitted), 'all native/source lifetimes completed') + need(dict(counts) == {'native': 145, 'add': 887, 'half': 103, 'double': 103}, 'literal operation inventory') + need(native.counts['native_rank_mass'] == 889 and native.counts['completed_floor_pairs'] == 227584, + 'native pair/rank inventory') + expected_frames = {name: FULL if name in omitted else () for name in roles} + need(frames == expected_frames, 'all93 physical endpoint frames and104 source frames') + for name in roles: + need(state[name] == expected[name], 'complete physical endpoint mismatch ' + name) + domain(state[name], 4 if name in ys else 1) + controls = primitive_controls(empty_to_full) + need(input_digests == [digest(value) for value in (word, completion, x_to_empty, empty_to_full)], 'source objects mutated') + need(digest(program) == program_hash, 'program object mutated') + if supplied_hash is not None: + need(digest(initial_fields) == supplied_hash, 'supplied initial arrays mutated') + receipt = { + 'status': 'PASS_INDEPENDENT_LOCAL_PHYSICAL_INPLACE_COMPLETION', + 'source_object_sha256': dict(zip(('word', 'completion', 'x_to_empty', 'empty_to_full'), input_digests)), + 'program_sha256': program_hash, 'basis_X': basis, + 'initial_fields_sha256': digest(initial), 'actual_fields_sha256': digest(state), + 'expected_fields_sha256': digest(expected), 'endpoint_frames_sha256': digest(frames), + 'array_equality': {'local_outputs': 93, 'restored_Y': 104, 'Gaussian_coordinates_per_field': N, + 'full_Gaussian_entries_compared': len(roles)*N, 'all_dirty_offsets_preserved': True}, + 'literal_program_counts': dict(counts), 'native_counts': dict(native.counts), + 'direct_scalar_real_primitives': {'ADD_SUB': 908288, 'exact_half': 105472, 'double': 105472}, + 'initial_local_domain': '93 physical dirty fields in B9;104 physical Y fields in4B9.', + 'initial_fixture': 'caller supplied' if supplied_hash is not None else 'dense_E9_formula_v1', + 'fixture_role_order': roles, 'input_component_magnitude_bits_limit': INPUT_BITS, + 'work_component_magnitude_bits_limit': WORK_BITS, 'observed_peak_component_magnitude': peak, + 'observed_peak_component_magnitude_bits': peak.bit_length(), + 'observed_peak_sampling': 'Stored fields after complete serialized operations; native-pair internal temporaries are not sampled.', + 'canonical_oracle': 'Greedy binary-basis enumeration;Q=I+A^T A;H phases;J_W=H^-1 C^-1 H;canonical empty/full cases.', + 'native_oracle': 'Actual right wrapper, literal signed-floor C pairs with integral ideal comparison, actual left wrapper.', + 'controls': controls, + 'width_convention': 'H_Y denotes actual unhalved common-frame Y. The 8H_X+95H_Y row attains the equal-bound peak103H; it is not a uniform two-parameter bound. Use the primary Pareto envelope for independent H_X,H_Y. Native adapters and temporaries are additional.', + 'scope': 'One complete dense local physical fixture, exact primitive controls, and supplied schedule binding. Universal recipe covariance and B9 invariance are separate proof inputs. No full-WORD arbitrary-input admission, register-owner, routing, total width/cost or frontier claim.', + } + return {'receipt': receipt, 'initial_fields': initial, 'actual_fields': state, + 'expected_fields': expected, 'actual_frames': frames, 'expected_frames': expected_frames} + + +if __name__ == '__main__': + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--repo', type=Path, required=True) + parser.add_argument('--recipes', type=Path, required=True, + help='JSON with x_to_empty and empty_to_full records') + parser.add_argument('--program', type=Path) + parser.add_argument('--output', type=Path, help='Exclusive-create compact receipt JSON') + args = parser.parse_args() + word_bytes = (args.repo / 'research/p104-rounded-collector/inputs/WORD.json').read_bytes() + completion_bytes = (args.repo / 'research/p104-omitted-completion/CERTIFICATE.json').read_bytes() + need(hashlib.sha256(word_bytes).hexdigest() == WORD_PIN, 'frozen WORD hash') + need(hashlib.sha256(completion_bytes).hexdigest() == COMPLETION_PIN, 'frozen completion hash') + records = json.loads(args.recipes.read_bytes()) + need(type(records) is dict and set(records) == {'schema_version', 'x_to_empty', 'empty_to_full'} + and type(records['schema_version']) is int and records['schema_version'] == 1, + 'serialized NATIVE object schema') + operations = json.loads(args.program.read_bytes()) if args.program else None + if type(operations) is dict: + need(type(operations.get('schema_version')) is int and operations['schema_version'] == 1 + and set(operations) == {'schema_version', 'program', 'retained_original_event_indices'}, + 'serialized PROGRAM object schema') + operations = operations['program'] + result = verify_physical(json.loads(word_bytes), json.loads(completion_bytes), + records['x_to_empty'], records['empty_to_full'], program=operations) + encoded = json.dumps(result['receipt'], indent=2, sort_keys=True) + '\n' + if args.output: + with args.output.open('x') as output: + output.write(encoded) + print(encoded, end='') diff --git a/research/p104-inplace-entrance/primary.py b/research/p104-inplace-entrance/primary.py new file mode 100644 index 0000000000..32fa9829d2 --- /dev/null +++ b/research/p104-inplace-entrance/primary.py @@ -0,0 +1,350 @@ +"""Source-bound normalised matrix and admission proof for one entrance word. + +Clear1nsight, with substantial OpenAI assistance. Apache-2.0. +The projection and CA/2 factorisation are credited to Hiroki KUMAZAKI/PR3446 +and Nick Petalas/PR3462. This module reconstructs their used implication from +WORD and checks the changed chronological program. No predecessor executable +is imported here. Native synthesis and literal Gaussian execution are separate. +""" + +from collections import Counter +from fractions import Fraction +import hashlib +import json + + +BASIS = ('X0', 'X33', 'X101', 'X102', 'X11', 'X12', 'X15', 'X24') +FULL = (256, 128, 64, 32, 16, 8, 4, 2, 1) +PROJECTION = '66113bcd513a17eac24f43944a8759bdae1bb2a85e2b9900122f281c5c676dc8' + + +def need(condition, message): + if not condition: + raise ValueError(message) + + +def canonical(value): + return json.dumps(value, sort_keys=True, separators=(',', ':')).encode() + + +def digest(value): + return hashlib.sha256(canonical(value)).hexdigest() + + +def order(name): + return name[0], int(name[1:]) + + +def row_add(target, source, coefficient): + result = dict(target) + for key, value in source.items(): + result[key] = result.get(key, Fraction()) + coefficient * value + if not result[key]: + del result[key] + return result + + +def rows_record(rows): + return {name: {key: str(value) for key, value in sorted(row.items())} + for name, row in sorted(rows.items())} + + +def initial_state(word, weights=None): + weights = weights or {} + return {name: {name: Fraction(weights.get(name, 1))} + for name in word['initial_frames']} + + +def projection(word): + """Rebuild PR3446's closure with a dependency graph, not saved event bits.""" + names = sorted(word['initial_frames']) + inputs = {-j-1: name for j, name in enumerate(names)} + current = {name: key for key, name in inputs.items()} + dependencies, allocation, cleanup = {}, {}, {} + for event, op in enumerate(word['program']): + kind, target = op[:2] + if kind == 'zero': + need(target not in current, 'closure private alias') + dependencies[event] = () + allocation[target] = event + else: + need(target in current, 'closure live target') + dependencies[event] = (current[target],) + if kind == 'add': + dependencies[event] += (current[op[2]],) + current[target] = event + if kind == 'erase': + cleanup[allocation.pop(target)] = event + del current[target] + need(not allocation and len(cleanup) == 8, 'closure private lifecycle') + roles = {'Y' + str(j) for j in (*range(22, 33), *range(63, 104))} + roles |= {prefix + str(j) for prefix in ('D', 'G') for j in range(27, 32)} | {'Q7'} + ports = [i for i, op in enumerate(word['program']) + if i <= 4516 and op[0] == 'add' and op[2] in roles + and op[1] not in roles | {'C'}] + need(len(ports) == 675, 'closure observed ports') + todo = ports + [current[b] for b in roles | {word['program'][i][1] for i in ports}] + reached = set() + while todo: + node = todo.pop() + if node in reached: + continue + reached.add(node) + if node < 0: + todo.append(current[inputs[node]]) + else: + todo.extend(dependencies[node]) + if node in cleanup: + todo.append(cleanup[node]) + selected = sorted(node for node in reached if node >= 0) + need(len(selected) == 4027 and sum(node < 0 for node in reached) == 265, + 'actual terminal-history closure') + need(digest(selected) == PROJECTION, 'independently reconstructed projection hash') + return selected + + +def original(word, selected, state=None, frames=None, admission=False): + """Exact field-module coefficients; every scalar read has its actual frame.""" + state = initial_state(word) if state is None else {b: dict(v) for b, v in state.items()} + frames = ({b: tuple(f) for b, f in word['initial_frames'].items()} + if frames is None else dict(frames)) + counts = Counter() + for event in selected: + op = word['program'][event] + kind, target = op[:2] + if kind == 'zero': + need(target not in state, 'private alias at ' + str(event)) + state[target], frames[target] = {}, tuple(op[2]) + elif kind == 'erase': + need(not state[target], 'nonzero private erasure at ' + str(event)) + del state[target], frames[target] + elif kind == 'transport': + need(frames[target] == tuple(op[2]), 'old native frame at ' + str(event)) + frames[target] = tuple(op[3]) + elif kind == 'sign': + state[target] = {b: -v for b, v in state[target].items()} + else: + need(kind == 'add', 'original opcode') + source, coefficient = op[2], Fraction(op[3]) + need(target != source and frames[target] == frames[source] == tuple(op[4]), + 'original ADD access at ' + str(event)) + increment = {b: coefficient * v for b, v in state[source].items()} + if admission: + need(all(v.denominator == 1 for v in increment.values()), + 'non-module increment at ' + str(event)) + state[target] = row_add(state[target], increment, 1) + if admission and target in state: + need(all(v.denominator == 1 for v in state[target].values()), + 'non-module state at ' + str(event)) + counts[kind] += 1 + need(set(state) == set(word['initial_frames']), 'original public-bank set') + return state, frames, dict(sorted(counts.items())) + + +def program_for(word, certificate, adapters): + A, C = certificate['factor']['A'], certificate['factor']['C'] + xs = sorted(C, key=order) + omitted = {row['bank'] for row in adapters['omitted_banks']} + other = sorted(omitted - set(xs), key=order) + need(len(xs) == 52 and len(other) == 41 and len(omitted) == 93, 'omitted roles') + need(tuple(certificate['residual']['minor_rows']) == BASIS, 'credited basis order') + need([C[b] for b in BASIS] == [[int(i == j) for j in range(8)] for i in range(8)], + 'dirty output pivot identity') + need(len(A) == 8 and all(len(row) == 8 for row in C.values()), 'factor dimensions') + ys = ['Y' + str(j) for j in range(104)] + need(all(set(row) <= set(ys) and all(type(v) is int for v in row.values()) for row in A), + 'integer gather') + need(all(type(v) is int for row in C.values() for v in row), 'integer scatter') + need(all(len(word['initial_frames'][x]) == 1 for x in xs), 'singleton X entrance') + need(all(word['initial_frames'][b] == [] for b in other + ys), 'empty NG/Y entrance') + need(all(tuple(word['final_frames'][b]) == FULL for b in omitted), 'full omitted exit') + program = [['native', b, 'enter'] for b in xs] + + def scatter(sign): + for target in xs: + if target in BASIS: + continue + for j, source in enumerate(BASIS): + coefficient = sign * C[target][j] + program.extend([['add', target, source, 1 if coefficient > 0 else -1] + for _ in range(abs(coefficient))]) + + scatter(-1) + for y in ys: + if not any(row.get(y, 0) for row in A): + continue + program.append(['half', y]) + for j, target in enumerate(BASIS): + coefficient = A[j].get(y, 0) + program.extend([['add', target, y, 1 if coefficient > 0 else -1] + for _ in range(abs(coefficient))]) + program.append(['double', y]) + scatter(1) + program.extend([['native', b, 'finish'] for b in xs + other]) + need(len(program) == 1238, 'changed prelude length') + return program + + +def entrance(word, program, weights=None): + state = initial_state(word, weights) + frames = {b: tuple(f) for b, f in word['initial_frames'].items()} + scalar_peak = {'twice_equal_bound': 0} + envelopes = {(1, 0): {'bank': 'initial X', 'after_prelude_operation': -1}, + (0, 2): {'bank': 'initial Y', 'after_prelude_operation': -1}} + counts = Counter() + for index, op in enumerate(program): + kind, target = op[:2] + need(target in state, 'entrance live bank') + if kind == 'native': + if op[2] == 'enter': + need(target.startswith('X') and len(frames[target]) == 1, 'entrance native frame') + frames[target] = () + else: + need(op[2] == 'finish' and frames[target] == (), 'exit native frame') + frames[target] = FULL + else: + need(frames[target] == (), 'scalar target common frame') + if kind == 'add': + source, sign = op[2:] + need(type(sign) is int and sign in (-1, 1), 'unit scalar coefficient') + need(source != target and frames[source] == (), 'scalar source common frame') + state[target] = row_add(state[target], state[source], sign) + else: + need(kind in ('half', 'double') and target.startswith('Y'), 'source scaling opcode') + scale = Fraction(1, 2) if kind == 'half' else Fraction(2) + state[target] = {b: scale * v for b, v in state[target].items()} + if weights is not None: + need(all(v.denominator == 1 for v in state[target].values()), + 'entrance module admission at ' + str(index)) + else: + x_weight = sum(abs(v) for b, v in state[target].items() if b.startswith('X')) + y_weight = sum(abs(v) for b, v in state[target].items() if b.startswith('Y')) + need(x_weight.denominator == 1 and (2*y_weight).denominator == 1, + 'half-integral scalar envelope') + envelopes.setdefault((int(x_weight), int(2*y_weight)), + {'bank': target, 'after_prelude_operation': index}) + bound = x_weight + y_weight + if 2 * bound > scalar_peak['twice_equal_bound']: + scalar_peak = {'twice_equal_bound': int(2*bound), 'x_weight': int(x_weight), + 'twice_y_weight': int(2*y_weight), 'bank': target, + 'after_prelude_operation': index} + counts[kind] += 1 + for b in state: + if b.startswith('Y'): + need(state[b] == initial_state(word, weights)[b], 'complete Y source restoration') + pareto = [{'x_weight': x, 'twice_y_weight': y, **envelopes[(x, y)]} + for x, y in sorted(envelopes) + if not any(u >= x and v >= y and (u, v) != (x, y) for u, v in envelopes)] + extreme = [] + if weights is None: + need([(row['x_weight'], row['twice_y_weight']) for row in pareto] + == [(8, 190), (9, 156), (11, 128), (12, 98), (13, 49), (14, 0)], + 'exact scalar Pareto rows') + # The first omitted row is below a convex combination of the first + # and third; the second is the midpoint of the last two extremes. + need(Fraction(2, 3)*8 + Fraction(1, 3)*11 == 9 + and Fraction(2, 3)*190 + Fraction(1, 3)*128 >= 156, + 'first scalar convex domination') + need(Fraction(12+14, 2) == 13 and Fraction(98+0, 2) == 49, + 'second scalar convex domination') + extreme = [row for row in pareto if row['x_weight'] in (8, 11, 12, 14)] + return state, frames, {'operations': dict(sorted(counts.items())), + 'scalar_peak_after_entering_empty_frame': scalar_peak, + 'two_bound_scalar_envelope': pareto, + 'convex_reduced_scalar_envelope': extreme, + 'width_interpretation': 'Maximum of the displayed x_weight*H_X + twice_y_weight*H_Y/2 rows;103H when H_X=H_Y=H. H_X is after entrance conversion and H_Y is unhalved. Native conversions/temporaries are additional.'} + + +def analyze(word, native, certificate, adapters, program): + need(len(word['program']) == 5398 and len(word['initial_frames']) == 358, 'pinned word shape') + selected = projection(word) + need(certificate['closure']['events'] == len(selected), 'credited closure size') + need(selected == sorted(set(selected)) and len(selected) == 4027 and digest(selected) == PROJECTION, + 'projection event binding') + omitted = {row['bank'] for row in adapters['omitted_banks']} + for i in selected: + op = word['program'][i] + need(op[1] not in omitted and (op[0] != 'add' or op[2] not in omitted), + 'retained projection accesses omitted bank') + need(word['chart'] == native['chart'], 'actual native chart convention') + bound = set() + for record in native['transports']: + for event in record['events']: + need(event not in bound, 'duplicate native occurrence') + bound.add(event) + op = word['program'][event] + need(op[0] == 'transport' and op[2:] == [record['old'], record['new'], record['recipe']['rank']], + 'native occurrence old/new/rank binding') + need(bound == {i for i, op in enumerate(word['program']) if op[0] == 'transport'} + and len(bound) == 2070, 'complete native occurrence coverage') + need(program == program_for(word, certificate, adapters), 'serialized entrance program differs') + full, full_frames, full_counts = original(word, range(5398)) + sliced, sliced_frames, slice_counts = original(word, selected) + A, C = certificate['factor']['A'], certificate['factor']['C'] + residual = {b: row_add(full[b], sliced[b], -1) for b in full} + need({b for b, row in residual.items() if row} == set(C), 'exact residual support') + for x in C: + expected = {} + for j in range(8): + expected = row_add(expected, A[j], Fraction(C[x][j], 2)) + need(residual[x] == expected, 'source-reconstructed CA/2 residual') + need(full_frames == {b: tuple(f) for b, f in word['final_frames'].items()}, 'original final frames') + prelude, new_frames, prelude_counts = entrance(word, program) + for b in full: + need(prelude[b] == row_add({b: Fraction(1)}, residual[b], 1), 'actual entrance I+K') + changed, changed_frames, _ = original(word, selected, prelude, new_frames) + need(changed == full and changed_frames == full_frames, 'all358 final fields and frames') + need(all(sliced[b] == {b: Fraction(1)} for b in omitted), 'omitted projection identity') + need(all(sliced[b] == {b: Fraction(1)} for b in sliced if b.startswith('Y')), 'normalised Y preservation') + + # A common explicit sufficient domain, deliberately not claimed minimal. + # Charts preserve B9 and each integer multiple of it by the pinned lemmas. + weights = {b: (4 if b.startswith('Y') else 2 if b.startswith('N') else 1) + for b in word['initial_frames']} + admitted_full, _, _ = original(word, range(5398), initial_state(word, weights), admission=True) + admitted_prelude, admitted_frames, _ = entrance(word, program, weights) + admitted_changed, _, _ = original(word, selected, admitted_prelude, admitted_frames, admission=True) + need(admitted_full == admitted_changed, 'common admitted full/changed endpoint map') + + controls = {} + # A direct source omission is a genuine observable error, not a schema error. + mutated = [op for op in program if op != ['double', 'Y0']] + try: + entrance(word, mutated) + except ValueError as error: + need(str(error) == 'complete Y source restoration', 'source-return control reason') + controls['omit_Y0_redoubling'] = str(error) + else: + raise ValueError('source-return control was vacuous') + weak = dict(weights) + weak['N100'] = 1 + try: + original(word, selected, initial_state(word, weak), admission=True) + except ValueError as error: + need(str(error) == 'non-module increment at 312', 'N100 boundary control reason') + controls['weaken_N100_to_B9'] = str(error) + else: + raise ValueError('N100 admission control was vacuous') + + return { + 'status': 'PASS_SOURCE_BOUND_ENTRANCE_MATRIX_AND_ADMISSION', + 'normalised_endpoint_fields_checked': 358, + 'normalised_matrix_entries_checked': 358*358, + 'endpoint_matrix_sha256': digest(rows_record(full)), + 'residual_nonzero_rows': 52, + 'residual_nonzero_coefficients': sum(len(row) for row in residual.values()), + 'projection_event_sha256': digest(selected), + 'projection_never_reads_or_writes_omitted': True, + 'new_program_sha256': digest(program), + 'native_occurrences_bound': len(bound), + 'original_opcode_counts': full_counts, + 'retained_opcode_counts': slice_counts, + 'entrance': prelude_counts, + 'common_sufficient_admission': {'Y_in_4B9': sum(b.startswith('Y') for b in weights), + 'N_in_2B9': sum(b.startswith('N') for b in weights), + 'other_in_B9': sum(not b.startswith(('Y', 'N')) for b in weights), + 'minimality_claimed': False, + 'all_scalar_increments_module_integral': True, + 'native_and_chart_module_lemmas': 'Pinned PR3382 and PR3416 proofs, not re-proved by this matrix check.'}, + 'controls': controls, + } diff --git a/research/p104-inplace-entrance/verify.py b/research/p104-inplace-entrance/verify.py new file mode 100644 index 0000000000..229334e664 --- /dev/null +++ b/research/p104-inplace-entrance/verify.py @@ -0,0 +1,200 @@ +#!/usr/bin/env python3 +"""Replay the source-bound P104 in-place entrance contract and budget screen. + +Clear1nsight, with substantial OpenAI assistance. Apache-2.0. +Normal replay authenticates and consumes committed artifacts without writing. +""" + +import argparse +from copy import deepcopy +import gzip +import hashlib +import json +from pathlib import Path +import sys +from types import ModuleType + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] +WORD = 'research/p104-rounded-collector/inputs/WORD.json' +OLD_NATIVE = 'research/p104-rounded-collector/inputs/NATIVE.json.gz' +COMPLETION = 'research/p104-omitted-completion/CERTIFICATE.json' +ADAPTERS = 'research/p104-omitted-frame-adapters/ADAPTERS.json' +COMPILER = ('research/gmx-t74-borrow43-handoff/new/fastnative/vendor/native/new/code/' + 'borrow/vendor/clifford/clifford_exact.py') +KERNEL = 'research/p104-omitted-frame-adapters/inputs/PR3416_verify.py' +OWN = ('primary.py', 'native.py', 'physical.py', 'invoice.py', 'controls.py', + 'verify.py', 'README.md', 'PROOF.md', 'COSTS.md', 'TASK.json', 'VERIFY.json') + + +def need(condition, message): + if not condition: + raise ValueError(message) + + +def canonical(value): + return json.dumps(value, sort_keys=True, separators=(',', ':')).encode() + + +def sha(raw): + return hashlib.sha256(raw).hexdigest() + + +def strict_json(raw): + def pairs(items): + result = {} + for key, value in items: + need(key not in result, 'duplicate JSON key ' + key) + result[key] = value + return result + + def invalid(token): + raise ValueError('noninteger JSON token ' + token) + return json.loads(raw, object_pairs_hook=pairs, parse_float=invalid, parse_constant=invalid) + + +def same(a, b): + if type(a) is not type(b): + return False + if isinstance(a, dict): + return a.keys() == b.keys() and all(same(a[k], b[k]) for k in a) + if isinstance(a, (list, tuple)): + return len(a) == len(b) and all(same(x, y) for x, y in zip(a, b)) + return a == b + + +def read(path): + need(not any(p.is_symlink() for p in (path, *path.parents)), 'symbolic link in source ' + str(path)) + need(path.is_file(), 'missing regular source ' + str(path)) + with path.open('rb') as stream: + raw = stream.read(32*1024*1024+1) + need(len(raw) <= 32*1024*1024, 'source size limit') + return raw + + +def module(raw, path, name): + value = ModuleType(name) + value.__file__ = str(path) + sys.modules[name] = value + exec(compile(raw, str(path), 'exec'), value.__dict__) + return value + + +def capture(): + manifest_bytes = read(HERE/'SOURCES.json') + manifest = strict_json(manifest_bytes) + need(type(manifest.get('schema_version')) is int and manifest['schema_version'] == 1, + 'source schema') + raw = {} + for pin in manifest['files']: + if pin['usage'] != 'input': + continue + path = pin['path'] + need(type(path) is str and not path.startswith('/') + and all(part not in ('', '.', '..') for part in path.split('/')), 'input path') + need(path not in raw, 'duplicate scientific input') + raw[path] = read(ROOT/path) + need(sha(raw[path]) == pin['sha256'], 'source hash mismatch ' + path) + need({WORD, OLD_NATIVE, COMPLETION, ADAPTERS, COMPILER, KERNEL} <= set(raw), + 'required scientific inputs missing') + own = {name: read(HERE/name) for name in OWN} + return manifest_bytes, raw, own + + +def artifact(name, expected, regenerate): + path = HERE/name + if regenerate: + need(not path.is_symlink(), 'linked artifact destination') + path.write_text(json.dumps(expected, indent=2, sort_keys=True)+'\n', encoding='utf8') + raw = read(path) + actual = strict_json(raw) + need(same(actual, expected), 'typed serialized artifact mismatch ' + name) + return actual, raw + + +def calculate(regenerate=False): + manifest, raw, own = capture() + engines = {name: module(own[name+'.py'], HERE/(name+'.py'), 'p104_inplace_'+name) + for name in ('primary', 'native', 'physical', 'invoice', 'controls')} + compiler = module(raw[COMPILER], ROOT/COMPILER, 'p104_inplace_retained_compiler') + kernel = module(raw[KERNEL], ROOT/KERNEL, 'p104_inplace_retained_kernel') + word, completion, adapters = (strict_json(raw[name]) for name in (WORD, COMPLETION, ADAPTERS)) + expanded = gzip.decompress(raw[OLD_NATIVE]) + need(len(expanded) <= 8*1024*1024, 'native expansion limit') + old_native = strict_json(expanded) + primary, native = engines['primary'], engines['native'] + generated = {'schema_version': 1, 'program': primary.program_for(word, completion, adapters), + 'retained_original_event_indices': primary.projection(word)} + program, program_bytes = artifact('PROGRAM.json', generated, regenerate) + x_maps, full_map, native_receipt = native.synthesize(word, compiler.__dict__, kernel.__dict__) + need(set(x_maps) == set(completion['factor']['C']), 'new native output keys differ from source factor') + records, native_bytes = artifact('NATIVE.json', {'schema_version': 1, 'x_to_empty': x_maps, + 'empty_to_full': full_map}, regenerate) + old_full = next(r for r in adapters['recipes'] if r['old'] == []) + current_full = native_receipt['certificates']['empty_to_full'] + for key in ('signed_pauli_sha256', 'exact_anchor_sha256'): + need(current_full[key] == old_full['certificate'][key], 'retained common exit certificate') + altered = deepcopy(records['empty_to_full']) + altered['recipe']['left']['phase'] = (altered['recipe']['left']['phase']+1) % 4 + try: + native.certify_record(altered, kernel.__dict__) + except ValueError as error: + need(str(error) == 'exact global phase mismatch', 'wrong native phase control reason') + else: + raise ValueError('wrong global phase was admitted') + matrix = primary.analyze(word, old_native, completion, adapters, program['program']) + invoice = engines['invoice'].analyze(word, old_native, completion, adapters, + program['retained_original_event_indices']) + dirty = engines['controls'].scalar_controls(program['program'], completion['factor']['C'], + completion['factor']['A']) + physical = engines['physical'].verify_physical(word, completion, records['x_to_empty'], + records['empty_to_full'], program=program['program']) + need(physical['actual_fields'] == physical['expected_fields'], 'full independent physical arrays') + need(physical['actual_frames'] == physical['expected_frames'], 'full independent physical frames') + p = physical['receipt'] + need(p['program_sha256'] == matrix['new_program_sha256'], 'independent executed schedule digest') + need(p['native_counts']['native_rank_mass'] == invoice['entrance_completion']['native_rank_mass'] + == native_receipt['proposed_native_rank_mass'], 'three independent native invoices') + need(p['native_counts']['completed_floor_pairs'] == native_receipt['proposed_native_pair_count'], + 'literal complete-pair inventory') + need(not same({'count': True}, {'count': 1}), 'Boolean/integer receipt distinction') + for path, before in raw.items(): + need(read(ROOT/path) == before, 'source changed during replay '+path) + for path, before in own.items(): + need(read(HERE/path) == before, 'implementation changed during replay '+path) + need(read(HERE/'SOURCES.json') == manifest, 'source manifest changed during replay') + need(read(HERE/'PROGRAM.json') == program_bytes and read(HERE/'NATIVE.json') == native_bytes, + 'serialized artifact changed during replay') + result = {'schema_version': 1, 'status': 'PASS_P104_INPLACE_ENTRANCE', + 'SOURCES_sha256': sha(manifest), 'input_sha256': {p: sha(b) for p, b in raw.items()}, + 'implementation_and_proof_sha256': {p: sha(b) for p, b in own.items()}, + 'artifact_sha256': {'PROGRAM.json': sha(program_bytes), 'NATIVE.json': sha(native_bytes)}, + 'primary': matrix, 'native': native_receipt, 'physical': p, + 'invoice': invoice, 'dirty_controls': dirty, + 'global_phase_control': 'Altered scalar i rejected by exact global-phase anchor.', + 'typed_receipt_control': 'Boolean true is distinct from integer1.', + 'scope': 'An actual local in-place entrance completion, a source-bound all358 endpoint/module implication, one independent dense literal prefix, and a conditional rejected consumer budget. No global owner, full physical bill, all-size supplier, or new selected saving.'} + return strict_json(canonical(result)) + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--write-artifacts', action='store_true', + help='Explicitly regenerate only this package PROGRAM, NATIVE, and RECEIPT artifacts.') + args = parser.parse_args() + result = calculate(args.write_artifacts) + path = HERE/'RECEIPT.json' + if args.write_artifacts: + need(not path.is_symlink(), 'linked receipt destination') + path.write_text(json.dumps(result, indent=2, sort_keys=True)+'\n', encoding='utf8') + else: + need(same(result, strict_json(read(path))), 'typed deterministic receipt mismatch') + print('PASS_P104_INPLACE_ENTRANCE receipt='+sha(read(path))) + + +if __name__ == '__main__': + try: + main() + except (ValueError, OSError, KeyError, TypeError, StopIteration) as error: + print('FAIL_P104_INPLACE_ENTRANCE: '+str(error), file=sys.stderr) + raise SystemExit(1) from error