diff --git a/research/pr4470-frame-audit/.gitattributes b/research/pr4470-frame-audit/.gitattributes new file mode 100644 index 0000000000..7467454cb8 --- /dev/null +++ b/research/pr4470-frame-audit/.gitattributes @@ -0,0 +1 @@ +source/** -text diff --git a/research/pr4470-frame-audit/README.md b/research/pr4470-frame-audit/README.md new file mode 100644 index 0000000000..1de132d2e7 --- /dev/null +++ b/research/pr4470-frame-audit/README.md @@ -0,0 +1,152 @@ +# Independent chronological frame and invoice audit of PR4470 + +**Scoped independent check; no new kappa.** Both native orientations of +[PR4470](https://github.com/CrocSwap/integer-mult-bounds/pull/4470) at +`b9a13c1673e0e9697de410de16e8bbf3207a7363` reproduce the claimed local paid +and productive-helper profiles. The check reconstructs the chronological frame +requirements from pinned inputs, then compares them with the original +constructor's emitted word. It does not call the original proof engines. + +This takes the local native-word part of +[#4478's handoff](https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-19111584). +The canonical investigation is [Discussion #4500](https://github.com/CrocSwap/integer-mult-bounds/discussions/4500). +The `independent-moment` card is refined to this actual changed ledger; see +[TASK.json](TASK.json). Canonical main is +`2a13eb1827784206202db90e5dc8327cf8a250db`, priority revision 7. The selected +record remains conditional kappa `23/10000`. + +## Result and exact coverage + +All 499 patch locations bind to their predecessor: 38 helper entrances, +47 helper exits, and 414 scalar contacts (A: 21, B: 238, cleanup tail: 155). +The 224 main boundaries remain fixed. All 408 helper fields have a strictly +nested positive endpoint. In **each** orientation: + +| Checked quantity | PR4447 predecessor | PR4470 | +|---|---:|---:| +| Persistent frame transports | 3,355 | 3,302 | +| Owned center jobs, all rank 8 | 8 | 8 | +| Total paid jobs | 3,363 | 3,310 | +| Paid rank mass | 5,290 | 5,327 | +| Productive-helper rank mass | 3,434 | 3,471 | +| Scalar events | 17,453 | 17,453 | +| Warp events | 240 | 240 | + +The independently reconstructed new profiles are: + +```text +helpers = {4:28, 7:7, 8:47, 9:326} +paid = {1:2237, 2:388, 3:494, 4:147, 5:36, 8:8} +``` + +Thus the change removes 53 paid jobs per local call while increasing **both** +rank masses by 37. These are local bills, not a runtime comparison between the +different p16 and p17 controllers. Every actual transport is checked at its +chronological position, including its source state, subspace inclusion and +rank; an aggregate rank histogram alone cannot pass. All scalar coefficients, +warp labels, main adapters and owned operations match the pinned source word. +All eight rank-eight center operations remain paid, and the owned field ends +with an explicit clear. [RESULT.json](RESULT.json) records both full receipts. + +## Method and implication + +`verify.py` independently applies the PR4441 boundary/contact edits, PR4447's +B/480 patch and PR4470's patch. Binary row elimination supplies subspace equality, +containment and rank. It deliberately assigns different frame IDs from the +constructor; comparisons use reduced subspaces. The expected demand path is +built separately for each persistent field from scalar operands, warp +entrances/exits and final boundaries. Its charged transitions must match the +entire emitted stream, position by position. + +`emit_source.py` runs only the pinned `native_joint.construct()` in a temporary +source tree. Its output is the **object under test**, not a verification oracle. +No source `span`, `synthesize`, literal interpreter, rank checker or proof result +is called by the independent checking code. The source constructor necessarily +uses its own helpers to generate the candidate. The old word is checked through +the same independent path as a positive calibration case. + +The limited frame-coordinate implication is as follows. Assign one fixed +invertible operator `C_F` to each frame subspace F. A checked transition +F -> G implements `C_G C_F^-1`; a scalar operation whose operands all have +frame F commutes with this common coordinate change. The unchanged native warp +at its unchanged entrance/exit has its inherited logical action. Induction +through the checked event word therefore preserves the predecessor's logical +word, with the new helper endpoints. This implication assumes the proposed +physical transitions and normalizers actually implement those operators. +The executable check establishes the frame and event premises, not that +physical-operator assumption or the predecessor's complete identity theorem. + +Eleven negative controls reject nonnested rank-only transitions, dependent +bases, a false emitted rank, a changed scalar coefficient, a changed warp label, +a borrowed clear, an omitted paid climb, an omitted center job, duplicate +patch locations, main-field productive credit and a false predecessor basis. +Equivalent binary bases are an additional positive control. Failures use +explicit exceptions and remain active with optimized Python. + +## Reproduce and source availability + +Python 3.12, standard library only. From the repository root: + +```sh +python -B scripts/research_package.py --package research/pr4470-frame-audit +``` + +The registered command authenticates snapshots, checks both old/new words and +all controls, then compares the complete result to the committed receipt. +The same mathematical check works without Git or network access: + +```sh +python -I -O -B research/pr4470-frame-audit/verify.py +``` + +`--write` is an explicit authoring mode to regenerate the receipt; ordinary +verification does not rewrite evidence. [VERIFY.json](VERIFY.json) lists the +inputs. [UPSTREAM.json](UPSTREAM.json) records all nine byte-exact snapshots, +source paths, public head, Git blob IDs and SHA256 hashes. These retained files +make the pending PR available without fetching foreign commits. The source +constructor, its parent implementation and its proof retain their notices. +[SOURCES.json](SOURCES.json) separately pins the base catalogue and selected +record as historical provenance. No historical package is edited. + +## Limitations and overlap + +This is an independently implemented check of the source schedule and bill, +author-checked in this session. It is not maintainer acceptance or a new +physical supplier. Exact Clifford operators and absolute phases, whole-helper +normalizers, the full arbitrary-input-column identity, controller ownership, +p16 queries, precision/stock, compiler, analytic and outer obligations remain +separate. No new moment root or kappa is claimed. + +PR4470 already has author checks of these objects. This contribution adds +separate elimination and per-field chronological verification against the +actual constructor. PR4478 checks arithmetic; its latest verifier also checks +uniform local gain, despite the older grid-only PR description. PR4457 checks +the predecessor native/lift layer. PR4479 and the later compiler refinements +retain PR4470's local word. These predecessors are credited rather than counted +as new work here. Live overlap and local-note coverage are recorded in TASK.json. + +## Open next questions + +- Independently lower PR4470's 423 changed transport/helper pairs in both + orientations, comparing absolute phases as well as rank. This would check + the physical premise left by the frame-coordinate argument. Start from the + exact source head and its native receipt; an independent Clifford lowering + and a separate resource budget are needed. +- Check the p16 controller's actual query/owner protocol using the audited + local call. Start by adapting the PR4457 lift audit to PR4470's + `CONTROLLER.json`, retaining every query and owner charge. This is outside + the local-word scope; coordinate on the PR4478 handoff before starting. + +The structured questions and blockers are also in TASK.json. This package +does not authorize expanding the construction family or selecting a frontier. + +## Credit and license + +Prepared by mihir-s-05 with substantial OpenAI Codex assistance, Apache-2.0. +The construction and native constructor are Cinna Davis / 1337isnot1337's +PR4470, extending PR4447 and PR4441. Credit zxv's native/controller work, +Jacob Alan Sussman's mixed-flow work, the retained scalar/Clifford/geometry +contributors, and Ryanson Jonathan / pinterbanget's PR4478 audit and handoff. +The retained source PROOF.md and Python notices give predecessor credit. +The package scaffold and replay infrastructure retain Douglas Colkitt's +attribution. This independent audit claims no ownership of the construction. diff --git a/research/pr4470-frame-audit/RESULT.json b/research/pr4470-frame-audit/RESULT.json new file mode 100644 index 0000000000..423d1bbe38 --- /dev/null +++ b/research/pr4470-frame-audit/RESULT.json @@ -0,0 +1,135 @@ +{ + "changes": { + "A": 21, + "B": 238, + "cleanup_tail": 155, + "entrance": 38, + "exit": 47 + }, + "helper_mass_change": 37, + "negative_controls": [ + "rank-only non-nested transition", + "dependent frame basis", + "wrong emitted rank", + "changed scalar coefficient", + "changed warp operator", + "borrowed clear", + "unpaid climb", + "unpaid center", + "duplicate edit", + "main-field credit", + "wrong old basis" + ], + "paid_job_reduction": 53, + "paid_mass_change": 37, + "positive_controls": [ + "actual predecessor and changed source constructors, both orientations", + "equivalent binary bases" + ], + "profiles": { + "new": { + "backward": { + "events": { + "adapter": 448, + "center": 8, + "climb": 3302, + "phase": 10, + "scalar": 17453, + "warp": 240 + }, + "owned_center_jobs": 8, + "paid": { + "1": 2237, + "2": 388, + "3": 494, + "4": 147, + "5": 36, + "8": 8 + }, + "persistent_transports": 3302, + "scalar_contacts": 17453 + }, + "forward": { + "events": { + "adapter": 448, + "center": 8, + "climb": 3302, + "phase": 10, + "scalar": 17453, + "warp": 240 + }, + "owned_center_jobs": 8, + "paid": { + "1": 2237, + "2": 388, + "3": 494, + "4": 147, + "5": 36, + "8": 8 + }, + "persistent_transports": 3302, + "scalar_contacts": 17453 + }, + "helpers": { + "4": 28, + "7": 7, + "8": 47, + "9": 326 + } + }, + "old": { + "backward": { + "events": { + "adapter": 448, + "center": 8, + "climb": 3355, + "phase": 10, + "scalar": 17453, + "warp": 240 + }, + "owned_center_jobs": 8, + "paid": { + "1": 2254, + "2": 514, + "3": 444, + "4": 103, + "5": 40, + "8": 8 + }, + "persistent_transports": 3355, + "scalar_contacts": 17453 + }, + "forward": { + "events": { + "adapter": 448, + "center": 8, + "climb": 3355, + "phase": 10, + "scalar": 17453, + "warp": 240 + }, + "owned_center_jobs": 8, + "paid": { + "1": 2254, + "2": 514, + "3": 444, + "4": 103, + "5": 40, + "8": 8 + }, + "persistent_transports": 3355, + "scalar_contacts": 17453 + }, + "helpers": { + "4": 26, + "5": 2, + "7": 29, + "8": 42, + "9": 309 + } + } + }, + "scope": "Chronological frames, retained event word, local paid and helper profiles; no physical phases, full column identity, controller or kappa admission.", + "source_files": 9, + "status": "PASS_PR4470_CHRONOLOGICAL_FRAME_AUDIT" +} diff --git a/research/pr4470-frame-audit/SOURCES.json b/research/pr4470-frame-audit/SOURCES.json new file mode 100644 index 0000000000..9124bb10fe --- /dev/null +++ b/research/pr4470-frame-audit/SOURCES.json @@ -0,0 +1,18 @@ +{ + "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" + } + ] +} diff --git a/research/pr4470-frame-audit/TASK.json b/research/pr4470-frame-audit/TASK.json new file mode 100644 index 0000000000..a8d849666d --- /dev/null +++ b/research/pr4470-frame-audit/TASK.json @@ -0,0 +1,148 @@ +{ + "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 PR4470 chronological native frame demands, compare the emitted programs, and bind both orientations to the complete local helper/paid profiles.", + "scope_change_reason": "Take the native-word portion of PR4478 handoff; its latest code already covers uniform local gain. The current selected productive-helper mechanism supersedes the historical card examples.", + "bottleneck_link": "A paid histogram must match legal chronological transports and owned operations before its moment can support a conditional claim.", + "budget_minutes": 60, + "stop_rule": "Stop after both native orientations, source constructor comparison, and semantic failure controls. Do not expand into physical phase lowering, full all-column replay, p16 controller, or frontier admission.", + "outcome": "completed", + "evidence": "RESULT.json: both orientations of predecessor and changed source constructor reproduce all chronological frame demands, 17453 scalar events, 240 warps, 8 charged centers, 408 strictly productive helpers, and 11 semantic rejection controls. Registered, optimized, committed-byte and Git-free export verification commands are recorded in VALIDATION.md.", + "author": "mihir-s-05", + "ai_assistance": "Substantial OpenAI Codex assistance in investigation, implementation, proof exposition and verification.", + "open_questions": [ + { + "question": "Do the changed frame transports and whole-helper normalizers have the asserted exact physical Clifford operators, including phases, under an independent lowering?", + "why_it_matters": "This audit checks GF(2) nesting, chronological legality, source logical-word preservation and billing; physical phases are an additional interface premise.", + "first_step": "At the pinned PR4470 head, independently lower its 423 distinct changed transport/helper pairs in both orientations and compare absolute phases.", + "blocked_by": "Not run in this scoped session; needs an independent physical Clifford implementation or a separately budgeted review." + }, + { + "question": "Does the p16 controller use the audited local call with the correct query and owner protocol?", + "why_it_matters": "A valid local schedule alone does not establish the complete 64620-job controller or supplier admission.", + "first_step": "Adapt the predecessor PR4457 operator-lift audit to PR4470 CONTROLLER.json, preserving all query and owner costs.", + "blocked_by": "Outside the local native-frame scope; coordinate with the PR4478 handoff." + } + ], + "canonical_discussion": "https://github.com/CrocSwap/integer-mult-bounds/discussions/4500", + "source_head": "b9a13c1673e0e9697de410de16e8bbf3207a7363", + "predecessor_head": "322e0ec764aa7ef7801383feb1f656e460dd8bed", + "environment": { + "python": "3.12.0", + "platform": "Windows-11-10.0.26300-SP0" + }, + "overlap": { + "canonical_thread": "https://github.com/CrocSwap/integer-mult-bounds/discussions/4500", + "initial_open_prs": { + "fetched_at": "2026-10-22T02:18:09.783103+00:00", + "complete_pagination": true, + "records": 352 + }, + "initial_discussions": { + "fetched_at": "2026-10-22T02:14:08.901458+00:00", + "complete_pagination": true, + "records": 3375 + }, + "local_head_note_inventory": { + "head_records": 5731, + "complete_head_inventory": true, + "unsearched_head_paths_count": 0 + }, + "nearest_work": [ + 4470, + 4478, + 4457, + 4479 + ], + "limits": "Titles/bodies/comments/replies and top-level notes; no exhaustive diff or closed-PR-body search. Claims are advisory; current source heads are checked separately.", + "submission_refresh": { + "main": "2a13eb1827784206202db90e5dc8327cf8a250db", + "open_prs_fetched_at": "2026-10-22T02:32:04.085852+00:00", + "open_pr_records": 354, + "discussions_fetched_at": "2026-10-22T02:33:19.780892+00:00", + "discussion_records": 3381, + "complete_remote_pagination": true, + "source_head_unchanged": true, + "independent_arithmetic_head": "4e5072ad3bbdf76f2935f9488207db3969b38c90" + } + } +} diff --git a/research/pr4470-frame-audit/UPSTREAM.json b/research/pr4470-frame-audit/UPSTREAM.json new file mode 100644 index 0000000000..6a70c399b2 --- /dev/null +++ b/research/pr4470-frame-audit/UPSTREAM.json @@ -0,0 +1,86 @@ +{ + "scope": "Byte-exact source snapshots; retention is not scientific validation. Replays are offline and do not require these pending commits in Git history.", + "files": [ + { + "path": "source/research/kappa-rebuild/complex/full-identity-certificates/THREE-base-FULL-IDENTITY-CANONICAL.json.gz", + "upstream_path": "research/kappa-rebuild/complex/full-identity-certificates/THREE-base-FULL-IDENTITY-CANONICAL.json.gz", + "commit": "b9a13c1673e0e9697de410de16e8bbf3207a7363", + "repository": "1337isnot1337/integer-mult-bounds", + "git_blob": "4a8c4ed26e53a72362d571c972e65aff546be784", + "sha256": "6418ec3da24d548a57f5c3fe5b9062c26c9478e638504a61c387f5cfb5f4ed61", + "bytes": 82793 + }, + { + "path": "source/research/kappa-rebuild/complex/full-identity-certificates/THREE-base-FULL-IDENTITY-NATIVE.json.gz", + "upstream_path": "research/kappa-rebuild/complex/full-identity-certificates/THREE-base-FULL-IDENTITY-NATIVE.json.gz", + "commit": "b9a13c1673e0e9697de410de16e8bbf3207a7363", + "repository": "1337isnot1337/integer-mult-bounds", + "git_blob": "b46d44c6ee624968dd57be928b0c15d9d45f3b2c", + "sha256": "c54b0a3e129d28e6dbf74fa731fc3bb70fe3c6705f07256750fbecddcc842d39", + "bytes": 198063 + }, + { + "path": "source/research/fresh-helper-boundary/native.py", + "upstream_path": "research/fresh-helper-boundary/native.py", + "commit": "b9a13c1673e0e9697de410de16e8bbf3207a7363", + "repository": "1337isnot1337/integer-mult-bounds", + "git_blob": "1b36f6cb5f205c33bf48811e0b1b3621c55e8154", + "sha256": "9b55a2d3c3972148fae9d112e745d9244968166bd89bd900c938f429fc76ab29", + "bytes": 8228 + }, + { + "path": "source/research/fresh-helper-boundary/CHANGES.json", + "upstream_path": "research/fresh-helper-boundary/CHANGES.json", + "commit": "b9a13c1673e0e9697de410de16e8bbf3207a7363", + "repository": "1337isnot1337/integer-mult-bounds", + "git_blob": "45744fedd0e28967aa72586048b8bc0c72f419a9", + "sha256": "cde73b8ff5b3c0d06e69e2293b991b24fd14a16dd4ccab7ff6b3439074a94624", + "bytes": 13176 + }, + { + "path": "source/research/missing-join-frame/PATCH.json", + "upstream_path": "research/missing-join-frame/PATCH.json", + "commit": "b9a13c1673e0e9697de410de16e8bbf3207a7363", + "repository": "1337isnot1337/integer-mult-bounds", + "git_blob": "f96d295d40014d4dd503f58eb3cdabcbb4b8e101", + "sha256": "9ab5328245ff02c9d0be21d39bcc375f50bc5d7909e9f7b9a3a9a6f812f5bd6e", + "bytes": 249 + }, + { + "path": "source/research/joint-helper-lattice/PATCH.json", + "upstream_path": "research/joint-helper-lattice/PATCH.json", + "commit": "b9a13c1673e0e9697de410de16e8bbf3207a7363", + "repository": "1337isnot1337/integer-mult-bounds", + "git_blob": "51304a6601061ed4e698f910b09135ef109555e3", + "sha256": "296d0e8c58cc70febe042c681ef30d6bb469818c0835fbcaac8aa8d330f5b727", + "bytes": 112792 + }, + { + "path": "source/research/joint-helper-lattice/native_joint.py", + "upstream_path": "research/joint-helper-lattice/native_joint.py", + "commit": "b9a13c1673e0e9697de410de16e8bbf3207a7363", + "repository": "1337isnot1337/integer-mult-bounds", + "git_blob": "0315f80e2fdef5e0eef13e3e9b8f72066238164d", + "sha256": "50869b1bcad7493e6b4cb2a4cd5d2fd9a193a5921100483fa2c3f2c999ddfd46", + "bytes": 6886 + }, + { + "path": "source/research/joint-helper-lattice/RESULT.json", + "upstream_path": "research/joint-helper-lattice/RESULT.json", + "commit": "b9a13c1673e0e9697de410de16e8bbf3207a7363", + "repository": "1337isnot1337/integer-mult-bounds", + "git_blob": "edf41a49a0350862c23378f837c7397fc5dc7596", + "sha256": "c7b2388f6511c19976b337d8c8ac374610af616866a249d75dace704eb5d9e21", + "bytes": 9199 + }, + { + "path": "source/research/joint-helper-lattice/PROOF.md", + "upstream_path": "research/joint-helper-lattice/PROOF.md", + "commit": "b9a13c1673e0e9697de410de16e8bbf3207a7363", + "repository": "1337isnot1337/integer-mult-bounds", + "git_blob": "e41106031da41fade7a7419c17a32c1bd9aa103b", + "sha256": "43ef4251cc300f1b18cbe8cdb060f96f95748e6797d2478b4c04b79a8373ef91", + "bytes": 11063 + } + ] +} diff --git a/research/pr4470-frame-audit/VALIDATION.md b/research/pr4470-frame-audit/VALIDATION.md new file mode 100644 index 0000000000..819053d106 --- /dev/null +++ b/research/pr4470-frame-audit/VALIDATION.md @@ -0,0 +1,58 @@ +# Validation record + +Environment: CPython 3.12.0, Windows 11 (10.0.26300), standard library only. +Canonical main: `2a13eb1827784206202db90e5dc8327cf8a250db`, priority revision 7. +Source PR4470: `b9a13c1673e0e9697de410de16e8bbf3207a7363`. +PR4478 overlap: `4e5072ad3bbdf76f2935f9488207db3969b38c90`. +Both heads and canonical main were unchanged at the pre-submission refresh. + +The authoring run completed with `PASS_PR4470_CHRONOLOGICAL_FRAME_AUDIT` and +generated RESULT.json. It checked both orientations of the predecessor and +changed word, plus all eleven semantic failure controls. + +The following checks completed on 2026-10-22 UTC: + +```text +python -B scripts/research_package.py --package research/pr4470-frame-audit + PASS_REGISTERED_RESEARCH_PACKAGE research/pr4470-frame-audit outcome=completed + +python -I -O -B research/pr4470-frame-audit/verify.py + PASS_PR4470_CHRONOLOGICAL_FRAME_AUDIT + +python -B scripts/check_research_commit.py --package research/pr4470-frame-audit + PASS_RESEARCH_COMMIT_BYTES (20 package/input files) + +python -B scripts/export_research_package.py export \ + --package research/pr4470-frame-audit --output +python -B scripts/export_research_package.py check + PASS_RESEARCH_EXPORT (20 files) +``` + +The committed export was extracted outside any Git worktree. Its standalone +verifier passed under `python -I -O -B` in 9.5 seconds. Appending one space to +the **exported copy** of the pinned PR4470 PATCH.json caused the same command +to fail with `source SHA256 mismatch`, before calling the source constructor. +The retained snapshots were not modified. The exporter and its checker +authenticate the package inventory; the standalone command performs the actual +frame/billing audit. All non-source verification code and source snapshots were +unchanged between that replay and publication; only this record and task +freshness metadata were subsequently completed. + +The first byte preflight caught CRLF in this package's newly authored +UPSTREAM.json versus Git's LF content. Normalizing that manifest's working +newlines fixed the preflight. All nine frozen source snapshots remained +byte-exact; no mathematical assertion or source pin was weakened. + +Overlap refresh: all 354 open PR records and 3,381 Discussion records were +paginated, at 02:32:04Z and 02:33:19Z respectively. All 5,731 base HEAD +top-level README/TASK/ledger paths were present in the local note inventory. +This does not cover every diff, nested note or closed PR body. Exact source +heads were separately rechecked. The introductory historical baseline command +was not used as evidence: its selected-certificate inputs were initially +omitted by the sparse checkout; the selected record and review were read +directly, and this package has its own self-contained replay. + +Linux execution, hosted CI, the optional full-history preflight, physical +Clifford lowering, full column identity replay, the p16 controller, Lean and +full supplier admission were not run. A selected-frontier change is outside +the scope. diff --git a/research/pr4470-frame-audit/VERIFY.json b/research/pr4470-frame-audit/VERIFY.json new file mode 100644 index 0000000000..7e8edb7ee7 --- /dev/null +++ b/research/pr4470-frame-audit/VERIFY.json @@ -0,0 +1,29 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "LICENSE", + "research/pr4470-frame-audit/source/research/kappa-rebuild/complex/full-identity-certificates/THREE-base-FULL-IDENTITY-CANONICAL.json.gz", + "research/pr4470-frame-audit/source/research/kappa-rebuild/complex/full-identity-certificates/THREE-base-FULL-IDENTITY-NATIVE.json.gz", + "research/pr4470-frame-audit/source/research/fresh-helper-boundary/native.py", + "research/pr4470-frame-audit/source/research/fresh-helper-boundary/CHANGES.json", + "research/pr4470-frame-audit/source/research/missing-join-frame/PATCH.json", + "research/pr4470-frame-audit/source/research/joint-helper-lattice/PATCH.json", + "research/pr4470-frame-audit/source/research/joint-helper-lattice/native_joint.py", + "research/pr4470-frame-audit/source/research/joint-helper-lattice/RESULT.json", + "research/pr4470-frame-audit/source/research/joint-helper-lattice/PROOF.md" + ], + "commands": [ + { + "argv": [ + "{python}", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Byte-exact source pins; independent binary elimination and per-field chronology; exact emitted source-word comparison; all old/new helper and paid profiles in both orientations; 11 semantic failures and equivalent-basis positive control; committed receipt equality." + } + ] +} diff --git a/research/pr4470-frame-audit/emit_source.py b/research/pr4470-frame-audit/emit_source.py new file mode 100644 index 0000000000..c2b4fe7b46 --- /dev/null +++ b/research/pr4470-frame-audit/emit_source.py @@ -0,0 +1,12 @@ +"""Emit the exact pinned constructor's candidate; no proof functions are called.""" +import json +from pathlib import Path +import sys + +root = Path(sys.argv[1]).resolve() +sys.path.insert(0, str(root / 'research/joint-helper-lattice')) +import native_joint + +c, programs, baseline, before, changes = native_joint.construct() +print(json.dumps({'canonical': c, 'programs': programs, 'baseline': baseline, + 'before': before, 'changes': dict(changes)})) diff --git a/research/pr4470-frame-audit/source/research/fresh-helper-boundary/CHANGES.json b/research/pr4470-frame-audit/source/research/fresh-helper-boundary/CHANGES.json new file mode 100644 index 0000000000..45744fedd0 --- /dev/null +++ b/research/pr4470-frame-audit/source/research/fresh-helper-boundary/CHANGES.json @@ -0,0 +1,562 @@ +{ + "entrances": [ + [448, 114, 0], + [449, 114, 0], + [450, 115, 0], + [451, 115, 0], + [452, 115, 0], + [453, 115, 0], + [454, 114, 0], + [455, 114, 0], + [457, 116, 0], + [458, 116, 0], + [460, 117, 0], + [462, 117, 0], + [473, 114, 0], + [474, 118, 0], + [475, 118, 0], + [476, 119, 0], + [477, 119, 0], + [478, 120, 0], + [480, 120, 0], + [482, 114, 0], + [483, 114, 0], + [484, 121, 0], + [485, 121, 0], + [486, 122, 0], + [487, 122, 0], + [492, 115, 0], + [493, 115, 0], + [502, 115, 0], + [503, 115, 0], + [504, 115, 0], + [513, 115, 0], + [514, 115, 0], + [515, 115, 0], + [516, 123, 0], + [517, 123, 0], + [518, 124, 0], + [519, 124, 0], + [520, 125, 0], + [521, 125, 0], + [522, 126, 0], + [523, 126, 0], + [524, 115, 0], + [525, 115, 0], + [526, 115, 0], + [527, 115, 0], + [528, 127, 0], + [529, 127, 0], + [530, 128, 0], + [531, 128, 0], + [532, 129, 0], + [533, 129, 0], + [534, 130, 0], + [535, 130, 0], + [536, 115, 0], + [537, 115, 0], + [538, 131, 114], + [539, 114, 0], + [544, 132, 0], + [545, 132, 0], + [546, 133, 0], + [547, 133, 0], + [548, 114, 0], + [549, 114, 0], + [550, 114, 0], + [551, 114, 0], + [553, 134, 0], + [555, 134, 0], + [556, 135, 0], + [557, 135, 0], + [558, 136, 0], + [559, 136, 0], + [563, 134, 0], + [565, 134, 0], + [570, 134, 0], + [571, 134, 0], + [572, 134, 0], + [573, 134, 0], + [578, 114, 0], + [579, 114, 0], + [580, 115, 0], + [581, 115, 0], + [582, 115, 0], + [583, 115, 0], + [585, 114, 0], + [586, 137, 0], + [587, 137, 0], + [588, 137, 0], + [589, 137, 0], + [590, 138, 0], + [591, 137, 0], + [592, 137, 0], + [593, 137, 0], + [596, 137, 0], + [597, 137, 0], + [598, 114, 0], + [599, 114, 0], + [600, 114, 0], + [601, 114, 0], + [606, 115, 0], + [607, 115, 0], + [608, 115, 0], + [609, 115, 0], + [610, 115, 0], + [611, 115, 0], + [612, 115, 0], + [614, 115, 0], + [615, 115, 0], + [616, 115, 0], + [617, 115, 0], + [618, 115, 0], + [619, 115, 0], + [620, 115, 0], + [621, 140, 0], + [622, 114, 0], + [623, 114, 0], + [624, 114, 0], + [625, 114, 0] + ], + "exits": [ + [277, 256, 299], + [282, 257, 299], + [293, 258, 301], + [298, 258, 301], + [307, 261, 303], + [309, 261, 303], + [311, 262, 1], + [314, 263, 303], + [323, 265, 304], + [325, 266, 304], + [327, 267, 1], + [330, 268, 304], + [337, 270, 305], + [339, 270, 305], + [341, 271, 305], + [346, 271, 305], + [353, 272, 307], + [355, 272, 307], + [357, 273, 307], + [362, 273, 307], + [369, 275, 308], + [371, 275, 308], + [373, 275, 308], + [378, 276, 308], + [385, 277, 309], + [387, 277, 309], + [389, 278, 309], + [394, 278, 309], + [494, 262, 1], + [495, 262, 1], + [505, 267, 1], + [506, 267, 1], + [548, 285, 1], + [560, 285, 1], + [566, 286, 279], + [567, 286, 279], + [568, 287, 280], + [569, 287, 280], + [574, 288, 279], + [575, 288, 279], + [576, 289, 281], + [577, 289, 281] + ], + "gates": [ + ["A", 626, 115, 0], + ["A", 627, 115, 0], + ["A", 628, 115, 0], + ["A", 629, 114, 0], + ["A", 630, 114, 0], + ["A", 631, 114, 0], + ["A", 632, 114, 0], + ["A", 633, 114, 0], + ["A", 1762, 134, 0], + ["A", 1763, 134, 0], + ["A", 1764, 134, 0], + ["A", 1765, 134, 0], + ["A", 1766, 134, 0], + ["A", 1767, 134, 0], + ["A", 1768, 134, 0], + ["A", 1769, 134, 0], + ["A", 1770, 134, 0], + ["A", 1771, 134, 0], + ["A", 1772, 134, 0], + ["A", 1773, 134, 0], + ["A", 1774, 134, 0], + ["A", 1775, 134, 0], + ["A", 1776, 134, 0], + ["A", 1777, 134, 0], + ["A", 1778, 134, 0], + ["A", 1779, 134, 0], + ["A", 1780, 134, 0], + ["A", 1781, 134, 0], + ["A", 1782, 134, 0], + ["A", 1783, 134, 0], + ["A", 1784, 134, 0], + ["A", 1785, 134, 0], + ["A", 1786, 134, 0], + ["A", 1787, 116, 0], + ["A", 1788, 119, 0], + ["A", 1789, 119, 0], + ["A", 1790, 119, 0], + ["A", 1791, 119, 0], + ["A", 1792, 117, 0], + ["A", 1793, 124, 0], + ["A", 1794, 124, 0], + ["A", 1795, 120, 0], + ["A", 1796, 124, 0], + ["A", 1797, 124, 0], + ["A", 1798, 125, 0], + ["A", 1799, 125, 0], + ["A", 1800, 125, 0], + ["A", 1801, 125, 0], + ["A", 1802, 135, 0], + ["A", 1803, 135, 0], + ["A", 1804, 117, 0], + ["A", 1805, 128, 0], + ["A", 1806, 128, 0], + ["A", 1807, 128, 0], + ["A", 1808, 128, 0], + ["A", 1809, 120, 0], + ["A", 1810, 130, 0], + ["A", 1811, 130, 0], + ["A", 1812, 130, 0], + ["A", 1813, 130, 0], + ["A", 1814, 133, 0], + ["A", 1815, 133, 0], + ["A", 1816, 116, 0], + ["A", 1817, 122, 0], + ["A", 1818, 122, 0], + ["A", 1819, 122, 0], + ["A", 1820, 122, 0], + ["A", 1821, 129, 0], + ["A", 1822, 129, 0], + ["A", 1823, 129, 0], + ["A", 1824, 129, 0], + ["A", 1825, 132, 0], + ["A", 1826, 132, 0], + ["A", 1827, 126, 0], + ["A", 1828, 126, 0], + ["A", 1829, 126, 0], + ["A", 1830, 126, 0], + ["A", 1831, 136, 0], + ["A", 1832, 136, 0], + ["A", 1833, 118, 0], + ["A", 1834, 118, 0], + ["A", 1835, 118, 0], + ["A", 1836, 118, 0], + ["A", 1837, 127, 0], + ["A", 1838, 127, 0], + ["A", 1839, 127, 0], + ["A", 1840, 127, 0], + ["A", 1841, 123, 0], + ["A", 1842, 123, 0], + ["A", 1843, 123, 0], + ["A", 1844, 123, 0], + ["A", 1845, 121, 0], + ["A", 1846, 121, 0], + ["A", 1847, 121, 0], + ["A", 1848, 121, 0], + ["A", 4031, 620, 621], + ["A", 4037, 622, 280], + ["B", 0, 115, 0], + ["B", 1, 115, 0], + ["B", 2, 115, 0], + ["B", 3, 115, 0], + ["B", 4, 115, 0], + ["B", 5, 115, 0], + ["B", 6, 115, 0], + ["B", 7, 115, 0], + ["B", 8, 114, 0], + ["B", 9, 114, 0], + ["B", 10, 114, 0], + ["B", 15, 114, 0], + ["B", 16, 114, 0], + ["B", 17, 114, 0], + ["B", 18, 114, 0], + ["B", 19, 115, 0], + ["B", 20, 115, 0], + ["B", 21, 115, 0], + ["B", 22, 115, 0], + ["B", 23, 115, 0], + ["B", 24, 115, 0], + ["B", 25, 115, 0], + ["B", 26, 115, 0], + ["B", 27, 114, 0], + ["B", 28, 114, 0], + ["B", 29, 114, 0], + ["B", 30, 114, 0], + ["B", 32, 114, 0], + ["B", 33, 114, 0], + ["B", 34, 114, 0], + ["B", 35, 115, 0], + ["B", 36, 115, 0], + ["B", 37, 115, 0], + ["B", 38, 115, 0], + ["B", 39, 115, 0], + ["B", 40, 115, 0], + ["B", 41, 115, 0], + ["B", 42, 115, 0], + ["B", 43, 114, 0], + ["B", 44, 114, 0], + ["B", 45, 114, 0], + ["B", 46, 114, 0], + ["B", 47, 114, 0], + ["B", 48, 114, 0], + ["B", 49, 115, 0], + ["B", 50, 115, 0], + ["B", 51, 115, 0], + ["B", 52, 115, 0], + ["B", 53, 115, 0], + ["B", 54, 115, 0], + ["B", 55, 115, 0], + ["B", 56, 115, 0], + ["B", 57, 114, 0], + ["B", 60, 114, 0], + ["B", 61, 137, 0], + ["B", 62, 137, 0], + ["B", 63, 137, 0], + ["B", 64, 137, 0], + ["B", 65, 137, 0], + ["B", 66, 137, 0], + ["B", 67, 137, 0], + ["B", 68, 137, 0], + ["B", 69, 137, 0], + ["B", 70, 137, 0], + ["B", 71, 137, 0], + ["B", 72, 137, 0], + ["B", 73, 137, 0], + ["B", 74, 137, 0], + ["B", 75, 137, 0], + ["B", 76, 137, 0], + ["B", 77, 137, 0], + ["B", 78, 137, 0], + ["B", 79, 137, 0], + ["B", 80, 137, 0], + ["B", 81, 137, 0], + ["B", 82, 137, 0], + ["B", 83, 137, 0], + ["B", 84, 137, 0], + ["B", 85, 137, 0], + ["B", 86, 137, 0], + ["B", 87, 137, 0], + ["B", 88, 137, 0], + ["B", 89, 137, 0], + ["B", 90, 137, 0], + ["B", 91, 137, 0], + ["B", 92, 137, 0], + ["B", 93, 137, 0], + ["B", 94, 137, 0], + ["B", 95, 137, 0], + ["B", 96, 137, 0], + ["B", 97, 114, 0], + ["B", 98, 114, 0], + ["B", 99, 114, 0], + ["B", 100, 114, 0], + ["B", 101, 114, 0], + ["B", 102, 114, 0], + ["B", 103, 114, 0], + ["B", 104, 114, 0], + ["B", 105, 114, 0], + ["B", 106, 114, 0], + ["B", 107, 114, 0], + ["B", 108, 114, 0], + ["B", 109, 114, 0], + ["B", 110, 114, 0], + ["B", 111, 114, 0], + ["B", 112, 114, 0], + ["B", 113, 114, 0], + ["B", 114, 114, 0], + ["B", 135, 115, 0], + ["B", 136, 115, 0], + ["B", 137, 115, 0], + ["B", 138, 115, 0], + ["B", 139, 115, 0], + ["B", 140, 115, 0], + ["B", 141, 115, 0], + ["B", 142, 115, 0], + ["B", 143, 115, 0], + ["B", 144, 115, 0], + ["B", 145, 115, 0], + ["B", 146, 115, 0], + ["B", 147, 115, 0], + ["B", 148, 115, 0], + ["B", 149, 115, 0], + ["B", 150, 115, 0], + ["B", 151, 115, 0], + ["B", 152, 115, 0], + ["B", 153, 115, 0], + ["B", 154, 115, 0], + ["B", 155, 115, 0], + ["B", 156, 115, 0], + ["B", 157, 115, 0], + ["B", 158, 115, 0], + ["B", 159, 115, 0], + ["B", 160, 115, 0], + ["B", 161, 115, 0], + ["B", 162, 115, 0], + ["B", 163, 115, 0], + ["B", 164, 115, 0], + ["B", 165, 115, 0], + ["B", 166, 115, 0], + ["B", 167, 115, 0], + ["B", 168, 115, 0], + ["B", 169, 115, 0], + ["B", 170, 115, 0], + ["B", 171, 115, 0], + ["B", 172, 115, 0], + ["B", 173, 115, 0], + ["B", 174, 115, 0], + ["B", 175, 115, 0], + ["B", 176, 115, 0], + ["B", 177, 115, 0], + ["B", 178, 115, 0], + ["B", 179, 115, 0], + ["B", 180, 115, 0], + ["B", 181, 115, 0], + ["B", 182, 115, 0], + ["B", 183, 115, 0], + ["B", 184, 115, 0], + ["B", 185, 115, 0], + ["B", 186, 115, 0], + ["B", 187, 115, 0], + ["B", 188, 115, 0], + ["B", 189, 115, 0], + ["B", 190, 115, 0], + ["B", 191, 115, 0], + ["B", 192, 115, 0], + ["B", 193, 115, 0], + ["B", 194, 115, 0], + ["B", 195, 115, 0], + ["B", 196, 115, 0], + ["B", 197, 115, 0], + ["B", 198, 115, 0], + ["B", 199, 114, 0], + ["B", 200, 114, 0], + ["B", 201, 114, 0], + ["B", 202, 114, 0], + ["B", 203, 114, 0], + ["B", 204, 114, 0], + ["B", 205, 114, 0], + ["B", 206, 114, 0], + ["B", 207, 114, 0], + ["B", 208, 114, 0], + ["B", 209, 114, 0], + ["B", 210, 114, 0], + ["B", 211, 114, 0], + ["B", 212, 114, 0], + ["B", 213, 114, 0], + ["B", 214, 114, 0], + ["B", 234, 114, 0], + ["B", 235, 114, 0], + ["B", 236, 114, 0], + ["B", 237, 114, 0], + ["B", 474, 138, 0], + ["B", 475, 731, 360], + ["B", 503, 743, 371], + ["B", 504, 744, 372], + ["B", 505, 745, 373], + ["B", 506, 746, 374], + ["B", 507, 747, 375], + ["B", 508, 748, 376], + ["B", 509, 749, 377], + ["B", 510, 750, 378], + ["B", 511, 751, 391], + ["B", 512, 752, 392], + ["B", 513, 753, 393], + ["B", 514, 754, 394], + ["B", 515, 755, 395], + ["B", 516, 756, 396], + ["B", 517, 757, 397], + ["B", 518, 758, 398], + ["B", 521, 256, 299], + ["B", 526, 257, 299], + ["B", 533, 765, 411], + ["B", 534, 766, 412], + ["B", 535, 767, 413], + ["B", 536, 768, 414], + ["B", 537, 769, 415], + ["B", 538, 770, 416], + ["B", 539, 771, 417], + ["B", 540, 772, 418], + ["B", 559, 779, 431], + ["B", 560, 780, 432], + ["B", 561, 781, 433], + ["B", 562, 782, 434], + ["B", 563, 783, 435], + ["B", 564, 784, 436], + ["B", 565, 785, 437], + ["B", 566, 786, 438], + ["B", 571, 261, 303], + ["B", 575, 263, 303], + ["B", 576, 263, 303], + ["B", 601, 268, 304], + ["B", 602, 268, 304], + ["B", 622, 271, 305], + ["B", 624, 270, 305], + ["B", 627, 271, 305], + ["B", 629, 270, 305], + ["B", 630, 140, 0], + ["B", 635, 801, 491], + ["B", 636, 802, 492], + ["B", 637, 803, 493], + ["B", 638, 804, 494], + ["B", 639, 805, 495], + ["B", 640, 806, 496], + ["B", 641, 807, 497], + ["B", 642, 808, 498], + ["B", 661, 813, 511], + ["B", 662, 814, 512], + ["B", 663, 815, 513], + ["B", 664, 816, 514], + ["B", 665, 817, 515], + ["B", 666, 818, 516], + ["B", 667, 819, 517], + ["B", 668, 820, 518], + ["B", 673, 275, 308], + ["B", 678, 276, 308], + ["B", 684, 131, 114], + ["cleanup_tail", 0, 286, 279], + ["cleanup_tail", 1, 286, 279], + ["cleanup_tail", 2, 286, 279], + ["cleanup_tail", 3, 287, 280], + ["cleanup_tail", 4, 287, 280], + ["cleanup_tail", 5, 287, 280], + ["cleanup_tail", 6, 288, 279], + ["cleanup_tail", 7, 288, 279], + ["cleanup_tail", 8, 288, 279], + ["cleanup_tail", 9, 289, 281], + ["cleanup_tail", 10, 289, 281], + ["cleanup_tail", 11, 289, 281], + ["cleanup_tail", 12, 262, 1], + ["cleanup_tail", 13, 262, 1], + ["cleanup_tail", 14, 262, 1], + ["cleanup_tail", 15, 267, 1], + ["cleanup_tail", 16, 267, 1], + ["cleanup_tail", 17, 267, 1], + ["cleanup_tail", 18, 267, 1], + ["cleanup_tail", 19, 267, 1], + ["cleanup_tail", 40, 262, 1], + ["cleanup_tail", 41, 262, 1], + ["cleanup_tail", 42, 262, 1], + ["cleanup_tail", 43, 262, 1], + ["cleanup_tail", 44, 262, 1], + ["cleanup_tail", 45, 262, 1], + ["cleanup_tail", 46, 262, 1], + ["cleanup_tail", 53, 267, 1], + ["cleanup_tail", 54, 267, 1], + ["cleanup_tail", 67, 285, 1], + ["cleanup_tail", 68, 285, 1], + ["cleanup_tail", 69, 285, 1], + ["cleanup_tail", 77, 285, 1], + ["cleanup_tail", 78, 285, 1], + ["cleanup_tail", 112, 267, 1], + ["cleanup_tail", 113, 267, 1], + ["cleanup_tail", 114, 267, 1], + ["cleanup_tail", 115, 267, 1], + ["cleanup_tail", 118, 262, 1], + ["cleanup_tail", 119, 262, 1], + ["cleanup_tail", 120, 262, 1] + ] +} diff --git a/research/pr4470-frame-audit/source/research/fresh-helper-boundary/native.py b/research/pr4470-frame-audit/source/research/fresh-helper-boundary/native.py new file mode 100644 index 0000000000..1b36f6cb5f --- /dev/null +++ b/research/pr4470-frame-audit/source/research/fresh-helper-boundary/native.py @@ -0,0 +1,183 @@ +"""Retiming of the pinned full-identity word; Apache-2.0, OpenAI Codex assistance. + +The scalar order and free-operator words stay fixed. Every changed transport +is independently lowered as an exact Clifford, including its absolute phase. +""" +from collections import Counter +from copy import deepcopy +from fractions import Fraction as Q +import gzip +import importlib.util +import json +from pathlib import Path +import sys + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] +BASE = ROOT/'research/kappa-rebuild/complex/full-identity-certificates' + +def need(ok, why): + if not ok: + raise ValueError(why) + +def load(path, name): + spec = importlib.util.spec_from_file_location(name, path) + m = importlib.util.module_from_spec(spec) + sys.modules[name] = m + spec.loader.exec_module(m) + return m + +def read(path): + data = Path(path).read_bytes() + return json.loads(gzip.decompress(data) if str(path).endswith('.gz') else data) + +def span(basis): + out = {0} + for x in basis: + out |= {v ^ x for v in tuple(out)} + return frozenset(out) + +def gates(program): + phase = None + counters = Counter() + result = {} + for i, e in enumerate(program): + if e[0] == 'phase': + phase = e[1] + if e[0] == 'scalar': + g = e[1] + roles = g[1:3] if g[0] in ('add', 'copy') else g[1:2] + if all(r[0] == 'L' for r in roles): + key = (phase, counters[phase]) + result[key] = i + counters[phase] += 1 + return result + +def dual(g): + g = deepcopy(g) + if g[0] == 'add': + g[1], g[2] = g[2], g[1] + g[3] *= -1 + else: + need(g[0] == 'scale', 'Reversible persistent scalar') + g[2], g[3] = g[3], g[2] + return g + +def synthesize(c, program): + current = c['start'][:] + out = [] + def climb(r, f): + old = current[r] + if old == f: + return + need(span(c['frames'][old]) < span(c['frames'][f]), 'Nested positive retimed transport') + out.append(['climb', 'retimed', r, old, f, len(c['frames'][f])-len(c['frames'][old])]) + current[r] = f + i = 0 + while i < len(program): + e = deepcopy(program[i]); i += 1 + if e[0] == 'climb': + continue + if e[0] == 'center': + second = program[i] + need(second[0] == 'center' and e[1] == second[1] == 0 and e[3] == second[2], 'Original center split') + need(sorted((e[4], second[4])) == [3, 5], 'Original 3+5 center') + e = ['center', 0, e[2], second[3], 8]; i += 1 + if e[0] == 'scalar': + g = e[1] + roles = g[1:3] if g[0] in ('add', 'copy') else g[1:2] + for r in roles: + if r[0] == 'L': + climb(r[1], e[2]) + elif e[0] == 'warp': + need(e[1][0] == 'L', 'Persistent source warp') + climb(e[1][1], e[3]); current[e[1][1]] = e[4] + elif e[0] in ('adapter', 'residual_adapter'): + # Helper wrappers are recomputed on the new whole-job boundaries. + role = e[2] if e[0] == 'adapter' else e[2] + if role >= 224: + continue + out.append(e) + for r, f in enumerate(c['final']): + climb(r, f) + return out + +def run(changes=None, phase_check=True): + c = read(BASE/'THREE-base-FULL-IDENTITY-CANONICAL.json.gz') + original = read(BASE/'THREE-base-FULL-IDENTITY-NATIVE.json.gz') + changes = read(HERE/'CHANGES.json') if changes is None else changes + for key, frame_key in (('entrances', 'start'), ('exits', 'final')): + seen = set() + for role, old, new in changes[key]: + need(role not in seen and 224 <= role < 632 and c[frame_key][role] == old, 'Bound unique helper boundary') + seen.add(role); c[frame_key][role] = new + maps = {d: gates(p) for d, p in original.items()} + need(set(maps['forward']) == set(maps['backward']), 'Both scalar orientations have the same contact inventory') + for key in maps['forward']: + f = original['forward'][maps['forward'][key]] + b = original['backward'][maps['backward'][key]] + need(b[1] == dual(f[1]) and b[2] == f[2], 'Actual inverse-transpose scalar correspondence') + changed = deepcopy(original) + seen = set() + for phase, ordinal, old, new in changes['gates']: + key = (phase, ordinal) + need(key not in seen and key in maps['forward'], 'Bound unique retimed scalar contact') + seen.add(key) + for d in changed: + e = changed[d][maps[d][key]] + need(e[2] == old, 'Original scalar frame pin') + e[2] = new + programs = {d: synthesize(c, p) for d, p in changed.items()} + V = load(ROOT/'research/kappa-causal-continuation/buffer-borrowing/verify_buffers.py', 'fresh_boundary_rows') + X = load(ROOT/'research/kappa-rebuild/complex/native_extensions.py', 'fresh_boundary_literal') + checks = {} + profiles = {} + for d, p in programs.items(): + rows, receipt = X.literal_replay(V, c, p, d == 'backward') + for r in range(632): + need(rows['L', r] == V.expected(('L', r), [], d == 'backward', False), 'Every actual arbitrary-input endpoint, role '+str(r)) + profiles[d] = Counter({int(k): v for k, v in receipt['paid_profile'].items()}) + rebound = deepcopy(c) + rebound['local_profile'] = dict(profiles[d]) + receipt['second_literal'] = V.replay(p, rebound, [], d == 'backward', False) + checks[d] = receipt + need(profiles['forward'] == profiles['backward'], 'Same complete native tariff in both orientations') + H = Counter() + for r in range(224, 632): + a, b = c['start'][r], c['final'][r] + need(span(c['frames'][a]) <= span(c['frames'][b]), 'Nested productive helper boundary') + width = len(c['frames'][b])-len(c['frames'][a]) + need(width > 0, 'Every declared helper is independently productive') + H[width] += 1 + physical = [] + if phase_check: + ce = load(ROOT/'research/t74-native-fast/vendor/native/new/code/borrow/vendor/clifford/clifford_exact.py', 'fresh_boundary_clifford') + P = load(ROOT/'research/kappa-function-composition/complex/prune_native.py', 'fresh_boundary_lowering') + N = X.N + old_edges = {(e[3], e[4]) for e in original['forward'] if e[0] == 'climb'} + new_edges = {(e[3], e[4]) for e in programs['forward'] if e[0] == 'climb'} + helper_edges = {(c['start'][r], c['final'][r]) for r in range(224, 632)} + for a, b in sorted((new_edges-old_edges) | helper_edges): + op = ce.canonical_frame(9, c['frames'][a]).adjoint().then(ce.canonical_frame(9, c['frames'][b])) + want = len(c['frames'][b])-len(c['frames'][a]) + directions = {} + for d in ('forward', 'backward'): + actual = P.conjugate(ce, op) if d == 'backward' else op + rec = N.lower_exact(P, ce, actual) + need(rec['rank'] == want, 'New physical Fourier rank including phase') + directions[d] = rec + physical.append({'old': a, 'new': b, 'rank': want, 'recipes': directions}) + return {'status': 'PASS_RETIMED_BOTH_ORIENTATIONS_ALL_632_COLUMNS', + 'helpers': dict(sorted(H.items())), 'paid': dict(sorted(profiles['forward'].items())), + 'changed_entrances': len(changes['entrances']), 'changed_exits': len(changes['exits']), + 'changed_scalar_frames': len(changes['gates']), 'native': checks, + 'new_physical_edges_and_boundaries': physical}, c, programs + +if __name__ == '__main__': + import argparse + p = argparse.ArgumentParser(); p.add_argument('--skip-phase', action='store_true'); p.add_argument('--write-result', action='store_true'); args = p.parse_args() + result, _, _ = run(phase_check=not args.skip_phase) + if args.write_result: + need(not args.skip_phase, 'Do not replace a complete phase receipt with a diagnostic') + (HERE/'NATIVE-RESULT.json.gz').write_bytes(gzip.compress((json.dumps(result, indent=2, sort_keys=True)+'\n').encode(),mtime=0)) + print(json.dumps({k: v for k, v in result.items() if k not in ('native', 'new_physical_edges_and_boundaries')}, sort_keys=True)) diff --git a/research/pr4470-frame-audit/source/research/joint-helper-lattice/PATCH.json b/research/pr4470-frame-audit/source/research/joint-helper-lattice/PATCH.json new file mode 100644 index 0000000000..51304a6601 --- /dev/null +++ b/research/pr4470-frame-audit/source/research/joint-helper-lattice/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-frame-audit/source/research/joint-helper-lattice/PROOF.md b/research/pr4470-frame-audit/source/research/joint-helper-lattice/PROOF.md new file mode 100644 index 0000000000..e41106031d --- /dev/null +++ b/research/pr4470-frame-audit/source/research/joint-helper-lattice/PROOF.md @@ -0,0 +1,102 @@ +# Construction and proof obligations + +## 1. Exact predecessor and changed object + +The input is PR4447 at commit `322e0ec764aa7ef7801383feb1f656e460dd8bed`, with its credited THREE-base native word, PR4441 helper-boundary retiming, and the added three-dimensional frame at B/480. `SOURCES.json` binds all external proof inputs by Git blob and SHA-256. + +There are 632 persistent local fields: 224 main fields and 408 helpers. Each helper is an arbitrary independent input, not initialized scratch. The separate owned center is initialized and erased under the inherited native contract. None of its eight uses receives productive-input credit. + +The patch retains the scalar order and coefficients in each orientation. It retains all native warp events and every main-field boundary. It changes 38 helper entrance frames, 47 helper terminal frames, and 414 scalar contact frames. A source pin accompanies every changed boundary or contact. The two orientations retain their exact inverse-transpose scalar correspondence. + +The optional search jointly optimized both helper boundaries and every mutable scalar contact over the finite intervals of subspaces of F2^9. Fixed main and warp events bound those intervals. The largest quotient dimension was five, so its interval has 374 subspaces. The discovery model used one-hot frame choices and edge marginals, with negative whole-helper credit. Its floating-point solution is a proposal, not a certificate. The following construction and exact tests do not use its claimed optimum. + +## 2. Frame-coordinate invariant + +Let C_F be the source's exact canonical frame operator for subspace F. Interpret a field at frame F as C_F applied to its logical arbitrary value. For nested frames E contained in F, the paid transport is C_F C_E^{-1}. Its Fourier rank is dim(F)-dim(E). The implementation follows the source's `adjoint().then(...)` composition convention and lowers the operator itself, not only that rank formula. + +At each scalar operation, all participating persistent fields are first moved into its declared common frame. A scalar linear combination commutes with the common frame operator. Therefore the operation implements the unchanged logical scalar step. A native warp is run only at its original pinned input frame, and leaves the original pinned output frame. This proves the invariant by induction through the complete chronological word. + +At the end of the word, main fields have their unchanged original endpoints. Helper r has the whole residual C_{T_r} C_{S_r}^{-1}, where S_r and T_r are its new entrance and exit. Every checked S_r is a proper subspace of T_r. Its positive productive rank is dim(T_r)-dim(S_r). There is no duplicate field, discarded helper, clean-input assumption, or free temporary productive input. + +The helper normalizers are recomputed on these whole-job boundaries. Every new transport and each distinct helper boundary is lowered in both orientations with exact Clifford tableaux and absolute phases. The receipt contains 423 distinct transport/boundary pairs, including 406 newly occurring transport pairs relative to PR4447. Two retained literal interpreters check the complete 632-column endpoint. The argument is the frame-coordinate invariant; the finite replay independently checks its application to the submitted circuit. + +## 3. Complete local bill and uniform moment gain + +Write H_r for productive helpers of rank r and P_r for paid jobs of rank r. The predecessor has + + H_old = {4:26, 5:2, 7:29, 8:42, 9:309} + P_old = {1:2254, 2:514, 3:444, 4:103, 5:40, 8:8}. + +The new word has + + H_new = {4:28, 7:7, 8:47, 9:326} + P_new = {1:2237, 2:388, 3:494, 4:147, 5:36, 8:8}. + +There are 408 helpers in both words. The new paid list has 3,310 entries, 53 fewer than the predecessor. Helper rank mass increases from 3,434 to 3,471, and paid rank mass from 5,290 to 5,327. Their difference remains 1,856. In particular, the improvement is not obtained by keeping old productive credit after removing paid work. + +For 0D(1)=0 for every 0 theta^1000, + 145^(1024*TESTED) < 2^1000. + +Set kappa=0.00302015 and d=(TESTED-kappa)/7=1/1,400,000,000. The integer test + + (1,400,000,000*j + 1)^1000 < 2^j + +passes at j=45,868 and fails at j-1. Thus the retained theorem supplies the sufficient uniform rank N=2^64,215,200,000,000. This is an existence construction with explicit finite constants. The resulting word is not materialized and no practical implementation claim follows. + +The new local scalar and fixed-route bound remains below 10^7 per full call. Eighteen such calls, all 15 thin-query charges, every scalar controller and boundary operation fit the complete raw bound 10^9. The number of roles, private storage, coefficient matrices and tapes is finite for the compiled template. Their sizes affect the eventual threshold and are not claimed uniform while changing that template. + +Retain the source BIT ordinary saving 0.0034, with atom exponent 0.004. Its delayed-cover, weighted-child, row-stock and conversion conditions are rechecked through the source package. Use complex uniform saving kappa+6d, followed by b=kappa+5d, a=kappa+4d, q=kappa+3d, epsilon=1-d, beta=1-3d, r0=d/10, stop=d and layout=d. All nine outer cost rows, 54 strict predicates and four functional guards pass exactly. The old BIT cap and closed exponent gaps are explicit rejected controls. + +## 7. Status of the conclusion + +Subject to the retained all-column/native and physical-operation contracts, owned erasure, whole-job matching, finite-template compiler closure, precision and fixed-tape bounds, analytic decomposition, prime avoidance and exact recovery, this construction gives the source framework's conditional multiplication saving kappa=0.00302015. + +The submitted change establishes an exact finite native word and a fully charged conditional parameter transfer. It does not remove the inherited analytic or physical premises. It does not promote the selected frontier, certify global optimality, claim a runtime speedup, or claim independent human or proof-assistant acceptance. + +Credits: zxv's native and higher-moment/logarithmic work; Jacob Alan Sussman's finite mixed-flow theorem; Cinna Davis's prior p7 padding, query-thinned and retimed constructions; and the unchanged credited scalar, Clifford, geometry and outer-ledger sources. New material was prepared for Cinna Davis with substantial OpenAI assistance, Apache-2.0. diff --git a/research/pr4470-frame-audit/source/research/joint-helper-lattice/RESULT.json b/research/pr4470-frame-audit/source/research/joint-helper-lattice/RESULT.json new file mode 100644 index 0000000000..edf41a49a0 --- /dev/null +++ b/research/pr4470-frame-audit/source/research/joint-helper-lattice/RESULT.json @@ -0,0 +1,274 @@ +{ + "compiler": { + "H": 64215200000000, + "N": "2^64215200000000", + "eta": { + "lower": "0.000000206231977820868640096499", + "upper": "0.000000206231977820868640096500" + }, + "gap": "1/1400000000", + "integer_test_exponent": 45868, + "logarithm_power": 1000, + "theta": "63/64", + "uniform_saving": "528527/175000000", + "word_materialized": false + }, + "fixed_profile_ceiling": { + "decreasing_through_C": "1/20", + "headroom": [ + "15977/1000000000000", + "159771/10000000000000" + ], + "negative_derivative_upper": { + "lower": "-195970.145588045890401261885812812963", + "upper": "-195970.145588045890401261885812812962" + }, + "remaining_interval_moment_upper": { + "lower": "-6847.019825166589746262304732988153", + "upper": "-6847.019825166589746262304732988152" + }, + "root": [ + "3020165977/1000000000000", + "30201659771/10000000000000" + ] + }, + "full_calls": 18, + "gain_over_PR4416": "4171/12500000", + "gain_over_PR4440": "1203/20000000", + "gain_over_PR4441": "191/10000000", + "gain_over_PR4447": "473/25000000", + "kappa": "60403/20000000", + "kappa_decimal": "0.00302015", + "local_helpers": { + "4": 28, + "7": 7, + "8": 47, + "9": 326 + }, + "local_paid": { + "1": 2237, + "2": 388, + "3": 494, + "4": 147, + "5": 36, + "8": 8 + }, + "negative_controls": { + "closed_epsilon": [ + "epsilon_below_one", + "global_gamma_power_slack", + "actual_logarithmic_gamma_guard", + "source_axis_superpolynomial", + "gaussian_above_main", + "new_semantic_guard_with_C1_one" + ], + "closed_uniform": [ + "new_complex_uniform_saving_above_b" + ], + "old_BIT": [ + "actual_bit_above_effective" + ], + "unfunded_endpoint": [ + "main_transform_above_kappa", + "global_coordinate_router_above_kappa", + "fused_gaussian_above_kappa", + "group_bit_router_above_kappa", + "boundary_algebraic_matrix_above_kappa" + ] + }, + "nonrecursive": { + "local_route_bound": 4814000, + "local_scalar_allowance": 158168, + "raw_budget": 1000000000, + "raw_upper": 181098496 + }, + "ordinary_BIT": { + "admitted": "17/5000", + "after_cover": "69/20000", + "atom": "1/250", + "before_cover": "3459/1000000", + "ordinary_saving": "8590884599/2500000000000", + "prime_rule": "odd q > 2^26*N^5 avoiding all fixed denominators and rank witnesses" + }, + "outer": { + "functional_checks": { + "actual_new_BIT_stock_sublinear": "348599999253/350000000000", + "fixed_halo_explicit_metadata_branch": "26950000001/350000000", + "new_BIT_row_stock_sublinear_in_active_group": "1395799997009/1400000000000", + "new_semantic_group_guard": "3/1400000000" + }, + "margins": { + "boundary_algebraic_matrix": "5919499595771787/1960000000000000000", + "fused_gaussian": "5919499587315361/1960000000000000000", + "global_coordinate_router": "2114107/700000000", + "group_bit_router": "2959750493657679/980000000000000000", + "group_scans": "699999999/700000000", + "main_transform": "5919498195771787/1960000000000000000", + "microbox_face_corrections": "26950000001/350000000", + "polynomial_products": "1399999999/1400000000", + "sparse_union_movement": "802169499595771787/1960000000000000000" + }, + "parameters": { + "a": "2114107/700000000", + "b": "845643/280000000", + "beta": "1399999997/1400000000", + "bit_saving": "17/5000", + "cap_xi": "1782169498195771787/1960000000000000000", + "complex_uniform_saving": "528527/175000000", + "d": "1/1400000000", + "epsilon": "1399999999/1400000000", + "kappa": "60403/20000000", + "lambda_": "398791939/400000000", + "lambda_prime": "1395771787/1400000000", + "layout": "1/1400000000", + "q": "4228213/1400000000", + "r0": "1/14000000000", + "stop": "1/1400000000", + "tested_saving": "604031/200000000" + }, + "strict_checks": { + "actual_bit_above_effective": "265893/700000000", + "actual_logarithmic_gamma_guard": "1/1400000000", + "actual_logarithmic_group_guard": "177830503904228213/980000000000000000", + "alpha_logarithm_absorption": "1/14000000000", + "boundary_algebraic_matrix_above_kappa": "5595771787/1960000000000000000", + "cap_above_band": "802169498195771787/1960000000000000000", + "cap_below_cell": "177830500404228213/1960000000000000000", + "cap_below_phase_cell_power": "2137830501804228213/1960000000000000000", + "complex_above_effective": "1/1400000000", + "complex_below_one_over_32": "7904357/280000000", + "complex_endpoint": "1/700000000", + "epsilon_below_one": "1/1400000000", + "epsilon_positive": "1399999999/1400000000", + "fine_prime_halo_umbrella": "7/2", + "fused_gaussian_above_kappa": "5587315361/1960000000000000000", + "gaussian_above_main": "695771787/980000000000000000", + "global_coordinate_router_above_kappa": "1/350000000", + "global_gamma_power_slack": "9/14000000000", + "group_below_dimension": "1/700000000", + "group_bit_router_above_kappa": "3493657679/980000000000000000", + "group_gauge_power_slack": "177830503834228213/980000000000000000", + "group_key_fits_record": "1/700000000", + "group_positive": "1399999997/1400000000", + "group_scans_above_kappa": "348942947/350000000", + "halo_covers_generic_inverse_radius": "5", + "improvement_over_user_baseline": "644589790400418148631/500000000000000000000000", + "lambda_above_internal": "1/2800000000", + "lambda_above_sigma": "3/2800000000", + "lambda_above_tau": "1/2800000000", + "lambda_prime_above_lambda": "1/2800000000", + "lambda_prime_above_leaf": "559154357/392000000000000000", + "leaf_saving_above_effective": "279154357/392000000000000000", + "main_transform_above_kappa": "4195771787/1960000000000000000", + "membership_arithmetic_fits_record": "1/1400000000", + "microbox_face_corrections_above_kappa": "53897885897/700000000", + "microbox_halo_volume": "110600000003/1400000000", + "new_complex_uniform_saving_above_b": "1/1400000000", + "new_semantic_guard_with_C1_one": "1/1400000000", + "polynomial_products_above_kappa": "1395771789/1400000000", + "positive_layout_slack": "1/1400000000", + "q_below_effective": "1/1400000000", + "q_below_internal": "1/1400000000", + "q_below_leaf": "559154357/392000000000000000", + "q_positive": "4228213/1400000000", + "short_record_fallback": "279154357/280000000", + "source_axis_superpolynomial": "1/1400000000", + "sparse_union_movement_above_kappa": "796250005595771787/1960000000000000000", + "stop_below_one": "1399999999/1400000000", + "stop_positive": "1/1400000000", + "strassen_integer_power_gap": "1951441519231", + "support_router_span": "3/1400000000", + "theta_positive_polynomial_power": "2", + "union_header_fits_record": "3/1400000000", + "union_tag_work_per_visit_fits_record": "3/1400000000" + } + }, + "paid": { + "1": 41946, + "16": 448, + "2": 6984, + "24": 448, + "3": 8892, + "32": 448, + "4": 2646, + "40": 448, + "48": 448, + "5": 648, + "56": 448, + "64": 448, + "72": 224, + "8": 144 + }, + "paid_calls": 64620, + "pairs": 16, + "prefix_pairs": 7, + "productive_fields": 10928, + "query_shears": 15, + "scope": "Author-checked conditional construction; retained native/all-column, owned-erasure, whole-job, analytic, precision, tape, prime and recovery contracts. No selected promotion or formal/human acceptance.", + "source_heads": { + "PR4440": "40e22a83ed660d3d6074c4f2dbf14bfb621eee51", + "PR4441_combination": "5f9d871c6bd1b9e34db5a7ea5ef08a908e94db39", + "PR4447": "322e0ec764aa7ef7801383feb1f656e460dd8bed", + "helper_retiming": "ccdae89b2ab9ced24ee3e7adfdb670ef80d223d9" + }, + "source_inputs": 51, + "status": "PASS_CONDITIONAL_JOINT_HELPER_KAPPA_00302015", + "strictification": { + "alpha": { + "lower": "0.999999988558808354139963023136", + "upper": "0.999999988558808354139963023137" + }, + "cutoff": 20, + "delta": { + "lower": "0.958284435309221389866479909583", + "upper": "0.958284435309221389866479909584" + }, + "floor": 21, + "gamma": { + "lower": "0.956176646497545264598139374323", + "upper": "0.956176646497545264598139374324" + }, + "limits": [ + "999999999/1000000000", + "97/100", + "97/100" + ], + "normalized_paid_upper": "2097152001953127/2097154147483648", + "power": 1024, + "tail_offset": "1/5", + "tested": "604031/200000000" + }, + "targets": { + "145": 224, + "17": 448, + "25": 448, + "33": 448, + "4": 504, + "41": 448, + "49": 448, + "57": 448, + "65": 448, + "7": 126, + "73": 224, + "8": 846, + "9": 5868 + }, + "uniform_local_gain": { + "coefficients": { + "1": 17, + "2": 126, + "3": -50, + "4": -42, + "5": 2, + "7": -22, + "8": 5, + "9": 17 + }, + "derivative_upper": { + "lower": "-16.327581880492435373215953558618", + "upper": "-16.327581880492435373215953558617" + }, + "intervals": 128, + "vanishes_at_one": true + } +} diff --git a/research/pr4470-frame-audit/source/research/joint-helper-lattice/native_joint.py b/research/pr4470-frame-audit/source/research/joint-helper-lattice/native_joint.py new file mode 100644 index 0000000000..0315f80e2f --- /dev/null +++ b/research/pr4470-frame-audit/source/research/joint-helper-lattice/native_joint.py @@ -0,0 +1,118 @@ +"""Joint entrance/exit/contact retiming, with literal and phase replay. + +Apache-2.0. Substantial OpenAI assistance. Uses the credited native retiming +implementation of PR4441 and preserves PR4447's missing-span predecessor. +""" +from collections import Counter +from copy import deepcopy +from pathlib import Path +import json,gzip,sys +sys.dont_write_bytecode=True +HERE=Path(__file__).resolve().parent +ROOT=HERE.parents[1] +sys.path.insert(0,str(ROOT/'research/fresh-helper-boundary')) +import native as F +need=F.need + +def construct(patch=None): + c=F.read(F.BASE/'THREE-base-FULL-IDENTITY-CANONICAL.json.gz') + original=F.read(F.BASE/'THREE-base-FULL-IDENTITY-NATIVE.json.gz') + parent=F.read(F.HERE/'CHANGES.json') + maps={d:F.gates(p) for d,p in original.items()} + need(set(maps['forward'])==set(maps['backward']),'Same scalar contact inventory') + for key in maps['forward']: + f=original['forward'][maps['forward'][key]];b=original['backward'][maps['backward'][key]] + need(b[1]==F.dual(f[1]) and b[2]==f[2],'Retained exact dual scalar words') + for key,field in [('entrances','start'),('exits','final')]: + for r,old,new in parent[key]: + need(c[field][r]==old,'Parent boundary pin');c[field][r]=new + for phase,ordinal,old,new in parent['gates']: + for d,p in original.items(): + i=maps[d][phase,ordinal];need(p[i][2]==old,'Parent scalar pin');p[i][2]=new + prior=F.read(ROOT/'research/missing-join-frame/PATCH.json') + need(prior['phase']=='B' and prior['ordinal']==480,'Exact prior contact') + prior_frame=len(c['frames']);c['frames'].append(prior['new_basis']) + for d,p in original.items(): + i=maps[d]['B',480];need(p[i][2]==prior['old_frame'],'Missing-span parent pin');p[i][2]=prior_frame + baseline=deepcopy(c) + before={d:F.synthesize(c,p) for d,p in original.items()} + patch=F.read(HERE/'PATCH.json') if patch is None else patch + need(patch['source_head']=='322e0ec764aa7ef7801383feb1f656e460dd8bed','Pinned candidate head') + labels={frozenset(F.span(b)):i for i,b in enumerate(c['frames'])} + def label(b): + s=frozenset(F.span(b));need(len(s)==2**len(b),'Independent binary basis') + if s not in labels:labels[s]=len(c['frames']);c['frames'].append(b) + return labels[s] + seen=set();counts=Counter() + for move in patch['changes']: + phase,r=move['phase'],move['ordinal'];key=(phase,r) + need(key not in seen,'No duplicate changed boundary/contact');seen.add(key) + a,b=F.span(move['old']),F.span(move['new']);need(a!=b,'No unchanged patch entry') + f=label(move['new']);counts[phase]+=1 + if phase in ('entrance','exit'): + need(224<=r<632,'Only independent helper boundaries may change') + field='start' if phase=='entrance' else 'final' + need(F.span(c['frames'][c[field][r]])==a,'Current helper source pin') + c[field][r]=f + else: + for d,p in original.items(): + i=maps[d][key];need(F.span(c['frames'][p[i][2]])==a,'Current scalar source pin');p[i][2]=f + programs={d:F.synthesize(c,p) for d,p in original.items()} + return c,programs,baseline,before,counts + +def run(phase_check=True): + c,programs,baseline,before,counts=construct() + V=F.load(ROOT/'research/kappa-causal-continuation/buffer-borrowing/verify_buffers.py','joint_rows') + X=F.load(ROOT/'research/kappa-rebuild/complex/native_extensions.py','joint_literal') + checks={};profiles={} + for d,p in programs.items(): + rows,rec=X.literal_replay(V,c,p,d=='backward') + for r in range(632):need(rows['L',r]==V.expected(('L',r),[],d=='backward',False),'All 632 arbitrary-input endpoints') + profiles[d]=Counter({int(k):v for k,v in rec['paid_profile'].items()}) + rebound=deepcopy(c);rebound['local_profile']=dict(profiles[d]) + rec['second_literal']=V.replay(p,rebound,[],d=='backward',False);checks[d]=rec + need(profiles['forward']==profiles['backward'],'Both complete native rank tariffs') + H=Counter() + for r in range(224,632): + a,b=c['start'][r],c['final'][r] + need(F.span(c['frames'][a])= 224): + continue + if e[0] == 'center': + second = program[position] + need(second[0] == 'center' and second[1] == e[1] == 0 and + second[2] == e[3] and sorted([e[4], second[4]]) == [3, 5], + 'retained center split') + e = ['center', 0, e[2], second[3], 8] + position += 1 + out.append(normalize(e, c)) + return out + + +def normalize(e, c): + e = deepcopy(e) + indices = {'scalar': [2], 'warp': [3, 4], 'center': [2, 3], + 'climb': [3, 4], 'adapter': [], 'residual_adapter': [], 'phase': []} + need(e[0] in indices, 'unknown native event') + for i in indices[e[0]]: + need(type(e[i]) is int and 0 <= e[i] < len(c['frames']), 'invalid frame reference') + e[i] = basis(c['frames'][e[i]]) + return e + + +def demands(word, c): + """Build each field's ordered demand path first; no source synthesis helpers.""" + requests = defaultdict(list) + for position, e in enumerate(word): + if e[0] == 'scalar': + for role in operands(e[1]): + if role[0] == 'L': + requests[role[1]].append((position, e[2], e[2])) + elif e[0] == 'warp': + need(e[1][0] == 'L', 'persistent warp domain') + requests[e[1][1]].append((position, e[3], e[4])) + plan, paid = {}, Counter() + for role in range(632): + current = basis(c['frames'][c['start'][role]]) + requests[role].append((len(word), basis(c['frames'][c['final'][role]]), None)) + transitions = [] + for position, target, after in requests[role]: + if current != target: + rank = rank_step(current, target) + transitions.append((position, current, target, rank)) + paid[rank] += 1 + current = target if after is None else after + plan[role] = transitions + return plan, paid + + +def audit_program(program, c, wanted_word, expected_c): + frames = [basis(row) for row in c['frames']] + need(c.keys() == expected_c.keys(), 'canonical field inventory') + for field in c.keys() - {'frames', 'start', 'final'}: + need(c[field] == expected_c[field], 'retained canonical declaration: ' + field) + for field in ('start', 'final'): + need(len(c[field]) == 632 and [frames[i] for i in c[field]] == + [basis(expected_c['frames'][i]) for i in expected_c[field]], 'emitted boundary mismatch') + expected_plan, paid = demands(wanted_word, expected_c) + current = {('L', i): frames[f] for i, f in enumerate(c['start'])} + actual_plan, actual_word, invoice, event_counts = defaultdict(list), [], Counter(), Counter() + owned_zero = {} + for raw in program: + e = normalize(raw, c) + kind = e[0] + event_counts[kind] += 1 + if kind == 'climb': + _, _, role, old, new, rank = e + need(type(role) is int and 0 <= role < 632, 'transport role domain') + need(current['L', role] == old, 'transport source state') + need(rank == rank_step(old, new), 'emitted transport rank') + current['L', role] = new + actual_plan[role].append((len(actual_word), old, new, rank)) + invoice[rank] += 1 + continue + if kind == 'scalar': + op, frame = e[1:] + role = tuple(op[1]) + need(role[0] in ('L', 'C'), 'scalar role kind') + if op[0] == 'clear': + need(role == ('C', 0), 'borrowed field clear') + current[role] = frame + owned_zero[role] = True + else: + for operand in operands(op): + need(current.get(tuple(operand)) == frame, 'scalar common frame') + if op[0] == 'copy': + need(role == ('C', 0), 'borrowed field copy') + else: + coefficient = Fraction(*op[-2:]) + n, d = abs(coefficient.numerator), coefficient.denominator + need(n > 0 and d & (d - 1) == 0, 'non-dyadic scalar') + if op[0] == 'scale': + need(n & (n - 1) == 0, 'nonunit dyadic scale') + else: + need(op[0] == 'add' and op[1] != op[2], 'invalid shear') + if role[0] == 'C': + owned_zero[role] = False + elif kind == 'warp': + role = tuple(e[1]) + need(current.get(role) == e[3], 'warp source state') + current[role] = e[4] + elif kind == 'center': + role = 'C', e[1] + old, new, rank = e[2:] + need(role == ('C', 0) and current.get(role) == old, 'owned center source state') + need((contained(old, new) or contained(new, old)) and old != new, + 'owned center nesting') + need(rank == abs(len(new) - len(old)) == 8, 'owned center charge') + current[role] = new + invoice[rank] += 1 + else: + need(kind in ('phase', 'adapter', 'residual_adapter'), 'unknown event') + actual_word.append(e) + need(actual_word == wanted_word, 'retained logical/owned event word mismatch') + need(all(actual_plan[r] == expected_plan[r] for r in range(632)), 'chronological demand path mismatch') + need([current['L', r] for r in range(632)] == [frames[f] for f in c['final']], 'final persistent frames') + need(owned_zero == {('C', 0): True}, 'owned center not finally cleared') + centers = sum(e[0] == 'center' for e in wanted_word) + need(centers == 8, 'all eight center jobs retained') + paid[8] += centers + need(invoice == paid, 'complete paid invoice mismatch') + return {'paid': dict(sorted(invoice.items())), 'events': dict(sorted(event_counts.items())), + 'persistent_transports': sum(len(v) for v in expected_plan.values()), + 'scalar_contacts': event_counts['scalar'], 'owned_center_jobs': centers} + + +def helper_profile(c): + result = Counter() + for r in range(224, 632): + a, b = (basis(c['frames'][c[field][r]]) for field in ('start', 'final')) + result[rank_step(a, b)] += 1 + need(sum(result.values()) == 408, '408 independent helper fields') + return dict(sorted(result.items())) + + +def source_inputs(): + rows = json.loads((HERE / 'UPSTREAM.json').read_bytes())['files'] + for row in rows: + path = HERE / row['path'] + need(path.resolve().is_relative_to(SOURCE.resolve()) and path.is_file() and not path.is_symlink(), + 'invalid source snapshot path') + raw = path.read_bytes() + need(len(raw) == row['bytes'] and hashlib.sha256(raw).hexdigest() == row['sha256'], 'source SHA256 mismatch') + need(hashlib.sha1(b'blob ' + str(len(raw)).encode() + b'\0' + raw).hexdigest() == row['git_blob'], 'source Git blob mismatch') + return rows + + +def emit_source(rows): + # Only the pinned constructor is executed. Its verification engines are never imported. + with tempfile.TemporaryDirectory(prefix='pr4470-frame-audit-') as directory: + root = Path(directory) + for row in rows: + target = root / row['upstream_path'] + need(target.resolve().is_relative_to(root), 'invalid upstream snapshot path') + target.parent.mkdir(parents=True, exist_ok=True) + shutil.copyfile(HERE / row['path'], target) + process = subprocess.run([sys.executable, '-I', '-B', str(HERE / 'emit_source.py'), str(root)], + cwd=root, capture_output=True, text=True, encoding='utf-8', timeout=60) + need(process.returncode == 0, 'source constructor failed: ' + process.stderr) + return json.loads(process.stdout) + + +def rejected(label, thunk, message): + try: + thunk() + except ValueError as exc: + need(message in str(exc), 'wrong rejection for ' + label + ': ' + str(exc)) + return label + raise ValueError('negative control accepted: ' + label) + + +def main(): + rows = source_inputs() + old_c, old_programs, new_c, new_programs, changes = reconstruct() + emitted = emit_source(rows) + need(set(emitted['programs']) == set(emitted['before']) == {'forward', 'backward'}, 'both emitted orientations') + results = {} + for name, c, originals, actual_c, actual in [ + ('old', old_c, old_programs, emitted['baseline'], emitted['before']), + ('new', new_c, new_programs, emitted['canonical'], emitted['programs'])]: + results[name] = {d: audit_program(actual[d], actual_c, skeleton(originals[d], c), c) for d in actual} + need(results[name]['forward']['paid'] == results[name]['backward']['paid'], 'orientation invoice agreement') + results[name]['helpers'] = helper_profile(c) + declared = read(NEW + 'RESULT.json') + need(results['new']['helpers'] == {int(k): v for k, v in declared['local_helpers'].items()}, 'declared helper profile') + need(results['new']['forward']['paid'] == {int(k): v for k, v in declared['local_paid'].items()}, 'declared paid profile') + need(changes == emitted['changes'], 'constructor patch coverage') + need(changes.get('entrance') == 38 and changes.get('exit') == 47 and + sum(v for k, v in changes.items() if k not in ('entrance', 'exit')) == 414, '499 changed locations') + controls = [rejected('rank-only non-nested transition', lambda: rank_step((1,), (4, 2)), 'non-nested'), + rejected('dependent frame basis', lambda: basis([1, 2, 3]), 'dependent')] + need(basis([1, 2]) == basis([3, 2]) and rank_step((), basis([3, 2])) == 2, 'equivalent-basis positive control') + good = emitted['programs']['forward'] + c = emitted['canonical'] + word = skeleton(new_programs['forward'], new_c) + mutations = [('wrong emitted rank', 'climb', lambda e: e.__setitem__(5, e[5] + 1), 'emitted transport rank'), + ('changed scalar coefficient', 'scalar', lambda e: e[1].__setitem__(3, e[1][3] + 1), 'word mismatch'), + ('changed warp operator', 'warp', lambda e: e.__setitem__(2, e[2] + 1), 'word mismatch'), + ('borrowed clear', 'scalar', lambda e: e.__setitem__(1, ['clear', ['L', 0]]), 'borrowed field clear')] + for label, kind, mutate, message in mutations: + bad = deepcopy(good) + event = next(e for e in bad if e[0] == kind and (kind != 'scalar' or e[1][0] == 'add')) + mutate(event) + controls.append(rejected(label, lambda: audit_program(bad, c, word, new_c), message)) + for kind, message in [('climb', 'scalar common frame'), ('center', 'scalar common frame')]: + bad = deepcopy(good) + del bad[next(i for i, e in enumerate(bad) if e[0] == kind)] + controls.append(rejected('unpaid ' + kind, lambda: audit_program(bad, c, word, new_c), message)) + patch = read(NEW + 'PATCH.json') + for label, mutate, message in [ + ('duplicate edit', lambda p: p['changes'].append(deepcopy(p['changes'][0])), 'duplicate patch'), + ('main-field credit', lambda p: p['changes'][0].__setitem__('ordinal', 0), 'non-helper'), + ('wrong old basis', lambda p: p['changes'][0].__setitem__('old', [1]), 'source pin')]: + bad = deepcopy(patch) + mutate(bad) + controls.append(rejected(label, lambda: apply_patch(deepcopy(old_c), deepcopy(old_programs), bad), message)) + def mass(profile): + return sum(k * v for k, v in profile.items()) + report = {'status': 'PASS_PR4470_CHRONOLOGICAL_FRAME_AUDIT', 'scope': 'Chronological frames, retained event word, local paid and helper profiles; no physical phases, full column identity, controller or kappa admission.', + 'source_files': len(rows), 'changes': changes, 'profiles': results, + 'paid_job_reduction': sum(results['old']['forward']['paid'].values()) - sum(results['new']['forward']['paid'].values()), + 'paid_mass_change': mass(results['new']['forward']['paid']) - mass(results['old']['forward']['paid']), + 'helper_mass_change': mass(results['new']['helpers']) - mass(results['old']['helpers']), + 'negative_controls': controls, 'positive_controls': ['actual predecessor and changed source constructors, both orientations', 'equivalent binary bases']} + text = json.dumps(report, indent=2, sort_keys=True) + '\n' + if '--write' in sys.argv: + (HERE / 'RESULT.json').write_text(text, encoding='utf-8', newline='\n') + else: + need(json.loads((HERE / 'RESULT.json').read_bytes()) == json.loads(text), 'committed audit receipt differs') + print(text) + + +if __name__ == '__main__': + main()