diff --git a/research/idle-star-paired-axis-census/README.md b/research/idle-star-paired-axis-census/README.md new file mode 100644 index 0000000000..6d76e96da7 --- /dev/null +++ b/research/idle-star-paired-axis-census/README.md @@ -0,0 +1,38 @@ +# Paired idle-axis transfers do not repair the T740 star profile + +**Scoped negative result; no new κ or admitted supplier.** PR #3184 claims a conditional κ of `0.001730189061233850760095…` from redistributing idle rank-48 axes. PR #3187 supplies an exact physical-operator counterexample to its first committed one-stream move. This package checks the most direct symmetry repair: move the same residual axis on both channels of a child pair, so the phase on that pair is scalar, then transfer it to another pair. + +## Result + +Using the authenticated PR3148 T740 fill (`SHA256 8f4d6965…e00`), we checked all 112 port recipes for owner replica zero. A candidate moves an axis present in both residual children 8 and 10 to both children 12 and 13, or makes the reverse transfer. It must be orthogonal to every original axis of both destination children, including hosted axes, so the move changes child ranks rather than replacing a nonorthogonal destination direction. + +The exact eight-stream replay found: + +- **2,688** eligible forward transfers; all 2,688 change the physical operator at the moved axis character. +- **2,688** eligible reverse transfers; all 2,688 change the physical operator at the moved axis character. Each of the 112 recipes has 24 candidates in each direction. +- A 147-mode baseline control passes for port 0, and the zero-character identity passes for all ports. The complete fill journal and payload authenticate, and a mutated journal preimage is rejected. + +For a concrete witness, port 0 and axis 7 change six entries of the exact Gaussian-integer matrix. For example, entry `(0,0)` changes from `[0,-1]` to `[1,0]`. `RESULT.json` contains the full before/after matrices and per-port counts. + +This also rejects every simultaneous nonempty set of transfers **within this restricted class**. Axes eligible in one direction are orthogonal to the complete destination basis; each source residual basis is orthonormal. Thus all selected axes, in both directions, are pairwise orthogonal. At the character equal to any one selected axis, every other moved phase is inactive, leaving the same one-transfer counterexample. + +This does not cover matched swaps that remove a nonorthogonal destination axis, longer cycles, other child/time pairs, nonzero replicas, or all operator-preserving assignments. It claims no general obstruction. The selected record and frontier are unchanged. + +## Reproduce + +From the repository root: + +```sh +python3 scripts/research_package.py --package research/idle-star-paired-axis-census --check-only +python3.12 scripts/research_package.py --package research/idle-star-paired-axis-census +``` + +The verifier independently implements the exact eight-stream Gaussian-integer replay. Live main inputs are pinned in `SOURCES.json`; the retained fill, journal and provider table are checked against the SHA256 and Git-blob IDs recorded from PR3148. The original PR3133 notice and credits are retained under `vendor/`. + +## Open next questions + +See the structured tasks in [TASK.json](TASK.json). The nearest continuation is to enumerate matched swaps or short cycles in the 48-by-48 cross-Gram graph and test whether they can create net rank imbalance without changing the full stream operator. A different child/time pair needs its own exact insertion-to-insertion intertwiner and source-bound replay. + +## Credit + +The physical-stream criterion and the first exact PR3184 counterexample are due to Nick Petalas in [PR #3187](https://github.com/CrocSwap/integer-mult-bounds/pull/3187). The T740 fill and 145-row exchange journal are from Jeremy Diviney’s [PR #3148](https://github.com/CrocSwap/integer-mult-bounds/pull/3148); the underlying fill/provider notice and credits are retained unchanged from PR3133 in `vendor/`. The challenged profile claim is Rohan Arun’s [PR #3184](https://github.com/CrocSwap/integer-mult-bounds/pull/3184). Recipe, template, plan and dispatch retain their PR2979/selected-supplier lineage. This package adds an independently written exact replay and an exhaustive, source-bound census of one paired rank-changing transfer family. Prepared by OpenAI Codex with substantial AI assistance; no independent human or proof-assistant review is claimed. New work is Apache-2.0. diff --git a/research/idle-star-paired-axis-census/RESULT.json b/research/idle-star-paired-axis-census/RESULT.json new file mode 100644 index 0000000000..daab4e70d3 --- /dev/null +++ b/research/idle-star-paired-axis-census/RESULT.json @@ -0,0 +1,1429 @@ +{ + "authenticated_fill_rows": 2717280, + "base_main": "997e6a9ca7b4f95d50e366f61412fd640d72a88a", + "baseline_modes_port0": 147, + "fill_payload_sha256": "8f4d6965ba573ff2b71fd7bf6b552643e086739d90bd73c55889502077638e00", + "forward": { + "eligible": 2688, + "fail_at_own_axis_character": 2688 + }, + "new_kappa": null, + "per_port_counts": [ + [ + 0, + 24, + 24, + 24, + 24 + ], + [ + 1, + 24, + 24, + 24, + 24 + ], + [ + 2, + 24, + 24, + 24, + 24 + ], + [ + 3, + 24, + 24, + 24, + 24 + ], + [ + 4, + 24, + 24, + 24, + 24 + ], + [ + 5, + 24, + 24, + 24, + 24 + ], + [ + 6, + 24, + 24, + 24, + 24 + ], + [ + 7, + 24, + 24, + 24, + 24 + ], + [ + 8, + 24, + 24, + 24, + 24 + ], + [ + 9, + 24, + 24, + 24, + 24 + ], + [ + 10, + 24, + 24, + 24, + 24 + ], + [ + 11, + 24, + 24, + 24, + 24 + ], + [ + 12, + 24, + 24, + 24, + 24 + ], + [ + 13, + 24, + 24, + 24, + 24 + ], + [ + 14, + 24, + 24, + 24, + 24 + ], + [ + 15, + 24, + 24, + 24, + 24 + ], + [ + 16, + 24, + 24, + 24, + 24 + ], + [ + 17, + 24, + 24, + 24, + 24 + ], + [ + 18, + 24, + 24, + 24, + 24 + ], + [ + 19, + 24, + 24, + 24, + 24 + ], + [ + 20, + 24, + 24, + 24, + 24 + ], + [ + 21, + 24, + 24, + 24, + 24 + ], + [ + 22, + 24, + 24, + 24, + 24 + ], + [ + 23, + 24, + 24, + 24, + 24 + ], + [ + 24, + 24, + 24, + 24, + 24 + ], + [ + 25, + 24, + 24, + 24, + 24 + ], + [ + 26, + 24, + 24, + 24, + 24 + ], + [ + 27, + 24, + 24, + 24, + 24 + ], + [ + 28, + 24, + 24, + 24, + 24 + ], + [ + 29, + 24, + 24, + 24, + 24 + ], + [ + 30, + 24, + 24, + 24, + 24 + ], + [ + 31, + 24, + 24, + 24, + 24 + ], + [ + 32, + 24, + 24, + 24, + 24 + ], + [ + 33, + 24, + 24, + 24, + 24 + ], + [ + 34, + 24, + 24, + 24, + 24 + ], + [ + 35, + 24, + 24, + 24, + 24 + ], + [ + 36, + 24, + 24, + 24, + 24 + ], + [ + 37, + 24, + 24, + 24, + 24 + ], + [ + 38, + 24, + 24, + 24, + 24 + ], + [ + 39, + 24, + 24, + 24, + 24 + ], + [ + 40, + 24, + 24, + 24, + 24 + ], + [ + 41, + 24, + 24, + 24, + 24 + ], + [ + 42, + 24, + 24, + 24, + 24 + ], + [ + 43, + 24, + 24, + 24, + 24 + ], + [ + 44, + 24, + 24, + 24, + 24 + ], + [ + 45, + 24, + 24, + 24, + 24 + ], + [ + 46, + 24, + 24, + 24, + 24 + ], + [ + 47, + 24, + 24, + 24, + 24 + ], + [ + 48, + 24, + 24, + 24, + 24 + ], + [ + 49, + 24, + 24, + 24, + 24 + ], + [ + 50, + 24, + 24, + 24, + 24 + ], + [ + 51, + 24, + 24, + 24, + 24 + ], + [ + 52, + 24, + 24, + 24, + 24 + ], + [ + 53, + 24, + 24, + 24, + 24 + ], + [ + 54, + 24, + 24, + 24, + 24 + ], + [ + 55, + 24, + 24, + 24, + 24 + ], + [ + 56, + 24, + 24, + 24, + 24 + ], + [ + 57, + 24, + 24, + 24, + 24 + ], + [ + 58, + 24, + 24, + 24, + 24 + ], + [ + 59, + 24, + 24, + 24, + 24 + ], + [ + 60, + 24, + 24, + 24, + 24 + ], + [ + 61, + 24, + 24, + 24, + 24 + ], + [ + 62, + 24, + 24, + 24, + 24 + ], + [ + 63, + 24, + 24, + 24, + 24 + ], + [ + 64, + 24, + 24, + 24, + 24 + ], + [ + 65, + 24, + 24, + 24, + 24 + ], + [ + 66, + 24, + 24, + 24, + 24 + ], + [ + 67, + 24, + 24, + 24, + 24 + ], + [ + 68, + 24, + 24, + 24, + 24 + ], + [ + 69, + 24, + 24, + 24, + 24 + ], + [ + 70, + 24, + 24, + 24, + 24 + ], + [ + 71, + 24, + 24, + 24, + 24 + ], + [ + 72, + 24, + 24, + 24, + 24 + ], + [ + 73, + 24, + 24, + 24, + 24 + ], + [ + 74, + 24, + 24, + 24, + 24 + ], + [ + 75, + 24, + 24, + 24, + 24 + ], + [ + 76, + 24, + 24, + 24, + 24 + ], + [ + 77, + 24, + 24, + 24, + 24 + ], + [ + 78, + 24, + 24, + 24, + 24 + ], + [ + 79, + 24, + 24, + 24, + 24 + ], + [ + 80, + 24, + 24, + 24, + 24 + ], + [ + 81, + 24, + 24, + 24, + 24 + ], + [ + 82, + 24, + 24, + 24, + 24 + ], + [ + 83, + 24, + 24, + 24, + 24 + ], + [ + 84, + 24, + 24, + 24, + 24 + ], + [ + 85, + 24, + 24, + 24, + 24 + ], + [ + 86, + 24, + 24, + 24, + 24 + ], + [ + 87, + 24, + 24, + 24, + 24 + ], + [ + 88, + 24, + 24, + 24, + 24 + ], + [ + 89, + 24, + 24, + 24, + 24 + ], + [ + 90, + 24, + 24, + 24, + 24 + ], + [ + 91, + 24, + 24, + 24, + 24 + ], + [ + 92, + 24, + 24, + 24, + 24 + ], + [ + 93, + 24, + 24, + 24, + 24 + ], + [ + 94, + 24, + 24, + 24, + 24 + ], + [ + 95, + 24, + 24, + 24, + 24 + ], + [ + 96, + 24, + 24, + 24, + 24 + ], + [ + 97, + 24, + 24, + 24, + 24 + ], + [ + 98, + 24, + 24, + 24, + 24 + ], + [ + 99, + 24, + 24, + 24, + 24 + ], + [ + 100, + 24, + 24, + 24, + 24 + ], + [ + 101, + 24, + 24, + 24, + 24 + ], + [ + 102, + 24, + 24, + 24, + 24 + ], + [ + 103, + 24, + 24, + 24, + 24 + ], + [ + 104, + 24, + 24, + 24, + 24 + ], + [ + 105, + 24, + 24, + 24, + 24 + ], + [ + 106, + 24, + 24, + 24, + 24 + ], + [ + 107, + 24, + 24, + 24, + 24 + ], + [ + 108, + 24, + 24, + 24, + 24 + ], + [ + 109, + 24, + 24, + 24, + 24 + ], + [ + 110, + 24, + 24, + 24, + 24 + ], + [ + 111, + 24, + 24, + 24, + 24 + ] + ], + "port0_forward_witness": { + "axis": 7, + "baseline": [ + [ + [ + 0, + -1 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ] + ], + [ + [ + 0, + 0 + ], + [ + 0, + -1 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ] + ], + [ + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + -1 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ] + ], + [ + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + -1 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ] + ], + [ + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + -1 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ] + ], + [ + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + -1 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ] + ], + [ + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + -1 + ], + [ + 0, + 0 + ] + ], + [ + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + -1 + ] + ] + ], + "differences": [ + [ + 0, + 0, + [ + 0, + -1 + ], + [ + 1, + 0 + ] + ], + [ + 0, + 2, + [ + 0, + 0 + ], + [ + 1, + 1 + ] + ], + [ + 1, + 1, + [ + 0, + -1 + ], + [ + 1, + 0 + ] + ], + [ + 3, + 1, + [ + 0, + 0 + ], + [ + 1, + 1 + ] + ], + [ + 6, + 6, + [ + 0, + -1 + ], + [ + -1, + 0 + ] + ], + [ + 7, + 7, + [ + 0, + -1 + ], + [ + -1, + 0 + ] + ] + ], + "overlay": [ + [ + [ + 1, + 0 + ], + [ + 0, + 0 + ], + [ + 1, + 1 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ] + ], + [ + [ + 0, + 0 + ], + [ + 1, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ] + ], + [ + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + -1 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ] + ], + [ + [ + 0, + 0 + ], + [ + 1, + 1 + ], + [ + 0, + 0 + ], + [ + 0, + -1 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ] + ], + [ + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + -1 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ] + ], + [ + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + -1 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ] + ], + [ + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + -1, + 0 + ], + [ + 0, + 0 + ] + ], + [ + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + 0, + 0 + ], + [ + -1, + 0 + ] + ] + ] + }, + "ports": 112, + "reverse": { + "eligible": 2688, + "fail_at_own_axis_character": 2688 + }, + "selected_frontier_changed": false, + "status": "PASS_NO_OPERATOR_PRESERVING_RANK_CHANGING_PAIRED_TRANSFER" +} diff --git a/research/idle-star-paired-axis-census/SOURCES.json b/research/idle-star-paired-axis-census/SOURCES.json new file mode 100644 index 0000000000..e23e4f3c99 --- /dev/null +++ b/research/idle-star-paired-axis-census/SOURCES.json @@ -0,0 +1,79 @@ +{ + "schema_version": 1, + "base_commit": "997e6a9ca7b4f95d50e366f61412fd640d72a88a", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "b1fea0c94436b236cc2b7d41a7be032811b94c81", + "sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "67f085acd86acd7d4e03922d9cf4b26bca66fed5", + "sha256": "47b42433f5a85809a3aadd29c2c339da2c6ed728e4f7762df6b88bccb7874cf0" + }, + { + "path": "research/adaptive-kernel-demotion/inputs/DATA-PHASES.json", + "usage": "input", + "git_blob": "d9a4f84211182ca200c081ea061d724c8a2cfb70", + "sha256": "c5916ff312678f12aba403847643fbbc29f643acec60bdf836fa56cd3e8251fa" + }, + { + "path": "research/rank7-joint-endframes/allocation/DISPATCH.json", + "usage": "input", + "git_blob": "9544fee4e6ee1f202cee22bfaeaf229ee3b2515e", + "sha256": "65e435bd68e97243c003677271b88485a29d4d0fae2dff1354100404a145e74c" + }, + { + "path": "research/rank7-joint-endframes/allocation/ORDER.json", + "usage": "input", + "git_blob": "7409c4df1092241729739596c7648bda504e6aad", + "sha256": "519d1d5dbb997a219fcfcad34c0b03e7838bef24199784d7e964fa10090f66e1" + }, + { + "path": "research/rank7-joint-endframes/allocation/vendor/PLAN.json.gz", + "usage": "input", + "git_blob": "7a1db55a4d53ee99280be4f3ab7d29f7b2033adf", + "sha256": "d566cfb87b71639d4138e1f89b543e2dd6a7772070226a2a14c799a6835bf21e" + }, + { + "path": "research/rank7-joint-endframes/allocation/vendor/TEMPLATE.json.gz", + "usage": "input", + "git_blob": "114808c32b1799da53524bdc25cea67efb60009e", + "sha256": "21297b20f1f2dc76eb9dd8124416068c3cb096bab9df17fa4da19bc68dfe082e" + } + ], + "retained_sources": [ + { + "local_path": "vendor/BASE-FILL.json.gz", + "source_pr": 3148, + "head": "f2927a4b8afcf0701a6b945e14f30de1d94f5176", + "upstream_path": "research/coupled-carrier-cap740/vendor/PR3133-FILL.json.gz", + "sha256": "68b8bae90144248774b1920cd27f9519caa3dc427704d8a9da6d4c491d912fc4", + "git_blob": "92b49b42b8f381d686a9fb8057e74e4b7548cd5c" + }, + { + "local_path": "vendor/EXCHANGE.json", + "source_pr": 3148, + "head": "f2927a4b8afcf0701a6b945e14f30de1d94f5176", + "upstream_path": "research/coupled-carrier-cap740/EXCHANGE.json", + "sha256": "5063791f327d067f37478488c97ce449e5b34cfb61d6309fc6924c5e360fe839", + "git_blob": "f323db0fd94a80f691b1606e813d0738b27058ae" + }, + { + "local_path": "vendor/PROVIDERS.json", + "source_pr": 3148, + "head": "f2927a4b8afcf0701a6b945e14f30de1d94f5176", + "upstream_path": "research/coupled-carrier-cap740/vendor/PR3133-PROVIDERS.json", + "sha256": "52eb0d85caa7b2d4a93acdf5011f52b793f61ddca86235fb03cd9a09397ad4cd", + "git_blob": "0b2343675099d0a9fe90da6e1f1e53f50235567e" + } + ], + "context": { + "pr3184_head": "ffab383a5f78eb1a4ad4c7c7259a4f32b86f9481", + "pr3187_head": "85cc6be02f5f912ac203449e06523ad53e6054d2", + "note": "PR3187\u2019s physical counterexample motivated this complementary census; the replay implementation in this package is independent." + } +} diff --git a/research/idle-star-paired-axis-census/TASK.json b/research/idle-star-paired-axis-census/TASK.json new file mode 100644 index 0000000000..f020a9a7d8 --- /dev/null +++ b/research/idle-star-paired-axis-census/TASK.json @@ -0,0 +1,72 @@ +{ + "schema_version": 1, + "task_id": "independent-moment", + "priority_revision": 6, + "base_commit": "997e6a9ca7b4f95d50e366f61412fd640d72a88a", + "original_card": { + "id": "independent-moment", + "question": "Does one changed supplier or assembly claim lack a source-bound independent check of a specific new implication?", + "starting_points": [ + "certificates/selected-result.json", + "research/rank7-joint-endframes/README.md", + "docs/research/research-family-status.md" + ], + "methods": [ + "Independently reconstruct a coordinated frame/circuit change and its single-change control, then derive the complete rank and physical ledger.", + "Implement certified moment inequalities through a different exact enclosure method." + ], + "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": "Read #2979 joint rank-7 end-frame proposal and the revision-6 evidence status. Its claimed kappa is not selected. Compare coordinated changes with the losing single-change controls and locate the complete physical ledger; an aggregate moment alone does not validate the mechanism.", + "scope": "Positive control / source-bound orientation only; this is not a new construction or full cold replay." + }, + "first_experiment": "Prioritize a bounded independent audit of #2979: reconstruct one joint group and its single-lowering control, check the declared frames/chronology, then trace changed children, idle widths and cleanup buffers into the complete invoice and both supplier caps. Choose one still-missing implication after checking existing audits. Stop with exact unresolved dependencies if full admission exceeds the session; do not launch a new lowering census on an unvalidated premise or substitute extra root digits for mechanism checking.", + "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.", + "Promoting #2979 from merged source archive to validated supplier solely from author PASS receipts or aggregate pricing." + ], + "overlap_terms": [ + "independent moment", + "rank histogram", + "exact enclosure", + "2979", + "rank7 joint endframes", + "paired extraction", + "joint lowering" + ] + }, + "scope_status": "refined", + "actual_scope": "Independent exact replay of the rank-changing paired-axis correction family suggested by PR3187: for each of the 112 T740 port recipes, move one common residual axis on both streams of child pair (8,10) to both streams of pair (12,13), or in reverse, subject to destination orthogonality. Check the actual hosted eight-stream operator at the moved axis character for every candidate, then derive the orthogonal-isolation argument for simultaneous candidates in this restricted class.", + "scope_change_reason": "PR3187 gives an exact counterexample to PR3184\u2019s first single-stream star move. This refines the independent-moment audit to the strongest immediate two-stream symmetry correction: transferring the same phase on both channels might commute where a single-channel transfer fails. The new replay is independently implemented and the scope is limited to this rank-changing paired family.", + "bottleneck_link": "A better rank histogram changes the moment only if the exact hosted eight-stream physical operator is preserved. This screen tests whether a natural paired correction can turn PR3184\u2019s structural idle-axis gains into an admissible profile; it does not price a new supplier.", + "budget_minutes": 60, + "stop_rule": "Authenticate the complete T740 fill and all 112 recipes; verify a positive baseline; enumerate every paired common-axis transfer that raises destination rank without replacing a nonorthogonal destination axis; test the exact operator at its own character. Stop this family if all candidates fail. Do not generalize to matched swaps, longer cycles, other child pairs, replicas, or all operator-preserving assignments.", + "outcome": "completed", + "evidence": "verify.py authenticates the PR3148 T740 payload SHA256 8f4d6965\u2026e00, checks the baseline on 147 modes for port 0 plus the zero-character identity for all ports, and tests 2,688 forward plus 2,688 reverse candidates (24 each direction on every one of 112 port recipes) for owner replica zero. Every candidate changes the exact Gaussian-integer stream matrix at its own Fourier character. Since eligible moved axes are pairwise orthogonal, any simultaneous nonempty set in this restricted class is isolated by one moved-axis character and fails too. Exact port-0 witness: axis 7; receipt is RESULT.json. No new kappa, supplier admission, or selected-frontier change.", + "author": "OpenAI Codex", + "ai_assistance": "OpenAI Codex wrote the independent exact replay, source-bound census and package. No independent human review or proof-assistant verification is claimed.", + "open_questions": [ + { + "question": "Can a net-rank-changing matched swap or longer axis cycle, which removes nonorthogonal destination directions while adding new ones, preserve the full operator across the intervening bridges?", + "why_it_matters": "The screened rank-changing family requires each incoming axis to be orthogonal to the full destination basis. Removing a matched axis relaxes that condition and is the simplest remaining way this child-pair geometry could evade the negative result.", + "first_step": "Build the 48-by-48 cross-Gram graph for each port, enumerate the smallest cycles that produce a nonzero child-rank imbalance, and replay each full overlay against the exact T740 schedule.", + "blocked_by": "No exact symbolic criterion for multi-axis cycles is supplied; cycle interactions can involve hosted phases and all intervening bridges." + }, + { + "question": "Does any other child/time pair on the T740 schedule admit a physically valid rank-changing transfer?", + "why_it_matters": "A different schedule cut could change the rank profile while avoiding this paired obstruction.", + "first_step": "Derive exact insertion-to-insertion intertwiners for each candidate pair and use the current port-0 witness as a regression control before optimizing a new profile.", + "blocked_by": "This package audits only child pairs (8,10) and (12,13) on owner replica zero; a complete all-pair search is outside its bounded scope." + } + ] +} diff --git a/research/idle-star-paired-axis-census/VERIFY.json b/research/idle-star-paired-axis-census/VERIFY.json new file mode 100644 index 0000000000..9a3d449cb4 --- /dev/null +++ b/research/idle-star-paired-axis-census/VERIFY.json @@ -0,0 +1,25 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/adaptive-kernel-demotion/inputs/DATA-PHASES.json", + "research/rank7-joint-endframes/allocation/DISPATCH.json", + "research/rank7-joint-endframes/allocation/ORDER.json", + "research/rank7-joint-endframes/allocation/vendor/PLAN.json.gz", + "research/rank7-joint-endframes/allocation/vendor/TEMPLATE.json.gz" + ], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Exact source and retained-allocation pins; complete T740 fill authentication; baseline 147-mode control; forward/reverse rank-changing paired-transfer census across 112 recipes; own-axis-character operator comparisons; isolated port-0 witness; journal-mutation rejection; stored RESULT.json receipt." + } + ] +} diff --git a/research/idle-star-paired-axis-census/vendor/BASE-FILL.json.gz b/research/idle-star-paired-axis-census/vendor/BASE-FILL.json.gz new file mode 100644 index 0000000000..92b49b42b8 Binary files /dev/null and b/research/idle-star-paired-axis-census/vendor/BASE-FILL.json.gz differ diff --git a/research/idle-star-paired-axis-census/vendor/EXCHANGE.json b/research/idle-star-paired-axis-census/vendor/EXCHANGE.json new file mode 100644 index 0000000000..f323db0fd9 --- /dev/null +++ b/research/idle-star-paired-axis-census/vendor/EXCHANGE.json @@ -0,0 +1,2762 @@ +{ + "base_fill_sha256": "68b8bae90144248774b1920cd27f9519caa3dc427704d8a9da6d4c491d912fc4", + "base_head": "51eb9c4ee9e4722010d308aa3309e039d3940cc2", + "copies": 10, + "edits": [ + [ + 1685, + [ + 40, + 53, + 23, + 8, + 0, + 0 + ], + [ + 40, + 53, + 0, + 4, + 0, + 27 + ] + ], + [ + 1690, + [ + 40, + 58, + 68, + 10, + 91, + 0 + ], + [ + 40, + 58, + 0, + 4, + 1, + 27 + ] + ], + [ + 3265, + [ + 80, + 1, + 1, + 4, + 1, + 0 + ], + [ + 80, + 1, + 23, + 8, + 0, + 0 + ] + ], + [ + 3267, + [ + 80, + 3, + 1, + 4, + 2, + 0 + ], + [ + 80, + 3, + 68, + 10, + 91, + 0 + ] + ], + [ + 3269, + [ + 80, + 5, + 1, + 4, + 3, + 0 + ], + [ + 80, + 5, + 31, + 10, + 91, + 0 + ] + ], + [ + 3271, + [ + 80, + 7, + 1, + 4, + 4, + 0 + ], + [ + 80, + 7, + 97, + 8, + 0, + 0 + ] + ], + [ + 3273, + [ + 80, + 9, + 1, + 4, + 6, + 0 + ], + [ + 80, + 9, + 142, + 10, + 91, + 0 + ] + ], + [ + 9793, + [ + 240, + 1, + 1, + 4, + 1, + 9 + ], + [ + 240, + 1, + 23, + 8, + 0, + 9 + ] + ], + [ + 9795, + [ + 240, + 3, + 1, + 4, + 2, + 9 + ], + [ + 240, + 3, + 68, + 10, + 91, + 9 + ] + ], + [ + 9797, + [ + 240, + 5, + 1, + 4, + 3, + 9 + ], + [ + 240, + 5, + 31, + 10, + 91, + 9 + ] + ], + [ + 9799, + [ + 240, + 7, + 1, + 4, + 4, + 9 + ], + [ + 240, + 7, + 97, + 8, + 0, + 9 + ] + ], + [ + 9801, + [ + 240, + 9, + 1, + 4, + 6, + 9 + ], + [ + 240, + 9, + 142, + 10, + 91, + 9 + ] + ], + [ + 23666, + [ + 580, + 2, + 23, + 8, + 0, + 4 + ], + [ + 580, + 2, + 1, + 4, + 1, + 0 + ] + ], + [ + 24074, + [ + 590, + 2, + 68, + 10, + 91, + 4 + ], + [ + 590, + 2, + 1, + 4, + 1, + 8 + ] + ], + [ + 25297, + [ + 620, + 1, + 1, + 4, + 1, + 18 + ], + [ + 620, + 1, + 23, + 8, + 0, + 18 + ] + ], + [ + 25299, + [ + 620, + 3, + 1, + 4, + 2, + 18 + ], + [ + 620, + 3, + 68, + 10, + 91, + 18 + ] + ], + [ + 25301, + [ + 620, + 5, + 1, + 4, + 3, + 18 + ], + [ + 620, + 5, + 31, + 10, + 91, + 18 + ] + ], + [ + 25303, + [ + 620, + 7, + 1, + 4, + 4, + 18 + ], + [ + 620, + 7, + 97, + 8, + 0, + 18 + ] + ], + [ + 25305, + [ + 620, + 9, + 1, + 4, + 6, + 18 + ], + [ + 620, + 9, + 142, + 10, + 91, + 18 + ] + ], + [ + 77369, + [ + 1890, + 257, + 68, + 10, + 91, + 12 + ], + [ + 1890, + 257, + 23, + 8, + 0, + 27 + ] + ], + [ + 94657, + [ + 2320, + 1, + 23, + 8, + 0, + 12 + ], + [ + 2320, + 1, + 105, + 10, + 91, + 0 + ] + ], + [ + 127536, + [ + 3120, + 240, + 23, + 8, + 0, + 21 + ], + [ + 3120, + 240, + 216, + 10, + 91, + 0 + ] + ], + [ + 134479, + [ + 3290, + 247, + 68, + 10, + 91, + 21 + ], + [ + 3290, + 247, + 245, + 8, + 0, + 0 + ] + ], + [ + 155705, + [ + 3810, + 257, + 68, + 10, + 91, + 30 + ], + [ + 3810, + 257, + 253, + 10, + 91, + 0 + ] + ], + [ + 155856, + [ + 3820, + 0, + 23, + 8, + 0, + 30 + ], + [ + 3820, + 0, + 364, + 10, + 91, + 0 + ] + ], + [ + 172995, + [ + 4240, + 3, + 23, + 8, + 0, + 39 + ], + [ + 4240, + 3, + 393, + 8, + 0, + 0 + ] + ], + [ + 188753, + [ + 4620, + 257, + 31, + 10, + 91, + 0 + ], + [ + 4620, + 257, + 401, + 10, + 91, + 0 + ] + ], + [ + 189161, + [ + 4630, + 257, + 68, + 10, + 91, + 39 + ], + [ + 4630, + 257, + 512, + 10, + 91, + 0 + ] + ], + [ + 273413, + [ + 41, + 53, + 97, + 8, + 0, + 0 + ], + [ + 41, + 53, + 0, + 4, + 2, + 27 + ] + ], + [ + 273418, + [ + 41, + 58, + 142, + 10, + 91, + 0 + ], + [ + 41, + 58, + 0, + 4, + 4, + 27 + ] + ], + [ + 295394, + [ + 581, + 2, + 97, + 8, + 0, + 4 + ], + [ + 581, + 2, + 1, + 4, + 1, + 16 + ] + ], + [ + 295802, + [ + 591, + 2, + 142, + 10, + 91, + 4 + ], + [ + 591, + 2, + 1, + 4, + 1, + 24 + ] + ], + [ + 349097, + [ + 1891, + 257, + 142, + 10, + 91, + 12 + ], + [ + 1891, + 257, + 23, + 8, + 0, + 36 + ] + ], + [ + 366385, + [ + 2321, + 1, + 97, + 8, + 0, + 12 + ], + [ + 2321, + 1, + 105, + 10, + 91, + 9 + ] + ], + [ + 399264, + [ + 3121, + 240, + 97, + 8, + 0, + 21 + ], + [ + 3121, + 240, + 216, + 10, + 91, + 9 + ] + ], + [ + 406207, + [ + 3291, + 247, + 142, + 10, + 91, + 21 + ], + [ + 3291, + 247, + 245, + 8, + 0, + 9 + ] + ], + [ + 427433, + [ + 3811, + 257, + 142, + 10, + 91, + 30 + ], + [ + 3811, + 257, + 253, + 10, + 91, + 9 + ] + ], + [ + 427584, + [ + 3821, + 0, + 97, + 8, + 0, + 30 + ], + [ + 3821, + 0, + 364, + 10, + 91, + 9 + ] + ], + [ + 444723, + [ + 4241, + 3, + 97, + 8, + 0, + 39 + ], + [ + 4241, + 3, + 393, + 8, + 0, + 9 + ] + ], + [ + 460481, + [ + 4621, + 257, + 105, + 10, + 91, + 0 + ], + [ + 4621, + 257, + 401, + 10, + 91, + 9 + ] + ], + [ + 460889, + [ + 4631, + 257, + 142, + 10, + 91, + 39 + ], + [ + 4631, + 257, + 512, + 10, + 91, + 9 + ] + ], + [ + 545141, + [ + 42, + 53, + 171, + 8, + 0, + 0 + ], + [ + 42, + 53, + 0, + 4, + 5, + 27 + ] + ], + [ + 545146, + [ + 42, + 58, + 216, + 10, + 91, + 0 + ], + [ + 42, + 58, + 0, + 4, + 6, + 27 + ] + ], + [ + 567122, + [ + 582, + 2, + 171, + 8, + 0, + 4 + ], + [ + 582, + 2, + 1, + 4, + 2, + 0 + ] + ], + [ + 567530, + [ + 592, + 2, + 216, + 10, + 91, + 4 + ], + [ + 592, + 2, + 1, + 4, + 2, + 8 + ] + ], + [ + 620825, + [ + 1892, + 257, + 216, + 10, + 91, + 12 + ], + [ + 1892, + 257, + 68, + 10, + 91, + 27 + ] + ], + [ + 638113, + [ + 2322, + 1, + 171, + 8, + 0, + 12 + ], + [ + 2322, + 1, + 105, + 10, + 91, + 18 + ] + ], + [ + 670992, + [ + 3122, + 240, + 171, + 8, + 0, + 21 + ], + [ + 3122, + 240, + 216, + 10, + 91, + 18 + ] + ], + [ + 677935, + [ + 3292, + 247, + 216, + 10, + 91, + 21 + ], + [ + 3292, + 247, + 245, + 8, + 0, + 18 + ] + ], + [ + 699161, + [ + 3812, + 257, + 216, + 10, + 91, + 30 + ], + [ + 3812, + 257, + 253, + 10, + 91, + 18 + ] + ], + [ + 699312, + [ + 3822, + 0, + 171, + 8, + 0, + 30 + ], + [ + 3822, + 0, + 364, + 10, + 91, + 18 + ] + ], + [ + 716451, + [ + 4242, + 3, + 171, + 8, + 0, + 39 + ], + [ + 4242, + 3, + 393, + 8, + 0, + 18 + ] + ], + [ + 732209, + [ + 4622, + 257, + 179, + 10, + 91, + 0 + ], + [ + 4622, + 257, + 401, + 10, + 91, + 18 + ] + ], + [ + 732617, + [ + 4632, + 257, + 216, + 10, + 91, + 39 + ], + [ + 4632, + 257, + 512, + 10, + 91, + 18 + ] + ], + [ + 816869, + [ + 43, + 53, + 245, + 8, + 0, + 0 + ], + [ + 43, + 53, + 0, + 4, + 7, + 27 + ] + ], + [ + 816874, + [ + 43, + 58, + 290, + 10, + 91, + 0 + ], + [ + 43, + 58, + 0, + 4, + 9, + 27 + ] + ], + [ + 838850, + [ + 583, + 2, + 245, + 8, + 0, + 4 + ], + [ + 583, + 2, + 1, + 4, + 2, + 16 + ] + ], + [ + 839258, + [ + 593, + 2, + 290, + 10, + 91, + 4 + ], + [ + 593, + 2, + 1, + 4, + 2, + 24 + ] + ], + [ + 892553, + [ + 1893, + 257, + 290, + 10, + 91, + 12 + ], + [ + 1893, + 257, + 68, + 10, + 91, + 36 + ] + ], + [ + 909841, + [ + 2323, + 1, + 245, + 8, + 0, + 12 + ], + [ + 2323, + 1, + 105, + 10, + 91, + 27 + ] + ], + [ + 942720, + [ + 3123, + 240, + 245, + 8, + 0, + 21 + ], + [ + 3123, + 240, + 216, + 10, + 91, + 27 + ] + ], + [ + 949663, + [ + 3293, + 247, + 290, + 10, + 91, + 21 + ], + [ + 3293, + 247, + 245, + 8, + 0, + 27 + ] + ], + [ + 970889, + [ + 3813, + 257, + 290, + 10, + 91, + 30 + ], + [ + 3813, + 257, + 253, + 10, + 91, + 27 + ] + ], + [ + 971040, + [ + 3823, + 0, + 245, + 8, + 0, + 30 + ], + [ + 3823, + 0, + 364, + 10, + 91, + 27 + ] + ], + [ + 988179, + [ + 4243, + 3, + 245, + 8, + 0, + 39 + ], + [ + 4243, + 3, + 393, + 8, + 0, + 27 + ] + ], + [ + 1003937, + [ + 4623, + 257, + 253, + 10, + 91, + 0 + ], + [ + 4623, + 257, + 401, + 10, + 91, + 27 + ] + ], + [ + 1004345, + [ + 4633, + 257, + 290, + 10, + 91, + 39 + ], + [ + 4633, + 257, + 512, + 10, + 91, + 27 + ] + ], + [ + 1088597, + [ + 44, + 53, + 319, + 8, + 0, + 0 + ], + [ + 44, + 53, + 0, + 4, + 10, + 27 + ] + ], + [ + 1088602, + [ + 44, + 58, + 364, + 10, + 91, + 0 + ], + [ + 44, + 58, + 0, + 4, + 11, + 27 + ] + ], + [ + 1110578, + [ + 584, + 2, + 319, + 8, + 0, + 4 + ], + [ + 584, + 2, + 1, + 4, + 3, + 0 + ] + ], + [ + 1110986, + [ + 594, + 2, + 364, + 10, + 91, + 4 + ], + [ + 594, + 2, + 1, + 4, + 3, + 8 + ] + ], + [ + 1164281, + [ + 1894, + 257, + 364, + 10, + 91, + 12 + ], + [ + 1894, + 257, + 31, + 10, + 91, + 27 + ] + ], + [ + 1181569, + [ + 2324, + 1, + 319, + 8, + 0, + 12 + ], + [ + 2324, + 1, + 105, + 10, + 91, + 36 + ] + ], + [ + 1214448, + [ + 3124, + 240, + 319, + 8, + 0, + 21 + ], + [ + 3124, + 240, + 216, + 10, + 91, + 36 + ] + ], + [ + 1221391, + [ + 3294, + 247, + 364, + 10, + 91, + 21 + ], + [ + 3294, + 247, + 245, + 8, + 0, + 36 + ] + ], + [ + 1242617, + [ + 3814, + 257, + 364, + 10, + 91, + 30 + ], + [ + 3814, + 257, + 253, + 10, + 91, + 36 + ] + ], + [ + 1242768, + [ + 3824, + 0, + 319, + 8, + 0, + 30 + ], + [ + 3824, + 0, + 364, + 10, + 91, + 36 + ] + ], + [ + 1259907, + [ + 4244, + 3, + 319, + 8, + 0, + 39 + ], + [ + 4244, + 3, + 393, + 8, + 0, + 36 + ] + ], + [ + 1275665, + [ + 4624, + 257, + 327, + 10, + 91, + 0 + ], + [ + 4624, + 257, + 401, + 10, + 91, + 36 + ] + ], + [ + 1276073, + [ + 4634, + 257, + 364, + 10, + 91, + 39 + ], + [ + 4634, + 257, + 512, + 10, + 91, + 36 + ] + ], + [ + 1360325, + [ + 45, + 53, + 393, + 8, + 0, + 0 + ], + [ + 45, + 53, + 0, + 4, + 12, + 27 + ] + ], + [ + 1360330, + [ + 45, + 58, + 438, + 10, + 91, + 0 + ], + [ + 45, + 58, + 0, + 4, + 14, + 27 + ] + ], + [ + 1382306, + [ + 585, + 2, + 393, + 8, + 0, + 4 + ], + [ + 585, + 2, + 1, + 4, + 3, + 16 + ] + ], + [ + 1382714, + [ + 595, + 2, + 438, + 10, + 91, + 4 + ], + [ + 595, + 2, + 1, + 4, + 3, + 24 + ] + ], + [ + 1436009, + [ + 1895, + 257, + 438, + 10, + 91, + 12 + ], + [ + 1895, + 257, + 31, + 10, + 91, + 36 + ] + ], + [ + 1453297, + [ + 2325, + 1, + 393, + 8, + 0, + 12 + ], + [ + 2325, + 1, + 171, + 8, + 0, + 0 + ] + ], + [ + 1486176, + [ + 3125, + 240, + 393, + 8, + 0, + 21 + ], + [ + 3125, + 240, + 179, + 10, + 91, + 0 + ] + ], + [ + 1493119, + [ + 3295, + 247, + 438, + 10, + 91, + 21 + ], + [ + 3295, + 247, + 290, + 10, + 91, + 0 + ] + ], + [ + 1514345, + [ + 3815, + 257, + 438, + 10, + 91, + 30 + ], + [ + 3815, + 257, + 319, + 8, + 0, + 0 + ] + ], + [ + 1514496, + [ + 3825, + 0, + 393, + 8, + 0, + 30 + ], + [ + 3825, + 0, + 327, + 10, + 91, + 0 + ] + ], + [ + 1531635, + [ + 4245, + 3, + 393, + 8, + 0, + 39 + ], + [ + 4245, + 3, + 438, + 10, + 91, + 0 + ] + ], + [ + 1547393, + [ + 4625, + 257, + 401, + 10, + 91, + 0 + ], + [ + 4625, + 257, + 467, + 8, + 0, + 0 + ] + ], + [ + 1547801, + [ + 4635, + 257, + 438, + 10, + 91, + 39 + ], + [ + 4635, + 257, + 475, + 10, + 91, + 0 + ] + ], + [ + 1632053, + [ + 46, + 53, + 467, + 8, + 0, + 0 + ], + [ + 46, + 53, + 0, + 4, + 15, + 27 + ] + ], + [ + 1632058, + [ + 46, + 58, + 512, + 10, + 91, + 0 + ], + [ + 46, + 58, + 0, + 4, + 16, + 27 + ] + ], + [ + 1654034, + [ + 586, + 2, + 467, + 8, + 0, + 4 + ], + [ + 586, + 2, + 1, + 4, + 4, + 0 + ] + ], + [ + 1654442, + [ + 596, + 2, + 512, + 10, + 91, + 4 + ], + [ + 596, + 2, + 1, + 4, + 4, + 8 + ] + ], + [ + 1707737, + [ + 1896, + 257, + 512, + 10, + 91, + 12 + ], + [ + 1896, + 257, + 97, + 8, + 0, + 27 + ] + ], + [ + 1725025, + [ + 2326, + 1, + 467, + 8, + 0, + 12 + ], + [ + 2326, + 1, + 171, + 8, + 0, + 9 + ] + ], + [ + 1757904, + [ + 3126, + 240, + 467, + 8, + 0, + 21 + ], + [ + 3126, + 240, + 179, + 10, + 91, + 9 + ] + ], + [ + 1764847, + [ + 3296, + 247, + 512, + 10, + 91, + 21 + ], + [ + 3296, + 247, + 290, + 10, + 91, + 9 + ] + ], + [ + 1786073, + [ + 3816, + 257, + 512, + 10, + 91, + 30 + ], + [ + 3816, + 257, + 319, + 8, + 0, + 9 + ] + ], + [ + 1786224, + [ + 3826, + 0, + 467, + 8, + 0, + 30 + ], + [ + 3826, + 0, + 327, + 10, + 91, + 9 + ] + ], + [ + 1803363, + [ + 4246, + 3, + 467, + 8, + 0, + 39 + ], + [ + 4246, + 3, + 438, + 10, + 91, + 9 + ] + ], + [ + 1819121, + [ + 4626, + 257, + 475, + 10, + 91, + 0 + ], + [ + 4626, + 257, + 467, + 8, + 0, + 9 + ] + ], + [ + 1819529, + [ + 4636, + 257, + 512, + 10, + 91, + 39 + ], + [ + 4636, + 257, + 475, + 10, + 91, + 9 + ] + ], + [ + 1903781, + [ + 47, + 53, + 541, + 8, + 0, + 0 + ], + [ + 47, + 53, + 0, + 4, + 17, + 27 + ] + ], + [ + 1903786, + [ + 47, + 58, + 586, + 10, + 91, + 0 + ], + [ + 47, + 58, + 0, + 4, + 19, + 27 + ] + ], + [ + 1925762, + [ + 587, + 2, + 541, + 8, + 0, + 4 + ], + [ + 587, + 2, + 1, + 4, + 4, + 16 + ] + ], + [ + 1926170, + [ + 597, + 2, + 586, + 10, + 91, + 4 + ], + [ + 597, + 2, + 1, + 4, + 4, + 24 + ] + ], + [ + 1979465, + [ + 1897, + 257, + 586, + 10, + 91, + 12 + ], + [ + 1897, + 257, + 97, + 8, + 0, + 36 + ] + ], + [ + 1996753, + [ + 2327, + 1, + 541, + 8, + 0, + 12 + ], + [ + 2327, + 1, + 171, + 8, + 0, + 18 + ] + ], + [ + 2029632, + [ + 3127, + 240, + 541, + 8, + 0, + 21 + ], + [ + 3127, + 240, + 179, + 10, + 91, + 18 + ] + ], + [ + 2036575, + [ + 3297, + 247, + 586, + 10, + 91, + 21 + ], + [ + 3297, + 247, + 290, + 10, + 91, + 18 + ] + ], + [ + 2057801, + [ + 3817, + 257, + 586, + 10, + 91, + 30 + ], + [ + 3817, + 257, + 319, + 8, + 0, + 18 + ] + ], + [ + 2057952, + [ + 3827, + 0, + 541, + 8, + 0, + 30 + ], + [ + 3827, + 0, + 327, + 10, + 91, + 18 + ] + ], + [ + 2075091, + [ + 4247, + 3, + 541, + 8, + 0, + 39 + ], + [ + 4247, + 3, + 438, + 10, + 91, + 18 + ] + ], + [ + 2090849, + [ + 4627, + 257, + 549, + 10, + 91, + 0 + ], + [ + 4627, + 257, + 467, + 8, + 0, + 18 + ] + ], + [ + 2091257, + [ + 4637, + 257, + 586, + 10, + 91, + 39 + ], + [ + 4637, + 257, + 475, + 10, + 91, + 18 + ] + ], + [ + 2175509, + [ + 48, + 53, + 615, + 8, + 0, + 0 + ], + [ + 48, + 53, + 0, + 4, + 20, + 27 + ] + ], + [ + 2175514, + [ + 48, + 58, + 660, + 10, + 91, + 0 + ], + [ + 48, + 58, + 0, + 4, + 21, + 27 + ] + ], + [ + 2197490, + [ + 588, + 2, + 615, + 8, + 0, + 4 + ], + [ + 588, + 2, + 1, + 4, + 6, + 0 + ] + ], + [ + 2197898, + [ + 598, + 2, + 660, + 10, + 91, + 4 + ], + [ + 598, + 2, + 1, + 4, + 6, + 8 + ] + ], + [ + 2251193, + [ + 1898, + 257, + 660, + 10, + 91, + 12 + ], + [ + 1898, + 257, + 142, + 10, + 91, + 27 + ] + ], + [ + 2268481, + [ + 2328, + 1, + 615, + 8, + 0, + 12 + ], + [ + 2328, + 1, + 171, + 8, + 0, + 27 + ] + ], + [ + 2301360, + [ + 3128, + 240, + 615, + 8, + 0, + 21 + ], + [ + 3128, + 240, + 179, + 10, + 91, + 27 + ] + ], + [ + 2308303, + [ + 3298, + 247, + 660, + 10, + 91, + 21 + ], + [ + 3298, + 247, + 290, + 10, + 91, + 27 + ] + ], + [ + 2329529, + [ + 3818, + 257, + 660, + 10, + 91, + 30 + ], + [ + 3818, + 257, + 319, + 8, + 0, + 27 + ] + ], + [ + 2329680, + [ + 3828, + 0, + 615, + 8, + 0, + 30 + ], + [ + 3828, + 0, + 327, + 10, + 91, + 27 + ] + ], + [ + 2346819, + [ + 4248, + 3, + 615, + 8, + 0, + 39 + ], + [ + 4248, + 3, + 438, + 10, + 91, + 27 + ] + ], + [ + 2362577, + [ + 4628, + 257, + 623, + 10, + 91, + 0 + ], + [ + 4628, + 257, + 467, + 8, + 0, + 27 + ] + ], + [ + 2362985, + [ + 4638, + 257, + 660, + 10, + 91, + 39 + ], + [ + 4638, + 257, + 475, + 10, + 91, + 27 + ] + ], + [ + 2447237, + [ + 49, + 53, + 689, + 8, + 0, + 0 + ], + [ + 49, + 53, + 0, + 4, + 22, + 27 + ] + ], + [ + 2447242, + [ + 49, + 58, + 734, + 10, + 91, + 0 + ], + [ + 49, + 58, + 0, + 4, + 24, + 27 + ] + ], + [ + 2469218, + [ + 589, + 2, + 689, + 8, + 0, + 4 + ], + [ + 589, + 2, + 1, + 4, + 6, + 16 + ] + ], + [ + 2469626, + [ + 599, + 2, + 734, + 10, + 91, + 4 + ], + [ + 599, + 2, + 1, + 4, + 6, + 24 + ] + ], + [ + 2522921, + [ + 1899, + 257, + 734, + 10, + 91, + 12 + ], + [ + 1899, + 257, + 142, + 10, + 91, + 36 + ] + ], + [ + 2540209, + [ + 2329, + 1, + 689, + 8, + 0, + 12 + ], + [ + 2329, + 1, + 171, + 8, + 0, + 36 + ] + ], + [ + 2573088, + [ + 3129, + 240, + 689, + 8, + 0, + 21 + ], + [ + 3129, + 240, + 179, + 10, + 91, + 36 + ] + ], + [ + 2580031, + [ + 3299, + 247, + 734, + 10, + 91, + 21 + ], + [ + 3299, + 247, + 290, + 10, + 91, + 36 + ] + ], + [ + 2601257, + [ + 3819, + 257, + 734, + 10, + 91, + 30 + ], + [ + 3819, + 257, + 319, + 8, + 0, + 36 + ] + ], + [ + 2601408, + [ + 3829, + 0, + 689, + 8, + 0, + 30 + ], + [ + 3829, + 0, + 327, + 10, + 91, + 36 + ] + ], + [ + 2618547, + [ + 4249, + 3, + 689, + 8, + 0, + 39 + ], + [ + 4249, + 3, + 438, + 10, + 91, + 36 + ] + ], + [ + 2634305, + [ + 4629, + 257, + 697, + 10, + 91, + 0 + ], + [ + 4629, + 257, + 467, + 8, + 0, + 36 + ] + ], + [ + 2634713, + [ + 4639, + 257, + 734, + 10, + 91, + 39 + ], + [ + 4639, + 257, + 475, + 10, + 91, + 36 + ] + ] + ] +} diff --git a/research/idle-star-paired-axis-census/vendor/PR3133-CREDITS.md b/research/idle-star-paired-axis-census/vendor/PR3133-CREDITS.md new file mode 100644 index 0000000000..24f00912d4 --- /dev/null +++ b/research/idle-star-paired-axis-census/vendor/PR3133-CREDITS.md @@ -0,0 +1,19 @@ +# Credits + +- **PR #2908, Jeremy Diviney**: the paired input/output extraction, its compensation rule `C*S`, the exact two-sided certificate (`structure.py`, vendored unchanged) and the closed-adapter admission chain. +- **PR #2917, Mason Hale**: the nine paired extractions and 82-endpoint words under PR2942, the refit/compose producer model that stage 2 follows, the T74 chronology (ORDER/DISPATCH), the allocation checker, moment auditor, extension stage and adapter derivation reused here. +- **PR #2957 / #2948 / #2966, Jeremy Kothe (jeremykothe2)**: the fourteen declared exactness-preserving gate rewrites in five classes (R-retime, A3779-cut-start-read, PM-carrier-lender-entry, B-carrier-retime, A-commuting-swap) and their pure applier (`vendor/declared_rewrites.py`, vendored unchanged); stage 3 composes exactly these rewrites onto this package's stage-2 word (`data/REWRITES-2957.json`, re-addressed with exact preimages). PR2966 composed the same rewrites onto our PR2942 words. +- **PR #2969, Dugongue**: the PR2942 + PR2957 composition at T370 and its cap-level headline nomination, this package's comparator and moment baseline (`allocation/baseline/`). Our stage 3 composes the same fourteen rewrites, here onto the stage-2 word. +- **PR #2918 (research/helper408-rank7-pairing), RossRichardson**: the fixed-cut rank-seven obstruction for helper408; this package's census of fresh rank-7 extractions reproduces it exactly and is consistent with it. +- **PR #2894 / #2833, Jeremy Kothe**: the preload re-synthesis supplier, the frame accounting and inverse-reverse cleanup (`vendor/preload_move.py`), the source materializer and the inherited supplier lineage. +- **PR #2857 / #2848, Yiyang Lu (Lyy-iiis)**: the shared-kernel words, the staged native/overlay tooling and the chronological flow model and realization (edge colouring) used to construct the allocation; PR2843 (Marius-Paul Dumitrean) is that flow model's starting point. +- **PR #2863 / #2839, Dugongue**: the packing lineage and the PR2839 owner engine. +- **Tekalign**: the independent owner/chronology checker (`allocation/vendor/independent_owners.py`) and admission tooling. +- **icekylinx**: the exact free-operator auditor retained as `vendor/audit_local.py` (PR2833). +- **themilkman216**: the observation that a cap-level allocation of these inventories needs a T whose basic counts are integral, which the allocation's degenerate-face step builds on. +- **Gareth Davidson (bitplane), PR #1995 / #2013**: the fixed-word terminal-subspace bounds that frame stage 1's scope; earlier rank-seven helper ends on other words are in `research/complex-rank7-end-pair`, `research/k8-rank7-composition` and the PR1090/PR1104 lineage (credited there). +- **PR #2930 / #2942, Marius-Paul Dumitrean**: the cap allocation of PR2917's words, the four normal-45 extractions under these words, the relaxation tools and the overlay/producer conventions reused here. +- **PR #2979, Marius-Paul Dumitrean (with substantial AI assistance from Anthropic Claude via Claude Code)**: the codimension-2 census on paired-extraction words, the joint end-frame lowering of 22 restored helpers in five groups (stage 1), the five further extractions it makes profitable (stage 2), the exact composition with PR2957's rewrites (stage 3), the producer and local verification for all three stages, the overlay stage `rank7-joint-endframes` with its rebuild guards, the adapter generalization to six width classes, the literal T74 allocation of the changed inventory, its relaxation certificates and recorded gap, and the complete fresh replay. +- **PR #3015, Jeremy Kothe (jeremykothe2)**: the declared literal edit stage (`edits/`, `tools/build_edits.py`) with its independent review (`edits/edits_review.py`), and edit R1 on PR #2979's restore section (carrier 61 for register 63). +- **PR #3042, dcharb78 (with AI assistance)**: the six restore carrier/pivot skips (`R1_E42` at `restore[162:188]`, `26 -> 33` gates skipping `{22, 40, 54, 63}`, and `R2_E7` at `restore[190:203]`, `13 -> 15` gates skipping `{5, 73}`) on PR #2979's words that serve as the direct starting words for `B_586_438` and `B_588_440`. +- **New here (dcharb78, with AI assistance)**: the two coupled `B` + `restore` dying-helper carrier folds (`B_586_438` and `B_588_440`, `6` hunks / `6 -> 5` gates each) and `helper_final` lowerings on entering helpers `586` ($E_{30} \to V_{30,76,82}$) and `588` ($E_{30} \to V_{30,97,127}$) shifting the helper width inventory from `{4:26, 5:2, 6:16, 7:52, 8:99, 9:213}` to `{4:26, 5:2, 6:18, 7:50, 8:99, 9:213}` (`+665` net profit per helper, `+1,330` joint), the literal `T74_optimal_idle39` allocation (`allocation/FILL.json.gz`), the 21-control per-word edit review (`edits/edits_review.py`) and 100-control four-stage replay (`verify.py`), and the re-derived paid profile, cap certificate (`certificates/RELAX-CAP.json`), and complete fresh-native admission and release receipts. PR #2979 (mdumitrean), PR #3015 (jeremykothe2), and PR #3042 (dcharb78) are credited first. diff --git a/research/idle-star-paired-axis-census/vendor/PR3133-NOTICE b/research/idle-star-paired-axis-census/vendor/PR3133-NOTICE new file mode 100644 index 0000000000..89c20926ea --- /dev/null +++ b/research/idle-star-paired-axis-census/vendor/PR3133-NOTICE @@ -0,0 +1,28 @@ +research/rank7-joint-endframes +Copyright 2026 Marius-Paul Dumitrean. Licensed under the Apache License, Version 2.0. +Prepared with substantial AI assistance (Anthropic Claude, via Claude Code). + +This package retains, byte-identical, Apache-2.0 files from: PR #2942 (Marius-Paul Dumitrean, head +a027b0f6fdb0ab2b42ba10fc31b53960166bf2bf, research/paired-extension-normal45): data/PARENT-base.json.gz and +data/PARENT-extra.json.gz (its data/WORD-*.json.gz), comparators/PR2942-CLAIM.json and tools/wordedit.py; PR #2917 +(Mason Hale, head 224bd5e56041c40078ff6b5fa7393733a215de5c, research/paired-helper-extension): structure.py (Jeremy +Diviney's PR2908 two-sided certificate checker), vendor/audit_local.py (PR2833's independent exact auditor, icekylinx +attribution), vendor/preload_move.py (Jeremy Kothe's PR2894 frame accounting and cleanup), allocation/ORDER.json, +allocation/DISPATCH.json and allocation/vendor/ (independent_owners.py: Tekalign's independent owner checker as vendored +by PR2839/PR2917; PLAN.json.gz, TEMPLATE.json.gz); PR #2957 (Jeremy Kothe, head b74b25f3ccc84c16e1a801d73b2f47e5ea764c78, +research/paired-extension-cap-fill-swaps): vendor/declared_rewrites.py (the pure applier of the fourteen declared +rewrites) and comparators/PR2957-CLAIM.json; PR #2966 (Jeremy Kothe, head e62d3eb9005117d82a9babcfa937ecc53237c490, +research/paired-extension-normal45-rewrites): comparators/PR2966-CLAIM.json; PR #2969 (Dugongue, head +e2ca469b08385d3d5e29a918d66dbefaf889e9f3, research/paired-swap-normal45): allocation/baseline/ (its CLAIM.json and its +allocation ORDER.json and PROFILE.json); and PR #2930 (head 81f3b5d12977eba09e06fbff729167d59faabe90): tools/relax.py, +tools/root.py, tools/relax_exact.py. +data/REWRITES-2957.json is Jeremy Kothe's PR2957 rewrite list, re-addressed to this package's stage-2 word with exact +preimages (every entry keeps a credit field). producer.py follows PR2917's producer.py (Mason Hale) for its paired steps; +verify.py, check_allocation.py, check_cap.py, run_registered.py and reproduce.py adapt our PR2942 versions of PR2917's and +PR2930's; tools/audit_allocation_moment.py is PR2917's exact moment auditor with only its authenticated baseline changed (to +the PR2969 headline); tools/derive_adapters.py generalizes PR2917's adapter derivation (PR2908, Jeremy Diviney); +tools/build_overlay.py follows the overlay conventions of PR2908's and PR2917's builders. construction/allocation/ retains +the flow model of PR2857/PR2843 (Yiyang Lu, Marius-Paul Dumitrean) as adapted for this allocation. All original notices of +the exported predecessor packages remain in force. + +Derived work (Apache-2.0): this package (`research/rank7-restore-carrier-skips`) builds on PR #2979 (Marius-Paul Dumitrean, head be191346, research/rank7-joint-endframes) and PR #3015 (Jeremy Kothe, jeremykothe2, research/rank7-joint-endframes-restore-edit), retained byte-identical except for the files named in README.md, plus two declared restore edit blocks (`R1_E42` and `R2_E7` in `edits/EDITS.json` and `edits/FINAL-WORD-*.json.gz`) and their re-derived certificates and complete fresh-native admission and release receipts by dcharb78, with AI assistance. PR #2979's own evidence is kept under evidence/pr2979/. diff --git a/research/idle-star-paired-axis-census/vendor/PROVIDERS.json b/research/idle-star-paired-axis-census/vendor/PROVIDERS.json new file mode 100644 index 0000000000..0b23436750 --- /dev/null +++ b/research/idle-star-paired-axis-census/vendor/PROVIDERS.json @@ -0,0 +1,842 @@ +{ + "extra": { + "actual_paid_profile": { + "1": 2433, + "2": 724, + "3": 228, + "4": 102, + "5": 20, + "8": 8 + }, + "widths": [ + 9, + 9, + 8, + 9, + 8, + 9, + 8, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 7, + 9, + 7, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 7, + 9, + 7, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 4, + 7, + 9, + 9, + 9, + 9, + 8, + 9, + 9, + 4, + 9, + 4, + 9, + 8, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 8, + 9, + 9, + 4, + 9, + 4, + 9, + 8, + 9, + 9, + 4, + 7, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 4, + 9, + 4, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 4, + 9, + 4, + 9, + 9, + 9, + 9, + 4, + 8, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 4, + 9, + 4, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 4, + 9, + 4, + 9, + 9, + 9, + 9, + 4, + 8, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 8, + 9, + 9, + 9, + 8, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 8, + 9, + 9, + 9, + 8, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 9, + 8, + 8, + 9, + 8, + 9, + 8, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 8, + 8, + 7, + 7, + 7, + 7, + 8, + 9, + 8, + 9, + 6, + 6, + 7, + 7, + 7, + 7, + 9, + 9, + 9, + 9, + 8, + 8, + 8, + 8, + 8, + 8, + 9, + 9, + 9, + 9, + 8, + 6, + 6, + 8, + 8, + 8, + 8, + 9, + 9, + 9, + 9, + 8, + 8, + 8, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 8, + 7, + 6, + 6, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 8, + 7, + 8, + 8, + 9, + 9, + 9, + 9, + 8, + 8, + 8, + 8, + 7, + 7, + 6, + 6, + 9, + 8, + 9, + 8, + 8, + 8, + 8, + 8, + 7, + 7, + 9, + 8, + 9, + 8, + 7, + 7, + 7, + 7, + 8, + 8, + 8, + 8, + 7, + 7, + 7, + 7, + 7, + 7, + 6, + 7, + 6, + 7, + 7, + 7, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 5, + 5, + 8, + 8, + 8, + 8 + ] + }, + "gauge44": { + "actual_paid_profile": { + "1": 2433, + "2": 724, + "3": 228, + "4": 102, + "5": 20, + "8": 8 + }, + "widths": [ + 9, + 9, + 8, + 9, + 8, + 9, + 8, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 7, + 9, + 7, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 7, + 9, + 7, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 4, + 7, + 9, + 9, + 9, + 9, + 8, + 9, + 9, + 4, + 9, + 4, + 9, + 8, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 8, + 9, + 9, + 4, + 9, + 4, + 9, + 8, + 9, + 9, + 4, + 7, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 4, + 9, + 4, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 4, + 9, + 4, + 9, + 9, + 9, + 9, + 4, + 8, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 4, + 9, + 4, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 4, + 9, + 4, + 9, + 9, + 9, + 9, + 4, + 8, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 8, + 9, + 9, + 9, + 8, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 8, + 9, + 9, + 9, + 8, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 9, + 8, + 8, + 9, + 8, + 9, + 8, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 8, + 8, + 7, + 7, + 7, + 7, + 8, + 9, + 8, + 9, + 6, + 6, + 7, + 7, + 7, + 7, + 9, + 9, + 9, + 9, + 8, + 8, + 8, + 8, + 8, + 8, + 9, + 9, + 9, + 9, + 8, + 6, + 6, + 8, + 8, + 8, + 8, + 9, + 9, + 9, + 9, + 8, + 8, + 8, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 8, + 7, + 6, + 6, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 8, + 7, + 8, + 8, + 9, + 9, + 9, + 9, + 8, + 8, + 8, + 8, + 7, + 7, + 6, + 6, + 9, + 8, + 9, + 8, + 8, + 8, + 8, + 8, + 7, + 7, + 9, + 8, + 9, + 8, + 7, + 7, + 7, + 7, + 8, + 8, + 8, + 8, + 7, + 7, + 7, + 7, + 7, + 7, + 6, + 7, + 6, + 7, + 7, + 7, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 5, + 5, + 8, + 8, + 8, + 8 + ] + } +} diff --git a/research/idle-star-paired-axis-census/verify.py b/research/idle-star-paired-axis-census/verify.py new file mode 100644 index 0000000000..d6c4ade44f --- /dev/null +++ b/research/idle-star-paired-axis-census/verify.py @@ -0,0 +1,468 @@ +#!/usr/bin/env python3 +"""Source-bound census of paired rank-changing idle-axis transfers.""" + +from __future__ import annotations + +from collections import defaultdict +import argparse +import gzip +import hashlib +import io +import json +from pathlib import Path + +PACKAGE = Path(__file__).resolve().parent +ROOT = PACKAGE.parents[1] +BASE_MAIN = "997e6a9ca7b4f95d50e366f61412fd640d72a88a" +FILL_SHA256 = "8f4d6965ba573ff2b71fd7bf6b552643e086739d90bd73c55889502077638e00" +BASE_ROWS = 9 * 74 * 408 +TOTAL_ROWS = 10 * BASE_ROWS +MAX_RAW = 32_000_000 + +# The allocation and journal are retained byte-for-byte from PR3148's head, +# as already bound by PR3187. Git blob IDs are checked as well as SHA256. +VENDOR_PINS = { + "BASE-FILL.json.gz": ( + "68b8bae90144248774b1920cd27f9519caa3dc427704d8a9da6d4c491d912fc4", + "92b49b42b8f381d686a9fb8057e74e4b7548cd5c", + ), + "EXCHANGE.json": ( + "5063791f327d067f37478488c97ce449e5b34cfb61d6309fc6924c5e360fe839", + "f323db0fd94a80f691b1606e813d0738b27058ae", + ), + "PROVIDERS.json": ( + "52eb0d85caa7b2d4a93acdf5011f52b793f61ddca86235fb03cd9a09397ad4cd", + "0b2343675099d0a9fe90da6e1f1e53f50235567e", + ), +} +NOTICE_PINS = { + "PR3133-NOTICE": "c9731c9cca25ede32c2a1b3aef6d5b249973cb2ed5fb2494407bdca598763661", + "PR3133-CREDITS.md": "1d9d8f56d8899f55878e4cb2c4e052b22506444016a51c2e678773505f5189e6", +} + +ZERO = (0, 0) +ONE = (1, 0) + + +def require(condition: bool, message: str) -> None: + if not condition: + raise ValueError(message) + + +def read_bytes(path: Path) -> bytes: + require(path.is_file() and not path.is_symlink(), f"missing or linked input: {path}") + require(path.stat().st_size <= MAX_RAW, f"oversized input: {path}") + return path.read_bytes() + + +def decode(raw: bytes): + if raw[:2] == b"\x1f\x8b": + with gzip.GzipFile(fileobj=io.BytesIO(raw)) as stream: + raw = stream.read(MAX_RAW + 1) + require(len(raw) <= MAX_RAW, "oversized decoded input") + return json.loads(raw) + + +def blob_sha(raw: bytes) -> str: + blob = b"blob " + str(len(raw)).encode() + b"\0" + raw + return hashlib.sha1(blob, usedforsecurity=False).hexdigest() + + +def authenticate() -> None: + sources = json.loads(read_bytes(PACKAGE / "SOURCES.json")) + require(sources["base_commit"] == BASE_MAIN, "unexpected base main") + retained = {row["local_path"]: row for row in sources.get("retained_sources", [])} + for name, (sha, blob) in VENDOR_PINS.items(): + row = retained.get("vendor/" + name) + require(row is not None, "retained source missing from SOURCES.json: " + name) + require(row["sha256"] == sha and row["git_blob"] == blob, "retained source manifest drift: " + name) + for row in sources["files"]: + path = read_bytes(ROOT / row["path"]) + require(hashlib.sha256(path).hexdigest() == row["sha256"], "main source SHA256") + require(blob_sha(path) == row["git_blob"], "main source Git blob") + for name, (sha, blob) in VENDOR_PINS.items(): + raw = read_bytes(PACKAGE / "vendor" / name) + require(hashlib.sha256(raw).hexdigest() == sha, "retained PR3148 SHA256: " + name) + require(blob_sha(raw) == blob, "retained PR3148 Git blob: " + name) + for name, sha in NOTICE_PINS.items(): + raw = read_bytes(PACKAGE / "vendor" / name) + require(hashlib.sha256(raw).hexdigest() == sha, "retained notice SHA256: " + name) + + +def lifted_row(base, index): + copy, original = divmod(index, BASE_ROWS) + time, helper, owner, child, port, offset = base[original] + return [10 * time + copy, helper, owner + 74 * copy, child, port, offset] + + +def journal_edits(base, journal): + require(len(base) == BASE_ROWS, "base role count") + require(journal.get("copies") == 10 and len(journal.get("edits", [])) == 145, "journal size") + edits = {} + for index, before, after in journal["edits"]: + require(type(index) is int and 0 <= index < TOTAL_ROWS, "journal index") + require(index not in edits, "duplicate journal edit") + require(before == lifted_row(base, index), "journal preimage") + require(len(after) == 6 and all(type(x) is int for x in after), "journal row") + require(after[:2] == before[:2], "changed call/helper identity") + edits[index] = after + return edits + + +def project_all_ports(base, edits): + header = { + "columns": ["time", "helper", "owner_replica", "child", "port", "offset"], + "dispatch_overrides": [], + } + prefix = json.dumps(header, sort_keys=True, separators=(",", ":"))[:-1] + ',"rows":[' + digest = hashlib.sha256(prefix.encode()) + rows = [[] for _ in range(112)] + for index in range(TOTAL_ROWS): + row = edits[index] if index in edits else lifted_row(base, index) + encoded = ("," if index else "") + json.dumps(row, separators=(",", ":")) + digest.update(encoded.encode()) + if row[2] == 0: + rows[row[4]].append(row) + digest.update(b"]}\n") + require(digest.hexdigest() == FILL_SHA256, "complete PR3148 T740 fill payload") + require(len(rows) == 112 and all(rows), "port projection coverage") + return rows + + +def parity(left: int, right: int) -> int: + return (left & right).bit_count() & 1 + + +def rotate(value, exponent: int): + real, imag = value + return ((real, imag), (-imag, real), (-real, -imag), (imag, -real))[exponent % 4] + + +def phase(matrix, stream: int, exponent: int) -> None: + matrix[stream] = [rotate(value, exponent) for value in matrix[stream]] + + +def shear(matrix, dst: int, src: int, coefficient: int) -> None: + matrix[dst] = [ + (a + coefficient * c, b + coefficient * d) + for (a, b), (c, d) in zip(matrix[dst], matrix[src], strict=True) + ] + + +def identity(): + return [[ONE if i == j else ZERO for j in range(8)] for i in range(8)] + + +def stage_blocks(template): + blocks = {} + stage = None + for event in template["execution_schedule"]: + kind = event["kind"] + if kind in ("bank_padding_cover_sweep", "translate_every_live_family"): + continue + if kind == "local_cover_sweep": + stage = event["stage"] + blocks[stage] = [] + require(stage is not None, "data event precedes first local stage") + blocks[stage].append(event) + require(set(blocks) == set(range(9)), "nine stage blocks") + return blocks + + +def run_data_event(matrix, event, context, residual, character): + recipe = context["recipe"] + kind = event["kind"] + qbit = parity(character, recipe["q"]) + if kind == "local_cover_sweep": + stage = event["stage"] + local = next( + item + for item in context["template"]["recipe"] + if item["kind"] == "local" and item["stage"] == stage + ) + x, y = 2 * local["pair"], 2 * local["pair"] + 1 + for side, stream in enumerate((x, y)): + before = ( + (1 - side) * qbit + if stage == 0 + else (character & ((1 << (9 + 8 * (stage - 1))) - 1)).bit_count() + - side * qbit + ) + phase(matrix, stream, -before) + if local["reverse"]: + shear(matrix, x, y, -1) + else: + shear(matrix, y, x, 1) + for side, stream in enumerate((x, y)): + after = (character & ((1 << (9 + 8 * stage)) - 1)).bit_count() - side * qbit + phase(matrix, stream, after) + elif kind == "idle_cover_sweep": + for side, child in enumerate(event["child_indices"]): + exponent = sum(parity(character, v) for v in residual[child]) + exponent += 2 * parity( + character, recipe["idle_children"][child]["translation_after"] + ) + phase(matrix, 2 * event["pair"] + side, exponent) + elif kind == "bridge": + dst, src, coefficient = event["dst"], event["src"], event["coefficient"] + shear(matrix, 2 * dst, 2 * src, coefficient) + shear(matrix, 2 * src + 1, 2 * dst + 1, -coefficient) + elif kind == "terminal_Y_translations": + for pair in event["pairs"]: + phase(matrix, 2 * pair + 1, 2 * qbit) + elif kind == "terminal": + for pair in range(event["pairs"]): + matrix[2 * pair], matrix[2 * pair + 1] = ( + matrix[2 * pair + 1], + [rotate(value, 2) for value in matrix[2 * pair]], + ) + else: + raise ValueError("unknown physical data event: " + kind) + + +def replay(context, residual, character, blocks): + require(type(character) is int and 0 <= character < 1 << 73, "Fourier character") + matrix = identity() + for time, (stage, replica) in enumerate(context["order"]): + for stream, axes in context["hosts"].get(time, ()): + phase(matrix, stream, sum(parity(character, v) for v in axes)) + if replica == 0: + for event in blocks[stage]: + run_data_event(matrix, event, context, residual, character) + return matrix + + +def prepare_port(port, rows, order, dispatch, providers, plan, template, recipes): + recipe = recipes[port] + hosts = defaultdict(list) + used_positions = defaultdict(set) + hosted_axes = defaultdict(list) + full_axes = [list(map(int, child["orthogonal_axes"])) for child in recipe["idle_children"]] + for time, helper, owner, child, row_port, offset in rows: + require(owner == 0 and row_port == port, "owner/port projection") + stage, replica = order[time] + tag = dispatch[(stage, replica % 74)] + width = providers[tag]["widths"][helper] + axes = full_axes[child] + require(offset >= 0 and offset + width <= len(axes), "host slice range") + positions = set(range(offset, offset + width)) + require(not used_positions[child] & positions, "host slice overlap") + used_positions[child].update(positions) + hosted_axes[child].extend(axes[offset : offset + width]) + stream = 2 * plan["pairs"][str(child)] + plan["sides"][str(child)] + hosts[time].append((stream, axes[offset : offset + width])) + residual = {} + for child, axes in enumerate(full_axes): + require( + used_positions[child] == set(range(len(used_positions[child]))), + "noncompact hosted prefix", + ) + residual[child] = [v for i, v in enumerate(axes) if i not in used_positions[child]] + return { + "recipe": recipe, + "template": template, + "order": order, + "hosts": hosts, + "residual": residual, + "full_axes": full_axes, + "hosted_axes": hosted_axes, + } + + +def orthonormal(values): + return all(parity(a, b) == int(i == j) for i, a in enumerate(values) for j, b in enumerate(values)) + + +def paired_overlay(residual, source_left, source_right, target_left, target_right, axis): + result = {child: list(values) for child, values in residual.items()} + for child in (source_left, source_right): + require(axis in result[child], "axis missing from both source children") + result[child].remove(axis) + result[target_left].append(axis) + result[target_right].append(axis) + return result + + +def matrix_differences(left, right): + return [ + [i, j, list(left[i][j]), list(right[i][j])] + for i in range(8) + for j in range(8) + if left[i][j] != right[i][j] + ] + + +def baseline_target(character): + value = rotate(ONE, character.bit_count()) + return [[value if i == j else ZERO for j in range(8)] for i in range(8)] + + +def check_baseline(context, residual, blocks): + modes = [0] + [1 << i for i in range(73)] + [(1 << 73) - 1] + modes += [(1 << i) | (1 << (i + 1)) for i in range(72)] + for character in modes: + require( + replay(context, residual, character, blocks) == baseline_target(character), + "baseline exact physical operator", + ) + return len(modes) + + +def check_candidate_pair(context, blocks, source_children, target_children): + # Each selected axis is an orthogonal source-basis vector and is orthogonal + # to every original destination axis, including the destination's hosted slice. + baseline = context["residual"] + for child in source_children + target_children: + require(orthonormal(baseline[child]), "paired residual basis is not orthonormal") + eligible = [] + for axis in sorted(set(baseline[source_children[0]]) & set(baseline[source_children[1]])): + if any(parity(axis, v) for child in target_children for v in context["full_axes"][child]): + continue + if any(len(baseline[child]) + 1 > 51 for child in target_children): + continue + trial = paired_overlay( + baseline, + source_children[0], + source_children[1], + target_children[0], + target_children[1], + axis, + ) + # Check the complete hosted + residual basis at all affected children. + valid = True + for child in set(source_children + target_children): + combined = context["hosted_axes"].get(child, []) + trial[child] + if not orthonormal(combined): + valid = False + break + if not valid: + continue + eligible.append(axis) + failures = 0 + witness = None + for axis in eligible: + original = replay(context, baseline, axis, blocks) + altered = replay( + context, + paired_overlay( + baseline, + source_children[0], + source_children[1], + target_children[0], + target_children[1], + axis, + ), + axis, + blocks, + ) + differences = matrix_differences(original, altered) + if differences: + failures += 1 + if witness is None: + witness = { + "axis": axis, + "baseline": original, + "overlay": altered, + "differences": differences, + } + return len(eligible), failures, witness + + +def check_mutations(base, journal): + altered = json.loads(json.dumps(journal)) + altered["edits"][0][1][0] ^= 1 + try: + journal_edits(base, altered) + except ValueError: + return True + return False + + +def run(): + authenticate() + vendor = PACKAGE / "vendor" + base = decode(read_bytes(vendor / "BASE-FILL.json.gz"))["rows"] + journal = decode(read_bytes(vendor / "EXCHANGE.json")) + rows_by_port = project_all_ports(base, journal_edits(base, journal)) + order_base = decode(read_bytes(ROOT / "research/rank7-joint-endframes/allocation/ORDER.json")) + require(len(order_base) == 666, "base chronology count") + order = [[stage, replica + 74 * copy] for stage, replica in order_base for copy in range(10)] + dispatch_rows = decode(read_bytes(ROOT / "research/rank7-joint-endframes/allocation/DISPATCH.json")) + dispatch = {(stage, replica): tag for stage, replica, tag in dispatch_rows} + require(len(dispatch) == 666, "base dispatch count") + providers = decode(read_bytes(vendor / "PROVIDERS.json")) + plan = decode(read_bytes(ROOT / "research/rank7-joint-endframes/allocation/vendor/PLAN.json.gz")) + template = decode(read_bytes(ROOT / "research/rank7-joint-endframes/allocation/vendor/TEMPLATE.json.gz")) + recipes = decode(read_bytes(ROOT / "research/adaptive-kernel-demotion/inputs/DATA-PHASES.json"))["recipes"] + require(len(recipes) == 112, "port recipe count") + blocks = stage_blocks(template) + + forward_count = reverse_count = forward_failures = reverse_failures = 0 + per_port = [] + first_forward_witness = None + baseline_modes = None + for port in range(112): + context = prepare_port(port, rows_by_port[port], order, dispatch, providers, plan, template, recipes) + context["residual"] = context.pop("residual") + if port == 0: + baseline_modes = check_baseline(context, context["residual"], blocks) + require( + replay(context, context["residual"], 0, blocks) == identity(), + "zero-character baseline identity control", + ) + f, ff, fw = check_candidate_pair( + context, blocks, (8, 10), (12, 13) + ) + r, rf, rw = check_candidate_pair( + context, blocks, (12, 13), (8, 10) + ) + forward_count += f + reverse_count += r + forward_failures += ff + reverse_failures += rf + per_port.append([port, f, ff, r, rf]) + if port == 0: + first_forward_witness = fw + require(check_mutations(base, journal), "mutated journal preimage accepted") + require(baseline_modes == 147, "baseline positive-control mode count") + require(forward_count == forward_failures and reverse_count == reverse_failures, "unrejected eligible transfer") + require(forward_count == reverse_count == 2688, "paired transfer count") + require(all(row[1] == row[2] == row[3] == row[4] == 24 for row in per_port), "per-port paired census") + require(first_forward_witness is not None and first_forward_witness["axis"] == 7, "exact forward witness") + return { + "status": "PASS_NO_OPERATOR_PRESERVING_RANK_CHANGING_PAIRED_TRANSFER", + "base_main": BASE_MAIN, + "fill_payload_sha256": FILL_SHA256, + "authenticated_fill_rows": TOTAL_ROWS, + "ports": 112, + "baseline_modes_port0": baseline_modes, + "forward": {"eligible": forward_count, "fail_at_own_axis_character": forward_failures}, + "reverse": {"eligible": reverse_count, "fail_at_own_axis_character": reverse_failures}, + "port0_forward_witness": first_forward_witness, + "per_port_counts": per_port, + "selected_frontier_changed": False, + "new_kappa": None, + } + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--write-result", action="store_true") + args = parser.parse_args() + result = json.loads(json.dumps(run())) + expected_path = PACKAGE / "RESULT.json" + if args.write_result: + expected_path.write_text(json.dumps(result, indent=2, sort_keys=True) + "\n", encoding="utf-8") + elif expected_path.is_file(): + expected = json.loads(read_bytes(expected_path)) + require(result == expected, "stored result differs") + print( + result["status"] + + f" ports={result['ports']} forward={result['forward']['eligible']}" + + f" reverse={result['reverse']['eligible']} baseline_modes={result['baseline_modes_port0']}" + + " no_new_kappa" + ) + + +if __name__ == "__main__": + main()