diff --git a/.github/workflows/pr4470-exact-transport-audit.yml b/.github/workflows/pr4470-exact-transport-audit.yml new file mode 100644 index 0000000000..2add93ec13 --- /dev/null +++ b/.github/workflows/pr4470-exact-transport-audit.yml @@ -0,0 +1,38 @@ +name: PR4470 exact transport audit +on: + pull_request: + paths: + - 'research/pr4470-exact-transport-audit/**' + - '.github/workflows/pr4470-exact-transport-audit.yml' +permissions: + contents: read +concurrency: + group: pr4470-exact-transport-${{ github.event.pull_request.number }} + cancel-in-progress: true +jobs: + exact-matrices: + runs-on: ubuntu-latest + timeout-minutes: 20 + steps: + - uses: actions/checkout@v4 + with: + fetch-depth: 1 + sparse-checkout: | + research/pr4470-exact-transport-audit + docs/research/agent-task-catalog.json + sparse-checkout-cone-mode: false + - uses: actions/setup-python@v5 + with: + python-version: '3.12' + - name: Install pinned numerical storage dependency + run: python -m pip install numpy==2.2.6 + - name: Exact source-bound scientific replay + run: timeout 600s python -B research/pr4470-exact-transport-audit/verify.py --out /tmp/pr4470-exact-result.json + - name: Optimized-mode controls + run: python -I -O -B research/pr4470-exact-transport-audit/verify.py --self-test + - name: Preserve exact receipt + uses: actions/upload-artifact@v4 + with: + name: pr4470-exact-transport-receipt + path: /tmp/pr4470-exact-result.json + if-no-files-found: error diff --git a/docs/ci-verification.md b/docs/ci-verification.md index 582e416aaf..4541cfa0e8 100644 --- a/docs/ci-verification.md +++ b/docs/ci-verification.md @@ -5,6 +5,25 @@ Start with the [selected record](../certificates/selected-result.json). Its `reproduce`, `review`, `source_manifest` and `validation` fields identify the replay command, scoped assessment, source bindings and integration evidence. +The selected checkpoint is #4359, documented in +[the proof review](research/pr-intake-evidence/pr4359/PROOF-REVIEW.md), +[the source manifest](../certificates/frontier4359-source.json) and +[the validation receipt](research/pr-intake-evidence/pr4359/VALIDATION.json). +The public cold replay is `make frontier4359-verify`; the configured +[frontier4359 workflow](../.github/workflows/frontier4359.yml) executes it +on Ubuntu 24.04 with Python 3.12 and the pinned requirements. Consult +[the integration receipt](research/pr-intake-evidence/pr4359/INTEGRATION.json) +and [workflow runs](https://github.com/CrocSwap/integer-mult-bounds/actions/workflows/frontier4359.yml) +for dated evidence and exact tested heads. + +`make selected-record-check` checks metadata and source/proof hashes. The +finite replay and changed-interface review retain the native/physical, +analytic, precision, fixed-tape and recovery hypotheses in the selected +record; they are not a full formal multiplication theorem. The winning +uniform templates are algorithm-defined and are not materialized. + +## Historical checkpoint through #1094 + At this checkpoint, the selected composition is #589 with #1094, documented in [the review](research/community-batch1099-review.md), [the source manifest](../research/community-frontier1094-audit/SELECTED-SOURCE.json) diff --git a/docs/research/current-status.md b/docs/research/current-status.md index 62a8cbb097..043a8cd78a 100644 --- a/docs/research/current-status.md +++ b/docs/research/current-status.md @@ -1,12 +1,14 @@ # Current reviewed status -Selected conditional κ: **0.0023 = 23/10000**, zxv’s #4359 productive-helper construction, using Jacob Alan Sussman’s mixed-target recursion and the credited cumulative native/outer lineage. +Selected conditional κ: **0.0023** = 23/10000, zxv’s #4359 productive-helper construction, using Jacob Alan Sussman’s mixed-target recursion and the credited cumulative native/outer lineage. [Selected record](../../certificates/selected-result.json) · [Proof review](pr-intake-evidence/pr4359/PROOF-REVIEW.md) · [Integration receipt](pr-intake-evidence/pr4359/INTEGRATION.json) · [Contributors](community-productive4359-contributors.md). Cold replay: `make frontier4359-verify`. The fresh 23-stage replay and 59 normalized artifacts pass; the changed interfaces have an AI-assisted proof review under retained analytic/native/fixed-tape hypotheses. Winning uniform templates are not materialized. This is not a complete formal or independent human verification. #4404 independently checks a narrower arithmetic/flow scope. -## Historical selected status through #1094 +The sections below are a historical snapshot; consult the selected record above for present status. + +## Historical checkpoint through #1094 Historical selected conditional κ: **0.001672660197076918**, Rohan Arun's #1094 on Jeremy Kothe's #1087 packing and the cumulative k8/slot/T16 construction. The bit supplier remains #589 on #555. diff --git a/docs/research/pr14-ci-repair.md b/docs/research/pr14-ci-repair.md new file mode 100644 index 0000000000..7ccdfd5a1e --- /dev/null +++ b/docs/research/pr14-ci-repair.md @@ -0,0 +1,25 @@ +# Fork PR14 CI repair and historical source roles + +The initial registered-package run 39712725535 at f4657a0ad4c11a56646c8c6c422f09335b0c73ba ran 318 onboarding tests and failed four current-status/navigation assertions. The separate exact transport run 39712725621 passed. No scientific failure is inferred from the planning failure. + +## Navigation repair + +The two documentation files reuse the exact corrections from zxv's PR4436 head 56003680aee2871773de408e5f01cc5dd46b144c. They identify selected conditional kappa 0.0023, its actual reproduction command and source/review/validation paths, and label earlier sections as historical. Credit zxv and the existing documentation authors. The tests and selected record are unchanged. + +## Historical replay boundary + +PR3563's historical-1042-link finding binds the old selected #1094 record and its previous_record pointer to #1042. Applying that frozen assertion directly to #4359 is incorrect. Its original verifier, test, RESULT.json, source hashes and base commit are retained unchanged. The added historical_replay.py authenticates the original manifest from ancestor f4657a0, retrieves the three exact original blobs from base 20ecf289, and executes the unchanged verifier and test in a temporary snapshot. It also checks that the live #1042 checkpoint has not changed. No working source file is overwritten. Git replacement objects are disabled and both blob IDs and SHA256 are checked. + +The two evolving documents in that package's SOURCES.json are now historical provenance, not required to equal working-tree bytes. All original VERIFY.json invalidation paths remain present. The registered command explicitly reports historical-snapshot scope. The original direct verify.py command still requires its original inputs; use the registered command on a later frontier. + +The locale package has a different contract. Its unchanged verifier deliberately tests the current status document and current test module, including both negative codec controls and the complete onboarding suite. Its old document hash is historical provenance; the current path remains a declared replay input. This preserves live regression coverage without freezing the document's entire contents. + +No hash is rewritten to a newer value, no failure is suppressed, and neither shared workflow nor package runner is weakened. Six new adapter tests cover exact retrieval, live-edit isolation, wrong hashes/blob IDs, missing history, Git replacements, unsafe paths and the immutable original-manifest guard. They pass locally on Python 3.13.5 in normal and optimised modes. Full Python 3.12 execution is assessed on the actual subsequent hosted run, not presumed from this note. + +## Scope and credit + +This is a fork-local workflow repair, not a new research result, supplier admission or frontier update. It preserves James Reed's PR3563 historical finding, the locale-package author and existing checker attribution, and zxv's documentation repair. Prepared for Chris / Clear1nsight with substantial OpenAI assistance, Apache-2.0. + +## Open next questions + +Confirm the exact-head hosted plan, both affected historical/locale replays and the transport package after publication. A scientific follow-up must separately bind the declared physical-pair list to every event and helper boundary in PR4470's chronological word. CI success alone does not establish that completeness. diff --git a/research/d8-mixed-target-seeda97c8e/SOURCE-ROLES.md b/research/d8-mixed-target-seeda97c8e/SOURCE-ROLES.md new file mode 100644 index 0000000000..c48d957e7e --- /dev/null +++ b/research/d8-mixed-target-seeda97c8e/SOURCE-ROLES.md @@ -0,0 +1,7 @@ +# Historical guidance versus scientific inputs + +The fork PR14 navigation repair selects this package because current-status.md is among its declared invalidation inputs. The old manifest additionally required the current autoresearch, selected record, catalogue and status page to retain their earlier bytes. Those pages have advanced since base 0b1cccf86e2f5132ed286a26ef0a681a495740ea. + +The complete unchanged verifier at Git blob a48d025d118840009764efe893654e2d28441f98 performs no file reads and imports no external data. It constructs the D8 group, F2 group algebra, 240 paid factors and finite word search from explicit definitions. Its seven controls and length-five positive witness do not depend on any current guidance or selected frontier. The four guidance/selection rows are therefore recorded as historical provenance at their original base. All original blob IDs and SHA256 hashes are retained. The referenced lower-bound README remains a pinned live input, and every original VERIFY.json input and command remains unchanged, including the changed-document triggers. + +This is a metadata-role correction, not a new mathematical check, altered alphabet, weakened negative control or changed result. The unchanged scientific replay must still run and succeed on the publication head. No current selection is inferred from the historical package. Original author and predecessor credit remain in README.md and TASK.json. This note was prepared for Chris / Clear1nsight with substantial OpenAI assistance, Apache-2.0. diff --git a/research/d8-mixed-target-seeda97c8e/SOURCES.json b/research/d8-mixed-target-seeda97c8e/SOURCES.json index 9384463ff4..5dcfa9dd60 100644 --- a/research/d8-mixed-target-seeda97c8e/SOURCES.json +++ b/research/d8-mixed-target-seeda97c8e/SOURCES.json @@ -4,25 +4,25 @@ "files": [ { "path": "autoresearch.md", - "usage": "input", + "usage": "provenance", "git_blob": "8d5403e0f10f68a61d0cb9294fa2e83e872d1d82", "sha256": "215b3222f6a943edc69422a28ac21ea1f397ddf54770f1d87ac4195385d73699" }, { "path": "certificates/selected-result.json", - "usage": "input", + "usage": "provenance", "git_blob": "ae6a99f28aa468649eb66a361e764d769363bf11", "sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32" }, { "path": "docs/research/agent-task-catalog.json", - "usage": "input", + "usage": "provenance", "git_blob": "06c96f5579bb67ed1b86d334e78fbed7da6945f1", "sha256": "6686ad58f1fbdbc87134a78901b60fd53a20d3984355e91defbbebc9e9fa8075" }, { "path": "docs/research/current-status.md", - "usage": "input", + "usage": "provenance", "git_blob": "d73b4ff9da41f044e793422db4318be17e234a6c", "sha256": "adb54af005eb11edaf84d782fe729338680ff908f6d4fbf39ba1062d2e7d8a77" }, diff --git a/research/historical-1042-link/SOURCES.json b/research/historical-1042-link/SOURCES.json index c6119ca5a8..6a1356cf2a 100644 --- a/research/historical-1042-link/SOURCES.json +++ b/research/historical-1042-link/SOURCES.json @@ -10,13 +10,13 @@ }, { "path": "docs/research/current-status.md", - "usage": "input", + "usage": "provenance", "git_blob": "4e0a8b7cdacc1d9680f7f81d03624118bb20416d", "sha256": "00a08925c51b26d168b8099ddeed659ac4381f7e04f3c7fd0e9de8e71f206823" }, { "path": "certificates/selected-result.json", - "usage": "input", + "usage": "provenance", "git_blob": "b1fea0c94436b236cc2b7d41a7be032811b94c81", "sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" }, diff --git a/research/historical-1042-link/VERIFY.json b/research/historical-1042-link/VERIFY.json index 5cff7b26c9..21d3b965ac 100644 --- a/research/historical-1042-link/VERIFY.json +++ b/research/historical-1042-link/VERIFY.json @@ -10,14 +10,14 @@ ], "commands": [ { - "argv": ["{python}", "-B", "{package}/verify.py"], - "timeout_seconds": 30, - "checks": "Compare the #1042 status link with the live record and the frontier1042 checkpoint." + "argv": ["{python}", "-B", "{package}/historical_replay.py"], + "timeout_seconds": 120, + "checks": "Authenticate and replay the unchanged PR3563 verifier, tests and receipt against its exact original three source blobs in a temporary snapshot. Current navigation is checked separately; all original invalidation paths remain declared." }, { "argv": ["{python}", "-B", "{package}/test_verify.py"], "timeout_seconds": 30, - "checks": "Check the printed decimal and the historical section cut." + "checks": "Check the unchanged printed decimal and historical section cut." } ] } diff --git a/research/historical-1042-link/historical_replay.py b/research/historical-1042-link/historical_replay.py new file mode 100644 index 0000000000..f46d15a9c2 --- /dev/null +++ b/research/historical-1042-link/historical_replay.py @@ -0,0 +1,115 @@ +#!/usr/bin/env python3 +"""Replay the unchanged PR3563 finding on its authenticated historical inputs. + +This adapter does not apply the old previous_record assertion to a new frontier. +Current navigation remains checked by tests/test_research_current_status.py. +Apache-2.0; prepared for Clear1nsight with substantial OpenAI assistance. +""" +from __future__ import annotations + +import hashlib +import json +import os +from pathlib import Path, PurePosixPath +import subprocess +import sys +import tempfile + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] +PUBLICATION = "f4657a0ad4c11a56646c8c6c422f09335b0c73ba" +PACKAGE = "research/historical-1042-link" +ORIGINAL = { + "verify.py": "12170922e5cd84746089d022f103bfe931fb8a15", + "test_verify.py": "140840530cbd9b4fdd80d8fa067334b61bfa4c17", + "RESULT.json": "a9d58d28814fc4a7c9b50a165b48d1a4f52d1892", + "SOURCES.json": "c6119ca5a8233edd0f8ed3a2e606de5b088d9fcf", +} +INPUTS = { + "docs/research/current-status.md", + "certificates/selected-result.json", + "certificates/checkpoints/frontier1042.json", +} + + +def require(ok: bool, message: str) -> None: + if not ok: + raise ValueError(message) + + +def blob_id(data: bytes) -> str: + return hashlib.sha1(b"blob " + str(len(data)).encode("ascii") + b"\0" + data).hexdigest() + + +def checked_path(path: str) -> str: + require(isinstance(path, str), "Non-text historical path") + p = PurePosixPath(path) + require(not p.is_absolute() and str(p) == path and ".." not in p.parts + and "\\" not in path and "\0" not in path, "Unsafe historical path") + return path + + +def git_bytes(root: Path, spec: str) -> bytes: + env = dict(os.environ) + env["GIT_NO_REPLACE_OBJECTS"] = "1" + result = subprocess.run( + ["git", "--no-replace-objects", "cat-file", "blob", spec], cwd=root, + env=env, check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, + timeout=30, + ) + return result.stdout + + +def authenticated_input(root: Path, base: str, row: dict) -> bytes: + path = checked_path(row["path"]) + require(len(base) == 40 and all(c in "0123456789abcdef" for c in base), + "Invalid historical base") + data = git_bytes(root, base + ":" + path) + require(blob_id(data) == row["git_blob"], "Historical Git blob mismatch: " + path) + require(hashlib.sha256(data).hexdigest() == row["sha256"], + "Historical SHA256 mismatch: " + path) + return data + + +def collect(root: Path = ROOT, here: Path = HERE) -> tuple[dict[str, bytes], dict]: + raw = git_bytes(root, PUBLICATION + ":" + PACKAGE + "/SOURCES.json") + require(blob_id(raw) == ORIGINAL["SOURCES.json"], "Original manifest changed") + manifest = json.loads(raw) + rows = [r for r in manifest["files"] if r["usage"] == "input"] + require(len(rows) == len(INPUTS) and {r["path"] for r in rows} == INPUTS, + "Original input inventory changed") + payload = {PACKAGE + "/SOURCES.json": raw} + for name in ("verify.py", "test_verify.py", "RESULT.json"): + path = here / name + require(path.is_file() and not path.is_symlink(), "Missing/aliased frozen file: " + name) + data = path.read_bytes() + require(blob_id(data) == ORIGINAL[name], "Frozen implementation/receipt changed: " + name) + payload[PACKAGE + "/" + name] = data + for row in rows: + data = authenticated_input(root, manifest["base_commit"], row) + payload[row["path"]] = data + if row["path"] == "certificates/checkpoints/frontier1042.json": + require((root / row["path"]).read_bytes() == data, "Live 1042 checkpoint drift") + return payload, manifest + + +def main() -> None: + payload, manifest = collect() + with tempfile.TemporaryDirectory(prefix="historical-1042-replay-") as directory: + root = Path(directory) + for relative, data in payload.items(): + path = root / checked_path(relative) + path.parent.mkdir(parents=True, exist_ok=True) + path.write_bytes(data) + flags = ["-I", "-B"] + (["-O"] if sys.flags.optimize else []) + for name in ("verify.py", "test_verify.py"): + subprocess.run([sys.executable, *flags, str(root / PACKAGE / name)], + cwd=root, check=True, timeout=30) + require(all((root / p).read_bytes() == b for p, b in payload.items()), + "Historical replay changed its inputs or receipt") + print("PASS_HISTORICAL_1042_SNAPSHOT base=" + manifest["base_commit"] + + " current_frontier_not_asserted=true") + + +if __name__ == "__main__": + main() diff --git a/research/pr4470-exact-transport-audit/README.md b/research/pr4470-exact-transport-audit/README.md new file mode 100644 index 0000000000..34b4bb94d1 --- /dev/null +++ b/research/pr4470-exact-transport-audit/README.md @@ -0,0 +1,47 @@ +# Exact physical transport audit of PR4470 + +This source-bound audit checks all 423 declared transport/helper-boundary pairs in PR4470 at `b9a13c1673e0e9697de410de16e8bbf3207a7363`. It claims no new kappa. The selected result and frozen scientific predecessor files are unchanged. + +The separately written checker reconstructs the reference frame catalogue and compares every entry of each 512 by 512 lowered matrix against the literal Gaussian-dyadic reference operator, in both orientations. It uses int64 Gaussian numerators and explicit powers-of-two denominators, not floating-point tolerances, predecessor interpreters, Clifford tableaux, or a zero-column-only phase comparison. A 28-Gaussian-gate cap keeps all arithmetic and squared magnitudes within int64. + +## Verification and reproduction + +The first complete hosted scientific replay passed in [run 39712725621](https://github.com/Clear1nsight/integer-mult-bounds/actions/runs/39712725621) at `f4657a0ad4c11a56646c8c6c422f09335b0c73ba`, with Python 3.12 and numpy==2.2.6. RESULT.json is the byte-exact downloaded receipt, SHA256 `53bdd869ebeee0980b139e422043922c87585bef90c2989969532ccb7b289a00`. It records 433,152 basis columns and 221,773,824 complex matrix entries compared, 196 positive self-checks, seven rejection controls, a tensor-phase control, and an actual-source phase mutation that preserves rank but fails equality. + +The earlier shared package plan failed four stale status/navigation assertions. The focused scientific pass was not a shared-CI pass. The separate [CI repair note](../../docs/research/pr14-ci-repair.md) records their correction without changing mathematical tests, selected records or frozen receipts. Exact-head hosted results must still be read from the PR checks. + +From a full checkout with Python 3.12: + +```sh +python -m pip install numpy==2.2.6 +python -B scripts/research_package.py --package research/pr4470-exact-transport-audit --check-only +python -B scripts/research_package.py --package research/pr4470-exact-transport-audit +python -B scripts/check_research_commit.py --package research/pr4470-exact-transport-audit --check-source-history +``` + +The registered replay freshly runs the unchanged scientific engine and compares every receipt field, then runs optimised scientific controls and five receipt-binding tests in normal and optimised modes. No runtime metadata is part of the scientific receipt. The source/receipt comparison rejects extra and missing fields and distinguishes booleans from integers. The five new wrapper tests passed locally on Python 3.13.5; registered Python 3.12 coverage is provided by the actual hosted job. + +A Git-free scientific replay is also available: + +```sh +python -I -B research/pr4470-exact-transport-audit/replay.py +python -I -O -B research/pr4470-exact-transport-audit/verify.py --self-test +``` + +SOURCES.json pins the four source exports to this fork's existing ancestor commit, so no unmerged foreign commit is needed. The original upstream identifiers and contributor notices remain in vendor/NOTICE.md. TASK.json preserves the original catalogue card and declares the narrowed scope. + +## Scope boundaries + +A passing full replay verifies the listed physical normal forms and their declared ranks/phases. It does not prove that the 423-pair list is exhaustive for the chronological word, replay the 632 persistent-field endpoint, admit the p16 controller, price physical movement, or establish precision, storage, and the outer multiplication theorem. Tensoring a checked operator identity preserves that identity for each positive column multiplicity; it does not by itself price the lifted implementation. + +## Task and overlap + +The scientific base remains canonical main `2a13eb1827784206202db90e5dc8327cf8a250db`, priority revision 7. Current main was refreshed to `f9f85c1e4fa1e955ff39f10fca447e3e2a4e4adc` during the workflow repair. The assigned PR4470 native audit refines independent-moment to physical operators rather than another root enclosure. PR4478 covers arithmetic, compiler and outer rows. PR4457 audits predecessor operators. PR4464/4466 cover stage-zero commutation. PR4504 independently reconstructs chronological frames and local billing, but leaves physical operators separate. This is targeted overlap coverage, not exhaustive novelty. The newer PR4483 compiler does not discharge this physical premise. + +## Open next questions + +First bind every chronological transition and helper endpoint from PR4504's independent reconstruction to the audited pair set, using canonical subspaces and orientation rather than raw frame IDs. Reject an omitted pair, a wrong orientation, and an unpriced transition. Then replay all 632 arbitrary persistent inputs and the owned centre under the assembled physical contract. A separate follow-up checks the actual p16 query/owner/erasure protocol. TASK.json gives the relevance, first step and blockers for both tasks. No new agent is claimed to have run these follow-ups. + +## Credit + +Prepared for Chris / Clear1nsight with substantial OpenAI assistance, Apache-2.0. This is separately implemented AI-assisted checking, not independent human or proof-kernel verification. Credit Cinna Davis for PR4470; zxv for receiver sharing, native/controller/compiler work and the reused PR4436 navigation repair; Jacob Alan Sussman for mixed-target recursion; Mark / Matarener for PR4457; Mihir Srivastava for PR4504; Ryanson Jonathan for PR4478; and the full retained notices in vendor/NOTICE.md. The historical CI adapter preserves James Reed's PR3563 result and the existing locale checker rather than silently updating their evidence. diff --git a/research/pr4470-exact-transport-audit/RESULT.json b/research/pr4470-exact-transport-audit/RESULT.json new file mode 100644 index 0000000000..d80b68175e --- /dev/null +++ b/research/pr4470-exact-transport-audit/RESULT.json @@ -0,0 +1,63 @@ +{ + "actual_source_phase_mutation_rejected": true, + "basis_columns_compared": 433152, + "complex_matrix_entries_compared": 221773824, + "coverage_index_sha256": "5f3923deb45470a9e9f3cf958e3876ea9e81bb2837f32b835196572993ed5d1f", + "frame_catalogue_count": 1224, + "matrix_dimension": 512, + "maximum_target_gaussian_gates": 16, + "new_kappa": false, + "not_covered": [ + "completeness of the declared 423-pair list", + "chronological native endpoint replay", + "p16 controller", + "physical tape costs", + "precision and storage", + "outer theorem" + ], + "orientations": 2, + "patch_changes": { + "A": 21, + "B": 238, + "cleanup_tail": 155, + "entrance": 38, + "exit": 47 + }, + "physical_pairs": 423, + "rank_histogram_both_orientations": { + "1": 262, + "2": 186, + "3": 264, + "4": 102, + "5": 16, + "7": 6, + "8": 8, + "9": 2 + }, + "schema": "pr4470-exact-transport-audit/v1", + "self_tests": { + "positive_checks": 196, + "rejected_controls": 7, + "tensor_phase_test": true + }, + "source_files": { + "CANONICAL.json.gz": { + "git_blob": "4a8c4ed26e53a72362d571c972e65aff546be784", + "sha256": "6418ec3da24d548a57f5c3fe5b9062c26c9478e638504a61c387f5cfb5f4ed61" + }, + "PR4447-PATCH.json": { + "git_blob": "f96d295d40014d4dd503f58eb3cdabcbb4b8e101", + "sha256": "9ab5328245ff02c9d0be21d39bcc375f50bc5d7909e9f7b9a3a9a6f812f5bd6e" + }, + "PR4470-NATIVE.json.gz": { + "git_blob": "0910f74138decf498e7fc445cc2daff4390169d6", + "sha256": "74582cce642c80f0235be7fcbce3716174666326ac6a1d46d02a62a75d7be4c6" + }, + "PR4470-PATCH.json": { + "git_blob": "51304a6601061ed4e698f910b09135ef109555e3", + "sha256": "296d0e8c58cc70febe042c681ef30d6bb469818c0835fbcaac8aa8d330f5b727" + } + }, + "source_head": "b9a13c1673e0e9697de410de16e8bbf3207a7363", + "status": "PASS_EXACT_TRANSPORT_MATRICES" +} diff --git a/research/pr4470-exact-transport-audit/SOURCES.json b/research/pr4470-exact-transport-audit/SOURCES.json new file mode 100644 index 0000000000..6e1ebbb572 --- /dev/null +++ b/research/pr4470-exact-transport-audit/SOURCES.json @@ -0,0 +1,46 @@ +{ + "schema_version": 1, + "base_commit": "2a13eb1827784206202db90e5dc8327cf8a250db", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "ed33caef5c5827693e9572d252a66f99cbb73d40", + "sha256": "5732707cc1e460b090b53f2463162749ad860de878a18f7408938671d295a9d9" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "64bfc5af6709ed9811171e0a2108f05e1219cb65", + "sha256": "352a6184713b8843d96fd2c2071eb7aeaa655906b7c51d45ad444912666c8a96" + }, + { + "path": "research/pr4470-exact-transport-audit/vendor/CANONICAL.json.gz", + "usage": "input", + "git_blob": "4a8c4ed26e53a72362d571c972e65aff546be784", + "sha256": "6418ec3da24d548a57f5c3fe5b9062c26c9478e638504a61c387f5cfb5f4ed61", + "pin": "head:f4657a0ad4c11a56646c8c6c422f09335b0c73ba:research/pr4470-exact-transport-audit/vendor/CANONICAL.json.gz" + }, + { + "path": "research/pr4470-exact-transport-audit/vendor/PR4447-PATCH.json", + "usage": "input", + "git_blob": "f96d295d40014d4dd503f58eb3cdabcbb4b8e101", + "sha256": "9ab5328245ff02c9d0be21d39bcc375f50bc5d7909e9f7b9a3a9a6f812f5bd6e", + "pin": "head:f4657a0ad4c11a56646c8c6c422f09335b0c73ba:research/pr4470-exact-transport-audit/vendor/PR4447-PATCH.json" + }, + { + "path": "research/pr4470-exact-transport-audit/vendor/PR4470-PATCH.json", + "usage": "input", + "git_blob": "51304a6601061ed4e698f910b09135ef109555e3", + "sha256": "296d0e8c58cc70febe042c681ef30d6bb469818c0835fbcaac8aa8d330f5b727", + "pin": "head:f4657a0ad4c11a56646c8c6c422f09335b0c73ba:research/pr4470-exact-transport-audit/vendor/PR4470-PATCH.json" + }, + { + "path": "research/pr4470-exact-transport-audit/vendor/PR4470-NATIVE.json.gz", + "usage": "input", + "git_blob": "0910f74138decf498e7fc445cc2daff4390169d6", + "sha256": "74582cce642c80f0235be7fcbce3716174666326ac6a1d46d02a62a75d7be4c6", + "pin": "head:f4657a0ad4c11a56646c8c6c422f09335b0c73ba:research/pr4470-exact-transport-audit/vendor/PR4470-NATIVE.json.gz" + } + ] +} diff --git a/research/pr4470-exact-transport-audit/TASK.json b/research/pr4470-exact-transport-audit/TASK.json new file mode 100644 index 0000000000..4d185c699b --- /dev/null +++ b/research/pr4470-exact-transport-audit/TASK.json @@ -0,0 +1,65 @@ +{ + "schema_version": 1, + "task_id": "independent-moment", + "priority_revision": 7, + "base_commit": "2a13eb1827784206202db90e5dc8327cf8a250db", + "original_card": { + "id": "independent-moment", + "question": "Does a new paid-profile or mixture-ceiling claim have independent source-bound coverage of its actual changed ledger?", + "starting_points": ["docs/research/research-family-status.md", "certificates/selected-result.json", "research/staged544-mixed-fourth-entry/README.md", "research/staged-fourth-mixture-ceiling/README.md", "research/r437-two-window-carrier/README.md"], + "methods": ["Independently reconstruct one changed paid ledger or pooled dual with exact source and model binding.", "Check a genuinely uncovered moment implication with a different enclosure method and semantic controls."], + "acceptance_gate": "Demonstrate independence, source binding, positive cases and semantic failure controls. Name the existing checks and the missing coverage. More digits or another equivalent evaluation of an unchanged root is not by itself new verification coverage.", + "first_step": { + "command": ["python3", "-B", "scripts/research_baseline.py"], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Choose one uncovered implication in #4088 literal mixed fill, #4091 pooled dual/model binding or #4067 changed frame/host bill. #4091 pins an earlier #4088 head: validate word, capacity and stock equivalence before applying that ceiling to the later fill.", + "scope": "Source-binding orientation only; no scientific replay, theorem acceptance or supplier admission. Budget any heavy replay separately." + }, + "first_experiment": "Independently reconstruct one changed ledger or pooled certificate with a positive case and a semantic failure control. Compare exact sources and name what existing checks miss. Keep this separate from supplier-boundary-audit (ordinary/outer dispatch) and uniform-transfer-audit (all-size proof). Stop after the chosen implication; more digits of an unchanged root are not additional mechanism coverage.", + "bottleneck_link": "Independent pricing prevents unsupported frontier claims and can reveal genuine accounting slack.", + "allowed_variations": ["Reconstruct either a source ledger or a numeric enclosure with a different method."], + "scope_change_triggers": ["Importing the primary function and calling its output independent verification.", "Calling an aggregate histogram or source archive an independently accepted physical supplier."], + "overlap_terms": ["independent moment", "rank histogram", "exact enclosure", "2979", "rank7 joint endframes", "paired extraction", "joint lowering", "4088", "4091", "4067", "staged544-mixed-fourth-entry", "staged-fourth-mixture-ceiling", "r437-two-window-carrier"], + "existing_checks": [ + {"scope": "PR #4088: mixed local/owner/phase ledger and moment reported.", "evidence": "research/staged544-mixed-fourth-entry/README.md", "remaining": "Independent binding of changed construction to paid histogram, distinct from full admission.", "status": "author-checked", "source_commit": "72d7efc181edb21806a878f174847c96dd410ab0", "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129"}, + {"scope": "PR #4091: sharp pooled ceiling proposed for fixed THREE/FOUR words and inventory.", "evidence": "research/staged-fourth-mixture-ceiling/README.md", "remaining": "Validate dual, exhaustive pattern scope and exact source equivalence before applying to newer fills.", "status": "author-checked", "source_commit": "a29bdd8f56cd18b805917775cdec09ff935eddc4", "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129"}, + {"scope": "PR #4067: paid (2,2) to (1,3) exchange and fixed OQ4 host reported.", "evidence": "research/r437-two-window-carrier/README.md", "remaining": "Independent full cost delta; remaining caller/precision/stock obligations are separate.", "status": "author-checked", "source_commit": "a95f11c52e3ca1e4c5171b3c20d8f4b0815aee2e", "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129"} + ] + }, + "scope_status": "refined", + "actual_scope": "Independently reconstruct and compare every entry of 423 declared PR4470 transport/helper normal forms in both orientations, with exact rank and absolute phase.", + "scope_change_reason": "User-assigned native audit narrowed to the physical-operator premise omitted by PR4504's chronological frame audit and PR4478's arithmetic checks.", + "scope_key": "pr4470-423-exact-matrices-b9a13c16", + "bottleneck_link": "Connect the charged recursive ranks to actual operators without mistaking an aggregate histogram for a physical supplier.", + "budget_minutes": 60, + "stop_rule": "Stop at the declared-pair matrix identity and controls. No completeness, full chronological native identity or new kappa claim.", + "outcome": "completed", + "evidence": "RESULT.json is the exact receipt from fork workflow 39712725621 at f4657a0ad4c11a56646c8c6c422f09335b0c73ba. The registered successor replays the unchanged engine and compares every field.", + "author": "Chris R / Clear1nsight, with substantial OpenAI assistance", + "ai_assistance": "Substantial OpenAI assistance. Separately implemented AI-assisted audit, not independent human or proof-kernel acceptance.", + "source_head": "b9a13c1673e0e9697de410de16e8bbf3207a7363", + "refresh_main": "f9f85c1e4fa1e955ff39f10fca447e3e2a4e4adc", + "original_card_first_step_status": "The historical baseline helper was not rerun in this workflow-repair session; current guidance was read through GitHub. No orientation PASS is claimed.", + "overlap": { + "method": "Targeted live PR/body and pinned-package reading; not an exhaustive local/Discussion snapshot.", + "nearby_prs": [4085, 4359, 4457, 4464, 4466, 4470, 4478, 4483, 4504], + "complete_discussion_pagination": false, + "find_overlap_helper_run": false, + "added_coverage": "Exact physical matrix entries and absolute phases of the listed pairs; completeness and chronological composition remain separate." + }, + "publication": {"repository": "Clear1nsight/integer-mult-bounds", "pull_request": 14, "upstream_pr_created": false}, + "open_questions": [ + { + "question": "Is the audited pair list complete for every chronological transition and helper endpoint?", + "why_it_matters": "All listed operators can be correct while a missing physical operation remains unverified.", + "first_step": "Join PR4504's independently reconstructed chronological demands to the 423 exact matrix records by canonical subspaces and orientation, rejecting missing or extra coverage.", + "blocked_by": "A source-bound coverage join and end-to-end arbitrary-column native replay are not supplied here." + }, + { + "question": "Does the p16 caller realise its full query, owner and erasure contract?", + "why_it_matters": "Formal controller diagonalisation does not price or implement the physical caller.", + "first_step": "Use the same PR4470 head, independently execute the owned-query protocol and bind each complete native invocation, with all spectator and scratch obligations explicit.", + "blocked_by": "Caller/native integration remains outside this pairwise audit." + } + ] +} diff --git a/research/pr4470-exact-transport-audit/VERIFY.json b/research/pr4470-exact-transport-audit/VERIFY.json new file mode 100644 index 0000000000..9843a5baf1 --- /dev/null +++ b/research/pr4470-exact-transport-audit/VERIFY.json @@ -0,0 +1,34 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": ["numpy==2.2.6"], + "inputs": [ + "research/pr4470-exact-transport-audit/vendor/CANONICAL.json.gz", + "research/pr4470-exact-transport-audit/vendor/PR4447-PATCH.json", + "research/pr4470-exact-transport-audit/vendor/PR4470-PATCH.json", + "research/pr4470-exact-transport-audit/vendor/PR4470-NATIVE.json.gz" + ], + "commands": [ + { + "argv": ["{python}", "-I", "-B", "{package}/replay.py"], + "timeout_seconds": 600, + "checks": "Fresh exact full-matrix replay of all 423 declared pairs in both orientations with source authentication, phase/rank controls and exact comparison of every hosted receipt field. No list-completeness or full native/theorem admission claim." + }, + { + "argv": ["{python}", "-I", "-O", "-B", "{package}/verify.py", "--self-test"], + "timeout_seconds": 60, + "checks": "196 positive checks, seven rejection controls and the tensor-phase control with assertions disabled." + }, + { + "argv": ["{python}", "-I", "-B", "{package}/test_replay.py"], + "timeout_seconds": 30, + "checks": "Five receipt/engine-binding tests reject changed scientific fields, scope fields, numeric types, missing/extra fields, corrupted receipts and changed engine bytes." + }, + { + "argv": ["{python}", "-I", "-O", "-B", "{package}/test_replay.py"], + "timeout_seconds": 30, + "checks": "The same five receipt controls with assertions disabled." + } + ] +} diff --git a/research/pr4470-exact-transport-audit/replay.py b/research/pr4470-exact-transport-audit/replay.py new file mode 100644 index 0000000000..caa2195092 --- /dev/null +++ b/research/pr4470-exact-transport-audit/replay.py @@ -0,0 +1,57 @@ +#!/usr/bin/env python3 +"""Fresh execution and exact comparison with the first hosted transport receipt. + +No mathematical field or source check is waived. Apache-2.0; OpenAI assistance. +""" +from __future__ import annotations +import hashlib +import json +from pathlib import Path +import subprocess +import sys +import tempfile + +HERE = Path(__file__).resolve().parent +EXPECTED_SHA256 = "53bdd869ebeee0980b139e422043922c87585bef90c2989969532ccb7b289a00" +ENGINE_BLOB = "1c9a9d6410e29b7c201547be9f0bef8685c4571b" + + +def require(ok: bool, message: str) -> None: + if not ok: + raise ValueError(message) + + +def load_expected(path: Path = HERE / "RESULT.json") -> dict: + require(path.is_file() and not path.is_symlink(), "Missing/aliased receipt") + raw = path.read_bytes() + require(hashlib.sha256(raw).hexdigest() == EXPECTED_SHA256, "Hosted receipt changed") + return json.loads(raw) + + +def compare(actual: object, expected: dict) -> None: + # Serialisation distinguishes bool/int and int/float, unlike dict equality. + encode = lambda value: json.dumps(value, sort_keys=True, separators=(",", ":"), allow_nan=False) + require(encode(actual) == encode(expected), "Scientific receipt mismatch") + + +def authenticate_engine(path: Path = HERE / "verify.py") -> None: + require(path.is_file() and not path.is_symlink(), "Missing/aliased engine") + raw = path.read_bytes() + actual = hashlib.sha1(b"blob " + str(len(raw)).encode("ascii") + b"\0" + raw).hexdigest() + require(actual == ENGINE_BLOB, "Scientific engine changed") + + +def main() -> None: + expected = load_expected() + authenticate_engine() + with tempfile.TemporaryDirectory(prefix="pr4470-exact-replay-") as directory: + out = Path(directory) / "fresh.json" + flags = ["-I", "-B"] + (["-O"] if sys.flags.optimize else []) + subprocess.run([sys.executable, *flags, str(HERE / "verify.py"), "--out", str(out)], + check=True, timeout=550) + compare(json.loads(out.read_text(encoding="utf-8")), expected) + print("PASS_PR4470_EXACT_TRANSPORT_REGISTERED all_receipt_fields=true") + + +if __name__ == "__main__": + main() diff --git a/research/pr4470-exact-transport-audit/test_replay.py b/research/pr4470-exact-transport-audit/test_replay.py new file mode 100644 index 0000000000..77bc0f7231 --- /dev/null +++ b/research/pr4470-exact-transport-audit/test_replay.py @@ -0,0 +1,51 @@ +"""Receipt comparison controls complement the scientific engine's controls.""" +import copy +import importlib.util +from pathlib import Path +import tempfile +import unittest + +HERE = Path(__file__).resolve().parent +SPEC = importlib.util.spec_from_file_location("transport_replay", HERE / "replay.py") +R = importlib.util.module_from_spec(SPEC) +SPEC.loader.exec_module(R) + + +class ReceiptTests(unittest.TestCase): + def test_exact_and_reordered_object(self): + value = R.load_expected() + R.compare(dict(reversed(list(value.items()))), value) + + def test_scientific_and_scope_fields_are_not_ignored(self): + value = R.load_expected() + for field, change in (("physical_pairs", 422), ("new_kappa", True), + ("source_head", "0" * 40), ("not_covered", [])): + actual = copy.deepcopy(value) + actual[field] = change + with self.assertRaises(ValueError): + R.compare(actual, value) + + def test_boolean_is_not_interchangeable_with_integer(self): + with self.assertRaises(ValueError): + R.compare({"positive": 1}, {"positive": True}) + with self.assertRaises(ValueError): + R.compare({"count": 1.0}, {"count": 1}) + + def test_extra_and_missing_fields_reject(self): + value = R.load_expected() + for actual in ({**value, "ignored": 0}, {k: v for k, v in value.items() if k != "status"}): + with self.assertRaises(ValueError): + R.compare(actual, value) + + def test_corrupted_expected_receipt_and_engine_reject(self): + with tempfile.TemporaryDirectory() as directory: + path = Path(directory) / "fixture" + path.write_bytes(b"{}\n") + with self.assertRaises(ValueError): + R.load_expected(path) + with self.assertRaises(ValueError): + R.authenticate_engine(path) + + +if __name__ == "__main__": + unittest.main() diff --git a/research/pr4470-exact-transport-audit/vendor/CANONICAL.json.gz b/research/pr4470-exact-transport-audit/vendor/CANONICAL.json.gz new file mode 100644 index 0000000000..4a8c4ed26e Binary files /dev/null and b/research/pr4470-exact-transport-audit/vendor/CANONICAL.json.gz differ diff --git a/research/pr4470-exact-transport-audit/vendor/NOTICE.md b/research/pr4470-exact-transport-audit/vendor/NOTICE.md new file mode 100644 index 0000000000..b84e0b8781 --- /dev/null +++ b/research/pr4470-exact-transport-audit/vendor/NOTICE.md @@ -0,0 +1,11 @@ +# Retained source notice + +These four files are unchanged byte-for-byte exports from Cinna Davis / 1337isnot1337's PR4470 at b9a13c1673e0e9697de410de16e8bbf3207a7363. They are retained scientific inputs, not new work by this audit. + +CANONICAL.json.gz is research/kappa-rebuild/complex/full-identity-certificates/THREE-base-FULL-IDENTITY-CANONICAL.json.gz. PR4447-PATCH.json is research/missing-join-frame/PATCH.json. PR4470-PATCH.json and PR4470-NATIVE.json.gz are research/joint-helper-lattice/PATCH.json and NATIVE.json.gz respectively. + +The immediate native, controller and compiler lineage credits zxv, Cinna Davis, Jacob Alan Sussman, David Ganz, Rohan Arun, Marius-Paul Dumitrean, Erwan Secousses, and the retained scalar, Clifford, geometry, BIT, precision, and outer-framework contributors. See canonical main docs/research/community-productive4359-contributors.md and the predecessor package notices. PR4457 by Mark / Matarener is methodological precedent for an independent operator audit. PR4478 by Ryanson Jonathan covers the separate arithmetic chain. PR4464/4466 cover the separate stage-zero commutation and translation questions. + +The source packages identify their new material as Apache-2.0 with substantial AI assistance. Original source ownership and attribution are retained. This audit does not claim authorship of their constructions, declare their full theorem independently accepted, or modify their frozen inputs. + +The reference operator convention is pinned to clifford_exact.py blob 166841a037f069249f6f7f6dedb89248812f59e2 at the same head. The checker reimplements its documented reference frame and monomial meanings but does not import its compiler, tableau evaluator, zero-state routine, or any predecessor verifier. diff --git a/research/pr4470-exact-transport-audit/vendor/PR4447-PATCH.json b/research/pr4470-exact-transport-audit/vendor/PR4447-PATCH.json new file mode 100644 index 0000000000..f96d295d40 --- /dev/null +++ b/research/pr4470-exact-transport-audit/vendor/PR4447-PATCH.json @@ -0,0 +1,24 @@ +{ + "phase": "B", + "ordinal": 480, + "old_frame": 732, + "new_basis": [ + 168, + 336, + 45 + ], + "old_basis": [ + 258, + 133, + 82, + 45 + ], + "incoming_frames": [ + 364, + 360 + ], + "outgoing_frames": [ + 736, + 692 + ] +} diff --git a/research/pr4470-exact-transport-audit/vendor/PR4470-NATIVE.json.gz b/research/pr4470-exact-transport-audit/vendor/PR4470-NATIVE.json.gz new file mode 100644 index 0000000000..0910f74138 Binary files /dev/null and b/research/pr4470-exact-transport-audit/vendor/PR4470-NATIVE.json.gz differ diff --git a/research/pr4470-exact-transport-audit/vendor/PR4470-PATCH.json b/research/pr4470-exact-transport-audit/vendor/PR4470-PATCH.json new file mode 100644 index 0000000000..51304a6601 --- /dev/null +++ b/research/pr4470-exact-transport-audit/vendor/PR4470-PATCH.json @@ -0,0 +1,8991 @@ +{ + "changes": [ + { + "new": [ + 51 + ], + "old": [], + "ordinal": 449, + "phase": "entrance" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 451, + "phase": "entrance" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 453, + "phase": "entrance" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 455, + "phase": "entrance" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 482, + "phase": "entrance" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 483, + "phase": "entrance" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 502, + "phase": "entrance" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 503, + "phase": "entrance" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 504, + "phase": "entrance" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 525, + "phase": "entrance" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 526, + "phase": "entrance" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 527, + "phase": "entrance" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 548, + "phase": "entrance" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 549, + "phase": "entrance" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 550, + "phase": "entrance" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 551, + "phase": "entrance" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 578, + "phase": "entrance" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 580, + "phase": "entrance" + }, + { + "new": [], + "old": [ + 45, + 76 + ], + "ordinal": 594, + "phase": "entrance" + }, + { + "new": [], + "old": [ + 45, + 76 + ], + "ordinal": 595, + "phase": "entrance" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 598, + "phase": "entrance" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 599, + "phase": "entrance" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 600, + "phase": "entrance" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 601, + "phase": "entrance" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 606, + "phase": "entrance" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 607, + "phase": "entrance" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 608, + "phase": "entrance" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 609, + "phase": "entrance" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 614, + "phase": "entrance" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 615, + "phase": "entrance" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 616, + "phase": "entrance" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 617, + "phase": "entrance" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 622, + "phase": "entrance" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 623, + "phase": "entrance" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 624, + "phase": "entrance" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 625, + "phase": "entrance" + }, + { + "new": [ + 7, + 51, + 82, + 136, + 264 + ], + "old": [ + 51, + 85, + 136, + 264 + ], + "ordinal": 626, + "phase": "entrance" + }, + { + "new": [ + 7, + 51, + 82, + 136, + 264 + ], + "old": [ + 51, + 85, + 136, + 264 + ], + "ordinal": 627, + "phase": "entrance" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 627, + "phase": "A" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 628, + "phase": "A" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 629, + "phase": "A" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 630, + "phase": "A" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 631, + "phase": "A" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 632, + "phase": "A" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 633, + "phase": "A" + }, + { + "new": [ + 11, + 21, + 38, + 448 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 1997, + "phase": "A" + }, + { + "new": [ + 11, + 21, + 38, + 448 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 2002, + "phase": "A" + }, + { + "new": [ + 45, + 85, + 133, + 261 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 2151, + "phase": "A" + }, + { + "new": [ + 45, + 85, + 133, + 261 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 2156, + "phase": "A" + }, + { + "new": [ + 14, + 35, + 69, + 400 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 2305, + "phase": "A" + }, + { + "new": [ + 14, + 35, + 69, + 400 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 2310, + "phase": "A" + }, + { + "new": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 4007, + "phase": "A" + }, + { + "new": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 4008, + "phase": "A" + }, + { + "new": [ + 3, + 5, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 4013, + "phase": "A" + }, + { + "new": [ + 3, + 5, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 4014, + "phase": "A" + }, + { + "new": [ + 2, + 4, + 9, + 17, + 32, + 64, + 128, + 256 + ], + "old": [ + 4, + 11, + 17, + 34, + 64, + 128, + 256 + ], + "ordinal": 4019, + "phase": "A" + }, + { + "new": [ + 1, + 2, + 8, + 20, + 36, + 64, + 128, + 256 + ], + "old": [ + 1, + 10, + 20, + 38, + 64, + 128, + 256 + ], + "ordinal": 4025, + "phase": "A" + }, + { + "new": [ + 2, + 4, + 8, + 16, + 33, + 65, + 128, + 256 + ], + "old": [ + 4, + 10, + 16, + 35, + 65, + 128, + 256 + ], + "ordinal": 4043, + "phase": "A" + }, + { + "new": [ + 1, + 2, + 12, + 16, + 32, + 68, + 128, + 256 + ], + "old": [ + 1, + 14, + 16, + 34, + 68, + 128, + 256 + ], + "ordinal": 4049, + "phase": "A" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 5, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 6, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 7, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 8, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 9, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 10, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 17, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 18, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 21, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 22, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 25, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 26, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 29, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 30, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 33, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 34, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 37, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 38, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 41, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 42, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 44, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 45, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 47, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 49, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 50, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 97, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 98, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 99, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 100, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 101, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 102, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 103, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 104, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 105, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 106, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 107, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 108, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 109, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 110, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 111, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 112, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 113, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 114, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 135, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 136, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 137, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 138, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 139, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 140, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 141, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 142, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 143, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 144, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 145, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 146, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 147, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 148, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 149, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 150, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 151, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 152, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 153, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 154, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 171, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 172, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 173, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 174, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 175, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 176, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 177, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 178, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 179, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 180, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 181, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 182, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 183, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 184, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 185, + "phase": "B" + }, + { + "new": [ + 30 + ], + "old": [], + "ordinal": 186, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 199, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 200, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 201, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 202, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 203, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 204, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 205, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 206, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 207, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 208, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 209, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 210, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 211, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 212, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 213, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 214, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 234, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 235, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 236, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [], + "ordinal": 237, + "phase": "B" + }, + { + "new": [ + 7, + 51, + 82, + 136, + 264 + ], + "old": [ + 51, + 85, + 136, + 264 + ], + "ordinal": 238, + "phase": "B" + }, + { + "new": [ + 7, + 51, + 82, + 136, + 264 + ], + "old": [ + 51, + 85, + 136, + 264 + ], + "ordinal": 239, + "phase": "B" + }, + { + "new": [ + 7, + 51, + 82, + 136, + 264 + ], + "old": [ + 51, + 85, + 136, + 264 + ], + "ordinal": 240, + "phase": "B" + }, + { + "new": [ + 7, + 51, + 82, + 136, + 264 + ], + "old": [ + 51, + 85, + 136, + 264 + ], + "ordinal": 241, + "phase": "B" + }, + { + "new": [ + 7, + 51, + 82, + 136, + 264 + ], + "old": [ + 51, + 85, + 136, + 264 + ], + "ordinal": 242, + "phase": "B" + }, + { + "new": [ + 7, + 51, + 82, + 136, + 264 + ], + "old": [ + 51, + 85, + 136, + 264 + ], + "ordinal": 243, + "phase": "B" + }, + { + "new": [ + 7, + 51, + 82, + 136, + 264 + ], + "old": [ + 51, + 85, + 136, + 264 + ], + "ordinal": 244, + "phase": "B" + }, + { + "new": [ + 7, + 51, + 82, + 136, + 264 + ], + "old": [ + 51, + 85, + 136, + 264 + ], + "ordinal": 245, + "phase": "B" + }, + { + "new": [ + 7, + 51, + 82, + 136, + 264 + ], + "old": [ + 51, + 85, + 136, + 264 + ], + "ordinal": 246, + "phase": "B" + }, + { + "new": [ + 7, + 51, + 82, + 136, + 264 + ], + "old": [ + 51, + 85, + 136, + 264 + ], + "ordinal": 247, + "phase": "B" + }, + { + "new": [ + 7, + 51, + 82, + 136, + 264 + ], + "old": [ + 51, + 85, + 136, + 264 + ], + "ordinal": 248, + "phase": "B" + }, + { + "new": [ + 7, + 51, + 82, + 136, + 264 + ], + "old": [ + 51, + 85, + 136, + 264 + ], + "ordinal": 249, + "phase": "B" + }, + { + "new": [ + 7, + 42, + 80, + 144, + 256 + ], + "old": [ + 45, + 80, + 144, + 256 + ], + "ordinal": 332, + "phase": "B" + }, + { + "new": [ + 2, + 5, + 9, + 33, + 208, + 336 + ], + "old": [ + 5, + 11, + 35, + 208, + 336 + ], + "ordinal": 335, + "phase": "B" + }, + { + "new": [ + 2, + 5, + 9, + 33, + 80, + 400 + ], + "old": [ + 5, + 11, + 35, + 80, + 400 + ], + "ordinal": 336, + "phase": "B" + }, + { + "new": [ + 7, + 16, + 42, + 64, + 128, + 256 + ], + "old": [ + 16, + 45, + 64, + 128, + 256 + ], + "ordinal": 337, + "phase": "B" + }, + { + "new": [ + 7, + 9, + 16, + 35, + 64, + 128, + 256 + ], + "old": [ + 14, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 338, + "phase": "B" + }, + { + "new": [ + 2, + 5, + 9, + 16, + 33, + 192, + 320 + ], + "old": [ + 5, + 11, + 16, + 35, + 192, + 320 + ], + "ordinal": 339, + "phase": "B" + }, + { + "new": [ + 2, + 5, + 9, + 33, + 80, + 128, + 272 + ], + "old": [ + 5, + 11, + 35, + 80, + 128, + 272 + ], + "ordinal": 340, + "phase": "B" + }, + { + "new": [ + 2, + 5, + 9, + 33, + 80, + 144, + 256 + ], + "old": [ + 5, + 11, + 35, + 80, + 144, + 256 + ], + "ordinal": 341, + "phase": "B" + }, + { + "new": [ + 45, + 73, + 137, + 286 + ], + "old": [ + 25, + 45, + 73, + 137, + 263 + ], + "ordinal": 353, + "phase": "B" + }, + { + "new": [ + 45, + 87, + 137, + 265 + ], + "old": [ + 25, + 45, + 78, + 137, + 265 + ], + "ordinal": 355, + "phase": "B" + }, + { + "new": [ + 45, + 80, + 146, + 261 + ], + "old": [ + 2, + 45, + 80, + 144, + 261 + ], + "ordinal": 374, + "phase": "B" + }, + { + "new": [ + 5, + 40, + 194, + 265 + ], + "old": [ + 5, + 40, + 82, + 144, + 265 + ], + "ordinal": 376, + "phase": "B" + }, + { + "new": [], + "old": [ + 45, + 76 + ], + "ordinal": 388, + "phase": "B" + }, + { + "new": [ + 45, + 400 + ], + "old": [ + 45, + 76, + 400 + ], + "ordinal": 389, + "phase": "B" + }, + { + "new": [ + 45, + 69, + 400 + ], + "old": [ + 9, + 36, + 69, + 400 + ], + "ordinal": 394, + "phase": "B" + }, + { + "new": [ + 45, + 69, + 146, + 272 + ], + "old": [ + 9, + 36, + 69, + 146, + 272 + ], + "ordinal": 397, + "phase": "B" + }, + { + "new": [ + 45, + 69, + 130, + 274 + ], + "old": [ + 9, + 36, + 69, + 130, + 274 + ], + "ordinal": 398, + "phase": "B" + }, + { + "new": [ + 45, + 73, + 144, + 274 + ], + "old": [ + 5, + 40, + 73, + 144, + 274 + ], + "ordinal": 399, + "phase": "B" + }, + { + "new": [], + "old": [ + 45, + 76 + ], + "ordinal": 410, + "phase": "B" + }, + { + "new": [ + 45, + 475 + ], + "old": [ + 45, + 76, + 407 + ], + "ordinal": 411, + "phase": "B" + }, + { + "new": [ + 14, + 35, + 469 + ], + "old": [ + 14, + 35, + 66, + 407 + ], + "ordinal": 416, + "phase": "B" + }, + { + "new": [ + 14, + 35, + 130, + 341 + ], + "old": [ + 14, + 35, + 66, + 130, + 279 + ], + "ordinal": 419, + "phase": "B" + }, + { + "new": [ + 14, + 35, + 215, + 258 + ], + "old": [ + 14, + 35, + 66, + 149, + 258 + ], + "ordinal": 420, + "phase": "B" + }, + { + "new": [ + 28, + 45, + 199, + 268 + ], + "old": [ + 28, + 45, + 76, + 139, + 268 + ], + "ordinal": 421, + "phase": "B" + }, + { + "new": [ + 2, + 5, + 40, + 217, + 256 + ], + "old": [ + 5, + 40, + 219, + 256 + ], + "ordinal": 440, + "phase": "B" + }, + { + "new": [ + 7, + 18, + 42, + 66, + 393 + ], + "old": [ + 21, + 45, + 69, + 398 + ], + "ordinal": 441, + "phase": "B" + }, + { + "new": [ + 7, + 42, + 66, + 130, + 258 + ], + "old": [ + 45, + 69, + 133, + 261 + ], + "ordinal": 442, + "phase": "B" + }, + { + "new": [ + 7, + 18, + 42, + 66, + 130, + 258 + ], + "old": [ + 21, + 45, + 69, + 133, + 261 + ], + "ordinal": 443, + "phase": "B" + }, + { + "new": [ + 2, + 5, + 16, + 40, + 64, + 393 + ], + "old": [ + 5, + 16, + 40, + 64, + 395 + ], + "ordinal": 444, + "phase": "B" + }, + { + "new": [ + 2, + 5, + 40, + 89, + 128, + 256 + ], + "old": [ + 5, + 40, + 91, + 128, + 256 + ], + "ordinal": 445, + "phase": "B" + }, + { + "new": [ + 2, + 5, + 25, + 40, + 64, + 128, + 256 + ], + "old": [ + 5, + 27, + 40, + 64, + 128, + 256 + ], + "ordinal": 446, + "phase": "B" + }, + { + "new": [ + 7, + 11, + 18, + 33, + 66, + 130, + 258 + ], + "old": [ + 11, + 21, + 38, + 69, + 133, + 261 + ], + "ordinal": 447, + "phase": "B" + }, + { + "new": [ + 2, + 5, + 16, + 40, + 64, + 128, + 265 + ], + "old": [ + 5, + 16, + 40, + 64, + 128, + 267 + ], + "ordinal": 448, + "phase": "B" + }, + { + "new": [ + 2, + 5, + 16, + 40, + 64, + 137, + 256 + ], + "old": [ + 5, + 16, + 40, + 64, + 139, + 256 + ], + "ordinal": 449, + "phase": "B" + }, + { + "new": [ + 28, + 45, + 194, + 258 + ], + "old": [ + 5, + 25, + 40, + 194, + 258 + ], + "ordinal": 461, + "phase": "B" + }, + { + "new": [ + 21, + 45, + 66, + 386 + ], + "old": [ + 12, + 21, + 33, + 66, + 386 + ], + "ordinal": 462, + "phase": "B" + }, + { + "new": [ + 5, + 40, + 137, + 336 + ], + "old": [ + 5, + 40, + 82, + 137, + 258 + ], + "ordinal": 483, + "phase": "B" + }, + { + "new": [ + 45, + 80, + 137, + 274 + ], + "old": [ + 2, + 45, + 80, + 137, + 272 + ], + "ordinal": 485, + "phase": "B" + }, + { + "new": [ + 4, + 8, + 17, + 34, + 64, + 387 + ], + "old": [ + 4, + 17, + 34, + 64, + 395 + ], + "ordinal": 530, + "phase": "B" + }, + { + "new": [ + 3, + 8, + 17, + 33, + 68, + 388 + ], + "old": [ + 11, + 17, + 34, + 68, + 388 + ], + "ordinal": 532, + "phase": "B" + }, + { + "new": [ + 12, + 21, + 38, + 71, + 132, + 260 + ], + "old": [ + 21, + 38, + 75, + 132, + 260 + ], + "ordinal": 556, + "phase": "B" + }, + { + "new": [ + 11, + 18, + 33, + 64, + 132, + 260 + ], + "old": [ + 11, + 51, + 64, + 132, + 260 + ], + "ordinal": 558, + "phase": "B" + }, + { + "new": [ + 6, + 10, + 18, + 32, + 65, + 385 + ], + "old": [ + 10, + 20, + 38, + 65, + 385 + ], + "ordinal": 583, + "phase": "B" + }, + { + "new": [ + 1, + 10, + 20, + 32, + 64, + 390 + ], + "old": [ + 1, + 10, + 20, + 64, + 422 + ], + "ordinal": 585, + "phase": "B" + }, + { + "new": [ + 12, + 18, + 38, + 64, + 129, + 257 + ], + "old": [ + 30, + 38, + 64, + 129, + 257 + ], + "ordinal": 608, + "phase": "B" + }, + { + "new": [ + 11, + 21, + 33, + 71, + 129, + 257 + ], + "old": [ + 11, + 21, + 102, + 129, + 257 + ], + "ordinal": 610, + "phase": "B" + }, + { + "new": [ + 1, + 6, + 24, + 32, + 64, + 394 + ], + "old": [ + 6, + 24, + 32, + 64, + 395 + ], + "ordinal": 632, + "phase": "B" + }, + { + "new": [ + 1, + 6, + 10, + 18, + 96, + 416 + ], + "old": [ + 6, + 11, + 19, + 96, + 416 + ], + "ordinal": 634, + "phase": "B" + }, + { + "new": [ + 7, + 25, + 33, + 75, + 129, + 257 + ], + "old": [ + 30, + 38, + 75, + 134, + 262 + ], + "ordinal": 658, + "phase": "B" + }, + { + "new": [ + 7, + 11, + 18, + 64, + 160, + 288 + ], + "old": [ + 11, + 21, + 64, + 160, + 288 + ], + "ordinal": 660, + "phase": "B" + }, + { + "new": [ + 51 + ], + "old": [ + 3, + 48, + 72, + 413 + ], + "ordinal": 685, + "phase": "B" + }, + { + "new": [ + 3, + 4, + 17, + 33, + 72, + 392 + ], + "old": [ + 3, + 21, + 37, + 72, + 392 + ], + "ordinal": 687, + "phase": "B" + }, + { + "new": [ + 3, + 4, + 8, + 48, + 64, + 401 + ], + "old": [ + 3, + 8, + 48, + 64, + 405 + ], + "ordinal": 689, + "phase": "B" + }, + { + "new": [ + 7, + 18, + 33, + 64, + 136, + 264 + ], + "old": [ + 21, + 38, + 64, + 136, + 264 + ], + "ordinal": 711, + "phase": "B" + }, + { + "new": [ + 7, + 11, + 51, + 82, + 131, + 259 + ], + "old": [ + 11, + 51, + 85, + 131, + 259 + ], + "ordinal": 713, + "phase": "B" + }, + { + "new": [ + 4, + 51, + 82, + 136, + 264 + ], + "old": [ + 4, + 51, + 136, + 264 + ], + "ordinal": 759, + "phase": "B" + }, + { + "new": [ + 30, + 32, + 76, + 129, + 257 + ], + "old": [ + 30, + 32, + 129, + 257 + ], + "ordinal": 769, + "phase": "B" + }, + { + "new": [ + 13, + 19, + 33, + 455 + ], + "old": [ + 13, + 19, + 33, + 65, + 390 + ], + "ordinal": 770, + "phase": "B" + }, + { + "new": [ + 10, + 20, + 32, + 70, + 129, + 257 + ], + "old": [ + 30, + 32, + 70, + 129, + 257 + ], + "ordinal": 779, + "phase": "B" + }, + { + "new": [ + 10, + 20, + 32, + 65, + 129, + 262 + ], + "old": [ + 10, + 20, + 65, + 161, + 262 + ], + "ordinal": 784, + "phase": "B" + }, + { + "new": [ + 15, + 17, + 37, + 67, + 129, + 257 + ], + "old": [ + 30, + 37, + 67, + 129, + 257 + ], + "ordinal": 840, + "phase": "B" + }, + { + "new": [ + 8, + 22, + 34, + 68, + 129, + 257 + ], + "old": [ + 8, + 22, + 102, + 129, + 257 + ], + "ordinal": 841, + "phase": "B" + }, + { + "new": [ + 2, + 28, + 40, + 76, + 129, + 257 + ], + "old": [ + 2, + 28, + 100, + 129, + 257 + ], + "ordinal": 842, + "phase": "B" + }, + { + "new": [ + 5, + 27, + 42, + 73, + 129, + 257 + ], + "old": [ + 30, + 47, + 73, + 129, + 257 + ], + "ordinal": 843, + "phase": "B" + }, + { + "new": [ + 10, + 20, + 32, + 65, + 131, + 260 + ], + "old": [ + 10, + 20, + 65, + 131, + 292 + ], + "ordinal": 848, + "phase": "B" + }, + { + "new": [ + 10, + 20, + 32, + 65, + 132, + 259 + ], + "old": [ + 10, + 20, + 65, + 164, + 259 + ], + "ordinal": 849, + "phase": "B" + }, + { + "new": [ + 5, + 10, + 17, + 32, + 65, + 386 + ], + "old": [ + 10, + 20, + 37, + 65, + 386 + ], + "ordinal": 850, + "phase": "B" + }, + { + "new": [ + 2, + 8, + 20, + 32, + 65, + 389 + ], + "old": [ + 2, + 8, + 20, + 65, + 421 + ], + "ordinal": 851, + "phase": "B" + }, + { + "new": [ + 7, + 24, + 43, + 74, + 136, + 264 + ], + "old": [ + 31, + 44, + 74, + 136, + 264 + ], + "ordinal": 872, + "phase": "B" + }, + { + "new": [ + 1, + 6, + 50, + 82, + 136, + 264 + ], + "old": [ + 1, + 50, + 84, + 136, + 264 + ], + "ordinal": 873, + "phase": "B" + }, + { + "new": [ + 2, + 5, + 49, + 80, + 136, + 264 + ], + "old": [ + 2, + 49, + 85, + 136, + 264 + ], + "ordinal": 874, + "phase": "B" + }, + { + "new": [ + 7, + 27, + 40, + 73, + 136, + 264 + ], + "old": [ + 28, + 47, + 73, + 136, + 264 + ], + "ordinal": 875, + "phase": "B" + }, + { + "new": [ + 3, + 4, + 48, + 72, + 137, + 272 + ], + "old": [ + 3, + 48, + 72, + 137, + 276 + ], + "ordinal": 880, + "phase": "B" + }, + { + "new": [ + 3, + 4, + 48, + 72, + 144, + 265 + ], + "old": [ + 3, + 48, + 72, + 148, + 265 + ], + "ordinal": 881, + "phase": "B" + }, + { + "new": [ + 3, + 4, + 24, + 40, + 72, + 385 + ], + "old": [ + 3, + 28, + 44, + 72, + 385 + ], + "ordinal": 882, + "phase": "B" + }, + { + "new": [ + 1, + 2, + 4, + 48, + 72, + 408 + ], + "old": [ + 1, + 2, + 48, + 72, + 412 + ], + "ordinal": 883, + "phase": "B" + }, + { + "new": [], + "old": [ + 2, + 5, + 40, + 80, + 409 + ], + "ordinal": 928, + "phase": "B" + }, + { + "new": [], + "old": [ + 7, + 42, + 75, + 144 + ], + "ordinal": 949, + "phase": "B" + }, + { + "new": [], + "old": [ + 7, + 42, + 75, + 144 + ], + "ordinal": 951, + "phase": "B" + }, + { + "new": [ + 10, + 20, + 32, + 65, + 131, + 260 + ], + "old": [ + 10, + 20, + 65, + 131, + 292 + ], + "ordinal": 1052, + "phase": "B" + }, + { + "new": [ + 10, + 20, + 32, + 65, + 132, + 259 + ], + "old": [ + 10, + 20, + 65, + 164, + 259 + ], + "ordinal": 1053, + "phase": "B" + }, + { + "new": [ + 5, + 10, + 17, + 32, + 65, + 386 + ], + "old": [ + 10, + 20, + 37, + 65, + 386 + ], + "ordinal": 1054, + "phase": "B" + }, + { + "new": [ + 2, + 8, + 20, + 32, + 65, + 389 + ], + "old": [ + 2, + 8, + 20, + 65, + 421 + ], + "ordinal": 1055, + "phase": "B" + }, + { + "new": [ + 7, + 24, + 43, + 74, + 136, + 264 + ], + "old": [ + 31, + 44, + 74, + 136, + 264 + ], + "ordinal": 1101, + "phase": "B" + }, + { + "new": [ + 1, + 6, + 50, + 82, + 136, + 264 + ], + "old": [ + 1, + 50, + 84, + 136, + 264 + ], + "ordinal": 1102, + "phase": "B" + }, + { + "new": [ + 2, + 5, + 49, + 80, + 136, + 264 + ], + "old": [ + 2, + 49, + 85, + 136, + 264 + ], + "ordinal": 1103, + "phase": "B" + }, + { + "new": [ + 7, + 27, + 40, + 73, + 136, + 264 + ], + "old": [ + 28, + 47, + 73, + 136, + 264 + ], + "ordinal": 1104, + "phase": "B" + }, + { + "new": [ + 3, + 4, + 48, + 72, + 137, + 272 + ], + "old": [ + 3, + 48, + 72, + 137, + 276 + ], + "ordinal": 1121, + "phase": "B" + }, + { + "new": [ + 3, + 4, + 48, + 72, + 144, + 265 + ], + "old": [ + 3, + 48, + 72, + 148, + 265 + ], + "ordinal": 1122, + "phase": "B" + }, + { + "new": [ + 3, + 4, + 24, + 40, + 72, + 385 + ], + "old": [ + 3, + 28, + 44, + 72, + 385 + ], + "ordinal": 1123, + "phase": "B" + }, + { + "new": [ + 1, + 2, + 4, + 48, + 72, + 408 + ], + "old": [ + 1, + 2, + 48, + 72, + 412 + ], + "ordinal": 1124, + "phase": "B" + }, + { + "new": [ + 3, + 12, + 21, + 37, + 68, + 132, + 260 + ], + "old": [ + 15, + 21, + 38, + 68, + 132, + 260 + ], + "ordinal": 1185, + "phase": "B" + }, + { + "new": [ + 4, + 8, + 17, + 34, + 67, + 128, + 256 + ], + "old": [ + 4, + 17, + 34, + 75, + 128, + 256 + ], + "ordinal": 1186, + "phase": "B" + }, + { + "new": [ + 4, + 11, + 18, + 33, + 64, + 128, + 256 + ], + "old": [ + 4, + 11, + 51, + 64, + 128, + 256 + ], + "ordinal": 1187, + "phase": "B" + }, + { + "new": [ + 3, + 8, + 17, + 33, + 64, + 132, + 260 + ], + "old": [ + 11, + 17, + 34, + 64, + 132, + 260 + ], + "ordinal": 1188, + "phase": "B" + }, + { + "new": [ + 4, + 8, + 17, + 34, + 64, + 128, + 259 + ], + "old": [ + 4, + 17, + 34, + 64, + 128, + 267 + ], + "ordinal": 1194, + "phase": "B" + }, + { + "new": [ + 3, + 8, + 17, + 33, + 68, + 132, + 256 + ], + "old": [ + 11, + 17, + 34, + 68, + 132, + 256 + ], + "ordinal": 1196, + "phase": "B" + }, + { + "new": [ + 1, + 12, + 18, + 38, + 64, + 128, + 256 + ], + "old": [ + 1, + 30, + 38, + 64, + 128, + 256 + ], + "ordinal": 1201, + "phase": "B" + }, + { + "new": [ + 6, + 10, + 18, + 32, + 64, + 129, + 257 + ], + "old": [ + 10, + 20, + 38, + 64, + 129, + 257 + ], + "ordinal": 1202, + "phase": "B" + }, + { + "new": [ + 6, + 11, + 19, + 33, + 65, + 129, + 257 + ], + "old": [ + 11, + 21, + 39, + 65, + 129, + 257 + ], + "ordinal": 1203, + "phase": "B" + }, + { + "new": [ + 1, + 10, + 20, + 32, + 70, + 128, + 256 + ], + "old": [ + 1, + 10, + 20, + 102, + 128, + 256 + ], + "ordinal": 1204, + "phase": "B" + }, + { + "new": [ + 1, + 10, + 20, + 32, + 70, + 128, + 256 + ], + "old": [ + 1, + 30, + 32, + 70, + 128, + 256 + ], + "ordinal": 1205, + "phase": "B" + }, + { + "new": [ + 6, + 10, + 18, + 32, + 65, + 129, + 256 + ], + "old": [ + 10, + 20, + 38, + 65, + 129, + 256 + ], + "ordinal": 1210, + "phase": "B" + }, + { + "new": [ + 1, + 10, + 20, + 32, + 64, + 128, + 262 + ], + "old": [ + 1, + 10, + 20, + 64, + 128, + 294 + ], + "ordinal": 1212, + "phase": "B" + }, + { + "new": [ + 1, + 10, + 20, + 32, + 64, + 128, + 262 + ], + "old": [ + 10, + 20, + 33, + 65, + 128, + 262 + ], + "ordinal": 1213, + "phase": "B" + }, + { + "new": [ + 7, + 10, + 19, + 33, + 65, + 129, + 257 + ], + "old": [ + 13, + 19, + 38, + 70, + 134, + 262 + ], + "ordinal": 1217, + "phase": "B" + }, + { + "new": [ + 1, + 6, + 24, + 32, + 74, + 128, + 256 + ], + "old": [ + 6, + 24, + 32, + 75, + 128, + 256 + ], + "ordinal": 1218, + "phase": "B" + }, + { + "new": [ + 7, + 11, + 18, + 32, + 64, + 128, + 256 + ], + "old": [ + 11, + 21, + 32, + 64, + 128, + 256 + ], + "ordinal": 1219, + "phase": "B" + }, + { + "new": [ + 1, + 6, + 10, + 18, + 64, + 160, + 288 + ], + "old": [ + 6, + 11, + 19, + 64, + 160, + 288 + ], + "ordinal": 1220, + "phase": "B" + }, + { + "new": [ + 1, + 6, + 10, + 18, + 64, + 160, + 288 + ], + "old": [ + 1, + 12, + 18, + 70, + 160, + 288 + ], + "ordinal": 1221, + "phase": "B" + }, + { + "new": [ + 1, + 6, + 24, + 32, + 64, + 128, + 266 + ], + "old": [ + 6, + 24, + 32, + 64, + 128, + 267 + ], + "ordinal": 1226, + "phase": "B" + }, + { + "new": [ + 1, + 6, + 10, + 18, + 96, + 160, + 256 + ], + "old": [ + 6, + 11, + 19, + 96, + 160, + 256 + ], + "ordinal": 1228, + "phase": "B" + }, + { + "new": [ + 1, + 6, + 10, + 18, + 96, + 160, + 256 + ], + "old": [ + 6, + 10, + 18, + 96, + 161, + 256 + ], + "ordinal": 1229, + "phase": "B" + }, + { + "new": [ + 7, + 8, + 18, + 33, + 64, + 128, + 256 + ], + "old": [ + 8, + 21, + 38, + 64, + 128, + 256 + ], + "ordinal": 1233, + "phase": "B" + }, + { + "new": [ + 3, + 4, + 17, + 33, + 64, + 136, + 264 + ], + "old": [ + 3, + 21, + 37, + 64, + 136, + 264 + ], + "ordinal": 1234, + "phase": "B" + }, + { + "new": [ + 7, + 11, + 17, + 34, + 67, + 131, + 259 + ], + "old": [ + 11, + 22, + 37, + 67, + 131, + 259 + ], + "ordinal": 1235, + "phase": "B" + }, + { + "new": [ + 3, + 4, + 8, + 48, + 81, + 128, + 256 + ], + "old": [ + 3, + 8, + 48, + 85, + 128, + 256 + ], + "ordinal": 1236, + "phase": "B" + }, + { + "new": [ + 3, + 4, + 17, + 33, + 72, + 136, + 256 + ], + "old": [ + 3, + 21, + 37, + 72, + 136, + 256 + ], + "ordinal": 1242, + "phase": "B" + }, + { + "new": [ + 3, + 4, + 8, + 48, + 64, + 128, + 273 + ], + "old": [ + 3, + 8, + 48, + 64, + 128, + 277 + ], + "ordinal": 1244, + "phase": "B" + }, + { + "new": [ + 8, + 22, + 37, + 71, + 135, + 263 + ], + "old": [ + 7, + 8, + 17, + 34, + 64, + 128, + 256 + ], + "ordinal": 1417, + "phase": "B" + }, + { + "new": [ + 8, + 22, + 37, + 71, + 135, + 263 + ], + "old": [ + 7, + 8, + 17, + 34, + 64, + 128, + 256 + ], + "ordinal": 1418, + "phase": "B" + }, + { + "new": [ + 12, + 18, + 33, + 67, + 131, + 259 + ], + "old": [ + 7, + 11, + 18, + 33, + 67, + 131, + 259 + ], + "ordinal": 1433, + "phase": "B" + }, + { + "new": [ + 12, + 18, + 33, + 67, + 131, + 259 + ], + "old": [ + 7, + 11, + 18, + 33, + 67, + 131, + 259 + ], + "ordinal": 1434, + "phase": "B" + }, + { + "new": [ + 4, + 8, + 18, + 33, + 192, + 320 + ], + "old": [ + 3, + 4, + 8, + 17, + 33, + 192, + 320 + ], + "ordinal": 1437, + "phase": "B" + }, + { + "new": [ + 4, + 8, + 18, + 33, + 192, + 320 + ], + "old": [ + 3, + 4, + 8, + 17, + 33, + 192, + 320 + ], + "ordinal": 1438, + "phase": "B" + }, + { + "new": [ + 12, + 18, + 33, + 70, + 134, + 262 + ], + "old": [ + 7, + 11, + 18, + 33, + 65, + 129, + 257 + ], + "ordinal": 1445, + "phase": "B" + }, + { + "new": [ + 12, + 18, + 33, + 70, + 134, + 262 + ], + "old": [ + 7, + 11, + 18, + 33, + 65, + 129, + 257 + ], + "ordinal": 1446, + "phase": "B" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 2, + 8, + 20, + 36, + 64, + 128, + 256 + ], + "ordinal": 0, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 2, + 8, + 20, + 36, + 64, + 128, + 256 + ], + "ordinal": 1, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 2, + 8, + 20, + 36, + 64, + 128, + 256 + ], + "ordinal": 2, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ], + "ordinal": 3, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ], + "ordinal": 4, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ], + "ordinal": 5, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 2, + 8, + 20, + 36, + 64, + 128, + 256 + ], + "ordinal": 6, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 2, + 8, + 20, + 36, + 64, + 128, + 256 + ], + "ordinal": 7, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 2, + 8, + 20, + 36, + 64, + 128, + 256 + ], + "ordinal": 8, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 2, + 12, + 16, + 32, + 68, + 128, + 256 + ], + "ordinal": 9, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 2, + 12, + 16, + 32, + 68, + 128, + 256 + ], + "ordinal": 10, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 2, + 12, + 16, + 32, + 68, + 128, + 256 + ], + "ordinal": 11, + "phase": "cleanup_tail" + }, + { + "new": [ + 2, + 5, + 24, + 40, + 72, + 385 + ], + "old": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "ordinal": 12, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 4, + 11, + 17, + 34, + 64, + 128, + 256 + ], + "ordinal": 20, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 4, + 11, + 17, + 34, + 64, + 128, + 256 + ], + "ordinal": 21, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 4, + 11, + 17, + 34, + 64, + 128, + 256 + ], + "ordinal": 22, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 4, + 11, + 17, + 34, + 64, + 128, + 256 + ], + "ordinal": 23, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 10, + 20, + 38, + 64, + 128, + 256 + ], + "ordinal": 24, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 10, + 20, + 38, + 64, + 128, + 256 + ], + "ordinal": 25, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 10, + 20, + 38, + 64, + 128, + 256 + ], + "ordinal": 26, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 10, + 20, + 38, + 64, + 128, + 256 + ], + "ordinal": 27, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 6, + 11, + 19, + 32, + 64, + 128, + 256 + ], + "ordinal": 28, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 6, + 11, + 19, + 32, + 64, + 128, + 256 + ], + "ordinal": 29, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 6, + 11, + 19, + 32, + 64, + 128, + 256 + ], + "ordinal": 30, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 6, + 11, + 19, + 32, + 64, + 128, + 256 + ], + "ordinal": 31, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 3, + 8, + 21, + 37, + 64, + 128, + 256 + ], + "ordinal": 32, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 3, + 8, + 21, + 37, + 64, + 128, + 256 + ], + "ordinal": 33, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 3, + 8, + 21, + 37, + 64, + 128, + 256 + ], + "ordinal": 34, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 3, + 8, + 21, + 37, + 64, + 128, + 256 + ], + "ordinal": 35, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 4, + 11, + 17, + 34, + 64, + 128, + 256 + ], + "ordinal": 36, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 4, + 11, + 17, + 34, + 64, + 128, + 256 + ], + "ordinal": 37, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 4, + 11, + 17, + 34, + 64, + 128, + 256 + ], + "ordinal": 38, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 4, + 11, + 17, + 34, + 64, + 128, + 256 + ], + "ordinal": 39, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 6, + 8, + 16, + 34, + 66, + 128, + 256 + ], + "ordinal": 47, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 6, + 8, + 16, + 34, + 66, + 128, + 256 + ], + "ordinal": 48, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 10, + 20, + 38, + 64, + 128, + 256 + ], + "ordinal": 49, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 10, + 20, + 38, + 64, + 128, + 256 + ], + "ordinal": 50, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 10, + 20, + 38, + 64, + 128, + 256 + ], + "ordinal": 51, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 10, + 20, + 38, + 64, + 128, + 256 + ], + "ordinal": 52, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 3, + 4, + 9, + 16, + 32, + 65, + 128, + 256 + ], + "ordinal": 55, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 3, + 4, + 9, + 16, + 32, + 65, + 128, + 256 + ], + "ordinal": 56, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 6, + 11, + 19, + 32, + 64, + 128, + 256 + ], + "ordinal": 60, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 6, + 11, + 19, + 32, + 64, + 128, + 256 + ], + "ordinal": 61, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 6, + 11, + 19, + 32, + 64, + 128, + 256 + ], + "ordinal": 62, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 6, + 11, + 19, + 32, + 64, + 128, + 256 + ], + "ordinal": 63, + "phase": "cleanup_tail" + }, + { + "new": [ + 3, + 12, + 17, + 33, + 64, + 388 + ], + "old": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "ordinal": 67, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 3, + 8, + 21, + 37, + 64, + 128, + 256 + ], + "ordinal": 73, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 3, + 8, + 21, + 37, + 64, + 128, + 256 + ], + "ordinal": 74, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 3, + 8, + 21, + 37, + 64, + 128, + 256 + ], + "ordinal": 75, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 3, + 8, + 21, + 37, + 64, + 128, + 256 + ], + "ordinal": 76, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 6, + 10, + 18, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 12, + 18, + 32, + 70, + 128, + 256 + ], + "ordinal": 85, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 6, + 10, + 18, + 32, + 64, + 128, + 256 + ], + "old": [ + 6, + 10, + 18, + 33, + 65, + 128, + 256 + ], + "ordinal": 88, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 2, + 8, + 20, + 36, + 64, + 128, + 256 + ], + "ordinal": 94, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 2, + 8, + 20, + 36, + 64, + 128, + 256 + ], + "ordinal": 95, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 2, + 8, + 20, + 36, + 64, + 128, + 256 + ], + "ordinal": 96, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 2, + 8, + 20, + 36, + 64, + 128, + 256 + ], + "ordinal": 97, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 2, + 12, + 16, + 32, + 68, + 128, + 256 + ], + "ordinal": 98, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 2, + 12, + 16, + 32, + 68, + 128, + 256 + ], + "ordinal": 99, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 2, + 12, + 16, + 32, + 68, + 128, + 256 + ], + "ordinal": 100, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ], + "ordinal": 101, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ], + "ordinal": 102, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ], + "ordinal": 103, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 10, + 20, + 38, + 64, + 128, + 256 + ], + "ordinal": 104, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 10, + 20, + 38, + 64, + 128, + 256 + ], + "ordinal": 105, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 10, + 20, + 38, + 64, + 128, + 256 + ], + "ordinal": 106, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 4, + 11, + 17, + 34, + 64, + 128, + 256 + ], + "ordinal": 107, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 4, + 11, + 17, + 34, + 64, + 128, + 256 + ], + "ordinal": 108, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 4, + 11, + 17, + 34, + 64, + 128, + 256 + ], + "ordinal": 109, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 3, + 4, + 9, + 16, + 32, + 65, + 128, + 256 + ], + "ordinal": 110, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 3, + 4, + 9, + 16, + 32, + 65, + 128, + 256 + ], + "ordinal": 111, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 6, + 8, + 16, + 34, + 66, + 128, + 256 + ], + "ordinal": 116, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 6, + 8, + 16, + 34, + 66, + 128, + 256 + ], + "ordinal": 117, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 121, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 122, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 123, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 124, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 125, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 126, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 127, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 128, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 129, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 130, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 131, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 132, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 133, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 134, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 135, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 136, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 137, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 138, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 139, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 140, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 141, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 142, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 143, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 144, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 145, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 146, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 147, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 148, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 149, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 150, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 151, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 152, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 153, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 154, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 155, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 156, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 157, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 158, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 159, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 160, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 161, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 4, + 11, + 17, + 34, + 64, + 128, + 256 + ], + "ordinal": 162, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 4, + 11, + 17, + 34, + 64, + 128, + 256 + ], + "ordinal": 163, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 4, + 11, + 17, + 34, + 64, + 128, + 256 + ], + "ordinal": 164, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 4, + 11, + 17, + 34, + 64, + 128, + 256 + ], + "ordinal": 165, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ], + "ordinal": 166, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ], + "ordinal": 167, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ], + "ordinal": 168, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ], + "ordinal": 169, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ], + "ordinal": 170, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 10, + 20, + 38, + 64, + 128, + 256 + ], + "ordinal": 171, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 10, + 20, + 38, + 64, + 128, + 256 + ], + "ordinal": 172, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 10, + 20, + 38, + 64, + 128, + 256 + ], + "ordinal": 173, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 10, + 20, + 38, + 64, + 128, + 256 + ], + "ordinal": 174, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 10, + 20, + 38, + 64, + 128, + 256 + ], + "ordinal": 175, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 10, + 20, + 38, + 64, + 128, + 256 + ], + "ordinal": 176, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 10, + 20, + 38, + 64, + 128, + 256 + ], + "ordinal": 177, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 10, + 20, + 38, + 64, + 128, + 256 + ], + "ordinal": 178, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ], + "ordinal": 179, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ], + "ordinal": 180, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ], + "ordinal": 181, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ], + "ordinal": 182, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ], + "ordinal": 183, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 188, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ], + "ordinal": 189, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ], + "ordinal": 191, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ], + "ordinal": 192, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ], + "ordinal": 193, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ], + "ordinal": 194, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ], + "ordinal": 195, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ], + "ordinal": 196, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 6, + 11, + 19, + 32, + 64, + 128, + 256 + ], + "ordinal": 197, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 3, + 5, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "ordinal": 198, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 3, + 5, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "ordinal": 199, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 3, + 5, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "ordinal": 200, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 3, + 5, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "ordinal": 201, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 3, + 5, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "ordinal": 202, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 3, + 8, + 21, + 37, + 64, + 128, + 256 + ], + "ordinal": 204, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 3, + 5, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "ordinal": 205, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 3, + 5, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "ordinal": 206, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 3, + 5, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "ordinal": 207, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 3, + 5, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "ordinal": 208, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 3, + 5, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "ordinal": 209, + "phase": "cleanup_tail" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ], + "ordinal": 226, + "phase": "exit" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ], + "ordinal": 228, + "phase": "exit" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 4, + 10, + 16, + 34, + 64, + 128, + 256 + ], + "ordinal": 230, + "phase": "exit" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 249, + "phase": "exit" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 251, + "phase": "exit" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 265, + "phase": "exit" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 5, + 11, + 16, + 35, + 64, + 128, + 256 + ], + "ordinal": 267, + "phase": "exit" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 4, + 11, + 17, + 34, + 64, + 128, + 256 + ], + "ordinal": 299, + "phase": "exit" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 6, + 8, + 16, + 34, + 66, + 128, + 256 + ], + "ordinal": 304, + "phase": "exit" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 3, + 4, + 9, + 16, + 32, + 65, + 128, + 256 + ], + "ordinal": 320, + "phase": "exit" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 10, + 20, + 38, + 64, + 128, + 256 + ], + "ordinal": 331, + "phase": "exit" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 3, + 5, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "ordinal": 363, + "phase": "exit" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 3, + 5, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "ordinal": 395, + "phase": "exit" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 2, + 8, + 20, + 36, + 64, + 128, + 256 + ], + "ordinal": 408, + "phase": "exit" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ], + "ordinal": 412, + "phase": "exit" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 2, + 8, + 20, + 36, + 64, + 128, + 256 + ], + "ordinal": 424, + "phase": "exit" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 2, + 12, + 16, + 32, + 68, + 128, + 256 + ], + "ordinal": 428, + "phase": "exit" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 4, + 11, + 17, + 34, + 64, + 128, + 256 + ], + "ordinal": 448, + "phase": "exit" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 4, + 11, + 17, + 34, + 64, + 128, + 256 + ], + "ordinal": 449, + "phase": "exit" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 10, + 20, + 38, + 64, + 128, + 256 + ], + "ordinal": 450, + "phase": "exit" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 10, + 20, + 38, + 64, + 128, + 256 + ], + "ordinal": 451, + "phase": "exit" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 6, + 11, + 19, + 32, + 64, + 128, + 256 + ], + "ordinal": 452, + "phase": "exit" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 6, + 11, + 19, + 32, + 64, + 128, + 256 + ], + "ordinal": 453, + "phase": "exit" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 3, + 8, + 21, + 37, + 64, + 128, + 256 + ], + "ordinal": 454, + "phase": "exit" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 3, + 8, + 21, + 37, + 64, + 128, + 256 + ], + "ordinal": 455, + "phase": "exit" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 4, + 11, + 17, + 34, + 64, + 128, + 256 + ], + "ordinal": 482, + "phase": "exit" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 4, + 11, + 17, + 34, + 64, + 128, + 256 + ], + "ordinal": 483, + "phase": "exit" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 6, + 8, + 16, + 34, + 66, + 128, + 256 + ], + "ordinal": 496, + "phase": "exit" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 6, + 8, + 16, + 34, + 66, + 128, + 256 + ], + "ordinal": 497, + "phase": "exit" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 10, + 20, + 38, + 64, + 128, + 256 + ], + "ordinal": 503, + "phase": "exit" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 10, + 20, + 38, + 64, + 128, + 256 + ], + "ordinal": 504, + "phase": "exit" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 3, + 4, + 9, + 16, + 32, + 65, + 128, + 256 + ], + "ordinal": 507, + "phase": "exit" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 3, + 4, + 9, + 16, + 32, + 65, + 128, + 256 + ], + "ordinal": 508, + "phase": "exit" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 6, + 11, + 19, + 32, + 64, + 128, + 256 + ], + "ordinal": 526, + "phase": "exit" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 6, + 11, + 19, + 32, + 64, + 128, + 256 + ], + "ordinal": 527, + "phase": "exit" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 3, + 8, + 21, + 37, + 64, + 128, + 256 + ], + "ordinal": 550, + "phase": "exit" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 3, + 8, + 21, + 37, + 64, + 128, + 256 + ], + "ordinal": 551, + "phase": "exit" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 2, + 8, + 20, + 36, + 64, + 128, + 256 + ], + "ordinal": 566, + "phase": "exit" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 2, + 8, + 20, + 36, + 64, + 128, + 256 + ], + "ordinal": 567, + "phase": "exit" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ], + "ordinal": 568, + "phase": "exit" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 3, + 5, + 9, + 17, + 33, + 65, + 128, + 256 + ], + "ordinal": 569, + "phase": "exit" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 2, + 8, + 20, + 36, + 64, + 128, + 256 + ], + "ordinal": 574, + "phase": "exit" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 2, + 8, + 20, + 36, + 64, + 128, + 256 + ], + "ordinal": 575, + "phase": "exit" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 2, + 12, + 16, + 32, + 68, + 128, + 256 + ], + "ordinal": 576, + "phase": "exit" + }, + { + "new": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 2, + 12, + 16, + 32, + 68, + 128, + 256 + ], + "ordinal": 577, + "phase": "exit" + }, + { + "new": [ + 1, + 6, + 10, + 18, + 32, + 64, + 128, + 256 + ], + "old": [ + 1, + 12, + 18, + 32, + 70, + 128, + 256 + ], + "ordinal": 580, + "phase": "exit" + }, + { + "new": [ + 1, + 6, + 10, + 18, + 32, + 64, + 128, + 256 + ], + "old": [ + 6, + 10, + 18, + 33, + 65, + 128, + 256 + ], + "ordinal": 582, + "phase": "exit" + } + ], + "source_head": "322e0ec764aa7ef7801383feb1f656e460dd8bed" +} diff --git a/research/pr4470-exact-transport-audit/verify.py b/research/pr4470-exact-transport-audit/verify.py new file mode 100644 index 0000000000..1c9a9d6410 --- /dev/null +++ b/research/pr4470-exact-transport-audit/verify.py @@ -0,0 +1,352 @@ +#!/usr/bin/env python3 +"""Exact full-matrix audit of the 423 declared PR4470 physical lowerings. + +Apache-2.0. Prepared for Chris / Clear1nsight with substantial OpenAI assistance. +No predecessor evaluator or compiler is imported. NumPy stores integer matrices; +there is no floating-point arithmetic in the scientific comparison. +""" +from __future__ import annotations +import argparse +from collections import Counter +from copy import deepcopy +import gzip +import hashlib +import json +from pathlib import Path +import platform +import random +import sys +import time +import numpy as np + +HERE = Path(__file__).resolve().parent +SOURCE_HEAD = "b9a13c1673e0e9697de410de16e8bbf3207a7363" +PINS = { + "CANONICAL.json.gz": "4a8c4ed26e53a72362d571c972e65aff546be784", + "PR4447-PATCH.json": "f96d295d40014d4dd503f58eb3cdabcbb4b8e101", + "PR4470-PATCH.json": "51304a6601061ed4e698f910b09135ef109555e3", + "PR4470-NATIVE.json.gz": "0910f74138decf498e7fc445cc2daff4390169d6", +} + +def require(ok: bool, message: str) -> None: + if not ok: + raise ValueError(message) + + +def blob_id(data: bytes) -> str: + return hashlib.sha1(b"blob " + str(len(data)).encode("ascii") + b"\0" + data).hexdigest() + + +def read_source(name: str) -> object: + raw = (HERE / "vendor" / name).read_bytes() + require(blob_id(raw) == PINS[name], "Source binding failed: " + name) + return json.loads(gzip.decompress(raw) if name.endswith(".gz") else raw) + + +def space(basis: list[int], n: int) -> frozenset[int]: + values = {0} + for vector in basis: + require(type(vector) is int and 0 < vector < 1 << n, "Invalid basis vector") + require(vector not in values, "Dependent basis") + values.update(tuple(x ^ vector for x in values)) + return frozenset(values) + + +def transpose(rows: list[int], n: int) -> list[int]: + return [sum(((rows[j] >> i) & 1) << j for j in range(n)) for i in range(n)] + + +def linear_map(rows: list[int], n: int) -> np.ndarray: + require(len(rows) == n and all(type(r) is int and 0 <= r < 1 << n for r in rows), + "Invalid binary matrix") + result = np.array([sum(((r & x).bit_count() % 2) << i for i, r in enumerate(rows)) + for x in range(1 << n)], dtype=np.int64) + require(len(set(map(int, result))) == 1 << n, "Singular binary matrix") + return result + + +def inverse_rows(rows: list[int], n: int) -> list[int]: + # Invert the finite bijection, independently of binary elimination. + p = list(map(int, linear_map(rows, n))) + inverse = [0] * len(p) + for x, y in enumerate(p): + inverse[y] = x + return transpose([inverse[1 << i] for i in range(n)], n) + + +def extend(basis: list[int], n: int) -> list[int]: + out = list(basis) + values = set(space(out, n)) + for i in range(n): + vector = 1 << i + if vector not in values: + values.update(tuple(x ^ vector for x in values)) + out.append(vector) + require(len(out) == n, "Incomplete basis") + return out + + +def adjoint(circuit: list[tuple], n: int) -> list[tuple]: + result = [] + for gate in reversed(circuit): + kind = gate[0] + if kind == "P": + result.append(("P", inverse_rows(gate[1], n))) + elif kind == "D": + result.append(("D", gate[1], [(-a) % 4 for a in gate[2]])) + elif kind == "C": + result.append(("C", gate[1], -gate[2])) + elif kind == "phase": + result.append(("phase", (-gate[1]) % 4)) + elif kind == "X": + result.append(gate) + else: + raise ValueError("Unknown primitive") + return result + + +def frame(basis: list[int], n: int) -> list[tuple]: + # Source-specified reference frame, not an imported lowering algorithm. + rank = len(basis) + space(basis, n) + core = [("C", 1 << i, 1) for i in range(rank)] + if rank in (0, n): + return core + rows = transpose(extend(basis, n), n) + inverse_columns = transpose(inverse_rows(rows, n), n) + quadratic = [(1 << i) ^ sum(((x & y).bit_count() % 2) << j + for j, y in enumerate(inverse_columns)) + for i, x in enumerate(inverse_columns)] + alpha = [(quadratic[i] >> i) & 1 for i in range(n)] + wrapper = [("P", rows), ("D", quadratic, alpha)] + return adjoint(wrapper, n) + core + wrapper + + +def monomial(record: dict, n: int) -> list[tuple]: + required = {"matrix_rows", "offset", "quadratic_rows", "linear_Z4", "phase"} + require(set(record) == required, "Unsupported monomial schema") + rows = list(record["matrix_rows"]) + linear_map(rows, n) + q = list(record["quadratic_rows"]) + a = list(record["linear_Z4"]) + require(len(q) == len(a) == n and transpose(q, n) == q, "Invalid quadratic form") + require(all(type(x) is int and 0 <= x < 1 << n for x in q), "Invalid quadratic row") + require(all(type(x) is int and 0 <= x < 4 for x in a), "Invalid linear phase") + require(all((a[i] % 2) == ((q[i] >> i) & 1) for i in range(n)), "Phase parity") + require(type(record["offset"]) is int and 0 <= record["offset"] < 1 << n, + "Invalid offset") + require(type(record["phase"]) is int and 0 <= record["phase"] < 4, "Invalid phase") + return [("D", q, a), ("P", rows), ("X", record["offset"]), ("phase", record["phase"])] + + +def recipe(record: dict, n: int) -> list[tuple]: + require(set(record) == {"rank", "left", "right"}, "Unsupported recipe schema") + rank = record["rank"] + require(type(rank) is int and 0 <= rank <= n, "Invalid child rank") + if rank == 0: + require(record["right"] is None, "Unexpected rank-zero right factor") + return monomial(record["left"], n) + return (monomial(record["right"], n) + [("C", 1 << i, 1) for i in range(rank)] + + monomial(record["left"], n)) + + +def matrix(circuit: list[tuple], n: int) -> tuple[np.ndarray, np.ndarray, int]: + """Return Gaussian integer numerators and a common denominator 2**d.""" + require(1 <= n <= 9, "Audit dimension out of range") + # Each C doubles the denominator; unitary prefixes bound each numerator by 2**d. + # The stricter 28 bound also keeps squared magnitudes and cross-scaled equality safe. + require(sum(e[0] == "C" for e in circuit) <= 28, "Integer safety cap exceeded") + size = 1 << n + real = np.eye(size, dtype=np.int64) + imag = np.zeros((size, size), dtype=np.int64) + denominator = 0 + for gate in circuit: + kind = gate[0] + if kind in ("P", "X"): + p = linear_map(gate[1], n) if kind == "P" else np.arange(size) ^ gate[1] + require(len(set(map(int, p))) == size, "Invalid address permutation") + rr = np.empty_like(real); ii = np.empty_like(imag) + rr[p, :] = real; ii[p, :] = imag + real, imag = rr, ii + elif kind in ("D", "phase"): + if kind == "phase": + phases = np.full(size, gate[1] % 4, dtype=np.int64) + else: + q, a = gate[1:] + phases = np.array([(sum(a[i] for i in range(n) if x >> i & 1) + + 2 * sum(((q[i] & x) >> (i + 1)).bit_count() + for i in range(n) if x >> i & 1)) % 4 + for x in range(size)], dtype=np.int64) + cos = np.array([1, 0, -1, 0], dtype=np.int64)[phases, None] + sin = np.array([0, 1, 0, -1], dtype=np.int64)[phases, None] + real, imag = cos * real - sin * imag, sin * real + cos * imag + elif kind == "C": + q, sign = gate[1:] + require(0 < q < size and sign in (-1, 1), "Invalid Gaussian gate") + shifted_r = real[np.arange(size) ^ q, :] + shifted_i = imag[np.arange(size) ^ q, :] + real, imag = (real - sign * imag + shifted_r + sign * shifted_i, + imag + sign * real + shifted_i - sign * shifted_r) + denominator += 1 + else: + raise ValueError("Unknown primitive " + str(kind)) + return real, imag, denominator + + +def equal(a: tuple, b: tuple) -> bool: + d = max(a[2], b[2]) + require(d <= 28, "Comparison safety cap") + return all(np.array_equal(a[i] * (1 << (d-a[2])), b[i] * (1 << (d-b[2]))) + for i in (0, 1)) + + +def check_rank(value: tuple, rank: int) -> None: + real, imag, d = value + require(0 <= rank <= 9 and 2*d >= rank, "Invalid magnitude exponent") + occupied = (real != 0) | (imag != 0) + require(bool(np.all(np.count_nonzero(occupied, axis=0) == 1 << rank)), "Column support rank") + require(bool(np.all(np.count_nonzero(occupied, axis=1) == 1 << rank)), "Row support rank") + square = real*real + imag*imag + require(bool(np.all(square[occupied] == 1 << (2*d-rank))), "Exact entry magnitude") + + +def self_tests() -> dict: + checks = 0 + rng = random.Random(4470) + for n in range(1, 5): + identity = matrix([], n) + for trial in range(12): + basis = [] + for x in rng.sample(range(1, 1 << n), (1 << n)-1): + if x not in space(basis, n): + basis.append(x) + if len(basis) == n: + break + for rank in range(n+1): + circuit = frame(basis[:rank], n) + require(equal(matrix(circuit + adjoint(circuit, n), n), identity), "Frame inverse control") + checks += 1 + for q in range(1, 1 << n): + # Independent entry-law oracle for a single Gaussian gate. + r, i, d = matrix([("C", q, 1)], n) + e = np.eye(1 << n, dtype=np.int64) + x = e[np.arange(1 << n) ^ q] + require(d == 1 and np.array_equal(r, e+x) and np.array_equal(i, e-x), "Gaussian entry law") + checks += 1 + # An absolute phase must fail even though support and all magnitudes survive. + good = matrix([("C", 1, 1)], 2) + shifted = matrix([("C", 1, 1), ("phase", 1)], 2) + check_rank(good, 1); check_rank(shifted, 1) + require(not equal(good, shifted), "Absolute-phase mutation escaped") + require(not equal(good, matrix([("C", 1, -1)], 2)), "Conjugation mutation escaped") + rejected = 0 + for test in (lambda: check_rank(good, 2), lambda: linear_map([1, 1], 2), + lambda: space([1, 1], 2), lambda: matrix([("C", 1, 1)]*29, 2)): + try: + test() + except ValueError: + rejected += 1 + require(rejected == 4, "Structural mutation escaped") + require(blob_id(b"source") != blob_id(b"sourcf"), "Source-byte control") + # Explicit two-column tensor identity with summed, not unscaled, phase. + r, i, d = matrix([("C", 1, 1), ("phase", 1)], 1) + rr = np.kron(r, r) - np.kron(i, i) + ii = np.kron(r, i) + np.kron(i, r) + require(equal((rr, ii, 2*d), matrix([("C", 1, 1), ("C", 2, 1), ("phase", 2)], 2)), + "Tensor phase lift") + return {"positive_checks": checks+2, "rejected_controls": 7, "tensor_phase_test": True} + + +def catalogue() -> tuple[list[list[int]], dict]: + base = read_source("CANONICAL.json.gz") + predecessor = read_source("PR4447-PATCH.json") + patch = read_source("PR4470-PATCH.json") + require(patch["source_head"] == "322e0ec764aa7ef7801383feb1f656e460dd8bed", "Patch predecessor") + frames = deepcopy(base["frames"]) + require(len(frames) == 1159, "Base frame census") + require(space(frames[predecessor["old_frame"]], 9) == space(predecessor["old_basis"], 9), + "Predecessor contact binding") + frames.append(predecessor["new_basis"]) + labels = {space(b, 9): index for index, b in enumerate(frames)} + changed = Counter() + keys = set() + for move in patch["changes"]: + key = (move["phase"], move["ordinal"]) + require(key not in keys, "Repeated changed contact") + keys.add(key); changed[move["phase"]] += 1 + old = space(move["old"], 9); new = space(move["new"], 9) + require(old != new, "Unchanged patch entry") + if new not in labels: + labels[new] = len(frames) + frames.append(move["new"]) + require(dict(changed) == {"entrance": 38, "exit": 47, "A": 21, "B": 238, "cleanup_tail": 155}, + "Changed-frame census") + return frames, dict(sorted(changed.items())) + + +def audit() -> dict: + controls = self_tests() + frames, changes = catalogue() + receipt = read_source("PR4470-NATIVE.json.gz") + records = receipt["new_physical_edges_and_boundaries"] + require(len(records) == 423, "Physical pair census") + seen = set(); histogram = Counter(); digest = hashlib.sha256() + largest_c = 0 + for index, record in enumerate(records): + a, b, rank = record["old"], record["new"], record["rank"] + require((a, b) not in seen, "Repeated physical pair") + seen.add((a, b)) + require(0 <= a < len(frames) and 0 <= b < len(frames), "Unknown frame") + require(space(frames[a], 9) < space(frames[b], 9), "Nonnested physical pair") + require(rank == len(frames[b])-len(frames[a]), "Declared dimension gap") + circuit = adjoint(frame(frames[a], 9), 9) + frame(frames[b], 9) + largest_c = max(largest_c, sum(e[0] == "C" for e in circuit)) + wanted = matrix(circuit, 9) + for direction in ("forward", "backward"): + lowered = record["recipes"][direction] + require(lowered["rank"] == rank, "Lowered rank disagrees") + actual = matrix(recipe(lowered, 9), 9) + expected = wanted if direction == "forward" else (wanted[0], -wanted[1], wanted[2]) + require(equal(actual, expected), f"Exact matrix mismatch at pair {a},{b}, {direction}") + check_rank(actual, rank) + digest.update(json.dumps([a, b, rank, direction], separators=(",", ":")).encode()) + histogram[rank] += 1 + if index == 0: + bad = deepcopy(record["recipes"]["forward"]) + bad["left"]["phase"] = (bad["left"]["phase"] + 1) % 4 + mutated = matrix(recipe(bad, 9), 9) + check_rank(mutated, rank) + require(not equal(mutated, wanted), "Real-source absolute-phase control escaped") + if (index+1) % 50 == 0: + print(f"CHECKED_PHYSICAL_PAIRS {index+1}/423", flush=True) + return {"schema": "pr4470-exact-transport-audit/v1", "status": "PASS_EXACT_TRANSPORT_MATRICES", + "source_head": SOURCE_HEAD, "physical_pairs": len(seen), "orientations": 2, + "source_files": {name: {"git_blob": pin, "sha256": hashlib.sha256((HERE / "vendor" / name).read_bytes()).hexdigest()} for name, pin in sorted(PINS.items())}, + "matrix_dimension": 512, "basis_columns_compared": 423*2*512, + "complex_matrix_entries_compared": 423*2*512*512, + "rank_histogram_both_orientations": dict(sorted(histogram.items())), + "frame_catalogue_count": len(frames), "patch_changes": changes, + "maximum_target_gaussian_gates": largest_c, "self_tests": controls, + "actual_source_phase_mutation_rejected": True, + "coverage_index_sha256": digest.hexdigest(), "new_kappa": False, + "not_covered": ["completeness of the declared 423-pair list", "chronological native endpoint replay", + "p16 controller", "physical tape costs", "precision and storage", "outer theorem"]} + + +def main() -> None: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--self-test", action="store_true") + parser.add_argument("--out", type=Path) + args = parser.parse_args() + started = time.monotonic() + result = self_tests() if args.self_test else audit() + text = json.dumps(result, indent=2, sort_keys=True) + "\n" + if args.out: + require(not args.out.exists(), "Refusing to overwrite an existing receipt") + args.out.write_text(text, encoding="utf-8") + print(text, end="") + print(json.dumps({"python": platform.python_version(), "numpy": np.__version__, + "elapsed_seconds": round(time.monotonic()-started, 3)}, sort_keys=True)) + +if __name__ == "__main__": + main() diff --git a/research/test-suite-locale-reads/SOURCES.json b/research/test-suite-locale-reads/SOURCES.json index be5f08378a..b3ee94816b 100644 --- a/research/test-suite-locale-reads/SOURCES.json +++ b/research/test-suite-locale-reads/SOURCES.json @@ -16,7 +16,7 @@ }, { "path": "docs/research/current-status.md", - "usage": "input", + "usage": "provenance", "git_blob": "d73b4ff9da41f044e793422db4318be17e234a6c", "sha256": "adb54af005eb11edaf84d782fe729338680ff908f6d4fbf39ba1062d2e7d8a77" }, diff --git a/tests/test_research_historical_1042_adapter.py b/tests/test_research_historical_1042_adapter.py new file mode 100644 index 0000000000..f891ad4ed8 --- /dev/null +++ b/tests/test_research_historical_1042_adapter.py @@ -0,0 +1,78 @@ +"""Historical replay must retain old bytes without freezing live documentation.""" +import hashlib +import importlib.util +import os +from pathlib import Path +import subprocess +import tempfile +import unittest +from unittest.mock import patch + +ROOT = Path(__file__).resolve().parents[1] +SPEC = importlib.util.spec_from_file_location( + "historical_1042_adapter", ROOT / "research/historical-1042-link/historical_replay.py") +A = importlib.util.module_from_spec(SPEC) +SPEC.loader.exec_module(A) + + +class Historical1042AdapterTests(unittest.TestCase): + def setUp(self): + self.temp = tempfile.TemporaryDirectory() + self.addCleanup(self.temp.cleanup) + self.root = Path(self.temp.name) + self.git("init", "-q") + self.git("config", "user.name", "Fixture") + self.git("config", "user.email", "fixture@example.invalid") + self.data = b"historical input\n" + (self.root / "fixture.txt").write_bytes(self.data) + self.git("add", "fixture.txt") + self.git("commit", "-qm", "Frozen fixture") + self.base = self.git("rev-parse", "HEAD").decode().strip() + self.row = {"path": "fixture.txt", "git_blob": A.blob_id(self.data), + "sha256": hashlib.sha256(self.data).hexdigest()} + + def git(self, *args, input=None, env=None): + return subprocess.run(["git", *args], cwd=self.root, input=input, env=env, + check=True, stdout=subprocess.PIPE, + stderr=subprocess.PIPE).stdout + + def test_exact_historical_bytes_ignore_live_edits(self): + (self.root / "fixture.txt").write_bytes(b"new current text\n") + self.assertEqual(A.authenticated_input(self.root, self.base, self.row), self.data) + self.assertEqual((self.root / "fixture.txt").read_bytes(), b"new current text\n") + + def test_wrong_hash_and_wrong_blob_reject(self): + for field in ("git_blob", "sha256"): + row = dict(self.row) + row[field] = "0" * len(row[field]) + with self.assertRaises(ValueError): + A.authenticated_input(self.root, self.base, row) + + def test_missing_history_fails_closed(self): + with self.assertRaises(subprocess.CalledProcessError): + A.authenticated_input(self.root, "0" * 40, self.row) + + def test_git_replacement_cannot_substitute_evidence(self): + replacement = self.git("hash-object", "-w", "--stdin", input=b"forged\n").decode().strip() + self.git("replace", self.row["git_blob"], replacement) + self.assertEqual(A.authenticated_input(self.root, self.base, self.row), self.data) + env = dict(os.environ, GIT_REPLACE_REF_BASE="refs/alternate-replacements/") + self.git("update-ref", env["GIT_REPLACE_REF_BASE"] + self.row["git_blob"], replacement) + with patch.dict(os.environ, env): + self.assertEqual(A.authenticated_input(self.root, self.base, self.row), self.data) + + def test_noncanonical_paths_and_bases_reject(self): + for path in ("../escape", "/absolute", "a/../b", "a//b", "a\\b", "a\0b"): + with self.assertRaises(ValueError): + A.checked_path(path) + with self.assertRaises(ValueError): + A.authenticated_input(self.root, "HEAD", self.row) + + def test_frozen_manifest_guard_is_not_only_json_parsing(self): + with patch.object(A, "git_bytes", return_value=b'{"files": []}'): + with self.assertRaisesRegex(ValueError, "Original manifest changed"): + A.collect(self.root, self.root) + + +if __name__ == "__main__": + unittest.main()