From 07e119dc44edf2bfa546f7212b5d60b0b9f44f12 Mon Sep 17 00:00:00 2001 From: ross Date: Wed, 14 Oct 2026 06:02:59 +1100 Subject: [PATCH 1/2] research: bound scratch-free complex permutation boundaries --- .../complex-scratch-free-boundaries.yml | 35 + .../complex-scratch-free-boundaries/CLAIM.md | 12 + .../EXPECTED.json | 10757 ++++++++++++++++ .../complex-scratch-free-boundaries/NOTICE.md | 25 + .../complex-scratch-free-boundaries/PROOF.md | 158 + .../complex-scratch-free-boundaries/README.md | 101 + .../SOURCES.json | 62 + .../VALIDATION.md | 49 + .../independent.cpp | 82 + .../complex-scratch-free-boundaries/search.py | 101 + .../test_package.py | 164 + .../complex-scratch-free-boundaries/verify.py | 261 + 12 files changed, 11807 insertions(+) create mode 100644 .github/workflows/complex-scratch-free-boundaries.yml create mode 100644 research/complex-scratch-free-boundaries/CLAIM.md create mode 100644 research/complex-scratch-free-boundaries/EXPECTED.json create mode 100644 research/complex-scratch-free-boundaries/NOTICE.md create mode 100644 research/complex-scratch-free-boundaries/PROOF.md create mode 100644 research/complex-scratch-free-boundaries/README.md create mode 100644 research/complex-scratch-free-boundaries/SOURCES.json create mode 100644 research/complex-scratch-free-boundaries/VALIDATION.md create mode 100644 research/complex-scratch-free-boundaries/independent.cpp create mode 100644 research/complex-scratch-free-boundaries/search.py create mode 100644 research/complex-scratch-free-boundaries/test_package.py create mode 100644 research/complex-scratch-free-boundaries/verify.py diff --git a/.github/workflows/complex-scratch-free-boundaries.yml b/.github/workflows/complex-scratch-free-boundaries.yml new file mode 100644 index 0000000000..4b4975435d --- /dev/null +++ b/.github/workflows/complex-scratch-free-boundaries.yml @@ -0,0 +1,35 @@ +name: Complex scratch-free boundary certificate + +on: + pull_request: + paths: + - 'research/complex-scratch-free-boundaries/**' + - 'research/complex-swap-runs-seed37/**' + - 'research/complex-dyadic-lowering/lower.py' + - 'research/community-k492-audit/pr626/replay/mixed-global/base/providers/**' + - '.github/workflows/complex-scratch-free-boundaries.yml' + workflow_dispatch: + +permissions: + contents: read + +jobs: + finite-boundary-check: + runs-on: ubuntu-24.04 + timeout-minutes: 5 + strategy: + fail-fast: false + matrix: + python-version: ['3.11', '3.14'] + steps: + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7 + with: + persist-credentials: false + - uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7 + with: + python-version: ${{ matrix.python-version }} + - name: Exact quotient, source census, witnesses and controls + run: | + python3 -I -O -B research/complex-scratch-free-boundaries/verify.py + python3 -I -O -B research/complex-scratch-free-boundaries/test_package.py + git diff --exit-code diff --git a/research/complex-scratch-free-boundaries/CLAIM.md b/research/complex-scratch-free-boundaries/CLAIM.md new file mode 100644 index 0000000000..047f872c67 --- /dev/null +++ b/research/complex-scratch-free-boundaries/CLAIM.md @@ -0,0 +1,12 @@ +# Sprint claim + +- Track: complex supplier. OS assignment seed **24**, drawn with Python `secrets.randbelow(100)` and persisted before selection. An earlier unpersisted draw was lost in truncated tool output and was not used for task selection. +- Exact base: `ba82555c64e1879e4b7decce28186f208fcb8262`. +- Current accepted selection: PR1042, kappa `1672188119205421/10^18`; selected manifest, assembly, actual gauge44-slots-t16 construction and batch1047 review inspected. No selected-frontier change proposed. +- Three candidates: CK coefficient-grid synthesis (overlaps PR1118); restored CK helper butterflies (overlaps PR1116); scratch-free permutation boundaries (selected). +- Object: PR971's 168 historical CK/JP8 deferred-swap boundaries, especially the 2+3-cycle boundary. Permit arbitrary mixed intermediate rows on exactly the moved coordinates, with the complete invertible PR696 real primitive alphabet and no work register or borrowed fixed coordinate. +- Hypothesis/method: reducing exact dyadic words modulo 3 permits an exhaustive meet-in-the-middle exclusion of words through length eight. Independently replay exact witnesses and classify the actual boundaries. Seed 24 fixes coordinate/generator presentation, not sampled coverage. +- Deliverable: one finite cost/scratch result with complete search domain, exact replay, meaningful adverse controls and a source-bound boundary census. No multiplication theorem or new kappa claim. +- Stopping rule: complete radius-four modular balls for dimensions 2, 3 and 5; permit one evidence-driven refinement only if needed. No unbounded circuit search. +- Expected finish: 2026-10-13 19:14 UTC; final verification/handoff starts by 19:06 UTC. +- Coordination: GitHub pinned-issue query immediately before claim returned none. Local claim used. Open queue read through PR1127; targeted scratch/permutation searches and PR1095 head `1db482a6cb63ae49cf156357ef98b8e4b676fcd9` inspected. PR1095's monomial-prefix class is distinct and credited. No workers delegated. diff --git a/research/complex-scratch-free-boundaries/EXPECTED.json b/research/complex-scratch-free-boundaries/EXPECTED.json new file mode 100644 index 0000000000..bfbb064c91 --- /dev/null +++ b/research/complex-scratch-free-boundaries/EXPECTED.json @@ -0,0 +1,10757 @@ +{ + "assignment_seed": 24, + "base_commit": "ba82555c64e1879e4b7decce28186f208fcb8262", + "finite_search": { + "2": { + "ball_format": "sorted little-endian uint64 ternary matrix, uint8 distance", + "ball_sha256": "d2bc435837f9dbb067e4e3ddc2e98f01df49f21ebcba415660b3987d2575d584", + "dimension": 2, + "generators": 6, + "layers": [ + 1, + 6, + 17, + 22, + 2 + ], + "lower_bound": 4, + "meetings_by_total_length": { + "4": 22, + "5": 16, + "6": 10 + }, + "minimum_if_at_most_eight": 4, + "radius": 4, + "states": 48, + "target": [ + 1, + 0 + ] + }, + "3": { + "ball_format": "sorted little-endian uint64 ternary matrix, uint8 distance", + "ball_sha256": "85b73529733dd928f323e92514d12962f77a94a04e996f2c5c6a22b2edbbfca1", + "dimension": 3, + "generators": 15, + "layers": [ + 1, + 15, + 135, + 787, + 3000 + ], + "lower_bound": 6, + "meetings_by_total_length": { + "6": 63, + "7": 240, + "8": 840 + }, + "minimum_if_at_most_eight": 6, + "radius": 4, + "states": 3938, + "target": [ + 1, + 2, + 0 + ] + }, + "5": { + "ball_format": "sorted little-endian uint64 ternary matrix, uint8 distance", + "ball_sha256": "56c6df0296f3f2bc289f98243ae781c13d3bbe267f6d4a3ff2798d1b47ab149b", + "dimension": 5, + "generators": 45, + "layers": [ + 1, + 45, + 1250, + 26830, + 477045 + ], + "lower_bound": 9, + "meetings_by_total_length": {}, + "minimum_if_at_most_eight": null, + "radius": 4, + "states": 505171, + "target": [ + 1, + 0, + 3, + 4, + 2 + ] + } + }, + "omitted_primitive_controls": 37, + "scope": "Arbitrary-input permutation interfaces on exactly the moved registers. No new kappa.", + "source_census": { + "ck/backward": { + "boundaries": [ + { + "cycles": [ + [ + [ + "L", + 224 + ], + [ + "L", + 229 + ] + ] + ], + "end": 10268, + "frame": 52, + "permutation": [ + [ + [ + "L", + 224 + ], + [ + "L", + 229 + ] + ], + [ + [ + "L", + 229 + ], + [ + "L", + 224 + ] + ] + ], + "start": 10264, + "swap_starts": [ + 10264 + ] + }, + { + "cycles": [ + [ + [ + "L", + 224 + ], + [ + "L", + 227 + ] + ] + ], + "end": 10277, + "frame": 52, + "permutation": [ + [ + [ + "L", + 224 + ], + [ + "L", + 227 + ] + ], + [ + [ + "L", + 227 + ], + [ + "L", + 224 + ] + ] + ], + "start": 10273, + "swap_starts": [ + 10273 + ] + }, + { + "cycles": [ + [ + [ + "L", + 57 + ], + [ + "L", + 81 + ] + ], + [ + [ + "L", + 92 + ], + [ + "L", + 225 + ], + [ + "L", + 224 + ] + ] + ], + "end": 10357, + "frame": 52, + "permutation": [ + [ + [ + "L", + 57 + ], + [ + "L", + 81 + ] + ], + [ + [ + "L", + 81 + ], + [ + "L", + 57 + ] + ], + [ + [ + "L", + 92 + ], + [ + "L", + 225 + ] + ], + [ + [ + "L", + 224 + ], + [ + "L", + 92 + ] + ], + [ + [ + "L", + 225 + ], + [ + "L", + 224 + ] + ], + [ + [ + "L", + 234 + ], + [ + "L", + 234 + ] + ] + ], + "start": 10282, + "swap_starts": [ + 10282, + 10287, + 10292, + 10300, + 10321, + 10337, + 10349 + ] + }, + { + "cycles": [ + [ + [ + "L", + 240 + ], + [ + "L", + 245 + ] + ] + ], + "end": 10467, + "frame": 81, + "permutation": [ + [ + [ + "L", + 240 + ], + [ + "L", + 245 + ] + ], + [ + [ + "L", + 245 + ], + [ + "L", + 240 + ] + ] + ], + "start": 10463, + "swap_starts": [ + 10463 + ] + }, + { + "cycles": [ + [ + [ + "L", + 240 + ], + [ + "L", + 243 + ] + ] + ], + "end": 10476, + "frame": 81, + "permutation": [ + [ + [ + "L", + 240 + ], + [ + "L", + 243 + ] + ], + [ + [ + "L", + 243 + ], + [ + "L", + 240 + ] + ] + ], + "start": 10472, + "swap_starts": [ + 10472 + ] + }, + { + "cycles": [ + [ + [ + "L", + 11 + ], + [ + "L", + 62 + ] + ], + [ + [ + "L", + 63 + ], + [ + "L", + 241 + ], + [ + "L", + 240 + ] + ] + ], + "end": 10556, + "frame": 81, + "permutation": [ + [ + [ + "L", + 11 + ], + [ + "L", + 62 + ] + ], + [ + [ + "L", + 62 + ], + [ + "L", + 11 + ] + ], + [ + [ + "L", + 63 + ], + [ + "L", + 241 + ] + ], + [ + [ + "L", + 240 + ], + [ + "L", + 63 + ] + ], + [ + [ + "L", + 241 + ], + [ + "L", + 240 + ] + ], + [ + [ + "L", + 250 + ], + [ + "L", + 250 + ] + ] + ], + "start": 10481, + "swap_starts": [ + 10481, + 10486, + 10491, + 10499, + 10520, + 10536, + 10548 + ] + }, + { + "cycles": [ + [ + [ + "L", + 256 + ], + [ + "L", + 261 + ] + ] + ], + "end": 10666, + "frame": 110, + "permutation": [ + [ + [ + "L", + 256 + ], + [ + "L", + 261 + ] + ], + [ + [ + "L", + 261 + ], + [ + "L", + 256 + ] + ] + ], + "start": 10662, + "swap_starts": [ + 10662 + ] + }, + { + "cycles": [ + [ + [ + "L", + 256 + ], + [ + "L", + 259 + ] + ] + ], + "end": 10675, + "frame": 110, + "permutation": [ + [ + [ + "L", + 256 + ], + [ + "L", + 259 + ] + ], + [ + [ + "L", + 259 + ], + [ + "L", + 256 + ] + ] + ], + "start": 10671, + "swap_starts": [ + 10671 + ] + }, + { + "cycles": [ + [ + [ + "L", + 9 + ], + [ + "L", + 94 + ] + ], + [ + [ + "L", + 61 + ], + [ + "L", + 257 + ], + [ + "L", + 256 + ] + ] + ], + "end": 10755, + "frame": 110, + "permutation": [ + [ + [ + "L", + 9 + ], + [ + "L", + 94 + ] + ], + [ + [ + "L", + 61 + ], + [ + "L", + 257 + ] + ], + [ + [ + "L", + 94 + ], + [ + "L", + 9 + ] + ], + [ + [ + "L", + 256 + ], + [ + "L", + 61 + ] + ], + [ + [ + "L", + 257 + ], + [ + "L", + 256 + ] + ], + [ + [ + "L", + 266 + ], + [ + "L", + 266 + ] + ] + ], + "start": 10680, + "swap_starts": [ + 10680, + 10685, + 10690, + 10698, + 10719, + 10735, + 10747 + ] + }, + { + "cycles": [ + [ + [ + "L", + 272 + ], + [ + "L", + 277 + ] + ] + ], + "end": 10865, + "frame": 139, + "permutation": [ + [ + [ + "L", + 272 + ], + [ + "L", + 277 + ] + ], + [ + [ + "L", + 277 + ], + [ + "L", + 272 + ] + ] + ], + "start": 10861, + "swap_starts": [ + 10861 + ] + }, + { + "cycles": [ + [ + [ + "L", + 272 + ], + [ + "L", + 275 + ] + ] + ], + "end": 10874, + "frame": 139, + "permutation": [ + [ + [ + "L", + 272 + ], + [ + "L", + 275 + ] + ], + [ + [ + "L", + 275 + ], + [ + "L", + 272 + ] + ] + ], + "start": 10870, + "swap_starts": [ + 10870 + ] + }, + { + "cycles": [ + [ + [ + "L", + 17 + ], + [ + "L", + 77 + ] + ], + [ + [ + "L", + 103 + ], + [ + "L", + 273 + ], + [ + "L", + 272 + ] + ] + ], + "end": 10955, + "frame": 139, + "permutation": [ + [ + [ + "L", + 17 + ], + [ + "L", + 77 + ] + ], + [ + [ + "L", + 77 + ], + [ + "L", + 17 + ] + ], + [ + [ + "L", + 103 + ], + [ + "L", + 273 + ] + ], + [ + [ + "L", + 272 + ], + [ + "L", + 103 + ] + ], + [ + [ + "L", + 273 + ], + [ + "L", + 272 + ] + ], + [ + [ + "L", + 282 + ], + [ + "L", + 282 + ] + ] + ], + "start": 10879, + "swap_starts": [ + 10879, + 10884, + 10889, + 10897, + 10918, + 10935, + 10947 + ] + }, + { + "cycles": [ + [ + [ + "L", + 288 + ], + [ + "L", + 293 + ] + ] + ], + "end": 11065, + "frame": 168, + "permutation": [ + [ + [ + "L", + 288 + ], + [ + "L", + 293 + ] + ], + [ + [ + "L", + 293 + ], + [ + "L", + 288 + ] + ] + ], + "start": 11061, + "swap_starts": [ + 11061 + ] + }, + { + "cycles": [ + [ + [ + "L", + 288 + ], + [ + "L", + 291 + ] + ] + ], + "end": 11074, + "frame": 168, + "permutation": [ + [ + [ + "L", + 288 + ], + [ + "L", + 291 + ] + ], + [ + [ + "L", + 291 + ], + [ + "L", + 288 + ] + ] + ], + "start": 11070, + "swap_starts": [ + 11070 + ] + }, + { + "cycles": [ + [ + [ + "L", + 18 + ], + [ + "L", + 289 + ], + [ + "L", + 288 + ] + ], + [ + [ + "L", + 39 + ], + [ + "L", + 40 + ] + ] + ], + "end": 11155, + "frame": 168, + "permutation": [ + [ + [ + "L", + 18 + ], + [ + "L", + 289 + ] + ], + [ + [ + "L", + 39 + ], + [ + "L", + 40 + ] + ], + [ + [ + "L", + 40 + ], + [ + "L", + 39 + ] + ], + [ + [ + "L", + 288 + ], + [ + "L", + 18 + ] + ], + [ + [ + "L", + 289 + ], + [ + "L", + 288 + ] + ], + [ + [ + "L", + 298 + ], + [ + "L", + 298 + ] + ] + ], + "start": 11079, + "swap_starts": [ + 11079, + 11084, + 11089, + 11097, + 11118, + 11135, + 11147 + ] + }, + { + "cycles": [ + [ + [ + "L", + 304 + ], + [ + "L", + 309 + ] + ] + ], + "end": 11265, + "frame": 197, + "permutation": [ + [ + [ + "L", + 304 + ], + [ + "L", + 309 + ] + ], + [ + [ + "L", + 309 + ], + [ + "L", + 304 + ] + ] + ], + "start": 11261, + "swap_starts": [ + 11261 + ] + }, + { + "cycles": [ + [ + [ + "L", + 304 + ], + [ + "L", + 307 + ] + ] + ], + "end": 11274, + "frame": 197, + "permutation": [ + [ + [ + "L", + 304 + ], + [ + "L", + 307 + ] + ], + [ + [ + "L", + 307 + ], + [ + "L", + 304 + ] + ] + ], + "start": 11270, + "swap_starts": [ + 11270 + ] + }, + { + "cycles": [ + [ + [ + "L", + 35 + ], + [ + "L", + 107 + ] + ], + [ + [ + "L", + 45 + ], + [ + "L", + 305 + ], + [ + "L", + 304 + ] + ] + ], + "end": 11355, + "frame": 197, + "permutation": [ + [ + [ + "L", + 35 + ], + [ + "L", + 107 + ] + ], + [ + [ + "L", + 45 + ], + [ + "L", + 305 + ] + ], + [ + [ + "L", + 107 + ], + [ + "L", + 35 + ] + ], + [ + [ + "L", + 304 + ], + [ + "L", + 45 + ] + ], + [ + [ + "L", + 305 + ], + [ + "L", + 304 + ] + ], + [ + [ + "L", + 314 + ], + [ + "L", + 314 + ] + ] + ], + "start": 11279, + "swap_starts": [ + 11279, + 11284, + 11289, + 11297, + 11318, + 11335, + 11347 + ] + }, + { + "cycles": [ + [ + [ + "L", + 320 + ], + [ + "L", + 325 + ] + ] + ], + "end": 11465, + "frame": 226, + "permutation": [ + [ + [ + "L", + 320 + ], + [ + "L", + 325 + ] + ], + [ + [ + "L", + 325 + ], + [ + "L", + 320 + ] + ] + ], + "start": 11461, + "swap_starts": [ + 11461 + ] + }, + { + "cycles": [ + [ + [ + "L", + 320 + ], + [ + "L", + 323 + ] + ] + ], + "end": 11474, + "frame": 226, + "permutation": [ + [ + [ + "L", + 320 + ], + [ + "L", + 323 + ] + ], + [ + [ + "L", + 323 + ], + [ + "L", + 320 + ] + ] + ], + "start": 11470, + "swap_starts": [ + 11470 + ] + }, + { + "cycles": [ + [ + [ + "L", + 22 + ], + [ + "L", + 23 + ] + ], + [ + [ + "L", + 108 + ], + [ + "L", + 321 + ], + [ + "L", + 320 + ] + ] + ], + "end": 11555, + "frame": 226, + "permutation": [ + [ + [ + "L", + 22 + ], + [ + "L", + 23 + ] + ], + [ + [ + "L", + 23 + ], + [ + "L", + 22 + ] + ], + [ + [ + "L", + 108 + ], + [ + "L", + 321 + ] + ], + [ + [ + "L", + 320 + ], + [ + "L", + 108 + ] + ], + [ + [ + "L", + 321 + ], + [ + "L", + 320 + ] + ], + [ + [ + "L", + 330 + ], + [ + "L", + 330 + ] + ] + ], + "start": 11479, + "swap_starts": [ + 11479, + 11484, + 11489, + 11497, + 11518, + 11535, + 11547 + ] + }, + { + "cycles": [ + [ + [ + "L", + 336 + ], + [ + "L", + 341 + ] + ] + ], + "end": 11665, + "frame": 255, + "permutation": [ + [ + [ + "L", + 336 + ], + [ + "L", + 341 + ] + ], + [ + [ + "L", + 341 + ], + [ + "L", + 336 + ] + ] + ], + "start": 11661, + "swap_starts": [ + 11661 + ] + }, + { + "cycles": [ + [ + [ + "L", + 336 + ], + [ + "L", + 339 + ] + ] + ], + "end": 11674, + "frame": 255, + "permutation": [ + [ + [ + "L", + 336 + ], + [ + "L", + 339 + ] + ], + [ + [ + "L", + 339 + ], + [ + "L", + 336 + ] + ] + ], + "start": 11670, + "swap_starts": [ + 11670 + ] + }, + { + "cycles": [ + [ + [ + "L", + 58 + ], + [ + "L", + 86 + ] + ], + [ + [ + "L", + 93 + ], + [ + "L", + 337 + ], + [ + "L", + 336 + ] + ] + ], + "end": 11755, + "frame": 255, + "permutation": [ + [ + [ + "L", + 58 + ], + [ + "L", + 86 + ] + ], + [ + [ + "L", + 86 + ], + [ + "L", + 58 + ] + ], + [ + [ + "L", + 93 + ], + [ + "L", + 337 + ] + ], + [ + [ + "L", + 336 + ], + [ + "L", + 93 + ] + ], + [ + [ + "L", + 337 + ], + [ + "L", + 336 + ] + ], + [ + [ + "L", + 346 + ], + [ + "L", + 346 + ] + ] + ], + "start": 11679, + "swap_starts": [ + 11679, + 11684, + 11689, + 11697, + 11718, + 11735, + 11747 + ] + }, + { + "cycles": [ + [ + [ + "L", + 352 + ], + [ + "L", + 357 + ] + ] + ], + "end": 11865, + "frame": 284, + "permutation": [ + [ + [ + "L", + 352 + ], + [ + "L", + 357 + ] + ], + [ + [ + "L", + 357 + ], + [ + "L", + 352 + ] + ] + ], + "start": 11861, + "swap_starts": [ + 11861 + ] + }, + { + "cycles": [ + [ + [ + "L", + 352 + ], + [ + "L", + 355 + ] + ] + ], + "end": 11874, + "frame": 284, + "permutation": [ + [ + [ + "L", + 352 + ], + [ + "L", + 355 + ] + ], + [ + [ + "L", + 355 + ], + [ + "L", + 352 + ] + ] + ], + "start": 11870, + "swap_starts": [ + 11870 + ] + }, + { + "cycles": [ + [ + [ + "L", + 29 + ], + [ + "L", + 30 + ] + ], + [ + [ + "L", + 59 + ], + [ + "L", + 353 + ], + [ + "L", + 352 + ] + ] + ], + "end": 11955, + "frame": 284, + "permutation": [ + [ + [ + "L", + 29 + ], + [ + "L", + 30 + ] + ], + [ + [ + "L", + 30 + ], + [ + "L", + 29 + ] + ], + [ + [ + "L", + 59 + ], + [ + "L", + 353 + ] + ], + [ + [ + "L", + 352 + ], + [ + "L", + 59 + ] + ], + [ + [ + "L", + 353 + ], + [ + "L", + 352 + ] + ], + [ + [ + "L", + 362 + ], + [ + "L", + 362 + ] + ] + ], + "start": 11879, + "swap_starts": [ + 11879, + 11884, + 11889, + 11897, + 11918, + 11935, + 11947 + ] + }, + { + "cycles": [ + [ + [ + "L", + 368 + ], + [ + "L", + 373 + ] + ] + ], + "end": 12065, + "frame": 313, + "permutation": [ + [ + [ + "L", + 368 + ], + [ + "L", + 373 + ] + ], + [ + [ + "L", + 373 + ], + [ + "L", + 368 + ] + ] + ], + "start": 12061, + "swap_starts": [ + 12061 + ] + }, + { + "cycles": [ + [ + [ + "L", + 368 + ], + [ + "L", + 371 + ] + ] + ], + "end": 12074, + "frame": 313, + "permutation": [ + [ + [ + "L", + 368 + ], + [ + "L", + 371 + ] + ], + [ + [ + "L", + 371 + ], + [ + "L", + 368 + ] + ] + ], + "start": 12070, + "swap_starts": [ + 12070 + ] + }, + { + "cycles": [ + [ + [ + "L", + 8 + ], + [ + "L", + 369 + ], + [ + "L", + 368 + ] + ], + [ + [ + "L", + 26 + ], + [ + "L", + 95 + ] + ] + ], + "end": 12155, + "frame": 313, + "permutation": [ + [ + [ + "L", + 8 + ], + [ + "L", + 369 + ] + ], + [ + [ + "L", + 26 + ], + [ + "L", + 95 + ] + ], + [ + [ + "L", + 95 + ], + [ + "L", + 26 + ] + ], + [ + [ + "L", + 368 + ], + [ + "L", + 8 + ] + ], + [ + [ + "L", + 369 + ], + [ + "L", + 368 + ] + ], + [ + [ + "L", + 378 + ], + [ + "L", + 378 + ] + ] + ], + "start": 12079, + "swap_starts": [ + 12079, + 12084, + 12089, + 12097, + 12118, + 12135, + 12147 + ] + }, + { + "cycles": [ + [ + [ + "L", + 384 + ], + [ + "L", + 389 + ] + ] + ], + "end": 12265, + "frame": 342, + "permutation": [ + [ + [ + "L", + 384 + ], + [ + "L", + 389 + ] + ], + [ + [ + "L", + 389 + ], + [ + "L", + 384 + ] + ] + ], + "start": 12261, + "swap_starts": [ + 12261 + ] + }, + { + "cycles": [ + [ + [ + "L", + 384 + ], + [ + "L", + 387 + ] + ] + ], + "end": 12274, + "frame": 342, + "permutation": [ + [ + [ + "L", + 384 + ], + [ + "L", + 387 + ] + ], + [ + [ + "L", + 387 + ], + [ + "L", + 384 + ] + ] + ], + "start": 12270, + "swap_starts": [ + 12270 + ] + }, + { + "cycles": [ + [ + [ + "L", + 64 + ], + [ + "L", + 65 + ] + ], + [ + [ + "L", + 96 + ], + [ + "L", + 385 + ], + [ + "L", + 384 + ] + ] + ], + "end": 12355, + "frame": 342, + "permutation": [ + [ + [ + "L", + 64 + ], + [ + "L", + 65 + ] + ], + [ + [ + "L", + 65 + ], + [ + "L", + 64 + ] + ], + [ + [ + "L", + 96 + ], + [ + "L", + 385 + ] + ], + [ + [ + "L", + 384 + ], + [ + "L", + 96 + ] + ], + [ + [ + "L", + 385 + ], + [ + "L", + 384 + ] + ], + [ + [ + "L", + 394 + ], + [ + "L", + 394 + ] + ] + ], + "start": 12279, + "swap_starts": [ + 12279, + 12284, + 12289, + 12297, + 12318, + 12335, + 12347 + ] + }, + { + "cycles": [ + [ + [ + "L", + 400 + ], + [ + "L", + 405 + ] + ] + ], + "end": 12465, + "frame": 371, + "permutation": [ + [ + [ + "L", + 400 + ], + [ + "L", + 405 + ] + ], + [ + [ + "L", + 405 + ], + [ + "L", + 400 + ] + ] + ], + "start": 12461, + "swap_starts": [ + 12461 + ] + }, + { + "cycles": [ + [ + [ + "L", + 400 + ], + [ + "L", + 403 + ] + ] + ], + "end": 12474, + "frame": 371, + "permutation": [ + [ + [ + "L", + 400 + ], + [ + "L", + 403 + ] + ], + [ + [ + "L", + 403 + ], + [ + "L", + 400 + ] + ] + ], + "start": 12470, + "swap_starts": [ + 12470 + ] + }, + { + "cycles": [ + [ + [ + "L", + 41 + ], + [ + "L", + 401 + ], + [ + "L", + 400 + ] + ], + [ + [ + "L", + 42 + ], + [ + "L", + 106 + ] + ] + ], + "end": 12554, + "frame": 371, + "permutation": [ + [ + [ + "L", + 41 + ], + [ + "L", + 401 + ] + ], + [ + [ + "L", + 42 + ], + [ + "L", + 106 + ] + ], + [ + [ + "L", + 106 + ], + [ + "L", + 42 + ] + ], + [ + [ + "L", + 400 + ], + [ + "L", + 41 + ] + ], + [ + [ + "L", + 401 + ], + [ + "L", + 400 + ] + ], + [ + [ + "L", + 410 + ], + [ + "L", + 410 + ] + ] + ], + "start": 12479, + "swap_starts": [ + 12479, + 12484, + 12489, + 12497, + 12518, + 12534, + 12546 + ] + }, + { + "cycles": [ + [ + [ + "L", + 416 + ], + [ + "L", + 421 + ] + ] + ], + "end": 12664, + "frame": 400, + "permutation": [ + [ + [ + "L", + 416 + ], + [ + "L", + 421 + ] + ], + [ + [ + "L", + 421 + ], + [ + "L", + 416 + ] + ] + ], + "start": 12660, + "swap_starts": [ + 12660 + ] + }, + { + "cycles": [ + [ + [ + "L", + 416 + ], + [ + "L", + 419 + ] + ] + ], + "end": 12673, + "frame": 400, + "permutation": [ + [ + [ + "L", + 416 + ], + [ + "L", + 419 + ] + ], + [ + [ + "L", + 419 + ], + [ + "L", + 416 + ] + ] + ], + "start": 12669, + "swap_starts": [ + 12669 + ] + }, + { + "cycles": [ + [ + [ + "L", + 16 + ], + [ + "L", + 104 + ] + ], + [ + [ + "L", + 43 + ], + [ + "L", + 417 + ], + [ + "L", + 416 + ] + ] + ], + "end": 12753, + "frame": 400, + "permutation": [ + [ + [ + "L", + 16 + ], + [ + "L", + 104 + ] + ], + [ + [ + "L", + 43 + ], + [ + "L", + 417 + ] + ], + [ + [ + "L", + 104 + ], + [ + "L", + 16 + ] + ], + [ + [ + "L", + 416 + ], + [ + "L", + 43 + ] + ], + [ + [ + "L", + 417 + ], + [ + "L", + 416 + ] + ], + [ + [ + "L", + 426 + ], + [ + "L", + 426 + ] + ] + ], + "start": 12678, + "swap_starts": [ + 12678, + 12683, + 12688, + 12696, + 12717, + 12733, + 12745 + ] + }, + { + "cycles": [ + [ + [ + "L", + 432 + ], + [ + "L", + 437 + ] + ] + ], + "end": 12863, + "frame": 429, + "permutation": [ + [ + [ + "L", + 432 + ], + [ + "L", + 437 + ] + ], + [ + [ + "L", + 437 + ], + [ + "L", + 432 + ] + ] + ], + "start": 12859, + "swap_starts": [ + 12859 + ] + }, + { + "cycles": [ + [ + [ + "L", + 432 + ], + [ + "L", + 435 + ] + ] + ], + "end": 12872, + "frame": 429, + "permutation": [ + [ + [ + "L", + 432 + ], + [ + "L", + 435 + ] + ], + [ + [ + "L", + 435 + ], + [ + "L", + 432 + ] + ] + ], + "start": 12868, + "swap_starts": [ + 12868 + ] + }, + { + "cycles": [ + [ + [ + "L", + 20 + ], + [ + "L", + 110 + ] + ], + [ + [ + "L", + 37 + ], + [ + "L", + 433 + ], + [ + "L", + 432 + ] + ] + ], + "end": 12952, + "frame": 429, + "permutation": [ + [ + [ + "L", + 20 + ], + [ + "L", + 110 + ] + ], + [ + [ + "L", + 37 + ], + [ + "L", + 433 + ] + ], + [ + [ + "L", + 110 + ], + [ + "L", + 20 + ] + ], + [ + [ + "L", + 432 + ], + [ + "L", + 37 + ] + ], + [ + [ + "L", + 433 + ], + [ + "L", + 432 + ] + ], + [ + [ + "L", + 442 + ], + [ + "L", + 442 + ] + ] + ], + "start": 12877, + "swap_starts": [ + 12877, + 12882, + 12887, + 12895, + 12916, + 12932, + 12944 + ] + } + ], + "real_primitive_penalty_at_least": 28, + "scratch_component_cost": 224, + "scratch_free_component_lower_bound": 238, + "scratch_free_component_upper_bound": 252, + "two_cycles": 28, + "two_plus_three_cycles": 14 + }, + "ck/forward": { + "boundaries": [ + { + "cycles": [ + [ + [ + "L", + 224 + ], + [ + "L", + 229 + ] + ] + ], + "end": 10268, + "frame": 52, + "permutation": [ + [ + [ + "L", + 224 + ], + [ + "L", + 229 + ] + ], + [ + [ + "L", + 229 + ], + [ + "L", + 224 + ] + ] + ], + "start": 10264, + "swap_starts": [ + 10264 + ] + }, + { + "cycles": [ + [ + [ + "L", + 224 + ], + [ + "L", + 227 + ] + ] + ], + "end": 10277, + "frame": 52, + "permutation": [ + [ + [ + "L", + 224 + ], + [ + "L", + 227 + ] + ], + [ + [ + "L", + 227 + ], + [ + "L", + 224 + ] + ] + ], + "start": 10273, + "swap_starts": [ + 10273 + ] + }, + { + "cycles": [ + [ + [ + "L", + 57 + ], + [ + "L", + 81 + ] + ], + [ + [ + "L", + 92 + ], + [ + "L", + 225 + ], + [ + "L", + 224 + ] + ] + ], + "end": 10357, + "frame": 52, + "permutation": [ + [ + [ + "L", + 57 + ], + [ + "L", + 81 + ] + ], + [ + [ + "L", + 81 + ], + [ + "L", + 57 + ] + ], + [ + [ + "L", + 92 + ], + [ + "L", + 225 + ] + ], + [ + [ + "L", + 224 + ], + [ + "L", + 92 + ] + ], + [ + [ + "L", + 225 + ], + [ + "L", + 224 + ] + ], + [ + [ + "L", + 234 + ], + [ + "L", + 234 + ] + ] + ], + "start": 10282, + "swap_starts": [ + 10282, + 10287, + 10292, + 10300, + 10321, + 10337, + 10349 + ] + }, + { + "cycles": [ + [ + [ + "L", + 240 + ], + [ + "L", + 245 + ] + ] + ], + "end": 10467, + "frame": 81, + "permutation": [ + [ + [ + "L", + 240 + ], + [ + "L", + 245 + ] + ], + [ + [ + "L", + 245 + ], + [ + "L", + 240 + ] + ] + ], + "start": 10463, + "swap_starts": [ + 10463 + ] + }, + { + "cycles": [ + [ + [ + "L", + 240 + ], + [ + "L", + 243 + ] + ] + ], + "end": 10476, + "frame": 81, + "permutation": [ + [ + [ + "L", + 240 + ], + [ + "L", + 243 + ] + ], + [ + [ + "L", + 243 + ], + [ + "L", + 240 + ] + ] + ], + "start": 10472, + "swap_starts": [ + 10472 + ] + }, + { + "cycles": [ + [ + [ + "L", + 11 + ], + [ + "L", + 62 + ] + ], + [ + [ + "L", + 63 + ], + [ + "L", + 241 + ], + [ + "L", + 240 + ] + ] + ], + "end": 10556, + "frame": 81, + "permutation": [ + [ + [ + "L", + 11 + ], + [ + "L", + 62 + ] + ], + [ + [ + "L", + 62 + ], + [ + "L", + 11 + ] + ], + [ + [ + "L", + 63 + ], + [ + "L", + 241 + ] + ], + [ + [ + "L", + 240 + ], + [ + "L", + 63 + ] + ], + [ + [ + "L", + 241 + ], + [ + "L", + 240 + ] + ], + [ + [ + "L", + 250 + ], + [ + "L", + 250 + ] + ] + ], + "start": 10481, + "swap_starts": [ + 10481, + 10486, + 10491, + 10499, + 10520, + 10536, + 10548 + ] + }, + { + "cycles": [ + [ + [ + "L", + 256 + ], + [ + "L", + 261 + ] + ] + ], + "end": 10666, + "frame": 110, + "permutation": [ + [ + [ + "L", + 256 + ], + [ + "L", + 261 + ] + ], + [ + [ + "L", + 261 + ], + [ + "L", + 256 + ] + ] + ], + "start": 10662, + "swap_starts": [ + 10662 + ] + }, + { + "cycles": [ + [ + [ + "L", + 256 + ], + [ + "L", + 259 + ] + ] + ], + "end": 10675, + "frame": 110, + "permutation": [ + [ + [ + "L", + 256 + ], + [ + "L", + 259 + ] + ], + [ + [ + "L", + 259 + ], + [ + "L", + 256 + ] + ] + ], + "start": 10671, + "swap_starts": [ + 10671 + ] + }, + { + "cycles": [ + [ + [ + "L", + 9 + ], + [ + "L", + 94 + ] + ], + [ + [ + "L", + 61 + ], + [ + "L", + 257 + ], + [ + "L", + 256 + ] + ] + ], + "end": 10755, + "frame": 110, + "permutation": [ + [ + [ + "L", + 9 + ], + [ + "L", + 94 + ] + ], + [ + [ + "L", + 61 + ], + [ + "L", + 257 + ] + ], + [ + [ + "L", + 94 + ], + [ + "L", + 9 + ] + ], + [ + [ + "L", + 256 + ], + [ + "L", + 61 + ] + ], + [ + [ + "L", + 257 + ], + [ + "L", + 256 + ] + ], + [ + [ + "L", + 266 + ], + [ + "L", + 266 + ] + ] + ], + "start": 10680, + "swap_starts": [ + 10680, + 10685, + 10690, + 10698, + 10719, + 10735, + 10747 + ] + }, + { + "cycles": [ + [ + [ + "L", + 272 + ], + [ + "L", + 277 + ] + ] + ], + "end": 10865, + "frame": 139, + "permutation": [ + [ + [ + "L", + 272 + ], + [ + "L", + 277 + ] + ], + [ + [ + "L", + 277 + ], + [ + "L", + 272 + ] + ] + ], + "start": 10861, + "swap_starts": [ + 10861 + ] + }, + { + "cycles": [ + [ + [ + "L", + 272 + ], + [ + "L", + 275 + ] + ] + ], + "end": 10874, + "frame": 139, + "permutation": [ + [ + [ + "L", + 272 + ], + [ + "L", + 275 + ] + ], + [ + [ + "L", + 275 + ], + [ + "L", + 272 + ] + ] + ], + "start": 10870, + "swap_starts": [ + 10870 + ] + }, + { + "cycles": [ + [ + [ + "L", + 17 + ], + [ + "L", + 77 + ] + ], + [ + [ + "L", + 103 + ], + [ + "L", + 273 + ], + [ + "L", + 272 + ] + ] + ], + "end": 10955, + "frame": 139, + "permutation": [ + [ + [ + "L", + 17 + ], + [ + "L", + 77 + ] + ], + [ + [ + "L", + 77 + ], + [ + "L", + 17 + ] + ], + [ + [ + "L", + 103 + ], + [ + "L", + 273 + ] + ], + [ + [ + "L", + 272 + ], + [ + "L", + 103 + ] + ], + [ + [ + "L", + 273 + ], + [ + "L", + 272 + ] + ], + [ + [ + "L", + 282 + ], + [ + "L", + 282 + ] + ] + ], + "start": 10879, + "swap_starts": [ + 10879, + 10884, + 10889, + 10897, + 10918, + 10935, + 10947 + ] + }, + { + "cycles": [ + [ + [ + "L", + 288 + ], + [ + "L", + 293 + ] + ] + ], + "end": 11065, + "frame": 168, + "permutation": [ + [ + [ + "L", + 288 + ], + [ + "L", + 293 + ] + ], + [ + [ + "L", + 293 + ], + [ + "L", + 288 + ] + ] + ], + "start": 11061, + "swap_starts": [ + 11061 + ] + }, + { + "cycles": [ + [ + [ + "L", + 288 + ], + [ + "L", + 291 + ] + ] + ], + "end": 11074, + "frame": 168, + "permutation": [ + [ + [ + "L", + 288 + ], + [ + "L", + 291 + ] + ], + [ + [ + "L", + 291 + ], + [ + "L", + 288 + ] + ] + ], + "start": 11070, + "swap_starts": [ + 11070 + ] + }, + { + "cycles": [ + [ + [ + "L", + 18 + ], + [ + "L", + 289 + ], + [ + "L", + 288 + ] + ], + [ + [ + "L", + 39 + ], + [ + "L", + 40 + ] + ] + ], + "end": 11155, + "frame": 168, + "permutation": [ + [ + [ + "L", + 18 + ], + [ + "L", + 289 + ] + ], + [ + [ + "L", + 39 + ], + [ + "L", + 40 + ] + ], + [ + [ + "L", + 40 + ], + [ + "L", + 39 + ] + ], + [ + [ + "L", + 288 + ], + [ + "L", + 18 + ] + ], + [ + [ + "L", + 289 + ], + [ + "L", + 288 + ] + ], + [ + [ + "L", + 298 + ], + [ + "L", + 298 + ] + ] + ], + "start": 11079, + "swap_starts": [ + 11079, + 11084, + 11089, + 11097, + 11118, + 11135, + 11147 + ] + }, + { + "cycles": [ + [ + [ + "L", + 304 + ], + [ + "L", + 309 + ] + ] + ], + "end": 11265, + "frame": 197, + "permutation": [ + [ + [ + "L", + 304 + ], + [ + "L", + 309 + ] + ], + [ + [ + "L", + 309 + ], + [ + "L", + 304 + ] + ] + ], + "start": 11261, + "swap_starts": [ + 11261 + ] + }, + { + "cycles": [ + [ + [ + "L", + 304 + ], + [ + "L", + 307 + ] + ] + ], + "end": 11274, + "frame": 197, + "permutation": [ + [ + [ + "L", + 304 + ], + [ + "L", + 307 + ] + ], + [ + [ + "L", + 307 + ], + [ + "L", + 304 + ] + ] + ], + "start": 11270, + "swap_starts": [ + 11270 + ] + }, + { + "cycles": [ + [ + [ + "L", + 35 + ], + [ + "L", + 107 + ] + ], + [ + [ + "L", + 45 + ], + [ + "L", + 305 + ], + [ + "L", + 304 + ] + ] + ], + "end": 11355, + "frame": 197, + "permutation": [ + [ + [ + "L", + 35 + ], + [ + "L", + 107 + ] + ], + [ + [ + "L", + 45 + ], + [ + "L", + 305 + ] + ], + [ + [ + "L", + 107 + ], + [ + "L", + 35 + ] + ], + [ + [ + "L", + 304 + ], + [ + "L", + 45 + ] + ], + [ + [ + "L", + 305 + ], + [ + "L", + 304 + ] + ], + [ + [ + "L", + 314 + ], + [ + "L", + 314 + ] + ] + ], + "start": 11279, + "swap_starts": [ + 11279, + 11284, + 11289, + 11297, + 11318, + 11335, + 11347 + ] + }, + { + "cycles": [ + [ + [ + "L", + 320 + ], + [ + "L", + 325 + ] + ] + ], + "end": 11465, + "frame": 226, + "permutation": [ + [ + [ + "L", + 320 + ], + [ + "L", + 325 + ] + ], + [ + [ + "L", + 325 + ], + [ + "L", + 320 + ] + ] + ], + "start": 11461, + "swap_starts": [ + 11461 + ] + }, + { + "cycles": [ + [ + [ + "L", + 320 + ], + [ + "L", + 323 + ] + ] + ], + "end": 11474, + "frame": 226, + "permutation": [ + [ + [ + "L", + 320 + ], + [ + "L", + 323 + ] + ], + [ + [ + "L", + 323 + ], + [ + "L", + 320 + ] + ] + ], + "start": 11470, + "swap_starts": [ + 11470 + ] + }, + { + "cycles": [ + [ + [ + "L", + 22 + ], + [ + "L", + 23 + ] + ], + [ + [ + "L", + 108 + ], + [ + "L", + 321 + ], + [ + "L", + 320 + ] + ] + ], + "end": 11555, + "frame": 226, + "permutation": [ + [ + [ + "L", + 22 + ], + [ + "L", + 23 + ] + ], + [ + [ + "L", + 23 + ], + [ + "L", + 22 + ] + ], + [ + [ + "L", + 108 + ], + [ + "L", + 321 + ] + ], + [ + [ + "L", + 320 + ], + [ + "L", + 108 + ] + ], + [ + [ + "L", + 321 + ], + [ + "L", + 320 + ] + ], + [ + [ + "L", + 330 + ], + [ + "L", + 330 + ] + ] + ], + "start": 11479, + "swap_starts": [ + 11479, + 11484, + 11489, + 11497, + 11518, + 11535, + 11547 + ] + }, + { + "cycles": [ + [ + [ + "L", + 336 + ], + [ + "L", + 341 + ] + ] + ], + "end": 11665, + "frame": 255, + "permutation": [ + [ + [ + "L", + 336 + ], + [ + "L", + 341 + ] + ], + [ + [ + "L", + 341 + ], + [ + "L", + 336 + ] + ] + ], + "start": 11661, + "swap_starts": [ + 11661 + ] + }, + { + "cycles": [ + [ + [ + "L", + 336 + ], + [ + "L", + 339 + ] + ] + ], + "end": 11674, + "frame": 255, + "permutation": [ + [ + [ + "L", + 336 + ], + [ + "L", + 339 + ] + ], + [ + [ + "L", + 339 + ], + [ + "L", + 336 + ] + ] + ], + "start": 11670, + "swap_starts": [ + 11670 + ] + }, + { + "cycles": [ + [ + [ + "L", + 58 + ], + [ + "L", + 86 + ] + ], + [ + [ + "L", + 93 + ], + [ + "L", + 337 + ], + [ + "L", + 336 + ] + ] + ], + "end": 11755, + "frame": 255, + "permutation": [ + [ + [ + "L", + 58 + ], + [ + "L", + 86 + ] + ], + [ + [ + "L", + 86 + ], + [ + "L", + 58 + ] + ], + [ + [ + "L", + 93 + ], + [ + "L", + 337 + ] + ], + [ + [ + "L", + 336 + ], + [ + "L", + 93 + ] + ], + [ + [ + "L", + 337 + ], + [ + "L", + 336 + ] + ], + [ + [ + "L", + 346 + ], + [ + "L", + 346 + ] + ] + ], + "start": 11679, + "swap_starts": [ + 11679, + 11684, + 11689, + 11697, + 11718, + 11735, + 11747 + ] + }, + { + "cycles": [ + [ + [ + "L", + 352 + ], + [ + "L", + 357 + ] + ] + ], + "end": 11865, + "frame": 284, + "permutation": [ + [ + [ + "L", + 352 + ], + [ + "L", + 357 + ] + ], + [ + [ + "L", + 357 + ], + [ + "L", + 352 + ] + ] + ], + "start": 11861, + "swap_starts": [ + 11861 + ] + }, + { + "cycles": [ + [ + [ + "L", + 352 + ], + [ + "L", + 355 + ] + ] + ], + "end": 11874, + "frame": 284, + "permutation": [ + [ + [ + "L", + 352 + ], + [ + "L", + 355 + ] + ], + [ + [ + "L", + 355 + ], + [ + "L", + 352 + ] + ] + ], + "start": 11870, + "swap_starts": [ + 11870 + ] + }, + { + "cycles": [ + [ + [ + "L", + 29 + ], + [ + "L", + 30 + ] + ], + [ + [ + "L", + 59 + ], + [ + "L", + 353 + ], + [ + "L", + 352 + ] + ] + ], + "end": 11955, + "frame": 284, + "permutation": [ + [ + [ + "L", + 29 + ], + [ + "L", + 30 + ] + ], + [ + [ + "L", + 30 + ], + [ + "L", + 29 + ] + ], + [ + [ + "L", + 59 + ], + [ + "L", + 353 + ] + ], + [ + [ + "L", + 352 + ], + [ + "L", + 59 + ] + ], + [ + [ + "L", + 353 + ], + [ + "L", + 352 + ] + ], + [ + [ + "L", + 362 + ], + [ + "L", + 362 + ] + ] + ], + "start": 11879, + "swap_starts": [ + 11879, + 11884, + 11889, + 11897, + 11918, + 11935, + 11947 + ] + }, + { + "cycles": [ + [ + [ + "L", + 368 + ], + [ + "L", + 373 + ] + ] + ], + "end": 12065, + "frame": 313, + "permutation": [ + [ + [ + "L", + 368 + ], + [ + "L", + 373 + ] + ], + [ + [ + "L", + 373 + ], + [ + "L", + 368 + ] + ] + ], + "start": 12061, + "swap_starts": [ + 12061 + ] + }, + { + "cycles": [ + [ + [ + "L", + 368 + ], + [ + "L", + 371 + ] + ] + ], + "end": 12074, + "frame": 313, + "permutation": [ + [ + [ + "L", + 368 + ], + [ + "L", + 371 + ] + ], + [ + [ + "L", + 371 + ], + [ + "L", + 368 + ] + ] + ], + "start": 12070, + "swap_starts": [ + 12070 + ] + }, + { + "cycles": [ + [ + [ + "L", + 8 + ], + [ + "L", + 369 + ], + [ + "L", + 368 + ] + ], + [ + [ + "L", + 26 + ], + [ + "L", + 95 + ] + ] + ], + "end": 12155, + "frame": 313, + "permutation": [ + [ + [ + "L", + 8 + ], + [ + "L", + 369 + ] + ], + [ + [ + "L", + 26 + ], + [ + "L", + 95 + ] + ], + [ + [ + "L", + 95 + ], + [ + "L", + 26 + ] + ], + [ + [ + "L", + 368 + ], + [ + "L", + 8 + ] + ], + [ + [ + "L", + 369 + ], + [ + "L", + 368 + ] + ], + [ + [ + "L", + 378 + ], + [ + "L", + 378 + ] + ] + ], + "start": 12079, + "swap_starts": [ + 12079, + 12084, + 12089, + 12097, + 12118, + 12135, + 12147 + ] + }, + { + "cycles": [ + [ + [ + "L", + 384 + ], + [ + "L", + 389 + ] + ] + ], + "end": 12265, + "frame": 342, + "permutation": [ + [ + [ + "L", + 384 + ], + [ + "L", + 389 + ] + ], + [ + [ + "L", + 389 + ], + [ + "L", + 384 + ] + ] + ], + "start": 12261, + "swap_starts": [ + 12261 + ] + }, + { + "cycles": [ + [ + [ + "L", + 384 + ], + [ + "L", + 387 + ] + ] + ], + "end": 12274, + "frame": 342, + "permutation": [ + [ + [ + "L", + 384 + ], + [ + "L", + 387 + ] + ], + [ + [ + "L", + 387 + ], + [ + "L", + 384 + ] + ] + ], + "start": 12270, + "swap_starts": [ + 12270 + ] + }, + { + "cycles": [ + [ + [ + "L", + 64 + ], + [ + "L", + 65 + ] + ], + [ + [ + "L", + 96 + ], + [ + "L", + 385 + ], + [ + "L", + 384 + ] + ] + ], + "end": 12355, + "frame": 342, + "permutation": [ + [ + [ + "L", + 64 + ], + [ + "L", + 65 + ] + ], + [ + [ + "L", + 65 + ], + [ + "L", + 64 + ] + ], + [ + [ + "L", + 96 + ], + [ + "L", + 385 + ] + ], + [ + [ + "L", + 384 + ], + [ + "L", + 96 + ] + ], + [ + [ + "L", + 385 + ], + [ + "L", + 384 + ] + ], + [ + [ + "L", + 394 + ], + [ + "L", + 394 + ] + ] + ], + "start": 12279, + "swap_starts": [ + 12279, + 12284, + 12289, + 12297, + 12318, + 12335, + 12347 + ] + }, + { + "cycles": [ + [ + [ + "L", + 400 + ], + [ + "L", + 405 + ] + ] + ], + "end": 12465, + "frame": 371, + "permutation": [ + [ + [ + "L", + 400 + ], + [ + "L", + 405 + ] + ], + [ + [ + "L", + 405 + ], + [ + "L", + 400 + ] + ] + ], + "start": 12461, + "swap_starts": [ + 12461 + ] + }, + { + "cycles": [ + [ + [ + "L", + 400 + ], + [ + "L", + 403 + ] + ] + ], + "end": 12474, + "frame": 371, + "permutation": [ + [ + [ + "L", + 400 + ], + [ + "L", + 403 + ] + ], + [ + [ + "L", + 403 + ], + [ + "L", + 400 + ] + ] + ], + "start": 12470, + "swap_starts": [ + 12470 + ] + }, + { + "cycles": [ + [ + [ + "L", + 41 + ], + [ + "L", + 401 + ], + [ + "L", + 400 + ] + ], + [ + [ + "L", + 42 + ], + [ + "L", + 106 + ] + ] + ], + "end": 12554, + "frame": 371, + "permutation": [ + [ + [ + "L", + 41 + ], + [ + "L", + 401 + ] + ], + [ + [ + "L", + 42 + ], + [ + "L", + 106 + ] + ], + [ + [ + "L", + 106 + ], + [ + "L", + 42 + ] + ], + [ + [ + "L", + 400 + ], + [ + "L", + 41 + ] + ], + [ + [ + "L", + 401 + ], + [ + "L", + 400 + ] + ], + [ + [ + "L", + 410 + ], + [ + "L", + 410 + ] + ] + ], + "start": 12479, + "swap_starts": [ + 12479, + 12484, + 12489, + 12497, + 12518, + 12534, + 12546 + ] + }, + { + "cycles": [ + [ + [ + "L", + 416 + ], + [ + "L", + 421 + ] + ] + ], + "end": 12664, + "frame": 400, + "permutation": [ + [ + [ + "L", + 416 + ], + [ + "L", + 421 + ] + ], + [ + [ + "L", + 421 + ], + [ + "L", + 416 + ] + ] + ], + "start": 12660, + "swap_starts": [ + 12660 + ] + }, + { + "cycles": [ + [ + [ + "L", + 416 + ], + [ + "L", + 419 + ] + ] + ], + "end": 12673, + "frame": 400, + "permutation": [ + [ + [ + "L", + 416 + ], + [ + "L", + 419 + ] + ], + [ + [ + "L", + 419 + ], + [ + "L", + 416 + ] + ] + ], + "start": 12669, + "swap_starts": [ + 12669 + ] + }, + { + "cycles": [ + [ + [ + "L", + 16 + ], + [ + "L", + 104 + ] + ], + [ + [ + "L", + 43 + ], + [ + "L", + 417 + ], + [ + "L", + 416 + ] + ] + ], + "end": 12753, + "frame": 400, + "permutation": [ + [ + [ + "L", + 16 + ], + [ + "L", + 104 + ] + ], + [ + [ + "L", + 43 + ], + [ + "L", + 417 + ] + ], + [ + [ + "L", + 104 + ], + [ + "L", + 16 + ] + ], + [ + [ + "L", + 416 + ], + [ + "L", + 43 + ] + ], + [ + [ + "L", + 417 + ], + [ + "L", + 416 + ] + ], + [ + [ + "L", + 426 + ], + [ + "L", + 426 + ] + ] + ], + "start": 12678, + "swap_starts": [ + 12678, + 12683, + 12688, + 12696, + 12717, + 12733, + 12745 + ] + }, + { + "cycles": [ + [ + [ + "L", + 432 + ], + [ + "L", + 437 + ] + ] + ], + "end": 12863, + "frame": 429, + "permutation": [ + [ + [ + "L", + 432 + ], + [ + "L", + 437 + ] + ], + [ + [ + "L", + 437 + ], + [ + "L", + 432 + ] + ] + ], + "start": 12859, + "swap_starts": [ + 12859 + ] + }, + { + "cycles": [ + [ + [ + "L", + 432 + ], + [ + "L", + 435 + ] + ] + ], + "end": 12872, + "frame": 429, + "permutation": [ + [ + [ + "L", + 432 + ], + [ + "L", + 435 + ] + ], + [ + [ + "L", + 435 + ], + [ + "L", + 432 + ] + ] + ], + "start": 12868, + "swap_starts": [ + 12868 + ] + }, + { + "cycles": [ + [ + [ + "L", + 20 + ], + [ + "L", + 110 + ] + ], + [ + [ + "L", + 37 + ], + [ + "L", + 433 + ], + [ + "L", + 432 + ] + ] + ], + "end": 12952, + "frame": 429, + "permutation": [ + [ + [ + "L", + 20 + ], + [ + "L", + 110 + ] + ], + [ + [ + "L", + 37 + ], + [ + "L", + 433 + ] + ], + [ + [ + "L", + 110 + ], + [ + "L", + 20 + ] + ], + [ + [ + "L", + 432 + ], + [ + "L", + 37 + ] + ], + [ + [ + "L", + 433 + ], + [ + "L", + 432 + ] + ], + [ + [ + "L", + 442 + ], + [ + "L", + 442 + ] + ] + ], + "start": 12877, + "swap_starts": [ + 12877, + 12882, + 12887, + 12895, + 12916, + 12932, + 12944 + ] + } + ], + "real_primitive_penalty_at_least": 28, + "scratch_component_cost": 224, + "scratch_free_component_lower_bound": 238, + "scratch_free_component_upper_bound": 252, + "two_cycles": 28, + "two_plus_three_cycles": 14 + }, + "jp8/backward": { + "boundaries": [ + { + "cycles": [ + [ + [ + "L", + 224 + ], + [ + "L", + 229 + ] + ] + ], + "end": 10324, + "frame": 36, + "permutation": [ + [ + [ + "L", + 224 + ], + [ + "L", + 229 + ] + ], + [ + [ + "L", + 229 + ], + [ + "L", + 224 + ] + ] + ], + "start": 10320, + "swap_starts": [ + 10320 + ] + }, + { + "cycles": [ + [ + [ + "L", + 224 + ], + [ + "L", + 227 + ] + ] + ], + "end": 10333, + "frame": 36, + "permutation": [ + [ + [ + "L", + 224 + ], + [ + "L", + 227 + ] + ], + [ + [ + "L", + 227 + ], + [ + "L", + 224 + ] + ] + ], + "start": 10329, + "swap_starts": [ + 10329 + ] + }, + { + "cycles": [ + [ + [ + "L", + 57 + ], + [ + "L", + 81 + ] + ], + [ + [ + "L", + 92 + ], + [ + "L", + 225 + ], + [ + "L", + 224 + ] + ] + ], + "end": 10413, + "frame": 36, + "permutation": [ + [ + [ + "L", + 57 + ], + [ + "L", + 81 + ] + ], + [ + [ + "L", + 81 + ], + [ + "L", + 57 + ] + ], + [ + [ + "L", + 92 + ], + [ + "L", + 225 + ] + ], + [ + [ + "L", + 224 + ], + [ + "L", + 92 + ] + ], + [ + [ + "L", + 225 + ], + [ + "L", + 224 + ] + ], + [ + [ + "L", + 234 + ], + [ + "L", + 234 + ] + ] + ], + "start": 10338, + "swap_starts": [ + 10338, + 10343, + 10348, + 10356, + 10377, + 10393, + 10405 + ] + }, + { + "cycles": [ + [ + [ + "L", + 240 + ], + [ + "L", + 245 + ] + ] + ], + "end": 10523, + "frame": 65, + "permutation": [ + [ + [ + "L", + 240 + ], + [ + "L", + 245 + ] + ], + [ + [ + "L", + 245 + ], + [ + "L", + 240 + ] + ] + ], + "start": 10519, + "swap_starts": [ + 10519 + ] + }, + { + "cycles": [ + [ + [ + "L", + 240 + ], + [ + "L", + 243 + ] + ] + ], + "end": 10532, + "frame": 65, + "permutation": [ + [ + [ + "L", + 240 + ], + [ + "L", + 243 + ] + ], + [ + [ + "L", + 243 + ], + [ + "L", + 240 + ] + ] + ], + "start": 10528, + "swap_starts": [ + 10528 + ] + }, + { + "cycles": [ + [ + [ + "L", + 11 + ], + [ + "L", + 62 + ] + ], + [ + [ + "L", + 63 + ], + [ + "L", + 241 + ], + [ + "L", + 240 + ] + ] + ], + "end": 10612, + "frame": 65, + "permutation": [ + [ + [ + "L", + 11 + ], + [ + "L", + 62 + ] + ], + [ + [ + "L", + 62 + ], + [ + "L", + 11 + ] + ], + [ + [ + "L", + 63 + ], + [ + "L", + 241 + ] + ], + [ + [ + "L", + 240 + ], + [ + "L", + 63 + ] + ], + [ + [ + "L", + 241 + ], + [ + "L", + 240 + ] + ], + [ + [ + "L", + 250 + ], + [ + "L", + 250 + ] + ] + ], + "start": 10537, + "swap_starts": [ + 10537, + 10542, + 10547, + 10555, + 10576, + 10592, + 10604 + ] + }, + { + "cycles": [ + [ + [ + "L", + 256 + ], + [ + "L", + 261 + ] + ] + ], + "end": 10722, + "frame": 94, + "permutation": [ + [ + [ + "L", + 256 + ], + [ + "L", + 261 + ] + ], + [ + [ + "L", + 261 + ], + [ + "L", + 256 + ] + ] + ], + "start": 10718, + "swap_starts": [ + 10718 + ] + }, + { + "cycles": [ + [ + [ + "L", + 256 + ], + [ + "L", + 259 + ] + ] + ], + "end": 10731, + "frame": 94, + "permutation": [ + [ + [ + "L", + 256 + ], + [ + "L", + 259 + ] + ], + [ + [ + "L", + 259 + ], + [ + "L", + 256 + ] + ] + ], + "start": 10727, + "swap_starts": [ + 10727 + ] + }, + { + "cycles": [ + [ + [ + "L", + 9 + ], + [ + "L", + 94 + ] + ], + [ + [ + "L", + 61 + ], + [ + "L", + 257 + ], + [ + "L", + 256 + ] + ] + ], + "end": 10811, + "frame": 94, + "permutation": [ + [ + [ + "L", + 9 + ], + [ + "L", + 94 + ] + ], + [ + [ + "L", + 61 + ], + [ + "L", + 257 + ] + ], + [ + [ + "L", + 94 + ], + [ + "L", + 9 + ] + ], + [ + [ + "L", + 256 + ], + [ + "L", + 61 + ] + ], + [ + [ + "L", + 257 + ], + [ + "L", + 256 + ] + ], + [ + [ + "L", + 266 + ], + [ + "L", + 266 + ] + ] + ], + "start": 10736, + "swap_starts": [ + 10736, + 10741, + 10746, + 10754, + 10775, + 10791, + 10803 + ] + }, + { + "cycles": [ + [ + [ + "L", + 272 + ], + [ + "L", + 277 + ] + ] + ], + "end": 10921, + "frame": 123, + "permutation": [ + [ + [ + "L", + 272 + ], + [ + "L", + 277 + ] + ], + [ + [ + "L", + 277 + ], + [ + "L", + 272 + ] + ] + ], + "start": 10917, + "swap_starts": [ + 10917 + ] + }, + { + "cycles": [ + [ + [ + "L", + 272 + ], + [ + "L", + 275 + ] + ] + ], + "end": 10930, + "frame": 123, + "permutation": [ + [ + [ + "L", + 272 + ], + [ + "L", + 275 + ] + ], + [ + [ + "L", + 275 + ], + [ + "L", + 272 + ] + ] + ], + "start": 10926, + "swap_starts": [ + 10926 + ] + }, + { + "cycles": [ + [ + [ + "L", + 17 + ], + [ + "L", + 77 + ] + ], + [ + [ + "L", + 103 + ], + [ + "L", + 273 + ], + [ + "L", + 272 + ] + ] + ], + "end": 11011, + "frame": 123, + "permutation": [ + [ + [ + "L", + 17 + ], + [ + "L", + 77 + ] + ], + [ + [ + "L", + 77 + ], + [ + "L", + 17 + ] + ], + [ + [ + "L", + 103 + ], + [ + "L", + 273 + ] + ], + [ + [ + "L", + 272 + ], + [ + "L", + 103 + ] + ], + [ + [ + "L", + 273 + ], + [ + "L", + 272 + ] + ], + [ + [ + "L", + 282 + ], + [ + "L", + 282 + ] + ] + ], + "start": 10935, + "swap_starts": [ + 10935, + 10940, + 10945, + 10953, + 10974, + 10991, + 11003 + ] + }, + { + "cycles": [ + [ + [ + "L", + 288 + ], + [ + "L", + 293 + ] + ] + ], + "end": 11121, + "frame": 152, + "permutation": [ + [ + [ + "L", + 288 + ], + [ + "L", + 293 + ] + ], + [ + [ + "L", + 293 + ], + [ + "L", + 288 + ] + ] + ], + "start": 11117, + "swap_starts": [ + 11117 + ] + }, + { + "cycles": [ + [ + [ + "L", + 288 + ], + [ + "L", + 291 + ] + ] + ], + "end": 11130, + "frame": 152, + "permutation": [ + [ + [ + "L", + 288 + ], + [ + "L", + 291 + ] + ], + [ + [ + "L", + 291 + ], + [ + "L", + 288 + ] + ] + ], + "start": 11126, + "swap_starts": [ + 11126 + ] + }, + { + "cycles": [ + [ + [ + "L", + 18 + ], + [ + "L", + 289 + ], + [ + "L", + 288 + ] + ], + [ + [ + "L", + 39 + ], + [ + "L", + 40 + ] + ] + ], + "end": 11211, + "frame": 152, + "permutation": [ + [ + [ + "L", + 18 + ], + [ + "L", + 289 + ] + ], + [ + [ + "L", + 39 + ], + [ + "L", + 40 + ] + ], + [ + [ + "L", + 40 + ], + [ + "L", + 39 + ] + ], + [ + [ + "L", + 288 + ], + [ + "L", + 18 + ] + ], + [ + [ + "L", + 289 + ], + [ + "L", + 288 + ] + ], + [ + [ + "L", + 298 + ], + [ + "L", + 298 + ] + ] + ], + "start": 11135, + "swap_starts": [ + 11135, + 11140, + 11145, + 11153, + 11174, + 11191, + 11203 + ] + }, + { + "cycles": [ + [ + [ + "L", + 304 + ], + [ + "L", + 309 + ] + ] + ], + "end": 11321, + "frame": 181, + "permutation": [ + [ + [ + "L", + 304 + ], + [ + "L", + 309 + ] + ], + [ + [ + "L", + 309 + ], + [ + "L", + 304 + ] + ] + ], + "start": 11317, + "swap_starts": [ + 11317 + ] + }, + { + "cycles": [ + [ + [ + "L", + 304 + ], + [ + "L", + 307 + ] + ] + ], + "end": 11330, + "frame": 181, + "permutation": [ + [ + [ + "L", + 304 + ], + [ + "L", + 307 + ] + ], + [ + [ + "L", + 307 + ], + [ + "L", + 304 + ] + ] + ], + "start": 11326, + "swap_starts": [ + 11326 + ] + }, + { + "cycles": [ + [ + [ + "L", + 35 + ], + [ + "L", + 107 + ] + ], + [ + [ + "L", + 45 + ], + [ + "L", + 305 + ], + [ + "L", + 304 + ] + ] + ], + "end": 11411, + "frame": 181, + "permutation": [ + [ + [ + "L", + 35 + ], + [ + "L", + 107 + ] + ], + [ + [ + "L", + 45 + ], + [ + "L", + 305 + ] + ], + [ + [ + "L", + 107 + ], + [ + "L", + 35 + ] + ], + [ + [ + "L", + 304 + ], + [ + "L", + 45 + ] + ], + [ + [ + "L", + 305 + ], + [ + "L", + 304 + ] + ], + [ + [ + "L", + 314 + ], + [ + "L", + 314 + ] + ] + ], + "start": 11335, + "swap_starts": [ + 11335, + 11340, + 11345, + 11353, + 11374, + 11391, + 11403 + ] + }, + { + "cycles": [ + [ + [ + "L", + 320 + ], + [ + "L", + 325 + ] + ] + ], + "end": 11521, + "frame": 210, + "permutation": [ + [ + [ + "L", + 320 + ], + [ + "L", + 325 + ] + ], + [ + [ + "L", + 325 + ], + [ + "L", + 320 + ] + ] + ], + "start": 11517, + "swap_starts": [ + 11517 + ] + }, + { + "cycles": [ + [ + [ + "L", + 320 + ], + [ + "L", + 323 + ] + ] + ], + "end": 11530, + "frame": 210, + "permutation": [ + [ + [ + "L", + 320 + ], + [ + "L", + 323 + ] + ], + [ + [ + "L", + 323 + ], + [ + "L", + 320 + ] + ] + ], + "start": 11526, + "swap_starts": [ + 11526 + ] + }, + { + "cycles": [ + [ + [ + "L", + 22 + ], + [ + "L", + 23 + ] + ], + [ + [ + "L", + 108 + ], + [ + "L", + 321 + ], + [ + "L", + 320 + ] + ] + ], + "end": 11611, + "frame": 210, + "permutation": [ + [ + [ + "L", + 22 + ], + [ + "L", + 23 + ] + ], + [ + [ + "L", + 23 + ], + [ + "L", + 22 + ] + ], + [ + [ + "L", + 108 + ], + [ + "L", + 321 + ] + ], + [ + [ + "L", + 320 + ], + [ + "L", + 108 + ] + ], + [ + [ + "L", + 321 + ], + [ + "L", + 320 + ] + ], + [ + [ + "L", + 330 + ], + [ + "L", + 330 + ] + ] + ], + "start": 11535, + "swap_starts": [ + 11535, + 11540, + 11545, + 11553, + 11574, + 11591, + 11603 + ] + }, + { + "cycles": [ + [ + [ + "L", + 336 + ], + [ + "L", + 341 + ] + ] + ], + "end": 11721, + "frame": 239, + "permutation": [ + [ + [ + "L", + 336 + ], + [ + "L", + 341 + ] + ], + [ + [ + "L", + 341 + ], + [ + "L", + 336 + ] + ] + ], + "start": 11717, + "swap_starts": [ + 11717 + ] + }, + { + "cycles": [ + [ + [ + "L", + 336 + ], + [ + "L", + 339 + ] + ] + ], + "end": 11730, + "frame": 239, + "permutation": [ + [ + [ + "L", + 336 + ], + [ + "L", + 339 + ] + ], + [ + [ + "L", + 339 + ], + [ + "L", + 336 + ] + ] + ], + "start": 11726, + "swap_starts": [ + 11726 + ] + }, + { + "cycles": [ + [ + [ + "L", + 58 + ], + [ + "L", + 86 + ] + ], + [ + [ + "L", + 93 + ], + [ + "L", + 337 + ], + [ + "L", + 336 + ] + ] + ], + "end": 11811, + "frame": 239, + "permutation": [ + [ + [ + "L", + 58 + ], + [ + "L", + 86 + ] + ], + [ + [ + "L", + 86 + ], + [ + "L", + 58 + ] + ], + [ + [ + "L", + 93 + ], + [ + "L", + 337 + ] + ], + [ + [ + "L", + 336 + ], + [ + "L", + 93 + ] + ], + [ + [ + "L", + 337 + ], + [ + "L", + 336 + ] + ], + [ + [ + "L", + 346 + ], + [ + "L", + 346 + ] + ] + ], + "start": 11735, + "swap_starts": [ + 11735, + 11740, + 11745, + 11753, + 11774, + 11791, + 11803 + ] + }, + { + "cycles": [ + [ + [ + "L", + 352 + ], + [ + "L", + 357 + ] + ] + ], + "end": 11921, + "frame": 268, + "permutation": [ + [ + [ + "L", + 352 + ], + [ + "L", + 357 + ] + ], + [ + [ + "L", + 357 + ], + [ + "L", + 352 + ] + ] + ], + "start": 11917, + "swap_starts": [ + 11917 + ] + }, + { + "cycles": [ + [ + [ + "L", + 352 + ], + [ + "L", + 355 + ] + ] + ], + "end": 11930, + "frame": 268, + "permutation": [ + [ + [ + "L", + 352 + ], + [ + "L", + 355 + ] + ], + [ + [ + "L", + 355 + ], + [ + "L", + 352 + ] + ] + ], + "start": 11926, + "swap_starts": [ + 11926 + ] + }, + { + "cycles": [ + [ + [ + "L", + 29 + ], + [ + "L", + 30 + ] + ], + [ + [ + "L", + 59 + ], + [ + "L", + 353 + ], + [ + "L", + 352 + ] + ] + ], + "end": 12011, + "frame": 268, + "permutation": [ + [ + [ + "L", + 29 + ], + [ + "L", + 30 + ] + ], + [ + [ + "L", + 30 + ], + [ + "L", + 29 + ] + ], + [ + [ + "L", + 59 + ], + [ + "L", + 353 + ] + ], + [ + [ + "L", + 352 + ], + [ + "L", + 59 + ] + ], + [ + [ + "L", + 353 + ], + [ + "L", + 352 + ] + ], + [ + [ + "L", + 362 + ], + [ + "L", + 362 + ] + ] + ], + "start": 11935, + "swap_starts": [ + 11935, + 11940, + 11945, + 11953, + 11974, + 11991, + 12003 + ] + }, + { + "cycles": [ + [ + [ + "L", + 368 + ], + [ + "L", + 373 + ] + ] + ], + "end": 12121, + "frame": 297, + "permutation": [ + [ + [ + "L", + 368 + ], + [ + "L", + 373 + ] + ], + [ + [ + "L", + 373 + ], + [ + "L", + 368 + ] + ] + ], + "start": 12117, + "swap_starts": [ + 12117 + ] + }, + { + "cycles": [ + [ + [ + "L", + 368 + ], + [ + "L", + 371 + ] + ] + ], + "end": 12130, + "frame": 297, + "permutation": [ + [ + [ + "L", + 368 + ], + [ + "L", + 371 + ] + ], + [ + [ + "L", + 371 + ], + [ + "L", + 368 + ] + ] + ], + "start": 12126, + "swap_starts": [ + 12126 + ] + }, + { + "cycles": [ + [ + [ + "L", + 8 + ], + [ + "L", + 369 + ], + [ + "L", + 368 + ] + ], + [ + [ + "L", + 26 + ], + [ + "L", + 95 + ] + ] + ], + "end": 12211, + "frame": 297, + "permutation": [ + [ + [ + "L", + 8 + ], + [ + "L", + 369 + ] + ], + [ + [ + "L", + 26 + ], + [ + "L", + 95 + ] + ], + [ + [ + "L", + 95 + ], + [ + "L", + 26 + ] + ], + [ + [ + "L", + 368 + ], + [ + "L", + 8 + ] + ], + [ + [ + "L", + 369 + ], + [ + "L", + 368 + ] + ], + [ + [ + "L", + 378 + ], + [ + "L", + 378 + ] + ] + ], + "start": 12135, + "swap_starts": [ + 12135, + 12140, + 12145, + 12153, + 12174, + 12191, + 12203 + ] + }, + { + "cycles": [ + [ + [ + "L", + 384 + ], + [ + "L", + 389 + ] + ] + ], + "end": 12321, + "frame": 326, + "permutation": [ + [ + [ + "L", + 384 + ], + [ + "L", + 389 + ] + ], + [ + [ + "L", + 389 + ], + [ + "L", + 384 + ] + ] + ], + "start": 12317, + "swap_starts": [ + 12317 + ] + }, + { + "cycles": [ + [ + [ + "L", + 384 + ], + [ + "L", + 387 + ] + ] + ], + "end": 12330, + "frame": 326, + "permutation": [ + [ + [ + "L", + 384 + ], + [ + "L", + 387 + ] + ], + [ + [ + "L", + 387 + ], + [ + "L", + 384 + ] + ] + ], + "start": 12326, + "swap_starts": [ + 12326 + ] + }, + { + "cycles": [ + [ + [ + "L", + 64 + ], + [ + "L", + 65 + ] + ], + [ + [ + "L", + 96 + ], + [ + "L", + 385 + ], + [ + "L", + 384 + ] + ] + ], + "end": 12411, + "frame": 326, + "permutation": [ + [ + [ + "L", + 64 + ], + [ + "L", + 65 + ] + ], + [ + [ + "L", + 65 + ], + [ + "L", + 64 + ] + ], + [ + [ + "L", + 96 + ], + [ + "L", + 385 + ] + ], + [ + [ + "L", + 384 + ], + [ + "L", + 96 + ] + ], + [ + [ + "L", + 385 + ], + [ + "L", + 384 + ] + ], + [ + [ + "L", + 394 + ], + [ + "L", + 394 + ] + ] + ], + "start": 12335, + "swap_starts": [ + 12335, + 12340, + 12345, + 12353, + 12374, + 12391, + 12403 + ] + }, + { + "cycles": [ + [ + [ + "L", + 400 + ], + [ + "L", + 405 + ] + ] + ], + "end": 12521, + "frame": 355, + "permutation": [ + [ + [ + "L", + 400 + ], + [ + "L", + 405 + ] + ], + [ + [ + "L", + 405 + ], + [ + "L", + 400 + ] + ] + ], + "start": 12517, + "swap_starts": [ + 12517 + ] + }, + { + "cycles": [ + [ + [ + "L", + 400 + ], + [ + "L", + 403 + ] + ] + ], + "end": 12530, + "frame": 355, + "permutation": [ + [ + [ + "L", + 400 + ], + [ + "L", + 403 + ] + ], + [ + [ + "L", + 403 + ], + [ + "L", + 400 + ] + ] + ], + "start": 12526, + "swap_starts": [ + 12526 + ] + }, + { + "cycles": [ + [ + [ + "L", + 41 + ], + [ + "L", + 401 + ], + [ + "L", + 400 + ] + ], + [ + [ + "L", + 42 + ], + [ + "L", + 106 + ] + ] + ], + "end": 12610, + "frame": 355, + "permutation": [ + [ + [ + "L", + 41 + ], + [ + "L", + 401 + ] + ], + [ + [ + "L", + 42 + ], + [ + "L", + 106 + ] + ], + [ + [ + "L", + 106 + ], + [ + "L", + 42 + ] + ], + [ + [ + "L", + 400 + ], + [ + "L", + 41 + ] + ], + [ + [ + "L", + 401 + ], + [ + "L", + 400 + ] + ], + [ + [ + "L", + 410 + ], + [ + "L", + 410 + ] + ] + ], + "start": 12535, + "swap_starts": [ + 12535, + 12540, + 12545, + 12553, + 12574, + 12590, + 12602 + ] + }, + { + "cycles": [ + [ + [ + "L", + 416 + ], + [ + "L", + 421 + ] + ] + ], + "end": 12720, + "frame": 384, + "permutation": [ + [ + [ + "L", + 416 + ], + [ + "L", + 421 + ] + ], + [ + [ + "L", + 421 + ], + [ + "L", + 416 + ] + ] + ], + "start": 12716, + "swap_starts": [ + 12716 + ] + }, + { + "cycles": [ + [ + [ + "L", + 416 + ], + [ + "L", + 419 + ] + ] + ], + "end": 12729, + "frame": 384, + "permutation": [ + [ + [ + "L", + 416 + ], + [ + "L", + 419 + ] + ], + [ + [ + "L", + 419 + ], + [ + "L", + 416 + ] + ] + ], + "start": 12725, + "swap_starts": [ + 12725 + ] + }, + { + "cycles": [ + [ + [ + "L", + 16 + ], + [ + "L", + 104 + ] + ], + [ + [ + "L", + 43 + ], + [ + "L", + 417 + ], + [ + "L", + 416 + ] + ] + ], + "end": 12809, + "frame": 384, + "permutation": [ + [ + [ + "L", + 16 + ], + [ + "L", + 104 + ] + ], + [ + [ + "L", + 43 + ], + [ + "L", + 417 + ] + ], + [ + [ + "L", + 104 + ], + [ + "L", + 16 + ] + ], + [ + [ + "L", + 416 + ], + [ + "L", + 43 + ] + ], + [ + [ + "L", + 417 + ], + [ + "L", + 416 + ] + ], + [ + [ + "L", + 426 + ], + [ + "L", + 426 + ] + ] + ], + "start": 12734, + "swap_starts": [ + 12734, + 12739, + 12744, + 12752, + 12773, + 12789, + 12801 + ] + }, + { + "cycles": [ + [ + [ + "L", + 432 + ], + [ + "L", + 437 + ] + ] + ], + "end": 12919, + "frame": 413, + "permutation": [ + [ + [ + "L", + 432 + ], + [ + "L", + 437 + ] + ], + [ + [ + "L", + 437 + ], + [ + "L", + 432 + ] + ] + ], + "start": 12915, + "swap_starts": [ + 12915 + ] + }, + { + "cycles": [ + [ + [ + "L", + 432 + ], + [ + "L", + 435 + ] + ] + ], + "end": 12928, + "frame": 413, + "permutation": [ + [ + [ + "L", + 432 + ], + [ + "L", + 435 + ] + ], + [ + [ + "L", + 435 + ], + [ + "L", + 432 + ] + ] + ], + "start": 12924, + "swap_starts": [ + 12924 + ] + }, + { + "cycles": [ + [ + [ + "L", + 20 + ], + [ + "L", + 110 + ] + ], + [ + [ + "L", + 37 + ], + [ + "L", + 433 + ], + [ + "L", + 432 + ] + ] + ], + "end": 13008, + "frame": 413, + "permutation": [ + [ + [ + "L", + 20 + ], + [ + "L", + 110 + ] + ], + [ + [ + "L", + 37 + ], + [ + "L", + 433 + ] + ], + [ + [ + "L", + 110 + ], + [ + "L", + 20 + ] + ], + [ + [ + "L", + 432 + ], + [ + "L", + 37 + ] + ], + [ + [ + "L", + 433 + ], + [ + "L", + 432 + ] + ], + [ + [ + "L", + 442 + ], + [ + "L", + 442 + ] + ] + ], + "start": 12933, + "swap_starts": [ + 12933, + 12938, + 12943, + 12951, + 12972, + 12988, + 13000 + ] + } + ], + "real_primitive_penalty_at_least": 28, + "scratch_component_cost": 224, + "scratch_free_component_lower_bound": 238, + "scratch_free_component_upper_bound": 252, + "two_cycles": 28, + "two_plus_three_cycles": 14 + }, + "jp8/forward": { + "boundaries": [ + { + "cycles": [ + [ + [ + "L", + 224 + ], + [ + "L", + 229 + ] + ] + ], + "end": 10324, + "frame": 36, + "permutation": [ + [ + [ + "L", + 224 + ], + [ + "L", + 229 + ] + ], + [ + [ + "L", + 229 + ], + [ + "L", + 224 + ] + ] + ], + "start": 10320, + "swap_starts": [ + 10320 + ] + }, + { + "cycles": [ + [ + [ + "L", + 224 + ], + [ + "L", + 227 + ] + ] + ], + "end": 10333, + "frame": 36, + "permutation": [ + [ + [ + "L", + 224 + ], + [ + "L", + 227 + ] + ], + [ + [ + "L", + 227 + ], + [ + "L", + 224 + ] + ] + ], + "start": 10329, + "swap_starts": [ + 10329 + ] + }, + { + "cycles": [ + [ + [ + "L", + 57 + ], + [ + "L", + 81 + ] + ], + [ + [ + "L", + 92 + ], + [ + "L", + 225 + ], + [ + "L", + 224 + ] + ] + ], + "end": 10413, + "frame": 36, + "permutation": [ + [ + [ + "L", + 57 + ], + [ + "L", + 81 + ] + ], + [ + [ + "L", + 81 + ], + [ + "L", + 57 + ] + ], + [ + [ + "L", + 92 + ], + [ + "L", + 225 + ] + ], + [ + [ + "L", + 224 + ], + [ + "L", + 92 + ] + ], + [ + [ + "L", + 225 + ], + [ + "L", + 224 + ] + ], + [ + [ + "L", + 234 + ], + [ + "L", + 234 + ] + ] + ], + "start": 10338, + "swap_starts": [ + 10338, + 10343, + 10348, + 10356, + 10377, + 10393, + 10405 + ] + }, + { + "cycles": [ + [ + [ + "L", + 240 + ], + [ + "L", + 245 + ] + ] + ], + "end": 10523, + "frame": 65, + "permutation": [ + [ + [ + "L", + 240 + ], + [ + "L", + 245 + ] + ], + [ + [ + "L", + 245 + ], + [ + "L", + 240 + ] + ] + ], + "start": 10519, + "swap_starts": [ + 10519 + ] + }, + { + "cycles": [ + [ + [ + "L", + 240 + ], + [ + "L", + 243 + ] + ] + ], + "end": 10532, + "frame": 65, + "permutation": [ + [ + [ + "L", + 240 + ], + [ + "L", + 243 + ] + ], + [ + [ + "L", + 243 + ], + [ + "L", + 240 + ] + ] + ], + "start": 10528, + "swap_starts": [ + 10528 + ] + }, + { + "cycles": [ + [ + [ + "L", + 11 + ], + [ + "L", + 62 + ] + ], + [ + [ + "L", + 63 + ], + [ + "L", + 241 + ], + [ + "L", + 240 + ] + ] + ], + "end": 10612, + "frame": 65, + "permutation": [ + [ + [ + "L", + 11 + ], + [ + "L", + 62 + ] + ], + [ + [ + "L", + 62 + ], + [ + "L", + 11 + ] + ], + [ + [ + "L", + 63 + ], + [ + "L", + 241 + ] + ], + [ + [ + "L", + 240 + ], + [ + "L", + 63 + ] + ], + [ + [ + "L", + 241 + ], + [ + "L", + 240 + ] + ], + [ + [ + "L", + 250 + ], + [ + "L", + 250 + ] + ] + ], + "start": 10537, + "swap_starts": [ + 10537, + 10542, + 10547, + 10555, + 10576, + 10592, + 10604 + ] + }, + { + "cycles": [ + [ + [ + "L", + 256 + ], + [ + "L", + 261 + ] + ] + ], + "end": 10722, + "frame": 94, + "permutation": [ + [ + [ + "L", + 256 + ], + [ + "L", + 261 + ] + ], + [ + [ + "L", + 261 + ], + [ + "L", + 256 + ] + ] + ], + "start": 10718, + "swap_starts": [ + 10718 + ] + }, + { + "cycles": [ + [ + [ + "L", + 256 + ], + [ + "L", + 259 + ] + ] + ], + "end": 10731, + "frame": 94, + "permutation": [ + [ + [ + "L", + 256 + ], + [ + "L", + 259 + ] + ], + [ + [ + "L", + 259 + ], + [ + "L", + 256 + ] + ] + ], + "start": 10727, + "swap_starts": [ + 10727 + ] + }, + { + "cycles": [ + [ + [ + "L", + 9 + ], + [ + "L", + 94 + ] + ], + [ + [ + "L", + 61 + ], + [ + "L", + 257 + ], + [ + "L", + 256 + ] + ] + ], + "end": 10811, + "frame": 94, + "permutation": [ + [ + [ + "L", + 9 + ], + [ + "L", + 94 + ] + ], + [ + [ + "L", + 61 + ], + [ + "L", + 257 + ] + ], + [ + [ + "L", + 94 + ], + [ + "L", + 9 + ] + ], + [ + [ + "L", + 256 + ], + [ + "L", + 61 + ] + ], + [ + [ + "L", + 257 + ], + [ + "L", + 256 + ] + ], + [ + [ + "L", + 266 + ], + [ + "L", + 266 + ] + ] + ], + "start": 10736, + "swap_starts": [ + 10736, + 10741, + 10746, + 10754, + 10775, + 10791, + 10803 + ] + }, + { + "cycles": [ + [ + [ + "L", + 272 + ], + [ + "L", + 277 + ] + ] + ], + "end": 10921, + "frame": 123, + "permutation": [ + [ + [ + "L", + 272 + ], + [ + "L", + 277 + ] + ], + [ + [ + "L", + 277 + ], + [ + "L", + 272 + ] + ] + ], + "start": 10917, + "swap_starts": [ + 10917 + ] + }, + { + "cycles": [ + [ + [ + "L", + 272 + ], + [ + "L", + 275 + ] + ] + ], + "end": 10930, + "frame": 123, + "permutation": [ + [ + [ + "L", + 272 + ], + [ + "L", + 275 + ] + ], + [ + [ + "L", + 275 + ], + [ + "L", + 272 + ] + ] + ], + "start": 10926, + "swap_starts": [ + 10926 + ] + }, + { + "cycles": [ + [ + [ + "L", + 17 + ], + [ + "L", + 77 + ] + ], + [ + [ + "L", + 103 + ], + [ + "L", + 273 + ], + [ + "L", + 272 + ] + ] + ], + "end": 11011, + "frame": 123, + "permutation": [ + [ + [ + "L", + 17 + ], + [ + "L", + 77 + ] + ], + [ + [ + "L", + 77 + ], + [ + "L", + 17 + ] + ], + [ + [ + "L", + 103 + ], + [ + "L", + 273 + ] + ], + [ + [ + "L", + 272 + ], + [ + "L", + 103 + ] + ], + [ + [ + "L", + 273 + ], + [ + "L", + 272 + ] + ], + [ + [ + "L", + 282 + ], + [ + "L", + 282 + ] + ] + ], + "start": 10935, + "swap_starts": [ + 10935, + 10940, + 10945, + 10953, + 10974, + 10991, + 11003 + ] + }, + { + "cycles": [ + [ + [ + "L", + 288 + ], + [ + "L", + 293 + ] + ] + ], + "end": 11121, + "frame": 152, + "permutation": [ + [ + [ + "L", + 288 + ], + [ + "L", + 293 + ] + ], + [ + [ + "L", + 293 + ], + [ + "L", + 288 + ] + ] + ], + "start": 11117, + "swap_starts": [ + 11117 + ] + }, + { + "cycles": [ + [ + [ + "L", + 288 + ], + [ + "L", + 291 + ] + ] + ], + "end": 11130, + "frame": 152, + "permutation": [ + [ + [ + "L", + 288 + ], + [ + "L", + 291 + ] + ], + [ + [ + "L", + 291 + ], + [ + "L", + 288 + ] + ] + ], + "start": 11126, + "swap_starts": [ + 11126 + ] + }, + { + "cycles": [ + [ + [ + "L", + 18 + ], + [ + "L", + 289 + ], + [ + "L", + 288 + ] + ], + [ + [ + "L", + 39 + ], + [ + "L", + 40 + ] + ] + ], + "end": 11211, + "frame": 152, + "permutation": [ + [ + [ + "L", + 18 + ], + [ + "L", + 289 + ] + ], + [ + [ + "L", + 39 + ], + [ + "L", + 40 + ] + ], + [ + [ + "L", + 40 + ], + [ + "L", + 39 + ] + ], + [ + [ + "L", + 288 + ], + [ + "L", + 18 + ] + ], + [ + [ + "L", + 289 + ], + [ + "L", + 288 + ] + ], + [ + [ + "L", + 298 + ], + [ + "L", + 298 + ] + ] + ], + "start": 11135, + "swap_starts": [ + 11135, + 11140, + 11145, + 11153, + 11174, + 11191, + 11203 + ] + }, + { + "cycles": [ + [ + [ + "L", + 304 + ], + [ + "L", + 309 + ] + ] + ], + "end": 11321, + "frame": 181, + "permutation": [ + [ + [ + "L", + 304 + ], + [ + "L", + 309 + ] + ], + [ + [ + "L", + 309 + ], + [ + "L", + 304 + ] + ] + ], + "start": 11317, + "swap_starts": [ + 11317 + ] + }, + { + "cycles": [ + [ + [ + "L", + 304 + ], + [ + "L", + 307 + ] + ] + ], + "end": 11330, + "frame": 181, + "permutation": [ + [ + [ + "L", + 304 + ], + [ + "L", + 307 + ] + ], + [ + [ + "L", + 307 + ], + [ + "L", + 304 + ] + ] + ], + "start": 11326, + "swap_starts": [ + 11326 + ] + }, + { + "cycles": [ + [ + [ + "L", + 35 + ], + [ + "L", + 107 + ] + ], + [ + [ + "L", + 45 + ], + [ + "L", + 305 + ], + [ + "L", + 304 + ] + ] + ], + "end": 11411, + "frame": 181, + "permutation": [ + [ + [ + "L", + 35 + ], + [ + "L", + 107 + ] + ], + [ + [ + "L", + 45 + ], + [ + "L", + 305 + ] + ], + [ + [ + "L", + 107 + ], + [ + "L", + 35 + ] + ], + [ + [ + "L", + 304 + ], + [ + "L", + 45 + ] + ], + [ + [ + "L", + 305 + ], + [ + "L", + 304 + ] + ], + [ + [ + "L", + 314 + ], + [ + "L", + 314 + ] + ] + ], + "start": 11335, + "swap_starts": [ + 11335, + 11340, + 11345, + 11353, + 11374, + 11391, + 11403 + ] + }, + { + "cycles": [ + [ + [ + "L", + 320 + ], + [ + "L", + 325 + ] + ] + ], + "end": 11521, + "frame": 210, + "permutation": [ + [ + [ + "L", + 320 + ], + [ + "L", + 325 + ] + ], + [ + [ + "L", + 325 + ], + [ + "L", + 320 + ] + ] + ], + "start": 11517, + "swap_starts": [ + 11517 + ] + }, + { + "cycles": [ + [ + [ + "L", + 320 + ], + [ + "L", + 323 + ] + ] + ], + "end": 11530, + "frame": 210, + "permutation": [ + [ + [ + "L", + 320 + ], + [ + "L", + 323 + ] + ], + [ + [ + "L", + 323 + ], + [ + "L", + 320 + ] + ] + ], + "start": 11526, + "swap_starts": [ + 11526 + ] + }, + { + "cycles": [ + [ + [ + "L", + 22 + ], + [ + "L", + 23 + ] + ], + [ + [ + "L", + 108 + ], + [ + "L", + 321 + ], + [ + "L", + 320 + ] + ] + ], + "end": 11611, + "frame": 210, + "permutation": [ + [ + [ + "L", + 22 + ], + [ + "L", + 23 + ] + ], + [ + [ + "L", + 23 + ], + [ + "L", + 22 + ] + ], + [ + [ + "L", + 108 + ], + [ + "L", + 321 + ] + ], + [ + [ + "L", + 320 + ], + [ + "L", + 108 + ] + ], + [ + [ + "L", + 321 + ], + [ + "L", + 320 + ] + ], + [ + [ + "L", + 330 + ], + [ + "L", + 330 + ] + ] + ], + "start": 11535, + "swap_starts": [ + 11535, + 11540, + 11545, + 11553, + 11574, + 11591, + 11603 + ] + }, + { + "cycles": [ + [ + [ + "L", + 336 + ], + [ + "L", + 341 + ] + ] + ], + "end": 11721, + "frame": 239, + "permutation": [ + [ + [ + "L", + 336 + ], + [ + "L", + 341 + ] + ], + [ + [ + "L", + 341 + ], + [ + "L", + 336 + ] + ] + ], + "start": 11717, + "swap_starts": [ + 11717 + ] + }, + { + "cycles": [ + [ + [ + "L", + 336 + ], + [ + "L", + 339 + ] + ] + ], + "end": 11730, + "frame": 239, + "permutation": [ + [ + [ + "L", + 336 + ], + [ + "L", + 339 + ] + ], + [ + [ + "L", + 339 + ], + [ + "L", + 336 + ] + ] + ], + "start": 11726, + "swap_starts": [ + 11726 + ] + }, + { + "cycles": [ + [ + [ + "L", + 58 + ], + [ + "L", + 86 + ] + ], + [ + [ + "L", + 93 + ], + [ + "L", + 337 + ], + [ + "L", + 336 + ] + ] + ], + "end": 11811, + "frame": 239, + "permutation": [ + [ + [ + "L", + 58 + ], + [ + "L", + 86 + ] + ], + [ + [ + "L", + 86 + ], + [ + "L", + 58 + ] + ], + [ + [ + "L", + 93 + ], + [ + "L", + 337 + ] + ], + [ + [ + "L", + 336 + ], + [ + "L", + 93 + ] + ], + [ + [ + "L", + 337 + ], + [ + "L", + 336 + ] + ], + [ + [ + "L", + 346 + ], + [ + "L", + 346 + ] + ] + ], + "start": 11735, + "swap_starts": [ + 11735, + 11740, + 11745, + 11753, + 11774, + 11791, + 11803 + ] + }, + { + "cycles": [ + [ + [ + "L", + 352 + ], + [ + "L", + 357 + ] + ] + ], + "end": 11921, + "frame": 268, + "permutation": [ + [ + [ + "L", + 352 + ], + [ + "L", + 357 + ] + ], + [ + [ + "L", + 357 + ], + [ + "L", + 352 + ] + ] + ], + "start": 11917, + "swap_starts": [ + 11917 + ] + }, + { + "cycles": [ + [ + [ + "L", + 352 + ], + [ + "L", + 355 + ] + ] + ], + "end": 11930, + "frame": 268, + "permutation": [ + [ + [ + "L", + 352 + ], + [ + "L", + 355 + ] + ], + [ + [ + "L", + 355 + ], + [ + "L", + 352 + ] + ] + ], + "start": 11926, + "swap_starts": [ + 11926 + ] + }, + { + "cycles": [ + [ + [ + "L", + 29 + ], + [ + "L", + 30 + ] + ], + [ + [ + "L", + 59 + ], + [ + "L", + 353 + ], + [ + "L", + 352 + ] + ] + ], + "end": 12011, + "frame": 268, + "permutation": [ + [ + [ + "L", + 29 + ], + [ + "L", + 30 + ] + ], + [ + [ + "L", + 30 + ], + [ + "L", + 29 + ] + ], + [ + [ + "L", + 59 + ], + [ + "L", + 353 + ] + ], + [ + [ + "L", + 352 + ], + [ + "L", + 59 + ] + ], + [ + [ + "L", + 353 + ], + [ + "L", + 352 + ] + ], + [ + [ + "L", + 362 + ], + [ + "L", + 362 + ] + ] + ], + "start": 11935, + "swap_starts": [ + 11935, + 11940, + 11945, + 11953, + 11974, + 11991, + 12003 + ] + }, + { + "cycles": [ + [ + [ + "L", + 368 + ], + [ + "L", + 373 + ] + ] + ], + "end": 12121, + "frame": 297, + "permutation": [ + [ + [ + "L", + 368 + ], + [ + "L", + 373 + ] + ], + [ + [ + "L", + 373 + ], + [ + "L", + 368 + ] + ] + ], + "start": 12117, + "swap_starts": [ + 12117 + ] + }, + { + "cycles": [ + [ + [ + "L", + 368 + ], + [ + "L", + 371 + ] + ] + ], + "end": 12130, + "frame": 297, + "permutation": [ + [ + [ + "L", + 368 + ], + [ + "L", + 371 + ] + ], + [ + [ + "L", + 371 + ], + [ + "L", + 368 + ] + ] + ], + "start": 12126, + "swap_starts": [ + 12126 + ] + }, + { + "cycles": [ + [ + [ + "L", + 8 + ], + [ + "L", + 369 + ], + [ + "L", + 368 + ] + ], + [ + [ + "L", + 26 + ], + [ + "L", + 95 + ] + ] + ], + "end": 12211, + "frame": 297, + "permutation": [ + [ + [ + "L", + 8 + ], + [ + "L", + 369 + ] + ], + [ + [ + "L", + 26 + ], + [ + "L", + 95 + ] + ], + [ + [ + "L", + 95 + ], + [ + "L", + 26 + ] + ], + [ + [ + "L", + 368 + ], + [ + "L", + 8 + ] + ], + [ + [ + "L", + 369 + ], + [ + "L", + 368 + ] + ], + [ + [ + "L", + 378 + ], + [ + "L", + 378 + ] + ] + ], + "start": 12135, + "swap_starts": [ + 12135, + 12140, + 12145, + 12153, + 12174, + 12191, + 12203 + ] + }, + { + "cycles": [ + [ + [ + "L", + 384 + ], + [ + "L", + 389 + ] + ] + ], + "end": 12321, + "frame": 326, + "permutation": [ + [ + [ + "L", + 384 + ], + [ + "L", + 389 + ] + ], + [ + [ + "L", + 389 + ], + [ + "L", + 384 + ] + ] + ], + "start": 12317, + "swap_starts": [ + 12317 + ] + }, + { + "cycles": [ + [ + [ + "L", + 384 + ], + [ + "L", + 387 + ] + ] + ], + "end": 12330, + "frame": 326, + "permutation": [ + [ + [ + "L", + 384 + ], + [ + "L", + 387 + ] + ], + [ + [ + "L", + 387 + ], + [ + "L", + 384 + ] + ] + ], + "start": 12326, + "swap_starts": [ + 12326 + ] + }, + { + "cycles": [ + [ + [ + "L", + 64 + ], + [ + "L", + 65 + ] + ], + [ + [ + "L", + 96 + ], + [ + "L", + 385 + ], + [ + "L", + 384 + ] + ] + ], + "end": 12411, + "frame": 326, + "permutation": [ + [ + [ + "L", + 64 + ], + [ + "L", + 65 + ] + ], + [ + [ + "L", + 65 + ], + [ + "L", + 64 + ] + ], + [ + [ + "L", + 96 + ], + [ + "L", + 385 + ] + ], + [ + [ + "L", + 384 + ], + [ + "L", + 96 + ] + ], + [ + [ + "L", + 385 + ], + [ + "L", + 384 + ] + ], + [ + [ + "L", + 394 + ], + [ + "L", + 394 + ] + ] + ], + "start": 12335, + "swap_starts": [ + 12335, + 12340, + 12345, + 12353, + 12374, + 12391, + 12403 + ] + }, + { + "cycles": [ + [ + [ + "L", + 400 + ], + [ + "L", + 405 + ] + ] + ], + "end": 12521, + "frame": 355, + "permutation": [ + [ + [ + "L", + 400 + ], + [ + "L", + 405 + ] + ], + [ + [ + "L", + 405 + ], + [ + "L", + 400 + ] + ] + ], + "start": 12517, + "swap_starts": [ + 12517 + ] + }, + { + "cycles": [ + [ + [ + "L", + 400 + ], + [ + "L", + 403 + ] + ] + ], + "end": 12530, + "frame": 355, + "permutation": [ + [ + [ + "L", + 400 + ], + [ + "L", + 403 + ] + ], + [ + [ + "L", + 403 + ], + [ + "L", + 400 + ] + ] + ], + "start": 12526, + "swap_starts": [ + 12526 + ] + }, + { + "cycles": [ + [ + [ + "L", + 41 + ], + [ + "L", + 401 + ], + [ + "L", + 400 + ] + ], + [ + [ + "L", + 42 + ], + [ + "L", + 106 + ] + ] + ], + "end": 12610, + "frame": 355, + "permutation": [ + [ + [ + "L", + 41 + ], + [ + "L", + 401 + ] + ], + [ + [ + "L", + 42 + ], + [ + "L", + 106 + ] + ], + [ + [ + "L", + 106 + ], + [ + "L", + 42 + ] + ], + [ + [ + "L", + 400 + ], + [ + "L", + 41 + ] + ], + [ + [ + "L", + 401 + ], + [ + "L", + 400 + ] + ], + [ + [ + "L", + 410 + ], + [ + "L", + 410 + ] + ] + ], + "start": 12535, + "swap_starts": [ + 12535, + 12540, + 12545, + 12553, + 12574, + 12590, + 12602 + ] + }, + { + "cycles": [ + [ + [ + "L", + 416 + ], + [ + "L", + 421 + ] + ] + ], + "end": 12720, + "frame": 384, + "permutation": [ + [ + [ + "L", + 416 + ], + [ + "L", + 421 + ] + ], + [ + [ + "L", + 421 + ], + [ + "L", + 416 + ] + ] + ], + "start": 12716, + "swap_starts": [ + 12716 + ] + }, + { + "cycles": [ + [ + [ + "L", + 416 + ], + [ + "L", + 419 + ] + ] + ], + "end": 12729, + "frame": 384, + "permutation": [ + [ + [ + "L", + 416 + ], + [ + "L", + 419 + ] + ], + [ + [ + "L", + 419 + ], + [ + "L", + 416 + ] + ] + ], + "start": 12725, + "swap_starts": [ + 12725 + ] + }, + { + "cycles": [ + [ + [ + "L", + 16 + ], + [ + "L", + 104 + ] + ], + [ + [ + "L", + 43 + ], + [ + "L", + 417 + ], + [ + "L", + 416 + ] + ] + ], + "end": 12809, + "frame": 384, + "permutation": [ + [ + [ + "L", + 16 + ], + [ + "L", + 104 + ] + ], + [ + [ + "L", + 43 + ], + [ + "L", + 417 + ] + ], + [ + [ + "L", + 104 + ], + [ + "L", + 16 + ] + ], + [ + [ + "L", + 416 + ], + [ + "L", + 43 + ] + ], + [ + [ + "L", + 417 + ], + [ + "L", + 416 + ] + ], + [ + [ + "L", + 426 + ], + [ + "L", + 426 + ] + ] + ], + "start": 12734, + "swap_starts": [ + 12734, + 12739, + 12744, + 12752, + 12773, + 12789, + 12801 + ] + }, + { + "cycles": [ + [ + [ + "L", + 432 + ], + [ + "L", + 437 + ] + ] + ], + "end": 12919, + "frame": 413, + "permutation": [ + [ + [ + "L", + 432 + ], + [ + "L", + 437 + ] + ], + [ + [ + "L", + 437 + ], + [ + "L", + 432 + ] + ] + ], + "start": 12915, + "swap_starts": [ + 12915 + ] + }, + { + "cycles": [ + [ + [ + "L", + 432 + ], + [ + "L", + 435 + ] + ] + ], + "end": 12928, + "frame": 413, + "permutation": [ + [ + [ + "L", + 432 + ], + [ + "L", + 435 + ] + ], + [ + [ + "L", + 435 + ], + [ + "L", + 432 + ] + ] + ], + "start": 12924, + "swap_starts": [ + 12924 + ] + }, + { + "cycles": [ + [ + [ + "L", + 20 + ], + [ + "L", + 110 + ] + ], + [ + [ + "L", + 37 + ], + [ + "L", + 433 + ], + [ + "L", + 432 + ] + ] + ], + "end": 13008, + "frame": 413, + "permutation": [ + [ + [ + "L", + 20 + ], + [ + "L", + 110 + ] + ], + [ + [ + "L", + 37 + ], + [ + "L", + 433 + ] + ], + [ + [ + "L", + 110 + ], + [ + "L", + 20 + ] + ], + [ + [ + "L", + 432 + ], + [ + "L", + 37 + ] + ], + [ + [ + "L", + 433 + ], + [ + "L", + 432 + ] + ], + [ + [ + "L", + 442 + ], + [ + "L", + 442 + ] + ] + ], + "start": 12933, + "swap_starts": [ + 12933, + 12938, + 12943, + 12951, + 12972, + 12988, + 13000 + ] + } + ], + "real_primitive_penalty_at_least": 28, + "scratch_component_cost": 224, + "scratch_free_component_lower_bound": 238, + "scratch_free_component_upper_bound": 252, + "two_cycles": 28, + "two_plus_three_cycles": 14 + } + }, + "status": "PASS_COMPLEX_SCRATCH_FREE_BOUNDARIES", + "witnesses": { + "2": { + "with_cost": 4, + "with_prefix_row_l1": "1", + "with_scratch": [ + [ + "copy", + 2, + 0 + ], + [ + "copy", + 0, + 1 + ], + [ + "copy", + 1, + 2 + ], + [ + "clear", + 2 + ] + ], + "without_cost": 4, + "without_prefix_row_l1": "2", + "without_scratch": [ + [ + "add", + 0, + 1 + ], + [ + "subtract", + 1, + 0 + ], + [ + "add", + 0, + 1 + ], + [ + "negate", + 1 + ] + ] + }, + "3": { + "with_cost": 5, + "with_prefix_row_l1": "1", + "with_scratch": [ + [ + "copy", + 3, + 0 + ], + [ + "copy", + 0, + 1 + ], + [ + "copy", + 1, + 2 + ], + [ + "copy", + 2, + 3 + ], + [ + "clear", + 3 + ] + ], + "without_cost": 6, + "without_prefix_row_l1": "3", + "without_scratch": [ + [ + "subtract", + 2, + 1 + ], + [ + "subtract", + 0, + 2 + ], + [ + "add", + 1, + 2 + ], + [ + "add", + 2, + 0 + ], + [ + "subtract", + 0, + 2 + ], + [ + "add", + 0, + 1 + ] + ] + }, + "5": { + "with_cost": 8, + "with_prefix_row_l1": "1", + "with_scratch": [ + [ + "copy", + 5, + 0 + ], + [ + "copy", + 0, + 1 + ], + [ + "copy", + 1, + 5 + ], + [ + "copy", + 5, + 2 + ], + [ + "copy", + 2, + 3 + ], + [ + "copy", + 3, + 4 + ], + [ + "copy", + 4, + 5 + ], + [ + "clear", + 5 + ] + ], + "without_cost": 10, + "without_prefix_row_l1": "3", + "without_scratch": [ + [ + "add", + 0, + 1 + ], + [ + "subtract", + 1, + 0 + ], + [ + "add", + 0, + 1 + ], + [ + "negate", + 1 + ], + [ + "subtract", + 4, + 3 + ], + [ + "subtract", + 2, + 4 + ], + [ + "add", + 3, + 4 + ], + [ + "add", + 4, + 2 + ], + [ + "subtract", + 2, + 4 + ], + [ + "add", + 2, + 3 + ] + ] + } + } +} diff --git a/research/complex-scratch-free-boundaries/NOTICE.md b/research/complex-scratch-free-boundaries/NOTICE.md new file mode 100644 index 0000000000..4a971efdee --- /dev/null +++ b/research/complex-scratch-free-boundaries/NOTICE.md @@ -0,0 +1,25 @@ +# Attribution and scope + +New search, independent implementation, controls and exposition: prepared for +Ross Richardson (@RossRichardson) with substantial OpenAI Codex assistance. +Both implementations were AI-assisted; no independent human review is claimed. +New material is covered by the repository's Apache-2.0 license. + +This builds on Eva Ayala / ToikY's PR971 deferred-permutation construction and +retained source census (`b4cb9709ac48e69002a25607e1ecc2ed8452d5b3`), and addresses +a different interface from woklerx's PR1095 monomial-prefix lower-bound audit +(`1db482a6cb63ae49cf156357ef98b8e4b676fcd9`, metadata inspected, no code imported). +PR971's eight-operation construction and source evidence retain their authorship. + +Sagar Thakrar's PR696 defines the inherited real primitive vocabulary and +lowering. Chafik Boukhalfa's PR626 and Jeremy Kothe's PR622 provide the historical +CK/JP8 words and retained interfaces. Credit also remains with icekylinx's +scalar/coefficient-work/gauge lineage, PR839's known-zero-work principle, +DreamingOfClouds, eumemic, Rohan Arun and the original notices in their packages. +Source-byte pins, original PR622/626 heads and the exact research base are in +SOURCES.json. No predecessor executable code is imported by the new search. + +Elementary permutation identities and modular group search are not claimed +as novel general techniques. The contribution is the source-bound finite +exclusion for the specified scratch-free boundary class. This contribution +does not edit the selected supplier, current frontier or upstream files. diff --git a/research/complex-scratch-free-boundaries/PROOF.md b/research/complex-scratch-free-boundaries/PROOF.md new file mode 100644 index 0000000000..b97fc54fb5 --- /dev/null +++ b/research/complex-scratch-free-boundaries/PROOF.md @@ -0,0 +1,158 @@ +# Scratch-free permutation boundaries with mixed intermediate rows + +This is a scoped computer-assisted negative result about exact scalar circuits, +not a formal proof of the integer-multiplication theorem. + +## Exact interface and price + +There are exactly `n` available registers containing arbitrary independent +real inputs. The required map is a specified permutation of these inputs. +One primitive costs one, with the PR696 real-component alphabet: + +- `x_t += x_s` or `x_t -= x_s`, with distinct registers; +- `x_t = -x_t`, `x_t = 2*x_t`, or `x_t = x_t/2`; +- `COPY x_t <- x_s` or `CLEAR x_t`. + +No other register may be read, written, borrowed or supplied with a known value. +Intermediate rows may be arbitrary dyadic combinations; there is no monomial, +coefficient-height, denominator-depth or prefix-magnitude restriction. There +are no free permutations, renamings or sign changes. Each source access in an +ADD/SUB is part of that charged primitive. Non-unit coefficient macros must +be expanded into their paid primitives. The class is a single real-component +circuit; it excludes cross-component complex arithmetic and nonlinear gates. + +COPY between distinct registers and CLEAR have singular matrices. Rank cannot +increase under subsequent linear maps on the same `n` registers. Therefore +neither can occur in a successful circuit whose endpoint is an invertible +permutation. A self-COPY is an identity and can simply be removed. This leaves +only invertible ADD, SUB, NEGATE, DOUBLE and HALVE. + +## Sound finite quotient + +The ring homomorphism `Z[1/2] -> F_3` sends `a/2^k` to `a*2^k mod 3`, because +`2^{-1}=2` in `F_3`. ADD and SUB reduce to their corresponding elementary row +operations. NEGATE, DOUBLE and HALVE all reduce to row negation. Thus every +successful exact circuit of length at most `L` gives a word of length at most +`L` in the following inverse-closed generating set of `GL(n,3)`: + +``` +row[t] += row[s], row[t] -= row[s] (t != s) +row[t] = -row[t] +``` + +There are `n(2n-1)` generators. Passing to the quotient can make a circuit +shorter or identify different exact matrices. Consequently modular +**nonexistence** is a lower bound for exact circuits; modular existence is +never used alone as an exact upper bound. The exact upper bounds below are +separately executed over rational numbers. Reduction modulo two would be +unsound for HALVE and is explicitly rejected by a control. + +## Complete short-word certificate + +Both implementations generate the entire radius-four ball `B` about identity +by breadth-first search, retaining minimum distances. Let `P` be the target +permutation matrix, with row `i` equal to `e_{p[i]}`. A word of length at most +eight exists if and only if there is `A` in `B` with `A P` also in `B`. + +For the forward implication, split a length-at-most-eight word into two +subwords of length at most four: `P = U V`; put `A = U^{-1}`. Inverse closure +gives `A in B`, and `A P = V in B`. Conversely `P = A^{-1}(A P)` is a word +of length `dist(A)+dist(A P) <= 8`. Minimizing that sum over intersections +also yields the actual minimum whenever it is at most eight. + +| Dimension / target | Radius-four layer counts | Minimum through length eight | +|---|---|---| +| 2 / `(01)` | 1, 6, 17, 22, 2 | 4 | +| 3 / `(012)` | 1, 15, 135, 787, 3000 | 6 | +| 5 / `(01)(234)` | 1, 45, 1250, 26830, 477045 | no intersection | + +There are 509,157 states across the three balls. Python represents each row +as a base-three integer and uses row lookup tables; a separate C++ program +stores two bits per coefficient and computes every row operation directly. +They use different generator orders. Every state and every minimum distance +is compared exactly in a canonical binary encoding, not merely by counts or +hashes. The hashes in EXPECTED.json summarize this full comparison. + +This exhausts the stated short-word domain, without a timeout, random sample, +heuristic pruning, solver status or unverified cached search result. +Assignment seed 24 rotates the generator presentation only. Search class +novelty comes from allowing mixed intermediate rows while removing scratch, +not from that seed. The independent implementation is also AI-written; no +independent human review is claimed. + +## Upper bounds and remaining one-operation gap + +An exact swap uses four primitives: + +``` +x += y; y -= x; x += y; y = -y +``` + +An exact three-cycle `(x,y,z) -> (y,z,x)` uses six: + +``` +z -= y; x -= z; y += z; z += x; x -= z; x += y +``` + +Taking their direct sum gives ten for the 2+3-cycle. The verifier applies +these literal words to every independent input column and checks their +literal inverses. Therefore the exact scratch-free minima are **4**, **6**, +and **between 9 and 10 inclusive**, respectively. We do not resolve nine +versus ten for the last case. No longer-word search was performed. + +With one disposable scratch register, PR971's construction needs `n+c+1` +primitives for `c` cycles: save one coordinate, rotate each cycle by COPY, +then CLEAR scratch once. For the same cases these prices are **4**, **5**, +and **8**. Incoming scratch may be arbitrary; the circuit overwrites and +eventually clears it. The comparison does not assume a free initial clear or +ignore final restoration work. Every operation is executed on all `n+1` +input columns, including arbitrary scratch dirt. All 37 single-primitive +omissions from the six displayed witnesses are detected. + +## Actual historical CK/JP8 boundaries + +An independently written exact two-coordinate recognizer scans all scalar +runs of both orientations of each frozen PR626 CK and JP8 word. A run ends +at every non-scalar event or frame change. It reconstructs the pending +permutation after all recognized swaps, including the fixed coordinates, +and matches every event interval, frame, swap position, mapping and cycle +against PR971's complete retained receipt. All source bytes are pinned. + +Each of the four programs has 28 two-cycle boundaries and 14 boundaries of +type 2+3. Register conjugation preserves the gate alphabet and price, so the +canonical modular exclusions apply to every actual coordinate labeling and +to inverse cycle direction. Some mappings also list a fixed coordinate: +it is **not available as scratch** in this result. + +If each boundary must implement its arbitrary-input permutation using exactly +its moved coordinates, the per-component boundary bill is at least + +``` +28*4 + 14*9 = 238, +``` + +compared with the retained scratch circuit's `28*4 + 14*8 = 224`. The explicit +scratch-free witnesses cost 252. Doubling for the separate real/imaginary +components gives a penalty of at least **28 real primitives per orientation**. +This favorable comparison charges no extra disposal of a removed scratch +cell; requiring an existing dirty work cell to clear would need further work. + +No frame change, copy, source access, restoration or recursive child is silently +saved. We propose no supplier substitution: the bound says that a particular +attempt to eliminate boundary scratch cannot tie the existing boundary bill. +Other scalar operations still use coefficient work, so this result by itself +does not eliminate a row from a complete supplier or change a recurrence. + +## Exclusions and inherited obligations + +The result does not cover borrowing another fixed coordinate, optimizing the +surrounding run jointly, changing the incoming-state contract, carrying a +permutation across a frame/event barrier, additional scratch, different +primitives, or cross-component arithmetic. It does not prove an optimum for +circuits with scratch. PR1095's monomial-prefix optimum for that different +class is credited as prior work, not reproved or imported here. + +Full-word native/phase/wrapper admission, physical arrays and tape, precision, +hosting, all-size compilation and analytic transfer are not executed or +discharged. Exact local witnesses are not a rounded-arithmetic guarantee. +The selected supplier and kappa are unchanged. diff --git a/research/complex-scratch-free-boundaries/README.md b/research/complex-scratch-free-boundaries/README.md new file mode 100644 index 0000000000..6729cffc92 --- /dev/null +++ b/research/complex-scratch-free-boundaries/README.md @@ -0,0 +1,101 @@ +# Exact scratch/work obstruction for historical complex boundaries + +**Scoped negative result; no new kappa.** The five moved registers at a +historical CK/JP8 2+3-cycle boundary cannot implement that permutation in eight +or fewer PR696 real primitives without a temporary register. The existing +PR971 circuit uses eight with one temporary register. Unlike the concurrent +PR1095 monomial-prefix audit, this exclusion allows arbitrary mixed dyadic +intermediate rows and unbounded coefficient magnitudes. + +| Permutation | With scratch, existing witness | Without scratch, proved range | +|---|---:|---:| +| two-cycle | 4 | 4 exactly | +| three-cycle | 5 | 6 exactly | +| disjoint two- and three-cycle | 8 | 9–10 | + +The precise restriction is **exactly the moved coordinates**: no fixed register +may be borrowed. Each circuit must implement its permutation for arbitrary +incoming values. Both qualifications matter; this is not a general claim +that temporary registers cannot be eliminated from the supplier. + +The complete source census finds 28 two-cycles and 14 two-plus-three-cycles in +each of four CK/JP8 orientation programs, 168 boundaries in total. Under this +interface the boundary invoice increases from 224 to at least 238 primitives +per real component, or **at least 28 additional real primitives per complete +orientation**. Exact witnesses give an upper bound of 252 per component. +Other operations still use coefficient work; no whole-supplier scratch saving +or changed paid recursive profile follows. + +## Reproduce + +Python 3.9+ and a C++17 compiler; standard libraries only, no network or Git: + +```sh +python3 -I -O -B research/complex-scratch-free-boundaries/verify.py +``` + +Expected final line: + +```text +PASS_COMPLEX_SCRATCH_FREE_BOUNDARIES boundaries=168 states=509157 costs=4,6,>=9 scratch_costs=4,5,8 no_new_kappa +``` + +The command rebuilds all three radius-four balls modulo three and independently +compiles a C++ implementation. Every state and minimum distance must match +exactly. It then checks the full meet-in-the-middle result, literal rational +witnesses, 37 gate omissions, all source pins and the complete source census. +It compares the entire fresh receipt against EXPECTED.json and writes nothing. +`CXX` can select a C++17 compiler. A missing compiler or failed independent +check is an error, never a skipped pass. + +```sh +python3 -I -O -B research/complex-scratch-free-boundaries/test_package.py +``` + +Additional tests cover an independent dense GL(2,3) oracle, all ordered +two-dimensional matrix products, quotient halving, generator/depth omissions, +modular false positives, wrong signs and boundary barriers, every source +corruption, complete receipt corruption, and an isolated minimal offline +relocation. See [VALIDATION.md](VALIDATION.md) for executed checks and limits. + +[PROOF.md](PROOF.md) gives the rank argument excluding destructive operations, +the dyadic reduction, completeness of the radius-four intersection test and +the precise scope. [EXPECTED.json](EXPECTED.json) contains all actual boundary +indices and exact witnesses. The search has no timeout or heuristic pruning; +the five-coordinate question at length nine remains open here. + +## Provenance, coordination and credit + +Exact research base: `ba82555c64e1879e4b7decce28186f208fcb8262`. +The selected result at that base is PR1042, conditional +`kappa = 1672188119205421/10^18`. Its actual construction, assembly and review +were followed; this contribution deliberately concerns historical PR626 +boundaries. [SOURCES.json](SOURCES.json) pins seven replay inputs by SHA256 +and Git blob, plus five base-context documents separately. No pending PR code +is imported. Input archive hashes bind immutable source containers; this +package does not regenerate those archives. + +The submission refresh is `ce7ad1b6ab09452c3478723a2e96ed5ff212dc08`, where +upstream now selects PR1094, kappa `0.001672660197076918`. All seven historical +inputs are unchanged. This package edits neither selected record. + +[CLAIM.md](CLAIM.md) records OS seed 24, three candidates, overlap checks, +bounded domain and stopping rule. There was no pinned coordination issue. +PR1118 covers CK grid synthesis and PR1116 restored helper butterflies; both +were excluded from task selection. PR1095 provides the adjacent one-scratch, +monomial-prefix lower bound. This contribution changes both premises: no +scratch and arbitrary mixed rows. A different seed alone is not the novelty. + +Credit **ToikY / Eva Ayala (PR971)** for the deferred-swap construction, +boundary inventory and existing 4/8-primitive witnesses; **woklerx (PR1095)** +for the adjacent scoped lower-bound question; **Sagar Thakrar (PR696)** for +the primitive lowering; **Chafik Boukhalfa (PR626)** and **Jeremy Kothe (PR622)** +for the historical words and interfaces; and icekylinx, DreamingOfClouds, +eumemic, Rohan Arun and the retained source lineage. No priority claim is made +for elementary permutation identities, modular group bounds or BFS. + +Prepared for **Ross Richardson / @RossRichardson**, with substantial +**OpenAI Codex assistance**, including the separately implemented checker. +Apache-2.0; repository notices and upstream sources remain unchanged. No +independent human review, full theorem proof, new kappa or measured +multiplication speedup is claimed. diff --git a/research/complex-scratch-free-boundaries/SOURCES.json b/research/complex-scratch-free-boundaries/SOURCES.json new file mode 100644 index 0000000000..96207ccb43 --- /dev/null +++ b/research/complex-scratch-free-boundaries/SOURCES.json @@ -0,0 +1,62 @@ +{ + "base_commit": "ba82555c64e1879e4b7decce28186f208fcb8262", + "hash_semantics": "Exact immutable source bytes; context pins record the base and are not moving replay dependencies.", + "files": { + "research/complex-dyadic-lowering/lower.py": { + "sha256": "eb37d00063dc09323e9aca041d23da749ce17fbd71dade9aaf1c059cab0b9753", + "git_blob": "a2c2889e5be41a0fc30d4dfa5dfcebb03d6d47f8" + }, + "research/complex-swap-runs-seed37/compiler.py": { + "sha256": "4fec1f1b03b583e95851b5b1243be6285d936c7c20fa863b24a277d54774b491", + "git_blob": "1d5cd6c423f2347d91a9a610d822afb13fe5a760" + }, + "research/complex-swap-runs-seed37/EXPECTED.json": { + "sha256": "b1d3b19f360c611802f105382e969f26e15bdbf57dae19264e412554805e43d5", + "git_blob": "995ec843dfa40a024390b309082377cf70695a8e" + }, + "research/community-k492-audit/pr626/replay/mixed-global/base/providers/ck/LOCAL-PROGRAMS.json.gz": { + "sha256": "b5da54e049cc127a1065190a647cb71cac0c6ba03d9ccdb71719f4fcbfa886f3", + "git_blob": "61ef73c1f958e0d26f3e7a3a82bc3826b7098c93" + }, + "research/community-k492-audit/pr626/replay/mixed-global/base/providers/ck/LOCAL-CHECKS.json": { + "sha256": "059c4e59142bdf5c19dc7c0afebcddfec28e6e60cbc7299b8bdcc624afbc0cbe", + "git_blob": "d2b8854114b19b88e14d2af0dd84ad79e9eedbaa" + }, + "research/community-k492-audit/pr626/replay/mixed-global/base/providers/jp8/LOCAL-PROGRAMS.json.gz": { + "sha256": "fa0c196f65bd6ec1424fdf7d789f6972075c7bb02bf43f573ea85eafab31be98", + "git_blob": "e22169a1633638213a5c63425a1919c7185f4c43" + }, + "research/community-k492-audit/pr626/replay/mixed-global/base/providers/jp8/LOCAL-CHECKS.json": { + "sha256": "0fad744aa863eedb288a9f87b1c23225a36b316b6275cc3b1bcedd42afe28a67", + "git_blob": "0d84d903086993330ddcd871e66b15854f0c3ccd" + } + }, + "base_context": { + "certificates/selected-result.json": { + "sha256": "207d1f49f113c585024b9d3c17eadbb8b1be17c1321e3d190aabe2f18ce1c5b7", + "git_blob": "f451ced6626a1f03aba6915ce23a136b01ebe51d" + }, + "docs/research/community-batch1047-review.md": { + "sha256": "a6271faf5db0afe3ff7d24a34a3be7a959cdc33ee37784572fba014ee5358787", + "git_blob": "2b9c9f584b5f9b4db5ca16f3942c178a77c19f11" + }, + "research/community-frontier1042-audit/ASSEMBLY.json": { + "sha256": "093f35445812ea96fe1bfe6a3af7d769cb7f274e08f4fb30f71a17ed1161e54e", + "git_blob": "4e308dc23da97373d66e5d8d4a68b0661caea8e9" + }, + "research/gauge44-slots-t16/README.md": { + "sha256": "e33534891b32397220d29cd60943a71b863b606e734d71902349e4cac78a1a35", + "git_blob": "0262339347a739be25b24860e96b4a20dd774807" + }, + "research/gauge44-slots-t16/CONSTRUCTION.md": { + "sha256": "7d96eb958a6b4274ea4c4c539b585f8ae2e89363b76aef930f90d2d513e164ea", + "git_blob": "fa156763668d1c761968b6dfaecbb55199904415" + } + }, + "predecessor_heads": { + "PR622": "f69477f4f6d3c7eb1f740b166881bffed4ffa9f6", + "PR626": "660de893d27bb7abd1d5b01b1640207528a5c851", + "PR1095_metadata_only": "1db482a6cb63ae49cf156357ef98b8e4b676fcd9", + "PR971": "b4cb9709ac48e69002a25607e1ecc2ed8452d5b3" + } +} diff --git a/research/complex-scratch-free-boundaries/VALIDATION.md b/research/complex-scratch-free-boundaries/VALIDATION.md new file mode 100644 index 0000000000..644e6f14ad --- /dev/null +++ b/research/complex-scratch-free-boundaries/VALIDATION.md @@ -0,0 +1,49 @@ +# Executed validation + +Research base: `ba82555c64e1879e4b7decce28186f208fcb8262`. +Submission refresh: `ce7ad1b6ab09452c3478723a2e96ed5ff212dc08`. +Seven replay input Git blobs are identical at both commits; five base-context +pins resolve to their recorded original blobs. During this run upstream +advanced the selected record from PR1042 to PR1094, +`836330098538459/500000000000000000 = 0.001672660197076918`. +This contribution changes neither selection; the historical source inputs +and scoped boundary result are unaffected. + +Local execution on 2026-10-13 UTC, macOS arm64, Apple clang 17.0.0: + +- CPython **3.14.6**: isolated optimized full replay passed, including fresh + C++17 compilation and equality of every modular state/minimum distance. +- CPython **3.9.6**: the same full replay passed with the same entire receipt. +- Both versions passed all **10 package test groups**. These include 37 literal + primitive omissions, seven input-file corruptions, a changed lower bound in + the receipt, and a complete minimal offline relocated replay in a path with + spaces. The relocated replay leaves all files byte-identical. +- Fresh `--record` output matches committed EXPECTED.json byte for byte. +- `make selected-record-check` and all **five selected-result tests** passed. +- Source/base pin checks, unchanged selected record, whitespace and focused + package/workflow scope were checked before submission. + +The complete modular balls contain 48, 3,938 and 505,171 matrices, respectively. +The five-register ball layers are `[1,45,1250,26830,477045]`; its translated +intersection for `(01)(234)` is empty. This completes the declared length-eight +search. No length-nine search or unrestricted optimality claim is made. + +The exact historical source census matches all 168 retained PR971 boundaries, +including every event interval, frame, swap site, permutation and cycle. Source +bytes and declared semantic word hashes both pass. The seven source pins are +immutable inputs; no original archive is regenerated or overwritten. + +The pre-submission overlap refresh reached PR1142, refreshed the nearest PR1095 at +`1db482a6cb63ae49cf156357ef98b8e4b676fcd9`, and searched open scratch-free +boundary/permutation work. PR1095 permits scratch and restricts prefixes to +monomial rows; this contribution removes scratch and permits mixed rows. +Its contribution is a different cost class, not another replay of PR1095. +PR1116/1118 remain unrelated helper-butterfly/grid-synthesis mechanisms. + +A focused Linux workflow is included. Hosted CI status is reported separately +in the PR handoff; no local result is represented as a hosted pass. + +Not run or claimed: repository-wide `make verify`, selected supplier cold +replay, whole historical primitive streams, native frame/phase/physical +admission, global hosting/invoice/assembly regeneration, rounded precision, +all-size/compiler/analytic proof or Lean. Those sources are unchanged. diff --git a/research/complex-scratch-free-boundaries/independent.cpp b/research/complex-scratch-free-boundaries/independent.cpp new file mode 100644 index 0000000000..6c24c41f0a --- /dev/null +++ b/research/complex-scratch-free-boundaries/independent.cpp @@ -0,0 +1,82 @@ +// Independent bit-packed F3 BFS; Ross Richardson / OpenAI Codex, Apache-2.0. +// Each coefficient occupies two bits. No Python tables or search data are read. +#include +#include +#include +#include +#include +#include +#include +#include +#include + +using Key = std::uint64_t; + +int coefficient(Key key, int n, int row, int column) { + return (key >> (2 * (row * n + column))) & 3; +} + +Key change(Key key, int n, int target, int source, int sign) { + Key result = key; + for (int column = 0; column < n; ++column) { + int a = coefficient(key, n, target, column); + int b = coefficient(key, n, source, column); + int value = target == source ? (3 - a) % 3 : (a + sign * b + 3) % 3; + int shift = 2 * (target * n + column); + result = (result & ~(Key(3) << shift)) | (Key(value) << shift); + } + return result; +} + +int main(int argc, char **argv) { + try { + if (argc != 3) throw std::runtime_error("usage: independent DIMENSION OUTPUT"); + int n = std::stoi(argv[1]); + if (n != 2 && n != 3 && n != 5) throw std::runtime_error("dimension"); + Key identity = 0; + for (int i = 0; i < n; ++i) identity |= Key(1) << (2 * (i * n + i)); + std::unordered_map distance; + distance.reserve(600000); + distance.emplace(identity, 0); + std::vector queue{identity}; + for (std::size_t cursor = 0; cursor < queue.size(); ++cursor) { + Key state = queue[cursor]; + int depth = distance.at(state); + if (depth == 4) continue; + // Deliberately use a different generator order from the Python BFS. + for (int s = n - 1; s >= 0; --s) { + for (int t = n - 1; t >= 0; --t) { + for (int sign : {1, -1}) { + if (s == t && sign == 1) continue; + Key next = change(state, n, t, s, sign); + if (distance.emplace(next, depth + 1).second) queue.push_back(next); + } + } + } + } + std::vector> ordered; + ordered.reserve(distance.size()); + for (const auto &entry : distance) { + Key ternary = 0, place = 1; + for (int r = 0; r < n; ++r) for (int c = 0; c < n; ++c) { + ternary += place * coefficient(entry.first, n, r, c); + place *= 3; + } + ordered.emplace_back(ternary, entry.second); + } + std::sort(ordered.begin(), ordered.end()); + std::ofstream output(argv[2], std::ios::binary); + if (!output) throw std::runtime_error("output open"); + for (const auto &entry : ordered) { + for (int i = 0; i < 8; ++i) output.put(char((entry.first >> (8 * i)) & 255)); + output.put(char(entry.second)); + } + output.close(); + if (!output) throw std::runtime_error("output write"); + std::cout << "PASS_INDEPENDENT_BALL n=" << n << " states=" << ordered.size() << '\n'; + return 0; + } catch (const std::exception &error) { + std::cerr << error.what() << '\n'; + return 1; + } +} diff --git a/research/complex-scratch-free-boundaries/search.py b/research/complex-scratch-free-boundaries/search.py new file mode 100644 index 0000000000..f1e8d0123d --- /dev/null +++ b/research/complex-scratch-free-boundaries/search.py @@ -0,0 +1,101 @@ +"""Exact dyadic boundary obstruction through the GL(n,3) quotient. + +Ross Richardson, with substantial OpenAI Codex assistance; Apache-2.0. +No predecessor search implementation is imported. +""" +from collections import Counter +from hashlib import sha256 +import struct + +SEED = 24 +RADIUS = 4 +PERMUTATIONS = {2: (1, 0), 3: (1, 2, 0), 5: (1, 0, 3, 4, 2)} + + +def require(ok, message): + if not ok: + raise ValueError(message) + + +def generators(n): + require(n in PERMUTATIONS, "unsupported dimension") + ops = [(t, s, sign) for t in range(n) for s in range(n) + for sign in (-1, 1) if t != s or sign == -1] + cut = SEED % len(ops) + return ops[cut:] + ops[:cut] + + +def row_tables(n): + size = 3 ** n + digits = [tuple((a // 3 ** j) % 3 for j in range(n)) for a in range(size)] + encode = lambda row: sum(x * 3 ** j for j, x in enumerate(row)) + plus = [[encode([(x + y) % 3 for x, y in zip(a, b)]) for b in digits] + for a in digits] + minus = [[encode([(x - y) % 3 for x, y in zip(a, b)]) for b in digits] + for a in digits] + return plus, minus + + +def ball(n, radius=RADIUS, ops=None): + """Rows are base-three integers; BFS keeps exact minimum distances.""" + require(type(n) is int and n in PERMUTATIONS, "unsupported dimension") + require(type(radius) is int and 0 <= radius <= RADIUS, "radius outside closed domain") + plus, minus = row_tables(n) + ops = generators(n) if ops is None else ops + identity = tuple(3 ** j for j in range(n)) + distance = {identity: 0} + level = [identity] + for depth in range(1, radius + 1): + following = [] + for matrix in level: + for target, source, sign in ops: + value = (minus[0][matrix[target]] if target == source else + (plus if sign == 1 else minus)[matrix[target]][matrix[source]]) + other = matrix[:target] + (value,) + matrix[target + 1:] + if other not in distance: + distance[other] = depth + following.append(other) + level = following + return distance + + +def encode_matrix(matrix): + size = 3 ** len(matrix) + return sum(row * size ** i for i, row in enumerate(matrix)) + + +def ball_bytes(distance): + return b"".join(struct.pack(" end: + return None + block = events[start:start + 4] + if any(e[0] != "scalar" for e in block): + return None + ops = [e[1] for e in block] + if [o[0] for o in ops] != ["add", "add", "add", "scale"]: + return None + a, b = tuple(ops[0][1]), tuple(ops[0][2]) + if a == b or a[0] != "L" or b[0] != "L": + return None + rows = {a: [Q(1), Q(0)], b: [Q(0), Q(1)]} + for op in ops: + target = tuple(op[1]) + if target not in rows: + return None + if op[0] == "add": + source = tuple(op[2]) + if source not in rows or source == target: + return None + scale = Q(*op[3:5]) + rows[target] = [x + scale * y for x, y in zip(rows[target], rows[source])] + else: + rows[target] = [Q(*op[2:4]) * x for x in rows[target]] + return (a, b) if rows[a] == [0, 1] and rows[b] == [1, 0] else None + + +def runs(events): + cursor = 0 + while cursor < len(events): + if events[cursor][0] != "scalar": + cursor += 1 + continue + start, frame = cursor, events[cursor][2] + while cursor < len(events) and events[cursor][0] == "scalar" and events[cursor][2] == frame: + cursor += 1 + yield start, cursor, frame + + +def cycles_of(mapping): + pending = {a for a, b in mapping.items() if a != b} + result = [] + while pending: + first = min(pending) + cycle = [first] + cursor = mapping[first] + while cursor != first: + require(cursor in pending and cursor not in cycle, "invalid cycle") + cycle.append(cursor) + cursor = mapping[cursor] + pending.difference_update(cycle) + result.append(cycle) + return result + + +def boundary_census(events): + result = [] + for start, end, frame in runs(events): + positions, mapping = [], {} + cursor = start + while cursor < end: + pair = recognize(events, cursor, end) + if pair is None: + cursor += 1 + continue + a, b = pair + mapping.setdefault(a, a) + mapping.setdefault(b, b) + mapping[a], mapping[b] = mapping[b], mapping[a] + positions.append(cursor) + cursor += 4 + if positions: + result.append({"start": start, "end": end, "frame": frame, + "swap_starts": positions, + "permutation": [[list(a), list(b)] for a, b in sorted(mapping.items())], + "cycles": [[list(a) for a in cycle] for cycle in cycles_of(mapping)]}) + return result + + +def census(root=ROOT): + previous = read(root / (PREDECESSOR + "EXPECTED.json")) + result = {} + for provider in ("ck", "jp8"): + directory = root / (PROVIDERS + provider) + programs = read(directory / "LOCAL-PROGRAMS.json.gz") + checks = read(directory / "LOCAL-CHECKS.json") + require(set(programs) == {"forward", "backward"}, "source orientations") + for direction, events in programs.items(): + key = provider + "/" + direction + require(hashlib.sha256(canonical(events)).hexdigest() == checks[direction]["sha256"], "semantic source pin") + blocks = boundary_census(events) + require(canonical(blocks) == canonical(previous["candidate_blocks"][key]), "complete boundary census: " + key) + types = Counter(tuple(sorted(len(c) for c in b["cycles"])) for b in blocks) + require(types == {(2,): 28, (2, 3): 14}, "cycle census") + result[key] = {"boundaries": blocks, "two_cycles": 28, "two_plus_three_cycles": 14, + "scratch_component_cost": 28 * 4 + 14 * 8, + "scratch_free_component_lower_bound": 28 * 4 + 14 * 9, + "scratch_free_component_upper_bound": 28 * 4 + 14 * 10, + "real_primitive_penalty_at_least": 2 * 14} + return result + + +def exact_word(n): + two = [("add", 0, 1), ("subtract", 1, 0), ("add", 0, 1), ("negate", 1)] + three = [("subtract", 2, 1), ("subtract", 0, 2), ("add", 1, 2), + ("add", 2, 0), ("subtract", 0, 2), ("add", 0, 1)] + return {2: two, 3: three, 5: two + [tuple([op[0]] + [i + 2 for i in op[1:]]) for op in three]}[n] + + +def with_scratch(n): + permutation = search.PERMUTATIONS[n] + cycles = cycles_of(dict(enumerate(permutation))) + word = [] + for cycle in cycles: + word.append(("copy", n, cycle[0])) + word.extend(("copy", t, s) for t, s in zip(cycle, cycle[1:])) + word.append(("copy", cycle[-1], n)) + return word + [("clear", n)] + + +def exact_matrix(width, word): + rows = [[Q(i == j) for j in range(width)] for i in range(width)] + peak = Q(1) + for op in word: + tag, target = op[:2] + require(0 <= target < width, "primitive target") + if tag == "clear": + rows[target] = [Q(0)] * width + elif tag in ("negate", "double", "halve"): + scale = {"negate": Q(-1), "double": Q(2), "halve": Q(1, 2)}[tag] + rows[target] = [scale * x for x in rows[target]] + else: + source = op[2] + require(0 <= source < width and source != target, "primitive source") + if tag == "copy": + rows[target] = rows[source][:] + else: + require(tag in ("add", "subtract"), "primitive tag") + sign = 1 if tag == "add" else -1 + rows[target] = [x + sign * y for x, y in zip(rows[target], rows[source])] + peak = max(peak, *(sum(abs(x) for x in row) for row in rows)) + return rows, peak + + +def witnesses(): + result, omissions = {}, 0 + for n, perm in search.PERMUTATIONS.items(): + target = [[Q(j == perm[i]) for j in range(n)] for i in range(n)] + word, copy_word = exact_word(n), with_scratch(n) + actual, peak = exact_matrix(n, word) + require(actual == target, "scratch-free exact endpoint") + extended = [row + [Q(0)] for row in target] + [[Q(0)] * (n + 1)] + actual_copy, copy_peak = exact_matrix(n + 1, copy_word) + require(actual_copy == extended, "arbitrary-dirty scratch endpoint") + inverse = [("subtract" if op[0] == "add" else "add" if op[0] == "subtract" else op[0], *op[1:]) + for op in reversed(word)] + identity, _ = exact_matrix(n, word + inverse) + require(identity == [[Q(i == j) for j in range(n)] for i in range(n)], "literal inverse") + for width, candidate, goal in ((n, word, target), (n + 1, copy_word, extended)): + for i in range(len(candidate)): + bad, _ = exact_matrix(width, candidate[:i] + candidate[i + 1:]) + require(bad != goal, "omitted primitive survived") + omissions += 1 + result[str(n)] = {"without_scratch": word, "with_scratch": copy_word, + "without_cost": len(word), "with_cost": len(copy_word), + "without_prefix_row_l1": str(peak), "with_prefix_row_l1": str(copy_peak)} + return result, omissions + + +def run(root=ROOT): + admit_sources(root) + finite = {} + with tempfile.TemporaryDirectory(prefix="scratch-free-boundaries-") as temporary: + tmp = Path(temporary) + executable = tmp / "independent" + command = shlex.split(os.environ.get("CXX", "c++")) + subprocess.run(command + ["-std=c++17", "-O2", "-Wall", "-Wextra", "-pedantic", + str(HERE / "independent.cpp"), "-o", str(executable)], check=True) + for n in search.PERMUTATIONS: + distance = search.ball(n) + path = tmp / (str(n) + ".bin") + completed = subprocess.run([str(executable), str(n), str(path)], check=True, capture_output=True, text=True) + require(completed.stdout == f"PASS_INDEPENDENT_BALL n={n} states={len(distance)}\n", "independent completion") + require(path.read_bytes() == search.ball_bytes(distance), "full independent states/distances differ") + finite[str(n)] = search.certificate(n, distance) + require([finite[str(n)]["lower_bound"] for n in (2, 3, 5)] == [4, 6, 9], "modular cost result") + exact, omissions = witnesses() + return {"status": "PASS_COMPLEX_SCRATCH_FREE_BOUNDARIES", "base_commit": BASE, + "assignment_seed": 24, "finite_search": finite, "witnesses": exact, + "omitted_primitive_controls": omissions, "source_census": census(root), + "scope": "Arbitrary-input permutation interfaces on exactly the moved registers. No new kappa."} + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--record", type=Path, help="write a NEW receipt after all checks") + args = parser.parse_args() + result = run() + if args.record: + with args.record.open("x") as handle: + json.dump(result, handle, indent=2, sort_keys=True) + handle.write("\n") + else: + require(canonical(result) == canonical(read(HERE / "EXPECTED.json")), "complete receipt mismatch") + print("PASS_COMPLEX_SCRATCH_FREE_BOUNDARIES boundaries=168 states=509157 costs=4,6,>=9 scratch_costs=4,5,8 no_new_kappa") + + +if __name__ == "__main__": + main() From fd4d5ffc448361297e717aa30eafed578caf8e61 Mon Sep 17 00:00:00 2001 From: ross Date: Wed, 14 Oct 2026 06:05:24 +1100 Subject: [PATCH 2/2] docs: close scratch-free boundary sprint claim --- research/complex-scratch-free-boundaries/CLAIM.md | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/research/complex-scratch-free-boundaries/CLAIM.md b/research/complex-scratch-free-boundaries/CLAIM.md index 047f872c67..418ad8ee79 100644 --- a/research/complex-scratch-free-boundaries/CLAIM.md +++ b/research/complex-scratch-free-boundaries/CLAIM.md @@ -10,3 +10,11 @@ - Stopping rule: complete radius-four modular balls for dimensions 2, 3 and 5; permit one evidence-driven refinement only if needed. No unbounded circuit search. - Expected finish: 2026-10-13 19:14 UTC; final verification/handoff starts by 19:06 UTC. - Coordination: GitHub pinned-issue query immediately before claim returned none. Local claim used. Open queue read through PR1127; targeted scratch/permutation searches and PR1095 head `1db482a6cb63ae49cf156357ef98b8e4b676fcd9` inspected. PR1095's monomial-prefix class is distinct and credited. No workers delegated. + +## Result and handoff — 2026-10-13 19:05 UTC + +Submitted [PR1145](https://github.com/CrocSwap/integer-mult-bounds/pull/1145), a scoped negative result. Complete independent radius-four balls agree on 509,157 matrices/distances. The scratch-free two-/three-cycle minima are 4/6; the disjoint 2+3-cycle minimum lies in [9,10], compared with the existing 8-operation scratch witness. All 168 historical boundaries are source-bound; exactly-moved-coordinate elimination costs at least 28 additional real primitives per orientation. Nine versus ten, borrowed fixed registers and full supplier integration remain unresolved. + +Research base is unchanged; submission rebased to `ce7ad1b6ab09452c3478723a2e96ed5ff212dc08`, which now selects PR1094. All seven input blobs remain identical. Tested implementation commit: `07e119dc44edf2bfa546f7212b5d60b0b9f44f12`. Full replay and ten test groups pass on CPython 3.14.6 and 3.9.6, with exact receipt regeneration, 37 gate omissions, source/receipt corruption and minimal relocation. Current selected-record integrity and five selected tests pass. Only this claim closeout changes after that tested implementation. + +Final overlap refresh through PR1142 and title searches for scratch-free/permutation work found no duplicate; PR1095's exact head stayed unchanged. No pinned coordination issue exists, so this is the single local claim update. Upstream has neither `codex` nor `codex-automation` label. Hosted CI remains separate from the completed local checks. No merge, selected-frontier edit or upstream source edit.