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/staged544-neutral-two-edit/.gitattributes b/research/staged544-neutral-two-edit/.gitattributes new file mode 100644 index 0000000000..fa1385d99a --- /dev/null +++ b/research/staged544-neutral-two-edit/.gitattributes @@ -0,0 +1 @@ +* -text diff --git a/research/staged544-neutral-two-edit/.gitignore b/research/staged544-neutral-two-edit/.gitignore new file mode 100644 index 0000000000..4d39da6267 --- /dev/null +++ b/research/staged544-neutral-two-edit/.gitignore @@ -0,0 +1,9 @@ +__pycache__/ +*.pyc +FIRST-*.json +SEARCH-*.json +PAIRS-*.json +NOVEL-*.json +GAINS-*.json +SEMANTICS-*.json +*.log diff --git a/research/staged544-neutral-two-edit/CENSUS.json b/research/staged544-neutral-two-edit/CENSUS.json new file mode 100644 index 0000000000..746311c0bf --- /dev/null +++ b/research/staged544-neutral-two-edit/CENSUS.json @@ -0,0 +1,10037 @@ +{ + "counts_are": "Insertion-cut/frame-dimension prices in a relaxation; not distinct circuits or all frame assignments.", + "evidence_kind": "Exact finite source-bound censuses plus informal scoped continuum proof; no formal kernel.", + "global_optimum_claim": false, + "new_current_supplier": false, + "providers": { + "base": { + "adjacent_dirty_block_checks": 3752, + "adjacent_swapped_gate_seconds": { + "counts": { + "commuting_adjacent_pairs": 3928, + "frame_rejected": 176, + "legal_first": 3752, + "second_prices": 3155468 + }, + "delta_types": [ + { + "caps": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "count": 5404, + "delta": { + "1": -2, + "2": 4, + "3": -2 + }, + "prefix_caps": [ + 0, + 2, + 2, + 2, + 2, + 2, + 2, + 2 + ] + }, + { + "caps": [ + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "count": 8951, + "delta": { + "1": -1, + "2": 1, + "3": 1, + "4": -1 + }, + "prefix_caps": [ + 0, + 1, + 2, + 2, + 2, + 2, + 2, + 2 + ] + }, + { + "caps": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "count": 2713223, + "delta": {}, + "prefix_caps": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + { + "caps": [ + 1, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "count": 9813, + "delta": { + "2": 2, + "4": -1 + }, + "prefix_caps": [ + 1, + 3, + 4, + 4, + 4, + 4, + 4, + 4 + ] + }, + { + "caps": [ + 1, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "count": 2498, + "delta": { + "2": 3, + "3": -2 + }, + "prefix_caps": [ + 1, + 3, + 3, + 3, + 3, + 3, + 3, + 3 + ] + }, + { + "caps": [ + 2, + 4, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "count": 37360, + "delta": { + "2": 4, + "4": -2 + }, + "prefix_caps": [ + 2, + 6, + 8, + 8, + 8, + 8, + 8, + 8 + ] + }, + { + "caps": [ + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "count": 14916, + "delta": { + "1": 1, + "3": 1, + "4": -1 + }, + "prefix_caps": [ + 1, + 2, + 3, + 3, + 3, + 3, + 3, + 3 + ] + }, + { + "caps": [ + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "count": 62032, + "delta": { + "1": 1, + "2": 1, + "3": -1 + }, + "prefix_caps": [ + 1, + 2, + 2, + 2, + 2, + 2, + 2, + 2 + ] + }, + { + "caps": [ + 1, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "count": 2908, + "delta": { + "1": 1, + "2": 2, + "3": -3, + "4": 1 + }, + "prefix_caps": [ + 1, + 2, + 1, + 1, + 1, + 1, + 1, + 1 + ] + }, + { + "caps": [ + 2, + 3, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "count": 14240, + "delta": { + "1": 1, + "2": 3, + "3": -1, + "4": -1 + }, + "prefix_caps": [ + 2, + 5, + 6, + 6, + 6, + 6, + 6, + 6 + ] + }, + { + "caps": [ + 1, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0 + ], + "count": 3260, + "delta": { + "1": 2, + "2": -2, + "3": 1, + "4": 1, + "5": -1 + }, + "prefix_caps": [ + 1, + 1, + 2, + 3, + 3, + 3, + 3, + 3 + ] + }, + { + "caps": [ + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "count": 588, + "delta": { + "1": 2, + "2": -2, + "3": 2, + "4": -1 + }, + "prefix_caps": [ + 1, + 1, + 2, + 2, + 2, + 2, + 2, + 2 + ] + }, + { + "caps": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "count": 5225, + "delta": { + "1": 2, + "2": -1 + }, + "prefix_caps": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ] + }, + { + "caps": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "count": 74720, + "delta": { + "1": 2, + "3": 2, + "4": -2 + }, + "prefix_caps": [ + 2, + 4, + 6, + 6, + 6, + 6, + 6, + 6 + ] + }, + { + "caps": [ + 2, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "count": 14240, + "delta": { + "1": 2, + "2": 1, + "4": -1 + }, + "prefix_caps": [ + 2, + 4, + 5, + 5, + 5, + 5, + 5, + 5 + ] + }, + { + "caps": [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "count": 77464, + "delta": { + "1": 2, + "2": 2, + "3": -2 + }, + "prefix_caps": [ + 2, + 4, + 4, + 4, + 4, + 4, + 4, + 4 + ] + }, + { + "caps": [ + 2, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "count": 84, + "delta": { + "1": 3, + "2": -1, + "3": 1, + "4": -1 + }, + "prefix_caps": [ + 2, + 3, + 4, + 4, + 4, + 4, + 4, + 4 + ] + }, + { + "caps": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "count": 11192, + "delta": { + "1": 3, + "3": -1 + }, + "prefix_caps": [ + 2, + 3, + 3, + 3, + 3, + 3, + 3, + 3 + ] + }, + { + "caps": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "count": 97350, + "delta": { + "1": 4, + "2": -2 + }, + "prefix_caps": [ + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2 + ] + } + ], + "neutral_second_prices": 2713223, + "ordered_state_sha256": "05effe1091c6d10c37f1bf48c42d54289407e23049843fc4a45d9a499cca0929", + "strictly_worse_second_prices": 442245 + }, + "adjacent_third_gate_new_middle": { + "counts": { + "legal_first": 3752, + "second_prices": 1045449 + }, + "delta_types": [ + { + "caps": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "count": 3018, + "delta": { + "1": -2, + "2": 4, + "3": -2 + }, + "prefix_caps": [ + 0, + 2, + 2, + 2, + 2, + 2, + 2, + 2 + ] + }, + { + "caps": [ + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "count": 4433, + "delta": { + "1": -1, + "2": 1, + "3": 1, + "4": -1 + }, + "prefix_caps": [ + 0, + 1, + 2, + 2, + 2, + 2, + 2, + 2 + ] + }, + { + "caps": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "count": 921868, + "delta": {}, + "prefix_caps": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + { + "caps": [ + 1, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "count": 4677, + "delta": { + "2": 2, + "4": -1 + }, + "prefix_caps": [ + 1, + 3, + 4, + 4, + 4, + 4, + 4, + 4 + ] + }, + { + "caps": [ + 1, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "count": 1235, + "delta": { + "2": 3, + "3": -2 + }, + "prefix_caps": [ + 1, + 3, + 3, + 3, + 3, + 3, + 3, + 3 + ] + }, + { + "caps": [ + 2, + 4, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "count": 9248, + "delta": { + "2": 4, + "4": -2 + }, + "prefix_caps": [ + 2, + 6, + 8, + 8, + 8, + 8, + 8, + 8 + ] + }, + { + "caps": [ + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "count": 3656, + "delta": { + "1": 1, + "3": 1, + "4": -1 + }, + "prefix_caps": [ + 1, + 2, + 3, + 3, + 3, + 3, + 3, + 3 + ] + }, + { + "caps": [ + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "count": 17781, + "delta": { + "1": 1, + "2": 1, + "3": -1 + }, + "prefix_caps": [ + 1, + 2, + 2, + 2, + 2, + 2, + 2, + 2 + ] + }, + { + "caps": [ + 1, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "count": 1369, + "delta": { + "1": 1, + "2": 2, + "3": -3, + "4": 1 + }, + "prefix_caps": [ + 1, + 2, + 1, + 1, + 1, + 1, + 1, + 1 + ] + }, + { + "caps": [ + 2, + 3, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "count": 3502, + "delta": { + "1": 1, + "2": 3, + "3": -1, + "4": -1 + }, + "prefix_caps": [ + 2, + 5, + 6, + 6, + 6, + 6, + 6, + 6 + ] + }, + { + "caps": [ + 1, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0 + ], + "count": 770, + "delta": { + "1": 2, + "2": -2, + "3": 1, + "4": 1, + "5": -1 + }, + "prefix_caps": [ + 1, + 1, + 2, + 3, + 3, + 3, + 3, + 3 + ] + }, + { + "caps": [ + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "count": 253, + "delta": { + "1": 2, + "2": -2, + "3": 2, + "4": -1 + }, + "prefix_caps": [ + 1, + 1, + 2, + 2, + 2, + 2, + 2, + 2 + ] + }, + { + "caps": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "count": 3054, + "delta": { + "1": 2, + "2": -1 + }, + "prefix_caps": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ] + }, + { + "caps": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "count": 18496, + "delta": { + "1": 2, + "3": 2, + "4": -2 + }, + "prefix_caps": [ + 2, + 4, + 6, + 6, + 6, + 6, + 6, + 6 + ] + }, + { + "caps": [ + 2, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "count": 3502, + "delta": { + "1": 2, + "2": 1, + "4": -1 + }, + "prefix_caps": [ + 2, + 4, + 5, + 5, + 5, + 5, + 5, + 5 + ] + }, + { + "caps": [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "count": 19698, + "delta": { + "1": 2, + "2": 2, + "3": -2 + }, + "prefix_caps": [ + 2, + 4, + 4, + 4, + 4, + 4, + 4, + 4 + ] + }, + { + "caps": [ + 2, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "count": 69, + "delta": { + "1": 3, + "2": -1, + "3": 1, + "4": -1 + }, + "prefix_caps": [ + 2, + 3, + 4, + 4, + 4, + 4, + 4, + 4 + ] + }, + { + "caps": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "count": 3666, + "delta": { + "1": 3, + "3": -1 + }, + "prefix_caps": [ + 2, + 3, + 3, + 3, + 3, + 3, + 3, + 3 + ] + }, + { + "caps": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "count": 25154, + "delta": { + "1": 4, + "2": -2 + }, + "prefix_caps": [ + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2 + ] + } + ], + "neutral_second_prices": 921868, + "ordered_state_sha256": "532217b93fa2c028810fc8e18e698434407f9cff1efa4f52502668a68d506461", + "strictly_worse_second_prices": 123581 + }, + "frame_changing_first": { + "counts": { + "legal_first": 122, + "second_prices": 1035911 + }, + "delta_types": [ + { + "caps": [ + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "count": 414, + "delta": { + "1": -1, + "2": 1, + "3": 1, + "4": -1 + }, + "prefix_caps": [ + 0, + 1, + 2, + 2, + 2, + 2, + 2, + 2 + ] + }, + { + "caps": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "count": 989125, + "delta": {}, + "prefix_caps": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + { + "caps": [ + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "count": 1415, + "delta": { + "1": 2, + "2": -2, + "3": 2, + "4": -1 + }, + "prefix_caps": [ + 1, + 1, + 2, + 2, + 2, + 2, + 2, + 2 + ] + }, + { + "caps": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "count": 7815, + "delta": { + "1": 2, + "2": -1 + }, + "prefix_caps": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ] + }, + { + "caps": [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "count": 33462, + "delta": { + "1": 2, + "2": 2, + "3": -2 + }, + "prefix_caps": [ + 2, + 4, + 4, + 4, + 4, + 4, + 4, + 4 + ] + }, + { + "caps": [ + 2, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "count": 1105, + "delta": { + "1": 3, + "2": -1, + "3": 1, + "4": -1 + }, + "prefix_caps": [ + 2, + 3, + 4, + 4, + 4, + 4, + 4, + 4 + ] + }, + { + "caps": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "count": 2575, + "delta": { + "1": 3, + "3": -1 + }, + "prefix_caps": [ + 2, + 3, + 3, + 3, + 3, + 3, + 3, + 3 + ] + } + ], + "first_edits": [ + { + "cut": 578, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 194 + ], + "index": 575, + "lower_dim": 0, + "registers": [ + 408, + 409 + ], + "section": "A", + "upper_dim": 1 + }, + { + "cut": 2026, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 11, + 21, + 38, + 448, + 5, + 64, + 128 + ], + "index": 2026, + "lower_dim": 4, + "registers": [ + 57, + 92 + ], + "section": "A", + "upper_dim": 7 + }, + { + "cut": 2028, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 11, + 21, + 38, + 448, + 5, + 64, + 128 + ], + "index": 2026, + "lower_dim": 4, + "registers": [ + 57, + 92 + ], + "section": "A", + "upper_dim": 7 + }, + { + "cut": 2029, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 11, + 21, + 38, + 448, + 5, + 64, + 128 + ], + "index": 2026, + "lower_dim": 4, + "registers": [ + 57, + 92 + ], + "section": "A", + "upper_dim": 7 + }, + { + "cut": 2180, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 45, + 85, + 133, + 261, + 5, + 11, + 16 + ], + "index": 2180, + "lower_dim": 4, + "registers": [ + 62, + 63 + ], + "section": "A", + "upper_dim": 7 + }, + { + "cut": 2182, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 45, + 85, + 133, + 261, + 5, + 11, + 16 + ], + "index": 2180, + "lower_dim": 4, + "registers": [ + 62, + 63 + ], + "section": "A", + "upper_dim": 7 + }, + { + "cut": 2183, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 45, + 85, + 133, + 261, + 5, + 11, + 16 + ], + "index": 2180, + "lower_dim": 4, + "registers": [ + 62, + 63 + ], + "section": "A", + "upper_dim": 7 + }, + { + "cut": 2334, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 14, + 35, + 69, + 400, + 5, + 16, + 128 + ], + "index": 2334, + "lower_dim": 4, + "registers": [ + 94, + 61 + ], + "section": "A", + "upper_dim": 7 + }, + { + "cut": 2336, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 14, + 35, + 69, + 400, + 5, + 16, + 128 + ], + "index": 2334, + "lower_dim": 4, + "registers": [ + 94, + 61 + ], + "section": "A", + "upper_dim": 7 + }, + { + "cut": 2337, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 14, + 35, + 69, + 400, + 5, + 16, + 128 + ], + "index": 2334, + "lower_dim": 4, + "registers": [ + 94, + 61 + ], + "section": "A", + "upper_dim": 7 + }, + { + "cut": 364, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 45, + 73, + 137, + 286, + 25 + ], + "index": 365, + "lower_dim": 4, + "registers": [ + 139, + 14 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 365, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 45, + 73, + 137, + 286, + 25 + ], + "index": 365, + "lower_dim": 4, + "registers": [ + 139, + 14 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 367, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 45, + 73, + 137, + 286, + 25 + ], + "index": 365, + "lower_dim": 4, + "registers": [ + 139, + 14 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 368, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 45, + 73, + 137, + 286, + 25 + ], + "index": 365, + "lower_dim": 4, + "registers": [ + 139, + 14 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 364, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 2, + 9, + 36, + 469, + 16 + ], + "index": 366, + "lower_dim": 4, + "registers": [ + 127, + 239 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 365, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 2, + 9, + 36, + 469, + 16 + ], + "index": 366, + "lower_dim": 4, + "registers": [ + 127, + 239 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 366, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 2, + 9, + 36, + 469, + 16 + ], + "index": 366, + "lower_dim": 4, + "registers": [ + 127, + 239 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 368, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 2, + 9, + 36, + 469, + 16 + ], + "index": 366, + "lower_dim": 4, + "registers": [ + 127, + 239 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 369, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 2, + 9, + 36, + 469, + 16 + ], + "index": 366, + "lower_dim": 4, + "registers": [ + 127, + 239 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 365, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 45, + 87, + 137, + 265, + 25 + ], + "index": 367, + "lower_dim": 4, + "registers": [ + 125, + 78 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 366, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 45, + 87, + 137, + 265, + 25 + ], + "index": 367, + "lower_dim": 4, + "registers": [ + 125, + 78 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 367, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 45, + 87, + 137, + 265, + 25 + ], + "index": 367, + "lower_dim": 4, + "registers": [ + 125, + 78 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 385, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 45, + 80, + 146, + 261, + 2 + ], + "index": 386, + "lower_dim": 4, + "registers": [ + 203, + 415 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 386, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 45, + 80, + 146, + 261, + 2 + ], + "index": 386, + "lower_dim": 4, + "registers": [ + 203, + 415 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 388, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 45, + 80, + 146, + 261, + 2 + ], + "index": 386, + "lower_dim": 4, + "registers": [ + 203, + 415 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 389, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 45, + 80, + 146, + 261, + 2 + ], + "index": 386, + "lower_dim": 4, + "registers": [ + 203, + 415 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 385, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 9, + 36, + 208, + 261, + 82 + ], + "index": 387, + "lower_dim": 4, + "registers": [ + 165, + 255 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 386, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 9, + 36, + 208, + 261, + 82 + ], + "index": 387, + "lower_dim": 4, + "registers": [ + 165, + 255 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 387, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 9, + 36, + 208, + 261, + 82 + ], + "index": 387, + "lower_dim": 4, + "registers": [ + 165, + 255 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 389, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 9, + 36, + 208, + 261, + 82 + ], + "index": 387, + "lower_dim": 4, + "registers": [ + 165, + 255 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 390, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 9, + 36, + 208, + 261, + 82 + ], + "index": 387, + "lower_dim": 4, + "registers": [ + 165, + 255 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 386, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 5, + 40, + 194, + 265, + 82 + ], + "index": 388, + "lower_dim": 4, + "registers": [ + 148, + 21 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 387, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 5, + 40, + 194, + 265, + 82 + ], + "index": 388, + "lower_dim": 4, + "registers": [ + 148, + 21 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 388, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 5, + 40, + 194, + 265, + 82 + ], + "index": 388, + "lower_dim": 4, + "registers": [ + 148, + 21 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 407, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 45, + 69, + 146, + 272, + 9 + ], + "index": 408, + "lower_dim": 4, + "registers": [ + 201, + 431 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 408, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 45, + 69, + 146, + 272, + 9 + ], + "index": 408, + "lower_dim": 4, + "registers": [ + 201, + 431 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 410, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 45, + 69, + 146, + 272, + 9 + ], + "index": 408, + "lower_dim": 4, + "registers": [ + 201, + 431 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 411, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 45, + 69, + 146, + 272, + 9 + ], + "index": 408, + "lower_dim": 4, + "registers": [ + 201, + 431 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 407, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 45, + 69, + 130, + 274, + 9 + ], + "index": 409, + "lower_dim": 4, + "registers": [ + 163, + 271 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 408, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 45, + 69, + 130, + 274, + 9 + ], + "index": 409, + "lower_dim": 4, + "registers": [ + 163, + 271 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 409, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 45, + 69, + 130, + 274, + 9 + ], + "index": 409, + "lower_dim": 4, + "registers": [ + 163, + 271 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 411, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 45, + 69, + 130, + 274, + 9 + ], + "index": 409, + "lower_dim": 4, + "registers": [ + 163, + 271 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 412, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 45, + 69, + 130, + 274, + 9 + ], + "index": 409, + "lower_dim": 4, + "registers": [ + 163, + 271 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 408, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 45, + 73, + 144, + 274, + 5 + ], + "index": 410, + "lower_dim": 4, + "registers": [ + 223, + 447 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 409, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 45, + 73, + 144, + 274, + 5 + ], + "index": 410, + "lower_dim": 4, + "registers": [ + 223, + 447 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 410, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 45, + 73, + 144, + 274, + 5 + ], + "index": 410, + "lower_dim": 4, + "registers": [ + 223, + 447 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 428, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 14, + 35, + 130, + 341, + 66 + ], + "index": 429, + "lower_dim": 4, + "registers": [ + 191, + 99 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 429, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 14, + 35, + 130, + 341, + 66 + ], + "index": 429, + "lower_dim": 4, + "registers": [ + 191, + 99 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 431, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 14, + 35, + 130, + 341, + 66 + ], + "index": 429, + "lower_dim": 4, + "registers": [ + 191, + 99 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 432, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 14, + 35, + 130, + 341, + 66 + ], + "index": 429, + "lower_dim": 4, + "registers": [ + 191, + 99 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 428, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 14, + 35, + 215, + 258, + 66 + ], + "index": 430, + "lower_dim": 4, + "registers": [ + 156, + 25 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 429, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 14, + 35, + 215, + 258, + 66 + ], + "index": 430, + "lower_dim": 4, + "registers": [ + 156, + 25 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 430, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 14, + 35, + 215, + 258, + 66 + ], + "index": 430, + "lower_dim": 4, + "registers": [ + 156, + 25 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 432, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 14, + 35, + 215, + 258, + 66 + ], + "index": 430, + "lower_dim": 4, + "registers": [ + 156, + 25 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 433, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 14, + 35, + 215, + 258, + 66 + ], + "index": 430, + "lower_dim": 4, + "registers": [ + 156, + 25 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 429, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 28, + 45, + 199, + 268, + 76 + ], + "index": 431, + "lower_dim": 4, + "registers": [ + 158, + 47 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 430, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 28, + 45, + 199, + 268, + 76 + ], + "index": 431, + "lower_dim": 4, + "registers": [ + 158, + 47 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 431, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 28, + 45, + 199, + 268, + 76 + ], + "index": 431, + "lower_dim": 4, + "registers": [ + 158, + 47 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 470, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 28, + 45, + 194, + 258, + 5 + ], + "index": 471, + "lower_dim": 4, + "registers": [ + 119, + 409 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 471, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 28, + 45, + 194, + 258, + 5 + ], + "index": 471, + "lower_dim": 4, + "registers": [ + 119, + 409 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 473, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 28, + 45, + 194, + 258, + 5 + ], + "index": 471, + "lower_dim": 4, + "registers": [ + 119, + 409 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 474, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 28, + 45, + 194, + 258, + 5 + ], + "index": 471, + "lower_dim": 4, + "registers": [ + 119, + 409 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 470, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 21, + 45, + 66, + 386, + 12 + ], + "index": 472, + "lower_dim": 4, + "registers": [ + 154, + 87 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 471, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 21, + 45, + 66, + 386, + 12 + ], + "index": 472, + "lower_dim": 4, + "registers": [ + 154, + 87 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 472, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 21, + 45, + 66, + 386, + 12 + ], + "index": 472, + "lower_dim": 4, + "registers": [ + 154, + 87 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 474, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 21, + 45, + 66, + 386, + 12 + ], + "index": 472, + "lower_dim": 4, + "registers": [ + 154, + 87 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 475, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 21, + 45, + 66, + 386, + 12 + ], + "index": 472, + "lower_dim": 4, + "registers": [ + 154, + 87 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 471, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 2, + 45, + 192, + 320, + 25 + ], + "index": 473, + "lower_dim": 4, + "registers": [ + 128, + 425 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 472, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 2, + 45, + 192, + 320, + 25 + ], + "index": 473, + "lower_dim": 4, + "registers": [ + 128, + 425 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 473, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 2, + 45, + 192, + 320, + 25 + ], + "index": 473, + "lower_dim": 4, + "registers": [ + 128, + 425 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 491, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 5, + 40, + 137, + 336, + 82 + ], + "index": 492, + "lower_dim": 4, + "registers": [ + 122, + 52 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 492, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 5, + 40, + 137, + 336, + 82 + ], + "index": 492, + "lower_dim": 4, + "registers": [ + 122, + 52 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 494, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 5, + 40, + 137, + 336, + 82 + ], + "index": 492, + "lower_dim": 4, + "registers": [ + 122, + 52 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 495, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 5, + 40, + 137, + 336, + 82 + ], + "index": 492, + "lower_dim": 4, + "registers": [ + 122, + 52 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 491, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 45, + 66, + 133, + 274, + 16 + ], + "index": 493, + "lower_dim": 4, + "registers": [ + 217, + 90 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 492, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 45, + 66, + 133, + 274, + 16 + ], + "index": 493, + "lower_dim": 4, + "registers": [ + 217, + 90 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 493, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 45, + 66, + 133, + 274, + 16 + ], + "index": 493, + "lower_dim": 4, + "registers": [ + 217, + 90 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 495, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 45, + 66, + 133, + 274, + 16 + ], + "index": 493, + "lower_dim": 4, + "registers": [ + 217, + 90 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 496, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 45, + 66, + 133, + 274, + 16 + ], + "index": 493, + "lower_dim": 4, + "registers": [ + 217, + 90 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 492, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 45, + 80, + 137, + 274, + 2 + ], + "index": 494, + "lower_dim": 4, + "registers": [ + 132, + 441 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 493, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 45, + 80, + 137, + 274, + 2 + ], + "index": 494, + "lower_dim": 4, + "registers": [ + 132, + 441 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 494, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 45, + 80, + 137, + 274, + 2 + ], + "index": 494, + "lower_dim": 4, + "registers": [ + 132, + 441 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 764, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 18, + 33, + 67, + 392, + 3 + ], + "index": 766, + "lower_dim": 4, + "registers": [ + 168, + 554 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 765, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 18, + 33, + 67, + 392, + 3 + ], + "index": 766, + "lower_dim": 4, + "registers": [ + 168, + 554 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 766, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 18, + 33, + 67, + 392, + 3 + ], + "index": 766, + "lower_dim": 4, + "registers": [ + 168, + 554 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 768, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 18, + 33, + 67, + 392, + 3 + ], + "index": 766, + "lower_dim": 4, + "registers": [ + 168, + 554 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 769, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 18, + 33, + 67, + 392, + 3 + ], + "index": 766, + "lower_dim": 4, + "registers": [ + 168, + 554 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 765, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 4, + 51, + 136, + 264, + 82 + ], + "index": 767, + "lower_dim": 4, + "registers": [ + 150, + 439 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 766, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 4, + 51, + 136, + 264, + 82 + ], + "index": 767, + "lower_dim": 4, + "registers": [ + 150, + 439 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 767, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 4, + 51, + 136, + 264, + 82 + ], + "index": 767, + "lower_dim": 4, + "registers": [ + 150, + 439 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 769, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 4, + 51, + 136, + 264, + 82 + ], + "index": 767, + "lower_dim": 4, + "registers": [ + 150, + 439 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 770, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 4, + 51, + 136, + 264, + 82 + ], + "index": 767, + "lower_dim": 4, + "registers": [ + 150, + 439 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 766, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 4, + 18, + 33, + 459, + 64 + ], + "index": 768, + "lower_dim": 4, + "registers": [ + 143, + 555 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 767, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 4, + 18, + 33, + 459, + 64 + ], + "index": 768, + "lower_dim": 4, + "registers": [ + 143, + 555 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 768, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 4, + 18, + 33, + 459, + 64 + ], + "index": 768, + "lower_dim": 4, + "registers": [ + 143, + 555 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 770, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 4, + 18, + 33, + 459, + 64 + ], + "index": 768, + "lower_dim": 4, + "registers": [ + 143, + 555 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 771, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 4, + 18, + 33, + 459, + 64 + ], + "index": 768, + "lower_dim": 4, + "registers": [ + 143, + 555 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 769, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 18, + 33, + 200, + 259, + 76 + ], + "index": 771, + "lower_dim": 4, + "registers": [ + 214, + 566 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 770, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 18, + 33, + 200, + 259, + 76 + ], + "index": 771, + "lower_dim": 4, + "registers": [ + 214, + 566 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 771, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 18, + 33, + 200, + 259, + 76 + ], + "index": 771, + "lower_dim": 4, + "registers": [ + 214, + 566 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 773, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 18, + 33, + 200, + 259, + 76 + ], + "index": 771, + "lower_dim": 4, + "registers": [ + 214, + 566 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 774, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 18, + 33, + 200, + 259, + 76 + ], + "index": 771, + "lower_dim": 4, + "registers": [ + 214, + 566 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 770, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 51, + 72, + 140, + 274, + 4 + ], + "index": 772, + "lower_dim": 4, + "registers": [ + 131, + 444 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 771, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 51, + 72, + 140, + 274, + 4 + ], + "index": 772, + "lower_dim": 4, + "registers": [ + 131, + 444 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 772, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 51, + 72, + 140, + 274, + 4 + ], + "index": 772, + "lower_dim": 4, + "registers": [ + 131, + 444 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 774, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 51, + 72, + 140, + 274, + 4 + ], + "index": 772, + "lower_dim": 4, + "registers": [ + 131, + 444 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 775, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 51, + 72, + 140, + 274, + 4 + ], + "index": 772, + "lower_dim": 4, + "registers": [ + 131, + 444 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 771, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 18, + 33, + 131, + 328, + 76 + ], + "index": 773, + "lower_dim": 4, + "registers": [ + 167, + 567 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 772, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 18, + 33, + 131, + 328, + 76 + ], + "index": 773, + "lower_dim": 4, + "registers": [ + 167, + 567 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 773, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 18, + 33, + 131, + 328, + 76 + ], + "index": 773, + "lower_dim": 4, + "registers": [ + 167, + 567 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 775, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 18, + 33, + 131, + 328, + 76 + ], + "index": 773, + "lower_dim": 4, + "registers": [ + 167, + 567 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 776, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 18, + 33, + 131, + 328, + 76 + ], + "index": 773, + "lower_dim": 4, + "registers": [ + 167, + 567 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 776, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 13, + 19, + 33, + 455, + 65 + ], + "index": 778, + "lower_dim": 4, + "registers": [ + 197, + 531 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 777, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 13, + 19, + 33, + 455, + 65 + ], + "index": 778, + "lower_dim": 4, + "registers": [ + 197, + 531 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 778, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 13, + 19, + 33, + 455, + 65 + ], + "index": 778, + "lower_dim": 4, + "registers": [ + 197, + 531 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 780, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 13, + 19, + 33, + 455, + 65 + ], + "index": 778, + "lower_dim": 4, + "registers": [ + 197, + 531 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 781, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 13, + 19, + 33, + 455, + 65 + ], + "index": 778, + "lower_dim": 4, + "registers": [ + 197, + 531 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 781, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 30, + 33, + 134, + 321, + 64 + ], + "index": 783, + "lower_dim": 4, + "registers": [ + 145, + 543 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 782, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 30, + 33, + 134, + 321, + 64 + ], + "index": 783, + "lower_dim": 4, + "registers": [ + 145, + 543 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 783, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 30, + 33, + 134, + 321, + 64 + ], + "index": 783, + "lower_dim": 4, + "registers": [ + 145, + 543 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 785, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 30, + 33, + 134, + 321, + 64 + ], + "index": 783, + "lower_dim": 4, + "registers": [ + 145, + 543 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 786, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 30, + 33, + 134, + 321, + 64 + ], + "index": 783, + "lower_dim": 4, + "registers": [ + 145, + 543 + ], + "section": "B", + "upper_dim": 5 + } + ], + "neutral_second_prices": 989125, + "ordered_state_sha256": "43c5ecc267c6c9ae62e0fc21b69b8674321ce36b414de63ac51c08f96826812a", + "strictly_worse_second_prices": 46786 + }, + "fresh_coverage_crosschecks": 39, + "full_dirty_first_word_checks": 122, + "total_second_prices": 5236828 + }, + "extra": { + "adjacent_dirty_block_checks": 3752, + "adjacent_swapped_gate_seconds": { + "counts": { + "commuting_adjacent_pairs": 3928, + "frame_rejected": 176, + "legal_first": 3752, + "second_prices": 3155468 + }, + "delta_types": [ + { + "caps": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "count": 5404, + "delta": { + "1": -2, + "2": 4, + "3": -2 + }, + "prefix_caps": [ + 0, + 2, + 2, + 2, + 2, + 2, + 2, + 2 + ] + }, + { + "caps": [ + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "count": 8951, + "delta": { + "1": -1, + "2": 1, + "3": 1, + "4": -1 + }, + "prefix_caps": [ + 0, + 1, + 2, + 2, + 2, + 2, + 2, + 2 + ] + }, + { + "caps": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "count": 2713223, + "delta": {}, + "prefix_caps": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + { + "caps": [ + 1, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "count": 9813, + "delta": { + "2": 2, + "4": -1 + }, + "prefix_caps": [ + 1, + 3, + 4, + 4, + 4, + 4, + 4, + 4 + ] + }, + { + "caps": [ + 1, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "count": 2498, + "delta": { + "2": 3, + "3": -2 + }, + "prefix_caps": [ + 1, + 3, + 3, + 3, + 3, + 3, + 3, + 3 + ] + }, + { + "caps": [ + 2, + 4, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "count": 37360, + "delta": { + "2": 4, + "4": -2 + }, + "prefix_caps": [ + 2, + 6, + 8, + 8, + 8, + 8, + 8, + 8 + ] + }, + { + "caps": [ + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "count": 14916, + "delta": { + "1": 1, + "3": 1, + "4": -1 + }, + "prefix_caps": [ + 1, + 2, + 3, + 3, + 3, + 3, + 3, + 3 + ] + }, + { + "caps": [ + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "count": 62032, + "delta": { + "1": 1, + "2": 1, + "3": -1 + }, + "prefix_caps": [ + 1, + 2, + 2, + 2, + 2, + 2, + 2, + 2 + ] + }, + { + "caps": [ + 1, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "count": 2908, + "delta": { + "1": 1, + "2": 2, + "3": -3, + "4": 1 + }, + "prefix_caps": [ + 1, + 2, + 1, + 1, + 1, + 1, + 1, + 1 + ] + }, + { + "caps": [ + 2, + 3, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "count": 14240, + "delta": { + "1": 1, + "2": 3, + "3": -1, + "4": -1 + }, + "prefix_caps": [ + 2, + 5, + 6, + 6, + 6, + 6, + 6, + 6 + ] + }, + { + "caps": [ + 1, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0 + ], + "count": 3260, + "delta": { + "1": 2, + "2": -2, + "3": 1, + "4": 1, + "5": -1 + }, + "prefix_caps": [ + 1, + 1, + 2, + 3, + 3, + 3, + 3, + 3 + ] + }, + { + "caps": [ + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "count": 588, + "delta": { + "1": 2, + "2": -2, + "3": 2, + "4": -1 + }, + "prefix_caps": [ + 1, + 1, + 2, + 2, + 2, + 2, + 2, + 2 + ] + }, + { + "caps": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "count": 5225, + "delta": { + "1": 2, + "2": -1 + }, + "prefix_caps": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ] + }, + { + "caps": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "count": 74720, + "delta": { + "1": 2, + "3": 2, + "4": -2 + }, + "prefix_caps": [ + 2, + 4, + 6, + 6, + 6, + 6, + 6, + 6 + ] + }, + { + "caps": [ + 2, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "count": 14240, + "delta": { + "1": 2, + "2": 1, + "4": -1 + }, + "prefix_caps": [ + 2, + 4, + 5, + 5, + 5, + 5, + 5, + 5 + ] + }, + { + "caps": [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "count": 77464, + "delta": { + "1": 2, + "2": 2, + "3": -2 + }, + "prefix_caps": [ + 2, + 4, + 4, + 4, + 4, + 4, + 4, + 4 + ] + }, + { + "caps": [ + 2, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "count": 84, + "delta": { + "1": 3, + "2": -1, + "3": 1, + "4": -1 + }, + "prefix_caps": [ + 2, + 3, + 4, + 4, + 4, + 4, + 4, + 4 + ] + }, + { + "caps": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "count": 11192, + "delta": { + "1": 3, + "3": -1 + }, + "prefix_caps": [ + 2, + 3, + 3, + 3, + 3, + 3, + 3, + 3 + ] + }, + { + "caps": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "count": 97350, + "delta": { + "1": 4, + "2": -2 + }, + "prefix_caps": [ + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2 + ] + } + ], + "neutral_second_prices": 2713223, + "ordered_state_sha256": "05effe1091c6d10c37f1bf48c42d54289407e23049843fc4a45d9a499cca0929", + "strictly_worse_second_prices": 442245 + }, + "adjacent_third_gate_new_middle": { + "counts": { + "legal_first": 3752, + "second_prices": 1045449 + }, + "delta_types": [ + { + "caps": [ + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "count": 3018, + "delta": { + "1": -2, + "2": 4, + "3": -2 + }, + "prefix_caps": [ + 0, + 2, + 2, + 2, + 2, + 2, + 2, + 2 + ] + }, + { + "caps": [ + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "count": 4433, + "delta": { + "1": -1, + "2": 1, + "3": 1, + "4": -1 + }, + "prefix_caps": [ + 0, + 1, + 2, + 2, + 2, + 2, + 2, + 2 + ] + }, + { + "caps": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "count": 921868, + "delta": {}, + "prefix_caps": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + { + "caps": [ + 1, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "count": 4677, + "delta": { + "2": 2, + "4": -1 + }, + "prefix_caps": [ + 1, + 3, + 4, + 4, + 4, + 4, + 4, + 4 + ] + }, + { + "caps": [ + 1, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "count": 1235, + "delta": { + "2": 3, + "3": -2 + }, + "prefix_caps": [ + 1, + 3, + 3, + 3, + 3, + 3, + 3, + 3 + ] + }, + { + "caps": [ + 2, + 4, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "count": 9248, + "delta": { + "2": 4, + "4": -2 + }, + "prefix_caps": [ + 2, + 6, + 8, + 8, + 8, + 8, + 8, + 8 + ] + }, + { + "caps": [ + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "count": 3656, + "delta": { + "1": 1, + "3": 1, + "4": -1 + }, + "prefix_caps": [ + 1, + 2, + 3, + 3, + 3, + 3, + 3, + 3 + ] + }, + { + "caps": [ + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "count": 17781, + "delta": { + "1": 1, + "2": 1, + "3": -1 + }, + "prefix_caps": [ + 1, + 2, + 2, + 2, + 2, + 2, + 2, + 2 + ] + }, + { + "caps": [ + 1, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "count": 1369, + "delta": { + "1": 1, + "2": 2, + "3": -3, + "4": 1 + }, + "prefix_caps": [ + 1, + 2, + 1, + 1, + 1, + 1, + 1, + 1 + ] + }, + { + "caps": [ + 2, + 3, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "count": 3502, + "delta": { + "1": 1, + "2": 3, + "3": -1, + "4": -1 + }, + "prefix_caps": [ + 2, + 5, + 6, + 6, + 6, + 6, + 6, + 6 + ] + }, + { + "caps": [ + 1, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0 + ], + "count": 770, + "delta": { + "1": 2, + "2": -2, + "3": 1, + "4": 1, + "5": -1 + }, + "prefix_caps": [ + 1, + 1, + 2, + 3, + 3, + 3, + 3, + 3 + ] + }, + { + "caps": [ + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "count": 253, + "delta": { + "1": 2, + "2": -2, + "3": 2, + "4": -1 + }, + "prefix_caps": [ + 1, + 1, + 2, + 2, + 2, + 2, + 2, + 2 + ] + }, + { + "caps": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "count": 3054, + "delta": { + "1": 2, + "2": -1 + }, + "prefix_caps": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ] + }, + { + "caps": [ + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "count": 18496, + "delta": { + "1": 2, + "3": 2, + "4": -2 + }, + "prefix_caps": [ + 2, + 4, + 6, + 6, + 6, + 6, + 6, + 6 + ] + }, + { + "caps": [ + 2, + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "count": 3502, + "delta": { + "1": 2, + "2": 1, + "4": -1 + }, + "prefix_caps": [ + 2, + 4, + 5, + 5, + 5, + 5, + 5, + 5 + ] + }, + { + "caps": [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "count": 19698, + "delta": { + "1": 2, + "2": 2, + "3": -2 + }, + "prefix_caps": [ + 2, + 4, + 4, + 4, + 4, + 4, + 4, + 4 + ] + }, + { + "caps": [ + 2, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "count": 69, + "delta": { + "1": 3, + "2": -1, + "3": 1, + "4": -1 + }, + "prefix_caps": [ + 2, + 3, + 4, + 4, + 4, + 4, + 4, + 4 + ] + }, + { + "caps": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "count": 3666, + "delta": { + "1": 3, + "3": -1 + }, + "prefix_caps": [ + 2, + 3, + 3, + 3, + 3, + 3, + 3, + 3 + ] + }, + { + "caps": [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "count": 25154, + "delta": { + "1": 4, + "2": -2 + }, + "prefix_caps": [ + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2 + ] + } + ], + "neutral_second_prices": 921868, + "ordered_state_sha256": "532217b93fa2c028810fc8e18e698434407f9cff1efa4f52502668a68d506461", + "strictly_worse_second_prices": 123581 + }, + "frame_changing_first": { + "counts": { + "legal_first": 122, + "second_prices": 1035911 + }, + "delta_types": [ + { + "caps": [ + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "count": 414, + "delta": { + "1": -1, + "2": 1, + "3": 1, + "4": -1 + }, + "prefix_caps": [ + 0, + 1, + 2, + 2, + 2, + 2, + 2, + 2 + ] + }, + { + "caps": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "count": 989125, + "delta": {}, + "prefix_caps": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + { + "caps": [ + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "count": 1415, + "delta": { + "1": 2, + "2": -2, + "3": 2, + "4": -1 + }, + "prefix_caps": [ + 1, + 1, + 2, + 2, + 2, + 2, + 2, + 2 + ] + }, + { + "caps": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "count": 7815, + "delta": { + "1": 2, + "2": -1 + }, + "prefix_caps": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ] + }, + { + "caps": [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "count": 33462, + "delta": { + "1": 2, + "2": 2, + "3": -2 + }, + "prefix_caps": [ + 2, + 4, + 4, + 4, + 4, + 4, + 4, + 4 + ] + }, + { + "caps": [ + 2, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "count": 1105, + "delta": { + "1": 3, + "2": -1, + "3": 1, + "4": -1 + }, + "prefix_caps": [ + 2, + 3, + 4, + 4, + 4, + 4, + 4, + 4 + ] + }, + { + "caps": [ + 2, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "count": 2575, + "delta": { + "1": 3, + "3": -1 + }, + "prefix_caps": [ + 2, + 3, + 3, + 3, + 3, + 3, + 3, + 3 + ] + } + ], + "first_edits": [ + { + "cut": 578, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 194 + ], + "index": 575, + "lower_dim": 0, + "registers": [ + 408, + 409 + ], + "section": "A", + "upper_dim": 1 + }, + { + "cut": 2026, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 11, + 21, + 38, + 448, + 5, + 64, + 128 + ], + "index": 2026, + "lower_dim": 4, + "registers": [ + 57, + 92 + ], + "section": "A", + "upper_dim": 7 + }, + { + "cut": 2028, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 11, + 21, + 38, + 448, + 5, + 64, + 128 + ], + "index": 2026, + "lower_dim": 4, + "registers": [ + 57, + 92 + ], + "section": "A", + "upper_dim": 7 + }, + { + "cut": 2029, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 11, + 21, + 38, + 448, + 5, + 64, + 128 + ], + "index": 2026, + "lower_dim": 4, + "registers": [ + 57, + 92 + ], + "section": "A", + "upper_dim": 7 + }, + { + "cut": 2180, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 45, + 85, + 133, + 261, + 5, + 11, + 16 + ], + "index": 2180, + "lower_dim": 4, + "registers": [ + 62, + 63 + ], + "section": "A", + "upper_dim": 7 + }, + { + "cut": 2182, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 45, + 85, + 133, + 261, + 5, + 11, + 16 + ], + "index": 2180, + "lower_dim": 4, + "registers": [ + 62, + 63 + ], + "section": "A", + "upper_dim": 7 + }, + { + "cut": 2183, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 45, + 85, + 133, + 261, + 5, + 11, + 16 + ], + "index": 2180, + "lower_dim": 4, + "registers": [ + 62, + 63 + ], + "section": "A", + "upper_dim": 7 + }, + { + "cut": 2334, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 14, + 35, + 69, + 400, + 5, + 16, + 128 + ], + "index": 2334, + "lower_dim": 4, + "registers": [ + 94, + 61 + ], + "section": "A", + "upper_dim": 7 + }, + { + "cut": 2336, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 14, + 35, + 69, + 400, + 5, + 16, + 128 + ], + "index": 2334, + "lower_dim": 4, + "registers": [ + 94, + 61 + ], + "section": "A", + "upper_dim": 7 + }, + { + "cut": 2337, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 14, + 35, + 69, + 400, + 5, + 16, + 128 + ], + "index": 2334, + "lower_dim": 4, + "registers": [ + 94, + 61 + ], + "section": "A", + "upper_dim": 7 + }, + { + "cut": 364, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 45, + 73, + 137, + 286, + 25 + ], + "index": 365, + "lower_dim": 4, + "registers": [ + 139, + 14 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 365, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 45, + 73, + 137, + 286, + 25 + ], + "index": 365, + "lower_dim": 4, + "registers": [ + 139, + 14 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 367, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 45, + 73, + 137, + 286, + 25 + ], + "index": 365, + "lower_dim": 4, + "registers": [ + 139, + 14 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 368, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 45, + 73, + 137, + 286, + 25 + ], + "index": 365, + "lower_dim": 4, + "registers": [ + 139, + 14 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 364, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 2, + 9, + 36, + 469, + 16 + ], + "index": 366, + "lower_dim": 4, + "registers": [ + 127, + 239 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 365, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 2, + 9, + 36, + 469, + 16 + ], + "index": 366, + "lower_dim": 4, + "registers": [ + 127, + 239 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 366, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 2, + 9, + 36, + 469, + 16 + ], + "index": 366, + "lower_dim": 4, + "registers": [ + 127, + 239 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 368, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 2, + 9, + 36, + 469, + 16 + ], + "index": 366, + "lower_dim": 4, + "registers": [ + 127, + 239 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 369, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 2, + 9, + 36, + 469, + 16 + ], + "index": 366, + "lower_dim": 4, + "registers": [ + 127, + 239 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 365, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 45, + 87, + 137, + 265, + 25 + ], + "index": 367, + "lower_dim": 4, + "registers": [ + 125, + 78 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 366, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 45, + 87, + 137, + 265, + 25 + ], + "index": 367, + "lower_dim": 4, + "registers": [ + 125, + 78 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 367, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 45, + 87, + 137, + 265, + 25 + ], + "index": 367, + "lower_dim": 4, + "registers": [ + 125, + 78 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 385, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 45, + 80, + 146, + 261, + 2 + ], + "index": 386, + "lower_dim": 4, + "registers": [ + 203, + 415 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 386, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 45, + 80, + 146, + 261, + 2 + ], + "index": 386, + "lower_dim": 4, + "registers": [ + 203, + 415 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 388, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 45, + 80, + 146, + 261, + 2 + ], + "index": 386, + "lower_dim": 4, + "registers": [ + 203, + 415 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 389, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 45, + 80, + 146, + 261, + 2 + ], + "index": 386, + "lower_dim": 4, + "registers": [ + 203, + 415 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 385, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 9, + 36, + 208, + 261, + 82 + ], + "index": 387, + "lower_dim": 4, + "registers": [ + 165, + 255 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 386, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 9, + 36, + 208, + 261, + 82 + ], + "index": 387, + "lower_dim": 4, + "registers": [ + 165, + 255 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 387, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 9, + 36, + 208, + 261, + 82 + ], + "index": 387, + "lower_dim": 4, + "registers": [ + 165, + 255 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 389, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 9, + 36, + 208, + 261, + 82 + ], + "index": 387, + "lower_dim": 4, + "registers": [ + 165, + 255 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 390, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 9, + 36, + 208, + 261, + 82 + ], + "index": 387, + "lower_dim": 4, + "registers": [ + 165, + 255 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 386, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 5, + 40, + 194, + 265, + 82 + ], + "index": 388, + "lower_dim": 4, + "registers": [ + 148, + 21 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 387, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 5, + 40, + 194, + 265, + 82 + ], + "index": 388, + "lower_dim": 4, + "registers": [ + 148, + 21 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 388, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 5, + 40, + 194, + 265, + 82 + ], + "index": 388, + "lower_dim": 4, + "registers": [ + 148, + 21 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 407, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 45, + 69, + 146, + 272, + 9 + ], + "index": 408, + "lower_dim": 4, + "registers": [ + 201, + 431 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 408, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 45, + 69, + 146, + 272, + 9 + ], + "index": 408, + "lower_dim": 4, + "registers": [ + 201, + 431 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 410, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 45, + 69, + 146, + 272, + 9 + ], + "index": 408, + "lower_dim": 4, + "registers": [ + 201, + 431 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 411, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 45, + 69, + 146, + 272, + 9 + ], + "index": 408, + "lower_dim": 4, + "registers": [ + 201, + 431 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 407, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 45, + 69, + 130, + 274, + 9 + ], + "index": 409, + "lower_dim": 4, + "registers": [ + 163, + 271 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 408, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 45, + 69, + 130, + 274, + 9 + ], + "index": 409, + "lower_dim": 4, + "registers": [ + 163, + 271 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 409, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 45, + 69, + 130, + 274, + 9 + ], + "index": 409, + "lower_dim": 4, + "registers": [ + 163, + 271 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 411, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 45, + 69, + 130, + 274, + 9 + ], + "index": 409, + "lower_dim": 4, + "registers": [ + 163, + 271 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 412, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 45, + 69, + 130, + 274, + 9 + ], + "index": 409, + "lower_dim": 4, + "registers": [ + 163, + 271 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 408, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 45, + 73, + 144, + 274, + 5 + ], + "index": 410, + "lower_dim": 4, + "registers": [ + 223, + 447 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 409, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 45, + 73, + 144, + 274, + 5 + ], + "index": 410, + "lower_dim": 4, + "registers": [ + 223, + 447 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 410, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 45, + 73, + 144, + 274, + 5 + ], + "index": 410, + "lower_dim": 4, + "registers": [ + 223, + 447 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 428, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 14, + 35, + 130, + 341, + 66 + ], + "index": 429, + "lower_dim": 4, + "registers": [ + 191, + 99 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 429, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 14, + 35, + 130, + 341, + 66 + ], + "index": 429, + "lower_dim": 4, + "registers": [ + 191, + 99 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 431, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 14, + 35, + 130, + 341, + 66 + ], + "index": 429, + "lower_dim": 4, + "registers": [ + 191, + 99 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 432, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 14, + 35, + 130, + 341, + 66 + ], + "index": 429, + "lower_dim": 4, + "registers": [ + 191, + 99 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 428, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 14, + 35, + 215, + 258, + 66 + ], + "index": 430, + "lower_dim": 4, + "registers": [ + 156, + 25 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 429, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 14, + 35, + 215, + 258, + 66 + ], + "index": 430, + "lower_dim": 4, + "registers": [ + 156, + 25 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 430, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 14, + 35, + 215, + 258, + 66 + ], + "index": 430, + "lower_dim": 4, + "registers": [ + 156, + 25 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 432, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 14, + 35, + 215, + 258, + 66 + ], + "index": 430, + "lower_dim": 4, + "registers": [ + 156, + 25 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 433, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 14, + 35, + 215, + 258, + 66 + ], + "index": 430, + "lower_dim": 4, + "registers": [ + 156, + 25 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 429, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 28, + 45, + 199, + 268, + 76 + ], + "index": 431, + "lower_dim": 4, + "registers": [ + 158, + 47 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 430, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 28, + 45, + 199, + 268, + 76 + ], + "index": 431, + "lower_dim": 4, + "registers": [ + 158, + 47 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 431, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 28, + 45, + 199, + 268, + 76 + ], + "index": 431, + "lower_dim": 4, + "registers": [ + 158, + 47 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 470, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 28, + 45, + 194, + 258, + 5 + ], + "index": 471, + "lower_dim": 4, + "registers": [ + 119, + 409 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 471, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 28, + 45, + 194, + 258, + 5 + ], + "index": 471, + "lower_dim": 4, + "registers": [ + 119, + 409 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 473, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 28, + 45, + 194, + 258, + 5 + ], + "index": 471, + "lower_dim": 4, + "registers": [ + 119, + 409 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 474, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 28, + 45, + 194, + 258, + 5 + ], + "index": 471, + "lower_dim": 4, + "registers": [ + 119, + 409 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 470, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 21, + 45, + 66, + 386, + 12 + ], + "index": 472, + "lower_dim": 4, + "registers": [ + 154, + 87 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 471, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 21, + 45, + 66, + 386, + 12 + ], + "index": 472, + "lower_dim": 4, + "registers": [ + 154, + 87 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 472, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 21, + 45, + 66, + 386, + 12 + ], + "index": 472, + "lower_dim": 4, + "registers": [ + 154, + 87 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 474, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 21, + 45, + 66, + 386, + 12 + ], + "index": 472, + "lower_dim": 4, + "registers": [ + 154, + 87 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 475, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 21, + 45, + 66, + 386, + 12 + ], + "index": 472, + "lower_dim": 4, + "registers": [ + 154, + 87 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 471, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 2, + 45, + 192, + 320, + 25 + ], + "index": 473, + "lower_dim": 4, + "registers": [ + 128, + 425 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 472, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 2, + 45, + 192, + 320, + 25 + ], + "index": 473, + "lower_dim": 4, + "registers": [ + 128, + 425 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 473, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 2, + 45, + 192, + 320, + 25 + ], + "index": 473, + "lower_dim": 4, + "registers": [ + 128, + 425 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 491, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 5, + 40, + 137, + 336, + 82 + ], + "index": 492, + "lower_dim": 4, + "registers": [ + 122, + 52 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 492, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 5, + 40, + 137, + 336, + 82 + ], + "index": 492, + "lower_dim": 4, + "registers": [ + 122, + 52 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 494, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 5, + 40, + 137, + 336, + 82 + ], + "index": 492, + "lower_dim": 4, + "registers": [ + 122, + 52 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 495, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 5, + 40, + 137, + 336, + 82 + ], + "index": 492, + "lower_dim": 4, + "registers": [ + 122, + 52 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 491, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 45, + 66, + 133, + 274, + 16 + ], + "index": 493, + "lower_dim": 4, + "registers": [ + 217, + 90 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 492, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 45, + 66, + 133, + 274, + 16 + ], + "index": 493, + "lower_dim": 4, + "registers": [ + 217, + 90 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 493, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 45, + 66, + 133, + 274, + 16 + ], + "index": 493, + "lower_dim": 4, + "registers": [ + 217, + 90 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 495, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 45, + 66, + 133, + 274, + 16 + ], + "index": 493, + "lower_dim": 4, + "registers": [ + 217, + 90 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 496, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 45, + 66, + 133, + 274, + 16 + ], + "index": 493, + "lower_dim": 4, + "registers": [ + 217, + 90 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 492, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 45, + 80, + 137, + 274, + 2 + ], + "index": 494, + "lower_dim": 4, + "registers": [ + 132, + 441 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 493, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 45, + 80, + 137, + 274, + 2 + ], + "index": 494, + "lower_dim": 4, + "registers": [ + 132, + 441 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 494, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 45, + 80, + 137, + 274, + 2 + ], + "index": 494, + "lower_dim": 4, + "registers": [ + 132, + 441 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 764, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 18, + 33, + 67, + 392, + 3 + ], + "index": 766, + "lower_dim": 4, + "registers": [ + 168, + 554 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 765, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 18, + 33, + 67, + 392, + 3 + ], + "index": 766, + "lower_dim": 4, + "registers": [ + 168, + 554 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 766, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 18, + 33, + 67, + 392, + 3 + ], + "index": 766, + "lower_dim": 4, + "registers": [ + 168, + 554 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 768, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 18, + 33, + 67, + 392, + 3 + ], + "index": 766, + "lower_dim": 4, + "registers": [ + 168, + 554 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 769, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 18, + 33, + 67, + 392, + 3 + ], + "index": 766, + "lower_dim": 4, + "registers": [ + 168, + 554 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 765, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 4, + 51, + 136, + 264, + 82 + ], + "index": 767, + "lower_dim": 4, + "registers": [ + 150, + 439 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 766, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 4, + 51, + 136, + 264, + 82 + ], + "index": 767, + "lower_dim": 4, + "registers": [ + 150, + 439 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 767, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 4, + 51, + 136, + 264, + 82 + ], + "index": 767, + "lower_dim": 4, + "registers": [ + 150, + 439 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 769, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 4, + 51, + 136, + 264, + 82 + ], + "index": 767, + "lower_dim": 4, + "registers": [ + 150, + 439 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 770, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 4, + 51, + 136, + 264, + 82 + ], + "index": 767, + "lower_dim": 4, + "registers": [ + 150, + 439 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 766, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 4, + 18, + 33, + 459, + 64 + ], + "index": 768, + "lower_dim": 4, + "registers": [ + 143, + 555 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 767, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 4, + 18, + 33, + 459, + 64 + ], + "index": 768, + "lower_dim": 4, + "registers": [ + 143, + 555 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 768, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 4, + 18, + 33, + 459, + 64 + ], + "index": 768, + "lower_dim": 4, + "registers": [ + 143, + 555 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 770, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 4, + 18, + 33, + 459, + 64 + ], + "index": 768, + "lower_dim": 4, + "registers": [ + 143, + 555 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 771, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 4, + 18, + 33, + 459, + 64 + ], + "index": 768, + "lower_dim": 4, + "registers": [ + 143, + 555 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 769, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 18, + 33, + 200, + 259, + 76 + ], + "index": 771, + "lower_dim": 4, + "registers": [ + 214, + 566 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 770, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 18, + 33, + 200, + 259, + 76 + ], + "index": 771, + "lower_dim": 4, + "registers": [ + 214, + 566 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 771, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 18, + 33, + 200, + 259, + 76 + ], + "index": 771, + "lower_dim": 4, + "registers": [ + 214, + 566 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 773, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 18, + 33, + 200, + 259, + 76 + ], + "index": 771, + "lower_dim": 4, + "registers": [ + 214, + 566 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 774, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 18, + 33, + 200, + 259, + 76 + ], + "index": 771, + "lower_dim": 4, + "registers": [ + 214, + 566 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 770, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 51, + 72, + 140, + 274, + 4 + ], + "index": 772, + "lower_dim": 4, + "registers": [ + 131, + 444 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 771, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 51, + 72, + 140, + 274, + 4 + ], + "index": 772, + "lower_dim": 4, + "registers": [ + 131, + 444 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 772, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 51, + 72, + 140, + 274, + 4 + ], + "index": 772, + "lower_dim": 4, + "registers": [ + 131, + 444 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 774, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 51, + 72, + 140, + 274, + 4 + ], + "index": 772, + "lower_dim": 4, + "registers": [ + 131, + 444 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 775, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 51, + 72, + 140, + 274, + 4 + ], + "index": 772, + "lower_dim": 4, + "registers": [ + 131, + 444 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 771, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 18, + 33, + 131, + 328, + 76 + ], + "index": 773, + "lower_dim": 4, + "registers": [ + 167, + 567 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 772, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 18, + 33, + 131, + 328, + 76 + ], + "index": 773, + "lower_dim": 4, + "registers": [ + 167, + 567 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 773, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 18, + 33, + 131, + 328, + 76 + ], + "index": 773, + "lower_dim": 4, + "registers": [ + 167, + 567 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 775, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 18, + 33, + 131, + 328, + 76 + ], + "index": 773, + "lower_dim": 4, + "registers": [ + 167, + 567 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 776, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 18, + 33, + 131, + 328, + 76 + ], + "index": 773, + "lower_dim": 4, + "registers": [ + 167, + 567 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 776, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 13, + 19, + 33, + 455, + 65 + ], + "index": 778, + "lower_dim": 4, + "registers": [ + 197, + 531 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 777, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 13, + 19, + 33, + 455, + 65 + ], + "index": 778, + "lower_dim": 4, + "registers": [ + 197, + 531 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 778, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 13, + 19, + 33, + 455, + 65 + ], + "index": 778, + "lower_dim": 4, + "registers": [ + 197, + 531 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 780, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 13, + 19, + 33, + 455, + 65 + ], + "index": 778, + "lower_dim": 4, + "registers": [ + 197, + 531 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 781, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 13, + 19, + 33, + 455, + 65 + ], + "index": 778, + "lower_dim": 4, + "registers": [ + 197, + 531 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 781, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 30, + 33, + 134, + 321, + 64 + ], + "index": 783, + "lower_dim": 4, + "registers": [ + 145, + 543 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 782, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 30, + 33, + 134, + 321, + 64 + ], + "index": 783, + "lower_dim": 4, + "registers": [ + 145, + 543 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 783, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 30, + 33, + 134, + 321, + 64 + ], + "index": 783, + "lower_dim": 4, + "registers": [ + 145, + 543 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 785, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 30, + 33, + 134, + 321, + 64 + ], + "index": 783, + "lower_dim": 4, + "registers": [ + 145, + 543 + ], + "section": "B", + "upper_dim": 5 + }, + { + "cut": 786, + "delta": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "frame": [ + 30, + 33, + 134, + 321, + 64 + ], + "index": 783, + "lower_dim": 4, + "registers": [ + 145, + 543 + ], + "section": "B", + "upper_dim": 5 + } + ], + "neutral_second_prices": 989125, + "ordered_state_sha256": "43c5ecc267c6c9ae62e0fc21b69b8674321ce36b414de63ac51c08f96826812a", + "strictly_worse_second_prices": 46786 + }, + "fresh_coverage_crosschecks": 39, + "full_dirty_first_word_checks": 122, + "total_second_prices": 5236828 + } + }, + "raw_moment_interval": "0 1+4`. With cleanup and basis spelling restored, the result is the pinned +source word. Full arbitrary-dirty replay checks the rollback, neutral middle +and recovered word in each provider. This detects a real two-step gain but is +not a new improvement over the current source. + +The two declared domains do not cover arbitrary nonadjacent neutral starts, +frame-changing starts beyond displacement two, non-neutral intermediate words, +simultaneous incompatible intermediate frames, SCALE moves, commutator +corrections, warp crossings, changed phases or interfaces. Unknown physical, +native realization and complete supplier costs are recorded as unknown, not +zero. No current supplier improvement, new kappa or selected-frontier change +is inferred from a failed finite search. diff --git a/research/staged544-neutral-two-edit/README.md b/research/staged544-neutral-two-edit/README.md new file mode 100644 index 0000000000..aca3e12d80 --- /dev/null +++ b/research/staged544-neutral-two-edit/README.md @@ -0,0 +1,131 @@ +# Exact neutral-first two-edit searches on staged544 + +This package continues PR3886's explicit open question: can a neutral first +retiming enable a strictly cheaper second gate/frame edit on the literal +PR3734 staged544 words? It preserves all caller, helper, phase and native-warp +interfaces and searches two declared first-edit domains. The result is scoped +to those domains; it is not a global barrier, supplier admission or new kappa. + +**Result:** neither declared domain lowers the raw recursive moment for any +real `0 1+4`. This is a sensitivity +control, not a new current improvement. The verifier also includes wrong-scalar, +bad-frame, cleanup, noncommutation, source-drift and invoice controls. + +Full per-first-word dirty replay, from the repository root: + +```sh +python3 -B research/staged544-neutral-two-edit/verify.py --provider base +python3 -B research/staged544-neutral-two-edit/verify.py --provider extra +``` + +The registered replay uses `--compositional-dirty`: it checks every first block +on independent dirty symbols and fully replays the baseline and positive +controls, rather than repeating 122 whole-word interpreter runs. The full mode +above remains available. Both modes regenerate all search cells, compare exact +certificates and check the complete ledger. Both full normal replays passed: +635.689 seconds for base and 540.046 seconds for extra on CPython 3.12.3. +Assertion-disabled checks repeat the positive fixtures, rejection controls and +retained sign arithmetic; they do not repeat the full enumeration under `-O`. +Finalized execution coverage is recorded in VALIDATION.json. + +```sh +python3 -B scripts/research_package.py --package research/staged544-neutral-two-edit +``` + +The opt-in hook is VERIFY.json. Metadata/history/hosted CI validation are +distinct from mathematical verification. The official registered replay and +metadata/pin checks passed in an isolated fixture with the exact authenticated +canonical Git objects; delivered scientific-code and manifest bytes match that +checked snapshot. The fixture explicitly marks missing older history shallow, +so no full source-history preflight or hosted CI result is claimed. No fresh native +Gaussian/Clifford, physical hosting/allocation, precision/tape, all-size/compiler, +full outer/supplier, analytic or BIT admission is asserted. + +## Open next questions + +* Can a nonadjacent neutral first move outside the two domains unlock a gain? + Pin one literal outside-domain word and derive its interacting second-move + ledger. The missing evidence is a legal source-bound witness, not another + aggregate histogram allowance. +* Can two coordinated frame changes improve the bill through an intermediate + word that is not neutral? Supply a literal before/after word and restored + dirty-state contract before a wider search. Simultaneous legality and full + physical consumer costs remain blockers. + +Structured questions, the explicit user assignment, expansion decision, +checkpoint and overlap limitations are retained in TASK.json. Neither a zero +result here nor PR3886's frozen-baseline certificate can be iterated into a +universal obstruction. + +## Credit and provenance + +* dataisfire / PR3734, `fa041037a3374eaa08feeca0b26a5d6893194147`: + literal staged544 providers and retained auditor sources. +* Chris R / Clear1nsight / PR3886 scientific head + `359fe0fe77d29544972fd22ee674085ed5a3b4d0`: single-ADD relaxation, + exact sign certificate and source-bound recovery control. The later PR head + `6e5c125bdc1064a31a8705d42f091e23c94fd659` changes only an unrelated workflow; + its research package is unchanged. +* Jeremy Kothe / PR2957 and PR2979, with the subsequent staged-entry and + retiming chain: already-retained circuit mechanism and construction lineage. +* Dugongue / PR3863, `635fe84596c19016f3d0316a5cf7abbe48285490`, and the + ranked-pair/MathProof predecessors: paid rank-profile targets and accounting. +* Sagar Thakrar's audit_core and roger-sato's semantic adapter are reused + unchanged. Their Arham Tahir frame-contract attribution is preserved in + vendor/SOURCE-CREDITS.md. They are not newly independent interpreters. + +New neutral-first enumeration, middle-cut reduction, exact block checks and +ledger by Chris R / Clear1nsight with substantial OpenAI Codex assistance. +Apache-2.0 and all retained notices apply. No independent human review or +formal-kernel acceptance is claimed. diff --git a/research/staged544-neutral-two-edit/SOURCES.json b/research/staged544-neutral-two-edit/SOURCES.json new file mode 100644 index 0000000000..df7d22541c --- /dev/null +++ b/research/staged544-neutral-two-edit/SOURCES.json @@ -0,0 +1,154 @@ +{ + "schema_version": 1, + "base_commit": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "files": [ + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "67f085acd86acd7d4e03922d9cf4b26bca66fed5", + "sha256": "47b42433f5a85809a3aadd29c2c339da2c6ed728e4f7762df6b88bccb7874cf0" + } + ], + "snapshots": [ + { + "local": "vendor/pr3886_retiming.py", + "bytes": 10391, + "sha256": "591d7278541ac4de9e9b6fc1e17aba23b205ac4b6c81824a28fc08294658ef0d", + "git_blob": "c33d7bbcdf2435056b3a56526e8e43f6513e381b", + "source_repository": "Clear1nsight/integer-mult-bounds", + "source_commit": "359fe0fe77d29544972fd22ee674085ed5a3b4d0", + "source_path": "research/rank-profile-retiming-obstruction/retiming.py" + }, + { + "local": "vendor/audit_core.py", + "bytes": 19364, + "sha256": "888679ca8502cdcb100420fe5382a052529a494bf76cb332928b86e62612b951", + "git_blob": "8b5e1d5f2a106402f036b63028ecef31a4e4c462", + "source_repository": "Clear1nsight/integer-mult-bounds", + "source_commit": "359fe0fe77d29544972fd22ee674085ed5a3b4d0", + "source_path": "research/rank-profile-retiming-obstruction/vendor/audit_core.py", + "predecessor_origin": { + "local": "vendor/audit_core.py", + "source_path": "research/staged544-producer-return/audit_core.py", + "source_repository": "dataisfire/integer-mult-bounds", + "source_commit": "fa041037a3374eaa08feeca0b26a5d6893194147", + "bytes": 19364, + "sha256": "888679ca8502cdcb100420fe5382a052529a494bf76cb332928b86e62612b951", + "git_blob": "8b5e1d5f2a106402f036b63028ecef31a4e4c462" + } + }, + { + "local": "vendor/audit_verify.py", + "bytes": 12382, + "sha256": "99971d3cc143cc894600e08c8cfbad3e8f537a544212f21dfbe4271cfa97354d", + "git_blob": "7f9fc1df424ae1d459616e49bda7a5dd17e40491", + "source_repository": "Clear1nsight/integer-mult-bounds", + "source_commit": "359fe0fe77d29544972fd22ee674085ed5a3b4d0", + "source_path": "research/rank-profile-retiming-obstruction/vendor/audit_verify.py", + "predecessor_origin": { + "local": "vendor/audit_verify.py", + "source_path": "research/staged544-producer-return/audit_verify.py", + "source_repository": "dataisfire/integer-mult-bounds", + "source_commit": "fa041037a3374eaa08feeca0b26a5d6893194147", + "bytes": 12382, + "sha256": "99971d3cc143cc894600e08c8cfbad3e8f537a544212f21dfbe4271cfa97354d", + "git_blob": "7f9fc1df424ae1d459616e49bda7a5dd17e40491" + } + }, + { + "local": "vendor/SOURCE-CREDITS.md", + "bytes": 2882, + "sha256": "d4a13d8b8ed9cdb594f00efb3d1a336e09d934423330f02a1514308a720c278b", + "git_blob": "c054fad87eeaa510865e682ee0c976c4cd728da2", + "source_repository": "Clear1nsight/integer-mult-bounds", + "source_commit": "359fe0fe77d29544972fd22ee674085ed5a3b4d0", + "source_path": "research/rank-profile-retiming-obstruction/vendor/SOURCE-CREDITS.md", + "predecessor_origin": { + "local": "vendor/SOURCE-CREDITS.md", + "source_path": "research/staged544-producer-return/SOURCE-CREDITS.md", + "source_repository": "dataisfire/integer-mult-bounds", + "source_commit": "fa041037a3374eaa08feeca0b26a5d6893194147", + "bytes": 2882, + "sha256": "d4a13d8b8ed9cdb594f00efb3d1a336e09d934423330f02a1514308a720c278b", + "git_blob": "c054fad87eeaa510865e682ee0c976c4cd728da2" + } + }, + { + "local": "inputs/PROFILE.json", + "bytes": 130, + "sha256": "06b4e2abe8d56b49bad3bdc8f8504082404b40609d548fa8de2618eb7373fd48", + "git_blob": "d1000454afc30925dc4b447a6f007e4b7dcbbab3", + "source_repository": "Clear1nsight/integer-mult-bounds", + "source_commit": "359fe0fe77d29544972fd22ee674085ed5a3b4d0", + "source_path": "research/rank-profile-retiming-obstruction/inputs/PROFILE.json", + "predecessor_origin": { + "local": "inputs/PROFILE.json", + "source_path": "research/staged544-producer-return/inputs/PROFILE.json", + "source_repository": "dataisfire/integer-mult-bounds", + "source_commit": "fa041037a3374eaa08feeca0b26a5d6893194147", + "bytes": 130, + "sha256": "06b4e2abe8d56b49bad3bdc8f8504082404b40609d548fa8de2618eb7373fd48", + "git_blob": "d1000454afc30925dc4b447a6f007e4b7dcbbab3" + } + }, + { + "local": "inputs/BORROW-WORD-43base.json.gz", + "bytes": 72769, + "sha256": "5ca4be99851f8878cbfe0fd6c454df926b11218f17feefa1664721cf03156699", + "git_blob": "674ea18ade4af85ca865fb08dc973637a09e30e6", + "source_repository": "Clear1nsight/integer-mult-bounds", + "source_commit": "359fe0fe77d29544972fd22ee674085ed5a3b4d0", + "source_path": "research/rank-profile-retiming-obstruction/inputs/BORROW-WORD-43base.json.gz", + "predecessor_origin": { + "local": "inputs/BORROW-WORD-43base.json.gz", + "source_path": "research/staged544-producer-return/words/BORROW-WORD-43base.json.gz", + "source_repository": "dataisfire/integer-mult-bounds", + "source_commit": "fa041037a3374eaa08feeca0b26a5d6893194147", + "bytes": 72769, + "sha256": "5ca4be99851f8878cbfe0fd6c454df926b11218f17feefa1664721cf03156699", + "git_blob": "674ea18ade4af85ca865fb08dc973637a09e30e6" + } + }, + { + "local": "inputs/BORROW-WORD-43extra.json.gz", + "bytes": 72766, + "sha256": "965268a9be73d3f62e7ef680d18f108cf064bfe1f44b82157baa61443232904e", + "git_blob": "b17e2be67e327f04802fd034c344fe4253c13a4a", + "source_repository": "Clear1nsight/integer-mult-bounds", + "source_commit": "359fe0fe77d29544972fd22ee674085ed5a3b4d0", + "source_path": "research/rank-profile-retiming-obstruction/inputs/BORROW-WORD-43extra.json.gz", + "predecessor_origin": { + "local": "inputs/BORROW-WORD-43extra.json.gz", + "source_path": "research/staged544-producer-return/words/BORROW-WORD-43extra.json.gz", + "source_repository": "dataisfire/integer-mult-bounds", + "source_commit": "fa041037a3374eaa08feeca0b26a5d6893194147", + "bytes": 72766, + "sha256": "965268a9be73d3f62e7ef680d18f108cf064bfe1f44b82157baa61443232904e", + "git_blob": "b17e2be67e327f04802fd034c344fe4253c13a4a" + } + } + ], + "external_snapshot_contract": "All scientific external bytes are self-contained package snapshots authenticated by length, SHA256 and Git blob before execution. Attribution heads are not runtime Git ancestry dependencies. No frozen predecessor is changed.", + "method_predecessors": [ + { + "pr": 3863, + "author": "Dugongue", + "head": "635fe84596c19016f3d0316a5cf7abbe48285490", + "scope": "Uniform rational paid-profile credit and proposed 2+2 to 1+3 target; read, not reimplemented as new mathematics." + }, + { + "pr": 2957, + "author": "Jeremy Kothe", + "retained_record": "research/rank7-joint-endframes/data/REWRITES-2957.json", + "retained_record_base": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "scope": "Already-retained commuting swap used as a counterfactual rollback/recovery positive control." + }, + { + "pr": 3886, + "author": "Chris R / Clear1nsight", + "scientific_head": "359fe0fe77d29544972fd22ee674085ed5a3b4d0", + "current_head_at_entry": "6e5c125bdc1064a31a8705d42f091e23c94fd659", + "scope": "Retiming, source words, exact sign certificates and counterfactual recovery. Latest commit only changes unrelated workflow." + } + ] +} diff --git a/research/staged544-neutral-two-edit/TASK.json b/research/staged544-neutral-two-edit/TASK.json new file mode 100644 index 0000000000..3196168c6d --- /dev/null +++ b/research/staged544-neutral-two-edit/TASK.json @@ -0,0 +1,128 @@ +{ + "schema_version": 1, + "task_id": "scalar-to-moment", + "priority_revision": 6, + "base_commit": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "original_card": { + "id": "scalar-to-moment", + "question": "Can one known scalar simplification be converted into an actual paid-profile improvement?", + "starting_points": [ + "research/r439-bsection-stars-seed01/README.md", + "certificates/selected-result.json" + ], + "methods": [ + "Derive the changed legal frame itinerary and exact child histogram.", + "Prove a scoped obstruction showing why that scalar gain cannot change the paid contract." + ], + "acceptance_gate": "An unchanged histogram is not a kappa gain; record any separate runtime or proof benefit explicitly.", + "first_step": { + "command": [ + "python3", + "-B", + "research/r439-bsection-stars-seed01/verify.py" + ], + "expected": "PASS_R439_BSECTION_STARS", + "inspect": "Observe that the positive control improves scalar counts while retaining the paid histogram.", + "scope": "Positive control / source-bound orientation only; this is not a new construction or full cold replay." + }, + "first_experiment": "Choose one simplification and derive the complete changed frame itinerary, or prove why it cannot change the histogram.", + "bottleneck_link": "A legal change to the histogram, not addition count alone, is the bridge to an exponent gain.", + "allowed_variations": [ + "One existing scalar simplification and one proposed frame-path change." + ], + "scope_change_triggers": [ + "Submitting only another scalar count as completion of a paid-profile task." + ], + "overlap_terms": [ + "scalar simplification", + "paid profile", + "R439" + ] + }, + "scope_status": "changed", + "scope_change_reason": "Explicit user assignment continues PR3886. The first-word geometry is allowed to change, so this goes beyond its frozen single-variable-frame baseline certificate. The adjacent-swap domain additionally prices third ADDs at the newly exposed cut; all other third-gate cuts inherit baseline prices by the written reduction.", + "actual_scope": "Two explicit neutral-first domains on both pinned PR3734 providers: all neutral frame-changing first ADD edits at displacement <=2 followed by any interacting second ADD retiming; and all adjacent frame-preserving commuting ADD swaps followed by any second ADD retiming, using an exact new-middle-cut reduction. All first/second edits stay within original scalar corridors and preserve interfaces.", + "bottleneck_link": "Decide whether a neutral source-level edit enables a paid moment improvement outside the frozen single-ADD certificate.", + "budget_minutes": 60, + "author": "Chris R / Clear1nsight", + "outcome": "negative-result", + "evidence": "Both exact two-edit domains completed on both providers: 10,473,656 new second cut/dimension prices, no improvement for 0 lo and R.crosses(g, gates[lower-1]): lower -= 1 + while upper < hi and R.crosses(g, gates[upper]): upper += 1 + else: + need(target_cut is not None,'trusted reach needs an exact cut') + lower,upper=target_cut,target_cut + if max_distance is not None: + lower, upper = max(lower,i-max_distance), min(upper,i+1+max_distance) + removal = [0]*10 + reduced, entries, exits = {}, {}, {} + for r in R.touched(g): + seq = nodes[r] + pos = where[((section,i),r)] + _, _, p, u = seq[pos] + q = seq[pos+1][3] + removal[R.rank(u)-R.rank(p)] -= 1 + removal[R.rank(q)-R.rank(u)] -= 1 + removal[R.rank(q)-R.rank(p)] += 1 + indices = occ[r] + reduced[r] = [x for x in indices if x != i] + entries[r] = seq[where[((section,indices[0]),r)]][2] + last = where[((section,indices[-1]),r)] + exits[r] = seq[last+1][3] + cuts=range(lower,upper+1) if target_cut is None else ([target_cut] if lower<=target_cut<=upper else []) + for cut in cuts: + if cut == i+1: continue + boundary = [] + for r in R.touched(g): + indices = reduced[r] + j = bisect_left(indices,cut) + p = R.span(tuple(gates[indices[j-1]][-1])) if j else entries[r] + q = R.span(tuple(gates[indices[j]][-1])) if j>v)&1): + extension.append(v); mask = R.span(tuple(extension)) + frames[len(extension)] = tuple(extension) + for d in range(R.rank(L),R.rank(H)+1): + delta = removal.copy() + for p,q in dims: + delta[q-p] -= 1; delta[d-p] += 1; delta[q-d] += 1 + delta[0] = 0 + yield {'section':section,'index':i,'cut':cut,'frame':list(frames[d]), + 'delta':tuple(delta),'lower_dim':R.rank(L),'upper_dim':R.rank(H), + 'registers':list(R.touched(g))} + +def apply(w, rec): + return R.apply_move(w,rec['section'],rec['index'],rec['cut'],rec['frame']) + +def inspect_first(tag, distance): + w=load(tag); counts=Counter(); examples=[]; unique=set() + t=time.monotonic() + for rec in placements(w,max_distance=distance): + counts['prices'] += 1 + if any(rec['delta']): continue + counts['neutral_prices'] += 1 + g=w[rec['section']][rec['index']] + newindex=rec['cut']-(rec['cut']>rec['index']) + if newindex==rec['index'] and R.span(tuple(g[-1]))==R.span(tuple(rec['frame'])): + counts['identity'] += 1; continue + key=(rec['section'],rec['index'],rec['cut'],R.span(tuple(rec['frame']))) + if key in unique:continue + unique.add(key) + examples.append(rec) + counts['changed_frame' if R.span(tuple(g[-1]))!=R.span(tuple(rec['frame'])) else 'same_frame'] += 1 + counts['by_'+rec['section']] += 1 + counts['slack_'+str(rec['upper_dim']-rec['lower_dim'])] += 1 + print(json.dumps({'provider':tag,'distance':distance,'counts':counts,'seconds':time.monotonic()-t}),flush=True) + (P/('FIRST-'+tag+'.json')).write_text(json.dumps(examples,sort_keys=True)+'\n') + +def explore(tag, distance=2, changed_only=True, limit=None, write=True, progress=True): + w=load(tag); original=C.frame_bill(w); counts=Counter(); states=[]; gains=[] + records=[r for r in placements(w,max_distance=distance) if not any(r['delta'])] + if changed_only: + records=[r for r in records if R.span(tuple(w[r['section']][r['index']][-1]))!=R.span(tuple(r['frame']))] + if limit is not None:records=records[:limit] + t=time.monotonic() + for serial,first in enumerate(records): + new=apply(w,first) + try:bill,widths,*_=C.frame_bill(new) + except C.AuditFailure: + counts['first_boundary_rejected']+=1;continue + need(bill==original[0] and widths==original[1],'neutral literal bill differs') + counts['legal_first']+=1 + touched=set(first['registers']) + scope=lambda sec,i,g:bool(touched.intersection(R.touched(g))) + delta_counts=Counter(); second_count=0;uncertified=[] + for second in placements(new,gate_filter=scope): + delta=second['delta'];delta_counts[delta]+=1;second_count+=1 + if not R.all_power_nonnegative(delta): + counts['uncertified_prices']+=1 + candidate=apply(new,second) + try:after,newwidths,*_=C.frame_bill(candidate) + except C.AuditFailure: + counts['second_boundary_rejected']+=1;continue + need(newwidths==widths,'helper inventory drift') + actual=tuple([0]+[after.get(k,0)-bill.get(k,0) for k in range(1,10)]) + need(actual==delta,'relaxed vs actual legal bill differs') + cap=R.caps(delta) + profitable=all(x<=0 for x in cap) and any(x<0 for x in cap) + item={'first':first,'second':second,'profile':after,'caps':cap,'all_concave_improvement':profitable} + uncertified.append(item) + if profitable: + gains.append(item) + if progress:print('GAIN',tag,serial,json.dumps(item),flush=True) + if write:(P/('GAINS-'+tag+'.json')).write_text(json.dumps(gains,sort_keys=True,indent=2)+'\n') + counts['second_prices']+=second_count + states.append({'first':first,'second_prices':second_count, + 'deltas':[{'delta':d,'count':n,'certificate':R.all_power_nonnegative(d)} for d,n in sorted(delta_counts.items())], + 'uncertified':uncertified}) + if progress and serial%10==0:print('PROGRESS',tag,serial+1,len(records),dict(counts),'seconds',time.monotonic()-t,flush=True) + report={'provider':tag,'distance':distance,'changed_frame_only':changed_only,'counts':counts,'states':states,'gains':gains} + if write:(P/('SEARCH-'+tag+'.json')).write_text(json.dumps(report,sort_keys=True,indent=2)+'\n') + if progress:print('DONE',tag,dict(counts),'seconds',time.monotonic()-t,flush=True) + return report + +def adjacent_pairs(tag, write=True, progress=True): + """Every original adjacent commuting ADD pair; retain both original frames. + + First move is the left ADD rightwards past the right ADD. The second move + may retime either of those ADDs anywhere in its corridor, with any frame + dimension. Other gates/frames and all external interfaces remain fixed. + """ + w=load(tag);baseline=R.tracing(w);original=baseline[2];counts=Counter();states=[];gains=[] + t=time.monotonic() + for section in ('A','B','restore'): + for lo,hi in R.segments(w,section): + for i in range(lo,hi-1): + g,h=w[section][i:i+2] + if g[0]!='add' or h[0]!='add' or not R.crosses(g,h):continue + counts['commuting_adjacent_pairs']+=1 + if g==h:counts['identical_gates']+=1;continue + new=w.copy();new[section]=w[section].copy() + new[section][i:i+2]=[h,g] + trace=adjacent_trace(w,baseline,section,i) + if trace is None: + counts['frame_rejected']+=1;continue + need(trace[2]==original,'frame-preserving commuting swap not neutral') + counts['legal_first']+=1 + filt=lambda sec,j,k:j in (i,i+1) + dc=Counter();unc=[] + for second in placements(new,gate_filter=filt,sections=(section,),trace=trace): + d=second['delta'];dc[d]+=1;counts['second_prices']+=1 + if not R.all_power_nonnegative(d): + counts['uncertified_prices']+=1 + cand=apply(new,second) + try:after,*_=C.frame_bill(cand) + except C.AuditFailure: + counts['second_boundary_rejected']+=1;continue + need(tuple([0]+[after.get(k,0)-original.get(k,0) for k in range(1,10)])==d,'invoice mismatch') + item={'first':{'section':section,'index':i,'cut':i+2,'frame':g[-1]},'second':second,'profile':after,'caps':R.caps(d)} + unc.append(item) + if all(x<=0 for x in R.caps(d)) and any(x<0 for x in R.caps(d)): + gains.append(item) + if progress:print('GAIN_PAIR',tag,json.dumps(item),flush=True) + states.append({'section':section,'left_index':i,'second_prices':sum(dc.values()), + 'deltas':[{'delta':d,'count':n,'certificate':R.all_power_nonnegative(d)} for d,n in sorted(dc.items())], + 'uncertified':unc}) + if progress and counts['legal_first']%250==0:print('PAIR_PROGRESS',tag,dict(counts),'seconds',time.monotonic()-t,flush=True) + result={'provider':tag,'counts':counts,'states':states,'gains':gains} + if write:(P/('PAIRS-'+tag+'.json')).write_text(json.dumps(result,sort_keys=True,indent=2)+'\n') + if progress:print('PAIRS_DONE',tag,dict(counts),'seconds',time.monotonic()-t,flush=True) + return result + +def corridor_bounds(w): + out={} + for section in ('A','B','restore'): + gates=w[section] + for lo,hi in R.segments(w,section): + for i in range(lo,hi): + g=gates[i] + if g[0]!='add':continue + low,up=i,i+1 + while low>lo and R.crosses(g,gates[low-1]):low-=1 + while up=i and R.crosses(k,h)) if j> x & 1] + + +def dim(mask): + size = bin(mask).count('1') + need(size and size & (size - 1) == 0, 'not a subspace point set') + return size.bit_length() - 1 + + +FULL = (1 << 512) - 1 +ZERO = 1 + + +def hyperplane(port): + return sum(1 << x for x in range(512) if bin(x & port).count('1') % 2 == 0) + + +def warp_images(columns): + """Images of all 512 vectors under the F_2-linear map with columns G e_i.""" + need(len(columns) == H and all(type(c) is int and 0 <= c < 512 for c in columns), 'warp columns') + images = [0] * 512 + for x in range(1, 512): + low = x & -x + images[x] = images[x ^ low] ^ columns[low.bit_length() - 1] + need(len(set(images)) == 512, 'singular warp') + return images + + +def image_mask(images, mask): + return sum(1 << images[x] for x in points(mask)) + + +def lagrangian_action_ok(images, U, E): + """K_G(x,z)=(Gx, Gx+G^{-T}(x+z)) is symplectic and maps L_U to L_E, L_0 and L_FULL to themselves. + + L_U={(x,x+p): x in U, p in U^perp}. This is the binary frame action only; it + is not a Clifford phase or Gaussian-product certificate. For invertible G with + G(U)=E it is implied by the frame-map check ( = ), so it is a + consistency check of the implementation, not extra evidence. + """ + inverse = [0] * 512 + for x, y in enumerate(images): + inverse[y] = x + # G^{-T} z: bit j of the result is . + git = lambda z: sum((bin(inverse[1 << j] & z).count('1') & 1) << j for j in range(H)) + lift = lambda x, z: (images[x], images[x] ^ git(x ^ z)) + pair = lambda a, b: (bin(a[0] & b[1]).count('1') + bin(a[1] & b[0]).count('1')) & 1 + basis = [(1 << i, 0) for i in range(H)] + [(0, 1 << i) for i in range(H)] + lifted = [lift(*b) for b in basis] + if any(pair(lifted[i], lifted[j]) != pair(basis[i], basis[j]) for i in range(18) for j in range(i + 1, 18)): + return False + + def frame(mask): + us = points(mask) + perp = [p for p in range(512) if all(bin(p & u).count('1') % 2 == 0 for u in us)] + return {(u, u ^ p) for u in us for p in perp} + return all({lift(*pt) for pt in frame(a)} == frame(b) for a, b in ((ZERO, ZERO), (FULL, FULL), (U, E))) + + +# ---------------------------------------------------------------------------- +# Chronological binary-frame bill (BORROW-WORD contract) +# ---------------------------------------------------------------------------- +def frame_bill(w, lagrangian=False): + rep = w['report'] + need((rep['v'], 2 * rep['v'] + rep['R'], rep['h']) == (V, N, H), 'word geometry') + removed = set(w['removed']) + need(len(removed) == len(w['removed']) and all(2 * V <= r < N for r in removed), 'removed helpers') + live = [r for r in range(N) if r not in removed] + liveset = set(live) + B, warps = w['B'], w['warps'] + for k, (pos, lender, cols, U, E) in enumerate(warps, 1): + need(0 <= pos <= len(B), 'warp position', k) + need(lender in liveset and not is_target(lender), 'warp lender', k) + images = warp_images(cols) + su, se = span(U), span(E) + need(dim(su) == len(U) == len(E) == dim(se), 'warp frame bases', k) + need(image_mask(images, su) == se, 'warp does not map its frame', k) + if lagrangian: + need(lagrangian_action_ok(images, su, se), 'lifted frame action', k) + for name in ('A', 'B', 'restore'): + for g in w[name]: + if g[0] != 'warp': + need(all(r in liveset for r in touched(g)), 'removed/out-of-range register', name, g) + if g[0] == 'add' and not is_target(g[1]): + need(not is_target(g[2]), 'non-target reads a target', name, g) + need(all(g[-1] is None and is_target(g[1]) and g[0] == 'add' for g in w['cut']), 'cut gates') + need(all(g[-1] == [] and is_target(g[1]) for g in w['precondition'] + w['compensation']), 'zero-frame wrapper writes') + need(all(not is_target(g[1]) for g in w['restore']), 'restore writes a target') + + ports = w['ports'] + start, end = {}, {} + for r in live: + if r < V: + start[r], end[r] = span((ports[r],)), FULL + elif r < 2 * V: + start[r], end[r] = ZERO, hyperplane(ports[r - V]) + else: + start[r], end[r] = ZERO, FULL + for q, U in w['start_extra'].items(): + need(int(q) in liveset and int(q) >= 2 * V, 'entrance names a live helper', q) + start[int(q)] = span(U) + for q, U in w['helper_final'].items(): + need(int(q) in liveset and int(q) >= 2 * V, 'terminal names a live helper', q) + end[int(q)] = span(U) + + current, bill, chain = dict(start), Counter(), {} + + def climb(r, mask, where): + need(current[r] & ~mask == 0, 'frame containment fails', where, r) + d = dim(mask) - dim(current[r]) + if d: + bill[d] += 1 + chain.setdefault(r, []).append((where, d, mask)) + current[r] = mask + + npre = w['prelude_events'] + for i, g in enumerate(w['A']): + if g[0] == 'warp': + need(i < npre and len(g) == 5, 'warp outside the prelude', i) + _, r, op, fr, to = g + need(op != 0 and abs(op) <= len(warps) and warps[abs(op) - 1][1] == r, 'prelude warp lender', i) + images = warp_images(warps[abs(op) - 1][2]) + if op < 0: + inverse = [0] * 512 + for x, y in enumerate(images): + inverse[y] = x + images = inverse + need(image_mask(images, span(fr)) == span(to), 'prelude warp frame action', i) + need(current[r] == span(fr), 'prelude warp entry frame', i, r) + current[r] = span(to) + chain.setdefault(r, []).append((('A', i), 'warp', span(to))) + else: + if i < npre: + need(is_target(g[1]), 'prelude scalar writes a non-target', i) + for r in touched(g): + climb(r, span(g[-1]), ('A', i)) + levels = {V + int(t): span(U) for t, U in w['target_levels'].items()} + need(all(current[t] == levels.get(t, ZERO) for t in range(V, 2 * V)), 'target cut levels') + for q, U in zip(w['centers'], w['center_frames']): + U = span(U) + need(current[q] == U, 'centre entry frame', q) + served = {levels.get(g[1], ZERO) for g in w['cut'] if g[2] == q} + for T in sorted(served, key=lambda m: -dim(m)): + need(T & ~U == 0, 'centre descent not nested', q) + d = dim(U) - dim(T) + if d: + bill[d] += 1 + chain.setdefault(q, []).append((('centre',), d, T)) + U = T + at = {} + for k, rec in enumerate(warps, 1): + at.setdefault(rec[0], []).append(k) + for p in range(len(B) + 1): + for k in at.get(p, ()): + _, lender, _, U, E = warps[k - 1] + need(current[lender] == span(U), 'native warp entry frame', k, lender) + current[lender] = span(E) + chain.setdefault(lender, []).append((('warp', k), 'warp', span(E))) + if p < len(B): + for r in touched(B[p]): + climb(r, span(B[p][-1]), ('B', p)) + for i, g in enumerate(w['restore']): + for r in touched(g): + climb(r, span(g[-1]), ('restore', i)) + for r in live: + climb(r, end[r], ('end',)) + restored = set(map(int, w['helper_final'])) + need(all(end[r] == FULL for r in live if r not in restored and not is_target(r)), 'a FULL-cleanup register ends low') + widths = Counter(dim(end[r]) - dim(start[r]) for r in live if r >= 2 * V) + return dict(sorted(bill.items())), dict(sorted(widths.items())), chain, start, end + + +def hygiene(w): + """Inherited structural contract: dyadic scalars, power-of-two scales, wrapper and correction access.""" + entering = set(map(int, w['start_extra'])) + restored = set(map(int, w['helper_final'])) + live = set(range(N)) - set(w['removed']) + for name in ('precondition', 'compensation', 'A', 'cut', 'B', 'restore', 'cleanup'): + for g in w[name]: + if g[0] == 'warp': + continue + q = Q(g[3], g[4]) if g[0] == 'add' else Q(g[2], g[3]) + need(q != 0 and q.denominator & (q.denominator - 1) == 0, 'non-dyadic scalar', name, g) + if g[0] == 'scale': + need(abs(q.numerator) & (abs(q.numerator) - 1) == 0, 'non power-of-two scale', name, g) + for g in w['precondition'] + w['compensation']: + need(not any(r in entering | restored for r in touched(g)), 'wrapper touches an entering or restored helper', g) + for c in w['initial_corrections']: + word = c['operator_word'] + need(is_target(c['target']) and c['source'] in live and c['source'] >= 2 * V + and c['source'] not in entering, 'correction access', c) + need(word and all(w['warps'][abs(o) - 1][1] == c['source'] for o in word), 'correction operator lender', c) + q = Q(c['coefficient']) + need(q != 0 and q.denominator & (q.denominator - 1) == 0, 'correction coefficient', c) + return True + + +# ---------------------------------------------------------------------------- +# Literal inverse cleanup, derived from the contract +# ---------------------------------------------------------------------------- +def ordinary_forward(w): + """Chronological non-wrapper actions whose inverse forms cleanup.""" + out = [g for g in w['A'][w['prelude_events']:]] + at = {} + for k, rec in enumerate(w['warps'], 1): + at.setdefault(rec[0], []).append(['warp', rec[1], k]) + for p in range(len(w['B']) + 1): + out += at.get(p, []) + if p < len(w['B']): + out.append(w['B'][p]) + return out + list(w['restore']) + + +def derive_cleanup(w): + restored = set(map(int, w['helper_final'])) + buf = lambda r: r + N if r in restored else r + full = [256, 128, 64, 32, 16, 8, 4, 2, 1] + out = [] + for g in reversed(ordinary_forward(w)): + if g[0] == 'warp': + out.append(['warp', buf(g[1]), -g[2], full]) + elif is_target(g[1]): + continue + elif g[0] == 'add': + out.append(['add', buf(g[1]), buf(g[2]), -g[3], g[4], full]) + else: + need(g[0] == 'scale', 'unknown primitive', g) + out.append(['scale', buf(g[1]), g[3], g[2], full]) + return out + + +def same_cleanup(a, b): + norm = lambda c: [(g[:-1], span(g[-1])) for g in c] + return len(a) == len(b) and norm(a) == norm(b) + + +# ---------------------------------------------------------------------------- +# Exact free-operator semantics. A value is a dict {(input, word): Fraction}; +# word is a reduced tuple of signed operator ids (leftmost = applied last). +# ---------------------------------------------------------------------------- +def program(w, cleanup=None): + """Literal executed sequence: corrections, wrapper, A, cut, B+warps, restore | cleanup.""" + items = [('corr', c['target'], c['source'], tuple(c['operator_word']), Q(c['coefficient'])) + for c in w['initial_corrections']] + items += w['precondition'] + w['compensation'] + w['A'] + w['cut'] + at = {} + for k, rec in enumerate(w['warps'], 1): + at.setdefault(rec[0], []).append(['warp', rec[1], k]) + for p in range(len(w['B']) + 1): + items += at.get(p, []) + if p < len(w['B']): + items.append(w['B'][p]) + items += w['restore'] + return items, list(w['cleanup'] if cleanup is None else cleanup) + + +def dual_op(op): + return (1 if op > 0 else -1) * (abs(op) + DUAL) + + +def _left(op, word): + return word[1:] if word and word[0] == -op else (op,) + word + + +def _right(word, op): + return word[:-1] if word and word[-1] == -op else word + (op,) + + +def _axpy(dst, src, q): + for key, x in src.items(): + y = dst.get(key, 0) + q * x + if y: + dst[key] = y + else: + dst.pop(key, None) + + +def forward_rows(w, cleanup=None, dual=False, symbolic_buffers=True, snapshot=None): + """Schrodinger pass: every register's value as a combination of initial inputs. + + Live inputs are independent symbols. Private buffers are independent symbols + when symbolic_buffers is set (dirty), otherwise zero. The optional snapshot + callback sees the rows at the cleanup boundary. + """ + removed = set(w['removed']) + live = [r for r in range(N) if r not in removed] + restored = sorted(map(int, w['helper_final'])) + rows = {r: {(r, ()): Q(1)} for r in live} + for c in restored: + rows[c + N] = {(c + N, ()): Q(1)} if symbolic_buffers else {} + prefix, tail = program(w, cleanup) + + def apply(g): + kind = g[0] + if kind == 'add': + t, s, q = g[1], g[2], Q(g[3], g[4]) + need(t != s and q, 'add gate', g) + if dual: + t, s, q = s, t, -q + _axpy(rows[t], rows[s], q) + elif kind == 'scale': + q = Q(g[2], g[3]) + need(q != 0, 'zero scale', g) + if dual: + q = 1 / q + rows[g[1]] = {k: q * x for k, x in rows[g[1]].items()} + elif kind == 'warp': + op = dual_op(g[2]) if dual else g[2] + rows[g[1]] = {(var, _left(op, word)): x for (var, word), x in rows[g[1]].items()} + elif kind == 'corr': + _, t, s, word, c = g + if dual: + src, ops, dst, c = rows[t], [-dual_op(o) for o in word], s, -c + else: + src, ops, dst = rows[s], list(reversed(word)), t + moved = {} + for (var, wd), x in src.items(): + for o in ops: + wd = _left(o, wd) + moved[var, wd] = x + _axpy(rows[dst], moved, c) + else: + raise AuditFailure('unknown primitive ' + repr(g)) + + for g in prefix: + apply(g) + if snapshot is not None: + snapshot(rows) + for g in tail: + apply(g) + return rows + + +def reverse_columns(w, cleanup=None, upto_cleanup=False): + """Heisenberg pull-back: process the forward program backwards. + + cols[s] = {(output, word): coefficient}: the final output register 'output' + contains coefficient*word*x_s. Words grow on the right. Every live input and + every private buffer is an independent symbol. + """ + removed = set(w['removed']) + live = [r for r in range(N) if r not in removed] + restored = sorted(map(int, w['helper_final'])) + regs = live + [c + N for c in restored] + cols = {r: {(r, ()): Q(1)} for r in regs} + prefix, tail = program(w, cleanup) + seq = prefix if upto_cleanup else prefix + tail + for g in reversed(seq): + kind = g[0] + if kind == 'add': + t, s, q = g[1], g[2], Q(g[3], g[4]) + need(t != s and q, 'add gate', g) + _axpy(cols[s], cols[t], q) + elif kind == 'scale': + q = Q(g[2], g[3]) + need(q != 0, 'zero scale', g) + cols[g[1]] = {k: q * x for k, x in cols[g[1]].items()} + elif kind == 'warp': + op = g[2] + cols[g[1]] = {(out, _right(word, op)): x for (out, word), x in cols[g[1]].items()} + elif kind == 'corr': + _, t, s, word, c = g + moved = {} + for (out, wd), x in cols[t].items(): + for o in word: + wd = _right(wd, o) + moved[out, wd] = x + _axpy(cols[s], moved, c) + else: + raise AuditFailure('unknown primitive ' + repr(g)) + return cols + + +def transpose(cols): + rows = {} + for s, col in cols.items(): + for (r, word), x in col.items(): + rows.setdefault(r, {})[s, word] = x + return rows + + +def endpoint_defects(w, rows, dual=False): + """Compare final rows with the contract on the zero-buffer (live-input) domain. + + Returns (bad live registers, dirty buffers, buffer->live leaks, buffer self-map identity). + """ + removed = set(w['removed']) + live = [r for r in range(N) if r not in removed] + restored = sorted(map(int, w['helper_final'])) + bad = [] + for r in live: + expect = {(r, ()): Q(1)} + if dual and r < V: + expect[r + V, ()] = Q(-1) + if not dual and is_target(r): + expect[r - V, ()] = Q(1) + got = {k: x for k, x in rows.get(r, {}).items() if k[0] < N} + if got != expect: + bad.append(r) + dirty = [c for c in restored if any(k[0] < N for k in rows.get(c + N, {}))] + leaks = sorted({r for r in live for k in rows.get(r, {}) if k[0] >= N}) + buffer_identity = all({k: x for k, x in rows.get(c + N, {}).items() if k[0] >= N} == {(c + N, ()): Q(1)} + for c in restored) + return bad, dirty, leaks, buffer_identity + + +def boundary_defects(w, rows): + """Contract at the cleanup boundary (forward): targets sheared, restored helpers clean and isolated.""" + restored = set(map(int, w['helper_final'])) + out = [] + for t in range(V, 2 * V): + if {k: x for k, x in rows[t].items() if k[0] < N} != {(t, ()): Q(1), (t - V, ()): Q(1)}: + out.append(('target', t)) + for c in restored: + if rows[c] != {(c, ()): Q(1)}: + out.append(('restored', c)) + for r, row in rows.items(): + if r < N and r not in restored and any(k[0] in restored for k in row): + out.append(('restored input read', r)) + return out diff --git a/research/staged544-neutral-two-edit/vendor/audit_verify.py b/research/staged544-neutral-two-edit/vendor/audit_verify.py new file mode 100644 index 0000000000..7f9fc1df42 --- /dev/null +++ b/research/staged544-neutral-two-edit/vendor/audit_verify.py @@ -0,0 +1,254 @@ +#!/usr/bin/env python3 +"""Whole-word cross-check of published RETIMED and DELAYED supplier words. + +Reuses Sagar Thakrar's exact PR3687 audit_core, unchanged and authenticated +before execution. This is not a new interpreter. No construction/native checker +is imported. roger-sato with substantial OpenAI Codex assistance; Apache-2.0. +""" +from collections import Counter +from copy import deepcopy +import gzip +import hashlib +import json +from pathlib import Path +import sys +import types + +HERE = Path(__file__).resolve().parent +STAGED = {1: 2439, 2: 726, 3: 224, 4: 102, 5: 20, 8: 8} +RETIMED = {1: 2437, 2: 724, 3: 226, 4: 102, 5: 20, 8: 8} +WIDTHS = {4: 26, 5: 2, 6: 18, 7: 52, 8: 97, 9: 213} +MOVES = ((591, 1045, 640, 644, 2, [423, 65, 20, 10]), + (641, 1085, 656, 660, -1, [427, 96, 24, 6])) +SOURCE_COMMITS = { + 3605: '3efbb5de06a49ffeea6684482f2d3fe48cdca3fb', + 3642: '044d24f12e74f228dd462c07ae2d7f3ea35e2be9', + 3653: '607a09ff441c79b215a8127a81f4cc70021d0d9b', + 3682: '431e6c6023ef352c41696469de7fb614cd4ded8c', + 3687: 'f798838eb8ede4178e94f240e7b7e54b3f80c82d', +} + + +def need(ok, message): + if not ok: + raise ValueError(message) + + +def authenticate(): + rows = json.loads((HERE / 'SOURCES.json').read_text())['snapshots'] + expected = {(3687, 'vendor/audit_core.py')} + for provider in ('base', 'extra'): + expected.update((number, f'inputs/{kind}-{provider}.json.gz') for number, kind in + ((3605, 'STAGED'), (3642, 'RETIMED'), (3653, 'RETIMED'), (3682, 'DELAYED'))) + keys = [(row['source_pr'], row['local']) for row in rows] + need(len(keys) == len(expected) and set(keys) == expected, 'source mapping inventory differs') + for row in rows: + need(row['source_commit'] == SOURCE_COMMITS[row['source_pr']], 'source commit differs') + raw = (HERE / row['local']).read_bytes() + need(len(raw) == row['bytes'], 'source byte length: ' + row['local']) + need(hashlib.sha256(raw).hexdigest() == row['sha256'], 'source SHA256: ' + row['local']) + blob = hashlib.sha1(b'blob ' + str(len(raw)).encode() + b'\0' + raw).hexdigest() + need(blob == row['git_blob'], 'source Git blob: ' + row['local']) + core = types.ModuleType('retained_audit_core') + path = HERE / 'vendor/audit_core.py' + # Execute the authenticated source bytes, without accepting a .pyc cache. + exec(compile(path.read_bytes(), str(path), 'exec'), core.__dict__) + return core + + +def load(kind, provider): + return json.loads(gzip.decompress((HERE / 'inputs' / f'{kind}-{provider}.json.gz').read_bytes())) + + +def events(w): + result = [] + for pos in range(len(w['B']) + 1): + result += [('warp', k, deepcopy(rec)) for k, rec in enumerate(w['warps']) if rec[0] == pos] + if pos < len(w['B']): + result.append(('gate', pos, deepcopy(w['B'][pos]))) + return result + + +def replace_events(w, seq): + result = deepcopy(w) + body, warps = [], [None] * len(w['warps']) + for kind, label, gate in seq: + gate = deepcopy(gate) + if kind == 'gate': + body.append(gate) + else: + gate[0] = len(body) + warps[label] = gate + need(all(rec is not None for rec in warps), 'lost warp in reconstruction') + result['B'], result['warps'] = body, warps + return result + + +def reconstruct(C, staged, kind): + """Literal prose recipes: adjacent shear swap, or move before first producer. + + This repeats the credited local structural arguments as an input control; + the new evidence is the full word calculation below. + """ + seq = events(staged) + for start, stop, donor, pivot, coefficient, frame in MOVES: + source = next(x for x in seq if x[:2] == ('gate', start)) + need(source[2] == ['add', donor, pivot, coefficient, 1, [429, 30]], 'source release') + if kind == 'RETIMED': + target = next(x for x in seq if x[:2] == ('gate', start + 1)) + need(target[2][0] == 'add' and target[2][2] == pivot, 'adjacent same-pivot shear') + need(not any(rec[0] == start + 1 for rec in staged['warps']), 'unexpected crossed warp') + where = seq.index(target) + 1 + else: + target = next(x for x in seq if x[:2] == ('gate', stop)) + writes = [i for i, g in enumerate(staged['B']) if i > start and g[1] == pivot] + need(writes[0] == stop, 'first producer cut') + where = seq.index(target) + changed = deepcopy(source[2]) + changed[-1] = frame + seq.insert(where, ('gate', -pivot, changed)) + seq.remove(source) + result = replace_events(staged, seq) + result['cleanup'] = C.derive_cleanup(result) + result['report']['local_profile'] = {str(k): v for k, v in RETIMED.items()} + return result + + +def semantics(C, w): + """All live and buffer inputs are symbols, with no zero-buffer assumption.""" + def endpoint(name, result): + bad_live, dirty_buffers, leaks, buffer_identity = result + need(not bad_live and not dirty_buffers and not leaks and buffer_identity, + name + ' endpoint: ' + repr(result)) + boundary = {} + rows = C.forward_rows(w, symbolic_buffers=True, + snapshot=lambda values: boundary.setdefault('defects', C.boundary_defects(w, values))) + endpoint('forward', C.endpoint_defects(w, rows)) + dual_rows = C.forward_rows(w, dual=True, symbolic_buffers=True) + endpoint('dual', C.endpoint_defects(w, dual_rows, dual=True)) + need(not boundary['defects'], 'cleanup boundary: ' + repr(boundary['defects'])) + pulled = C.transpose(C.reverse_columns(w)) + need(pulled == {r: row for r, row in rows.items() if row}, 'reverse pull-back differs from forward') + pre = C.transpose(C.reverse_columns(w, upto_cleanup=True)) + pre = {r: pre.get(r, {}) for r in set(pre) | set(range(C.N))} + need(not C.boundary_defects(w, pre), 'reverse cleanup-boundary contract') + live = C.N - len(w['removed']) + buffers = len(w['helper_final']) + need((live, buffers, len(rows)) == (632, 91, 723), 'complete symbolic domain') + # Endpoint expectations are derived by the retained checker: live x,y,h + # map to x,y+x,h; all private buffer symbols return unchanged. + return {'live_inputs': live, 'dirty_buffers': buffers, 'matrix_dimension': len(rows), + 'forward': 'PASS', 'dual': 'PASS', 'reverse_pullback_equals_forward': True, + 'cleanup_boundary_forward_and_reverse': 'PASS', + 'buffer_to_live_leaks': 0, 'buffer_self_map': 'identity', + 'nonzero_endpoint_terms': sum(len(row) for row in rows.values())} + + +def inspect(C, w, profile): + C.hygiene(w) + bill, widths, chain, _, _ = C.frame_bill(w) + need(bill == profile, 'computed profile differs') + need(w['report']['local_profile'] == {str(k): v for k, v in bill.items()}, 'declared profile differs') + need(widths == WIDTHS, 'helper widths differ') + need(w['cleanup'] == C.derive_cleanup(w), 'literal cleanup differs') + return {'semantics': semantics(C, w), 'profile': bill, 'widths': widths, + 'rank_mass': sum(r * n for r, n in bill.items())}, chain + + +def expect_rejection(C, fn, phrase): + try: + fn() + except (ValueError, C.AuditFailure) as exc: + need(phrase in str(exc), 'wrong rejection: ' + str(exc)) + return phrase + raise ValueError('mutant unexpectedly passed: ' + phrase) + + +def negative_controls(C, staged, w, kind): + controls = [] + for _, _, donor, pivot, _, _ in MOVES: + seq = events(w) + release = next(x for x in seq if x[0] == 'gate' and x[2][0] == 'add' and x[2][1:3] == [donor, pivot]) + for defect in ('omit', 'flip', 'cross_first_producer'): + changed = deepcopy(seq) + index = seq.index(release) + if defect == 'omit': + changed.pop(index) + elif defect == 'flip': + changed[index][2][3] *= -1 + else: + producer = next(x for x in changed[index + 1:] if x[0] == 'gate' and x[2][1] == pivot) + moved = changed.pop(index) + changed.insert(changed.index(producer) + 1, moved) + bad = replace_events(w, changed) + bad['cleanup'] = C.derive_cleanup(bad) + # Repair the literal inverse so stale cleanup is not the rejection. + reason = expect_rejection(C, lambda: semantics(C, bad), 'forward endpoint') + controls.append({'defect': defect, 'pivot': pivot, 'rejected_by': reason}) + old_cleanup = deepcopy(w) + old_cleanup['cleanup'] = staged['cleanup'] + # The inverse shears commute: this is a format failure, not a wrong operator. + semantic_control = semantics(C, old_cleanup) + need(old_cleanup['cleanup'] != C.derive_cleanup(old_cleanup), 'old cleanup unexpectedly literal') + controls.append({'defect': 'old_cleanup_order', 'semantics': semantic_control, + 'rejected_by': expect_rejection(C, lambda: inspect(C, old_cleanup, RETIMED), 'literal cleanup differs')}) + old_frames = deepcopy(w) + for gate in old_frames['B']: + if gate[0] == 'add' and gate[1:3] in ([640, 644], [656, 660]): + gate[-1] = [429, 30] + need(semantics(C, old_frames) == semantic_control, 'frame-only mutation changed operator') + if kind == 'RETIMED': + need(C.frame_bill(old_frames)[0] == STAGED, 'old frame control does not restore staged bill') + controls.append({'defect': 'old_release_frames', 'semantic_operator': 'PASS', + 'profile': STAGED, 'rejected_by': expect_rejection(C, lambda: inspect(C, old_frames, RETIMED), 'computed profile differs')}) + else: + # The later release encounters a donor that has already climbed, so + # the original rank-2 frame is now illegal, despite the same operator. + controls.append({'defect': 'old_release_frames', 'semantic_operator': 'PASS', + 'rejected_by': expect_rejection(C, lambda: inspect(C, old_frames, RETIMED), 'frame containment fails')}) + fake_report = deepcopy(w) + fake_report['report']['local_profile']['1'] += 1 + controls.append({'defect': 'wrong_declared_profile', 'rejected_by': + expect_rejection(C, lambda: inspect(C, fake_report, RETIMED), 'declared profile differs')}) + return controls + + +def run(C): + results = {} + for provider in ('base', 'extra'): + staged = load('STAGED', provider) + control, old_chain = inspect(C, staged, STAGED) + records = {'STAGED': control} + for kind in ('RETIMED', 'DELAYED'): + w = load(kind, provider) + need(reconstruct(C, staged, kind) == w, 'prose reconstruction differs: ' + kind) + record, chain = inspect(C, w, RETIMED) + deltas = {} + for register in set(chain) | set(old_chain): + before = Counter(d for _, d, _ in old_chain.get(register, []) if type(d) is int and d > 0) + after = Counter(d for _, d, _ in chain.get(register, []) if type(d) is int and d > 0) + delta = {r: after[r] - before[r] for r in set(after) | set(before) if after[r] != before[r]} + if delta: + deltas[register] = delta + need(deltas == {640: {1: -1, 2: -1, 3: 1}, 656: {1: -1, 2: -1, 3: 1}}, 'per-register invoice differs') + record['prose_reconstruction'] = 'exact complete JSON equality' + record['changed_register_bills'] = deltas + record['controls'] = negative_controls(C, staged, w, kind) + records[kind] = record + print('CHECKED', provider, kind, '723-register forward/dual/pull-back and 9 controls', flush=True) + results[provider] = records + return {'status': 'PASS_RETIMED_AND_DELAYED_WHOLE_WORD_AUDIT', + 'scope': 'Reused PR3687 interpreter; finite exact operator/frame audit only. No native Gaussian, owner, root, or complete supplier claim.', + 'providers': results} + + +if __name__ == '__main__': + need(sys.argv[1:] in ([], ['--write']), 'usage: verify.py [--write]') + C = authenticate() + result = run(C) + output = json.dumps(result, sort_keys=True, indent=2) + '\n' + if sys.argv[1:] == ['--write']: + (HERE / 'RESULT.json').write_text(output) + else: + need((HERE / 'RESULT.json').read_text() == output, 'committed result differs') + print(result['status']) diff --git a/research/staged544-neutral-two-edit/vendor/pr3886_retiming.py b/research/staged544-neutral-two-edit/vendor/pr3886_retiming.py new file mode 100644 index 0000000000..c33d7bbcdf --- /dev/null +++ b/research/staged544-neutral-two-edit/vendor/pr3886_retiming.py @@ -0,0 +1,269 @@ +# SPDX-License-Identifier: Apache-2.0 +"""Exact, fixed-neighbour single-ADD retiming relaxation. + +Chris R / Clear1nsight, with substantial OpenAI assistance. The BORROW-WORD +frame contract and scalar-retiming mechanism are credited in README.md. +This module does not import the retained auditor or a numerical optimiser. +""" +from bisect import bisect_left +from collections import Counter +from copy import deepcopy +from fractions import Fraction +from functools import lru_cache + + +def need(ok, message): + if not ok: + raise ValueError(message) + + +@lru_cache(maxsize=None) +def span(vectors): + points = {0} + for v in vectors: + need(type(v) is int and 0 <= v < 512, 'invalid frame vector') + points |= {x ^ v for x in tuple(points)} + return sum(1 << x for x in points) + + +@lru_cache(maxsize=None) +def basis(mask): + answer = [] + have = 1 + for v in range(1, 512): + if (mask >> v) & 1 and not (have >> v) & 1: + answer.append(v) + have = span(tuple(answer)) + need(have == mask, 'not a binary subspace') + return tuple(answer) + + +@lru_cache(maxsize=None) +def join(a, b): + return span(basis(a) + basis(b)) + + +@lru_cache(maxsize=None) +def rank(mask): + n = mask.bit_count() + need(n > 0 and n & (n - 1) == 0, 'invalid subspace cardinality') + return n.bit_length() - 1 + + +def contained(a, b): + return not a & ~b + + +def touched(gate): + return gate[1:3] if gate[0] == 'add' else gate[1:2] + + +def tracing(word): + """Own chronological trace; centre descent is NOT persistent state. + + A check node is a fixed boundary, not a charged instruction. The census + relaxes it to a virtual climb. Every legal witness has zero such charge. + """ + full = (1 << 512) - 1 + live = set(range(704)) - set(word['removed']) + start, end = {}, {} + for r in live: + if r < 112: + start[r], end[r] = span((word['ports'][r],)), full + elif r < 224: + p = word['ports'][r - 112] + start[r] = 1 + end[r] = sum(1 << x for x in range(512) if (x & p).bit_count() % 2 == 0) + else: + start[r], end[r] = 1, full + for r, fr in word['start_extra'].items(): + start[int(r)] = span(tuple(fr)) + for r, fr in word['helper_final'].items(): + end[int(r)] = span(tuple(fr)) + current = dict(start) + nodes = {r: [] for r in live} + where = {} + bill = Counter() + + def event(r, frame, address, kind='climb'): + before = current[r] + if kind != 'map': + need(contained(before, frame), 'source frame containment') + d = rank(frame) - rank(before) + if kind == 'check': + need(d == 0, 'source fixed boundary') + elif d: + bill[d] += 1 + if kind == 'climb': + where[(address, r)] = len(nodes[r]) + nodes[r].append((address, kind, before, frame)) + current[r] = frame + + for i, gate in enumerate(word['A']): + if gate[0] == 'warp': + event(gate[1], span(tuple(gate[3])), ('check-A', i), 'check') + event(gate[1], span(tuple(gate[4])), ('map-A', i), 'map') + else: + for r in touched(gate): + event(r, span(tuple(gate[-1])), ('A', i)) + levels = {112 + int(r): span(tuple(fr)) for r, fr in word['target_levels'].items()} + for r in range(112, 224): + event(r, levels.get(r, 1), ('target-cut', r), 'check') + for r, fr in zip(word['centers'], word['center_frames']): + u = span(tuple(fr)) + event(r, u, ('centre-cut', r), 'check') + served = {levels.get(g[1], 1) for g in word['cut'] if g[2] == r} + for v in sorted(served, key=lambda x: -rank(x)): + need(contained(v, u), 'centre nesting') + if rank(u) > rank(v): + bill[rank(u) - rank(v)] += 1 + u = v + # The main forward register remains at its declared centre entry. + warps = {} + for j, rec in enumerate(word['warps']): + warps.setdefault(rec[0], []).append((j, rec)) + for i in range(len(word['B']) + 1): + for j, rec in warps.get(i, []): + event(rec[1], span(tuple(rec[3])), ('check-B', j), 'check') + event(rec[1], span(tuple(rec[4])), ('map-B', j), 'map') + if i < len(word['B']): + gate = word['B'][i] + for r in touched(gate): + event(r, span(tuple(gate[-1])), ('B', i)) + for i, gate in enumerate(word['restore']): + for r in touched(gate): + event(r, span(tuple(gate[-1])), ('restore', i)) + for r in live: + event(r, end[r], ('end',)) + return nodes, where, dict(sorted(bill.items())) + + +def crosses(g, h): + """Sufficient exact scalar normal form, not all algebraic commutations.""" + if h[0] == 'add': + return g[1] != h[2] and h[1] != g[2] + return h[0] == 'scale' and h[2] != 0 + + +def segments(word, section): + if section == 'A': + cuts = [word['prelude_events'], len(word['A'])] + elif section == 'B': + cuts = sorted({0, len(word['B'])} | {rec[0] for rec in word['warps']}) + else: + cuts = [0, len(word[section])] + return list(zip(cuts, cuts[1:])) + + +def caps(delta): + return [sum(n * min(r, k) for r, n in enumerate(delta)) for k in range(1, 10)] + + +def all_power_nonnegative(delta): + """Sufficient exact certificate using decreasing positive curvatures.""" + values = caps(delta) + prefix = 0 + for value in values[:-1]: + prefix += value + if prefix < 0: + return False + return values[-1] == 0 + + +def census(word): + nodes, where, bill = tracing(word) + deltas = Counter() + counts = {} + for section in ('A', 'B', 'restore'): + gates = word[section] + count = 0 + for lo, hi in segments(word, section): + occurrences = {} + for i in range(lo, hi): + need(gates[i][0] in ('add', 'scale'), 'unexpected scalar segment') + for r in touched(gates[i]): + occurrences.setdefault(r, []).append(i) + for i in range(lo, hi): + g = gates[i] + if g[0] != 'add': + continue + lower = i + while lower > lo and crosses(g, gates[lower - 1]): + lower -= 1 + upper = i + 1 + while upper < hi and crosses(g, gates[upper]): + upper += 1 + removal = [0] * 10 + reduced, entries, exits = {}, {}, {} + for r in touched(g): + seq = nodes[r] + pos = where[((section, i), r)] + _, _, p, u = seq[pos] + need(pos + 1 < len(seq) and seq[pos + 1][1] != 'map', 'missing successor') + q = seq[pos + 1][3] + removal[rank(u) - rank(p)] -= 1 + removal[rank(q) - rank(u)] -= 1 + removal[rank(q) - rank(p)] += 1 + indices = occurrences[r] + reduced[r] = [x for x in indices if x != i] + entries[r] = seq[where[((section, indices[0]), r)]][2] + last = where[((section, indices[-1]), r)] + need(seq[last + 1][1] != 'map', 'missing exit check') + exits[r] = seq[last + 1][3] + for cut in range(lower, upper + 1): + if cut == i + 1: # Same placement as cut i, counted once. + continue + boundaries = [] + for r in touched(g): + indices = reduced[r] + j = bisect_left(indices, cut) + p = span(tuple(gates[indices[j - 1]][-1])) if j else entries[r] + q = span(tuple(gates[indices[j]][-1])) if j < len(indices) else exits[r] + boundaries.append((p, q)) + lower_frame = join(boundaries[0][0], boundaries[1][0]) + upper_frame = boundaries[0][1] & boundaries[1][1] + if not contained(lower_frame, upper_frame): + continue + dims = [(rank(p), rank(q)) for p, q in boundaries] + for d in range(rank(lower_frame), rank(upper_frame) + 1): + delta = removal.copy() + for p, q in dims: + delta[q - p] -= 1 + delta[d - p] += 1 + delta[q - d] += 1 + delta[0] = 0 + need(sum(r * n for r, n in enumerate(delta)) == 0, 'rank mass drift') + deltas[tuple(delta)] += 1 + count += 1 + counts[section] = count + return {'per_section': counts, 'candidates': sum(counts.values()), + 'source_profile': bill, + 'deltas': [{'delta': {r: n for r, n in enumerate(d) if n}, 'count': n, + 'caps': caps(d), 'certificate': all_power_nonnegative(d)} + for d, n in sorted(deltas.items())]} + + +def apply_move(word, section, index, cut, frame): + """Apply one exact scalar retiming. Caller must rederive cleanup and audit.""" + need(section in ('A', 'B', 'restore'), 'unknown section') + gates = word[section] + need(type(index) is int and 0 <= index < len(gates), 'bad source index') + need(type(cut) is int and 0 <= cut <= len(gates), 'bad insertion cut') + need(any(lo <= index < hi and lo <= cut <= hi for lo, hi in segments(word, section)), + 'crosses prelude or native warp boundary') + g = deepcopy(gates[index]) + need(g[0] == 'add', 'only ADD moves are covered') + crossed = gates[index + 1:cut] if cut > index else gates[cut:index] + need(all(crosses(g, h) for h in crossed), 'noncommuting scalar barrier') + coefficient = Fraction(g[3], g[4]) + for h in crossed: + if h[0] == 'scale' and h[1] in touched(g): + power = (1 if h[1] == g[1] else -1) * (1 if cut > index else -1) + coefficient *= Fraction(h[2], h[3]) ** power + g[3:5] = [coefficient.numerator, coefficient.denominator] + g[-1] = list(basis(span(tuple(frame)))) + result = deepcopy(word) + result[section].pop(index) + result[section].insert(cut - (cut > index), g) + # Segment length and all warp cuts are unchanged. No warp is crossed. + return result diff --git a/research/staged544-neutral-two-edit/verify.py b/research/staged544-neutral-two-edit/verify.py new file mode 100644 index 0000000000..57009d907d --- /dev/null +++ b/research/staged544-neutral-two-edit/verify.py @@ -0,0 +1,250 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Source-bound finite two-edit replay; no network, Git, solver or native build.""" +import argparse +from collections import Counter +from copy import deepcopy +from fractions import Fraction as Q +import hashlib +import json +from pathlib import Path +import time +import types + +P=Path(__file__).resolve().parent + +def need(ok,why): + if not ok:raise ValueError(why) + +def authentic(raw,row): + need(len(raw)==row['bytes'],'source length: '+row['local']) + need(hashlib.sha256(raw).hexdigest()==row['sha256'],'source SHA256: '+row['local']) + need(hashlib.sha1(b'blob '+str(len(raw)).encode()+b'\0'+raw).hexdigest()==row['git_blob'], + 'source Git blob: '+row['local']) + +sources=json.loads((P/'SOURCES.json').read_text()) +for row in sources['snapshots']:authentic((P/row['local']).read_bytes(),row) +S=types.ModuleType('neutral_search');S.__file__=str(P/'search.py') +exec(compile((P/'search.py').read_bytes(),str(P/'search.py'),'exec'),S.__dict__) +R,C,A=S.R,S.C,S.A + +def normal(x):return json.loads(json.dumps(x,sort_keys=True)) + +def object_hash(x): + return hashlib.sha256(json.dumps(x,sort_keys=True,separators=(',',':')).encode()).hexdigest() + +def block_matrix(gates,registers=None): + """Own rational scalar-block check, independent of retained interpreters. + + Every input row is an independent symbol, so equality is on all dirty states. + Frames are checked separately; native gates are forbidden in this block. + """ + if registers is None:registers=sorted({r for g in gates for r in (g[1:3] if g[0]=='add' else g[1:2])}) + rows={r:{r:Q(1)} for r in registers} + for g in gates: + if g[0]=='scale': + q=Q(g[2],g[3]);need(q!=0,'zero scalar') + rows[g[1]]={k:v*q for k,v in rows[g[1]].items()} + else: + need(g[0]=='add' and g[1]!=g[2],'non-scalar block or self ADD') + q=Q(g[3],g[4]);need(q!=0,'zero ADD') + for k,v in rows[g[2]].items(): + z=rows[g[1]].get(k,0)+q*v + if z:rows[g[1]][k]=z + else:rows[g[1]].pop(k,None) + return [[str(rows[r].get(c,0)) for c in registers] for r in registers] + +def block_equal(before,after): + regs=sorted({r for g in before+after for r in (g[1:3] if g[0]=='add' else g[1:2])}) + b,a=block_matrix(before,regs),block_matrix(after,regs) + need(a==b,'arbitrary-dirty scalar block differs') + return {'registers':regs,'matrix_sha256':object_hash(a)} + +def first_block(w,new,rec): + lo=min(rec['index'],rec['cut']);hi=max(rec['index']+1,rec['cut']) + return block_equal(w[rec['section']][lo:hi],new[rec['section']][lo:hi]) + +def summarize(report,keep_first=False): + totals=Counter() + for state in report['states']: + for row in state['deltas']: + d=tuple(row['delta']);need(R.all_power_nonnegative(d),'uncertified second delta') + need(sum(k*n for k,n in enumerate(d))==0,'rank mass drift') + totals[d]+=row['count'] + need(not report['gains'],'improving or uncertified literal candidate remains') + need(report['counts'].get('uncertified_prices',0)==0,'unresolved relaxed price') + rows=[{'delta':{str(k):n for k,n in enumerate(d) if n},'count':n, + 'caps':R.caps(d),'prefix_caps':[sum(R.caps(d)[:j]) for j in range(1,9)]} + for d,n in sorted(totals.items())] + result={'counts':dict(report['counts']),'delta_types':rows, + 'ordered_state_sha256':object_hash(report['states'])} + if keep_first:result['first_edits']=[x['first'] for x in report['states']] + return result + +def rejects(fn,label): + try:fn() + except (ValueError,C.AuditFailure):return label + raise ValueError('control accepted: '+label) + +def ledger(w): + bill,widths,chain,start,end=C.frame_bill(w) + need(R.tracing(w)[2]==bill,'independent chronological bill') + need(w['cleanup']==C.derive_cleanup(w),'source cleanup differs') + C.hygiene(w) + primitive={sec:dict(sorted(Counter(g[0] for g in w[sec]).items())) for sec in + ('precondition','compensation','A','cut','B','restore','cleanup')} + inherited=json.loads((P/'inputs/PROFILE.json').read_text()) + return {'local_profile':bill,'local_recursive_children':sum(bill.values()), + 'local_rank_mass':sum(r*n for r,n in bill.items()),'helper_width_inventory':widths, + 'helper_roles':sum(widths.values()),'live_inputs':C.N-len(w['removed']), + 'dirty_buffers':len(w['helper_final']),'primitive_inventory':primitive, + 'native_B_maps':len(w['warps']),'initial_operator_corrections':len(w['initial_corrections']), + 'extra_scalar_gates':0,'extra_helpers':0,'extra_dirty_buffers':0, + 'entrance_frame_sha256':object_hash({str(k):str(v) for k,v in start.items()}), + 'exit_frame_sha256':object_hash({str(k):str(v) for k,v in end.items()}), + 'inherited_outer_profile':inherited, + 'inherited_outer_profile_status':'Authenticated source only; not freshly reconstructed or admitted.', + 'proved_obligations':['Exact local chronological recursive invoice including centre descents and final climbs', + 'Fixed primitive counts, native maps/cuts, role and buffer counts', + 'Every admitted first-edit scalar block on arbitrary dirty inputs', + 'Full 723-input first-word and positive-control operator/cleanup checks'], + 'unknown_obligations':['Fresh native Gaussian/Clifford realization', + 'Fresh physical hosting and global allocation/owner chronology', + 'Uniform coefficient/precision/tape and bit-operation costs', + 'All-size/compiler and full outer/supplier admission','Analytic transfer and BIT H1-H5'], + 'unknown_costs_are_zero':False,'new_supplier_or_kappa':False} + +def positive_control(w): + old=deepcopy(w);g,h=old['A'][4043:4045] + need(g[:5]==['add',81,40,1,1] and h[:5]==['add',81,17,1,1],'control source drift') + old['A'][4043:4045]=[h[:-1]+[g[-1]],g] + old['cleanup']=C.derive_cleanup(old) + mid=R.apply_move(old,'A',4043,4045,g[-1]);mid['cleanup']=C.derive_cleanup(mid) + new=R.apply_move(mid,'A',4044,4044,h[-1]);new['A'][4044][-1]=deepcopy(h[-1]) + new['cleanup']=C.derive_cleanup(new) + before=C.frame_bill(old)[0];middle=C.frame_bill(mid)[0];after=C.frame_bill(new)[0] + need(before==middle,'positive first edit not neutral') + need(after==C.frame_bill(w)[0] and new==w,'positive recovery not literal source') + delta=tuple([0]+[after.get(k,0)-before.get(k,0) for k in range(1,10)]) + need(delta==(0,1,-1,-1,1,0,0,0,0,0),'positive control invoice') + need(not R.all_power_nonnegative(delta),'known profitable second edit excluded') + matches=[r for r in S.placements(mid,gate_filter=lambda s,i,g:s=='A' and i==4044, + sections=('A',),target_cut=4044) if tuple(r['delta'])==delta] + need(matches,'enumerator missed profitable frame-only second step') + block_equal(old['A'][4043:4045],mid['A'][4043:4045]) + semantics={name:A.semantics(C,value) for name,value in [('rollback',old),('neutral_middle',mid),('recovered',new)]} + return {'before_profile':before,'neutral_profile':middle,'after_profile':after, + 'delta':delta,'semantics':semantics,'credit':'Jeremy Kothe PR2957, recovered in PR3886; already in baseline'},mid + +def controls(w): + result=[];row=sources['snapshots'][0] + result.append(rejects(lambda:authentic((P/row['local']).read_bytes()+b'x',row),'source byte drift')) + bad=deepcopy(w);bad['A'][4044][3]*=-1;bad['cleanup']=C.derive_cleanup(bad) + result.append(rejects(lambda:A.semantics(C,bad),'wrong scalar after refreshed cleanup')) + bad=deepcopy(w);bad['A'][4044][-1]=[] + result.append(rejects(lambda:C.frame_bill(bad),'illegal gate frame')) + bad=deepcopy(w);bad['cleanup']=bad['cleanup'][1:] + result.append(rejects(lambda:A.semantics(C,bad),'omitted cleanup on arbitrary dirt')) + bad=deepcopy(w);bad['report']['local_profile']['1']+=1 + result.append(rejects(lambda:need(C.frame_bill(bad)[0]=={int(k):v for k,v in bad['report']['local_profile'].items()},'invoice differs'),'false declared invoice')) + i=next(i for i in range(w['prelude_events'],len(w['A'])-1) + if w['A'][i][0]=='add' and not R.crosses(w['A'][i],w['A'][i+1])) + result.append(rejects(lambda:R.apply_move(w,'A',i,i+2,w['A'][i][-1]),'noncommuting scalar barrier')) + pair=[['add',0,1,1,1,[]],['add',1,2,1,1,[]]] + result.append(rejects(lambda:block_equal(pair,list(reversed(pair))),'own dirty-block checker rejects noncommuting swap')) + need(not R.all_power_nonnegative((0,1,-2,1,0,0,0,0,0,0)),'profitable target has false sign certificate') + result.append('profitable 2+2 to 1+3 rejected by non-improvement certificate') + return result + +def verify_provider(tag,full_dirty=True): + w=S.load(tag);t=time.monotonic();base=R.census(w) + need(base['candidates']==1776295 and len(base['deltas'])==19,'baseline census drift') + need(all(x['certificate'] for x in base['deltas']),'baseline sign failure') + own=Counter(tuple(x['delta']) for x in S.placements(w)) + expected=Counter({tuple([0]+[x['delta'].get(k,0) for k in range(1,10)]):x['count'] for x in base['deltas']}) + need(own==expected,'new enumerator does not reproduce full baseline census') + print('BASELINE_BOUND',tag,base['candidates'],flush=True) + zero=[x for x in S.placements(w,max_distance=2) if not any(x['delta'])] + need(all(len(x['frame']) in (x['lower_dim'],x['upper_dim']) for x in zero),'unsampled interior neutral first subspace') + frame=S.explore(tag,write=False,progress=False) + print('FRAME_SECOND_PRICES',tag,frame['counts']['second_prices'],flush=True) + pair=S.adjacent_pairs(tag,write=False,progress=False) + print('SWAPPED_GATE_SECOND_PRICES',tag,pair['counts']['second_prices'],flush=True) + novel=S.adjacent_novel_cuts(tag,write=False,progress=False) + print('THIRD_GATE_MIDDLE_PRICES',tag,novel['counts']['second_prices'],flush=True) + need(pair['counts']['legal_first']==novel['counts']['legal_first'],'adjacent start inventory differs') + need([(s['section'],s['left_index']) for s in pair['states']]==[(s['section'],s['left_index']) for s in novel['states']], + 'adjacent start ordering differs') + first_checks=[] + for j,state in enumerate(frame['states']): + rec=state['first'];new=S.apply(w,rec);new['cleanup']=C.derive_cleanup(new) + block=first_block(w,new,rec) + C.hygiene(new) + need(C.frame_bill(new)[:2]==C.frame_bill(w)[:2],'first local invoice/inventory drift') + need(new['report']['local_profile']==w['report']['local_profile'],'first declared invoice drift') + semantic=A.semantics(C,new) if full_dirty else {'status':'compositional: exact local dirty-block equality plus full baseline replay'} + first_checks.append({'first':rec,'literal_word_sha256':S.digest(new),'block':block,'semantics':semantic}) + if (j+1)%20==0:print('DIRTY_FIRST_WORDS',tag,j+1,len(frame['states']),flush=True) + trace=R.tracing(w);pair_blocks=[];trace_controls=0;bounds=S.corridor_bounds(w) + for serial,state in enumerate(pair['states']): + sec,i=state['section'],state['left_index'];g,h=w[sec][i:i+2] + block=block_equal([g,h],[h,g]);pair_blocks.append([sec,i,block]) + if serial%101==0 or serial==len(pair['states'])-1: + new=w.copy();new[sec]=w[sec].copy();new[sec][i:i+2]=[h,g] + need(S.adjacent_trace(w,trace,sec,i)==R.tracing(new),'incremental trace differs') + need(C.frame_bill(new)[:2]==C.frame_bill(w)[:2],'retained adjacent auditor differs') + # Check the optimized third-gate reach filter against the unrestricted + # enumerator at precisely this middle cut, including all dimensions. + lo,hi=next((lo,hi) for lo,hi in R.segments(w,sec) if lo<=i=i and R.crosses(k,h)) if j