Prove P104 rank-eight cut under arbitrary frame-path interleaving

research/p104-commutation-cut/README.md

@@ -0,0 +1,179 @@
+# The P104 eight-array cut survives arbitrary interleaving of its frame paths
+
+Reordering the PR1972/PR1991 P104 channel and redesigning all its scalar
+operations cannot make its side correction free while its per-register frame
+paths and private lifetimes are retained. Even with arbitrary common-frame linear
+operations, the source-to-target transfer has rank at most **8d**, where d is
+the dimension of one array. The 104-port identity requires **104d**. The
+original `G/2` channel attains the bound.
+
+The new quantifier is **every interleaving of the per-register transport chains**,
+with **all original scalar reads/writes discarded and freely redesigned**, rather
+than one chronological event list. This
+closes a restricted version of the retiming question left open by
+[PR2082](https://github.com/CrocSwap/integer-mult-bounds/pull/2082) and
+[PR2090](https://github.com/CrocSwap/integer-mult-bounds/pull/2090). Changing a
+register's frame path, replacing/fusing transports,
+new storage lifetimes and non-common-chart operations remain outside the result.
+There is **no new supplier or kappa**.
+
+## Exact domain
+
+Start with the pinned 4,058-event word, its 104 X sources, 104 Y targets,
+72 arbitrary dirty helpers and eight owned C lifetimes. The input witness is
+SHA256 `0f541bef7f19fdeffd67157684e9f03d785f42c89973632f508fc1a0452b580e`.
+
+Delete all 2,624 original ADDs and eight COPY instructions, including all
+their cross-register ordering dependencies. Only the 1,410 transports and
+eight private allocation/disposal pairs remain. Retain their order separately
+for each register, including the order of C's eight lifetimes. Admit every
+interleaving of these chains as whole transport events. No access inside a
+recursive child is granted. Between events, grant any finite linear program
+on existing live registers in exactly the same canonical frame, including
+singular operations if desired. Original scalar coefficients, source choices
+and access order need not be retained. Requiring restoration of borrowed
+inputs only restricts this favorable class further.
+
+Retain the original frame transports and C allocation/disposal lifetimes.
+Each role ends at its original frame. We do not grant arbitrary storage at
+unoccupied frames or identify frames merely because they have equal rank.
+The theorem concerns linear maps, not adaptive or nonlinear programs.
+
+## A union graph for all retimings
+
+A wire node is one register's interval between successive retained transport
+or lifetime events, labelled by its canonical frame. Separate C lifetimes
+have separate nodes. Each transport supplies a directed wire edge from its
+input interval to its output interval; initialization has no predecessor and
+disposal has no successor.
+
+For every pair of intervals on different registers with exactly equal frames,
+add both directed communication edges. After the original scalar dependencies
+are discarded, different registers' transport chains are independent, so each
+such pair can overlap in some interleaving. More importantly, every actual
+common-frame operation in every admitted execution is represented by an edge.
+
+The graph deliberately permits incompatible choices from different schedules
+and even cycles. We do **not** claim that all its edges can occur together.
+Every actual data dependency maps to a walk in this enlarged graph. Extra
+operations may repeatedly change a row inside one interval without changing
+its frame, and are therefore still covered. Same-role intervals are connected
+only by their directed transport chains, not by free access to past values.
+
+The implementation also computes interval overlap from the event partial
+order, and checks that granting *every* cross-register equal-frame pair gives
+exactly the same graph. This prevents accidentally retaining an original
+scalar-order restriction.
+
+Delete the eight C-descending transport edges at original zero-based event
+indices
+
+```
+2463, 2472, 2479, 2487, 2495, 2503, 2510, 2518.
+```
+
+Each is one rank-seven native descent, and each carries **one array**. Native
+child rank seven is not seven independent array wires. Exact reachability
+in the enlarged graph finds no X-input to Y-output path.
+
+## Rank implication and attainment
+
+Fix any admitted retiming and inserted linear program. Replace the values
+at those eight transport outputs by eight independent array variables. In
+the resulting broken program, no X input influences a Y output except via
+these variables: otherwise its actual dependency path would appear in the
+union graph after the same eight edges were removed.
+
+With all other independent inputs set to zero, the original X-to-Y map
+therefore factors through the eight original edge values. These values may
+depend on previous such values; evaluating them in their actual chronological
+order still gives a linear map from X into an 8d-dimensional space. The
+transfer rank is at most 8d. Arbitrary dirty inputs and scalar/address mixing
+within frames do not increase this dimension.
+
+For sharpness, the original word is an admitted ordering. The checker
+reconstructs its 280-input rational map and verifies all source and helper
+endpoints, including query compensation and cleanup. Its transfer is `G/2`.
+The independently reconstructed roots satisfy `G²=26G` and `trace(G)=208`.
+Thus `G/26` is an idempotent of trace eight over Q, so G has rank eight; the
+array-valued transfer has rank 8d. This replays the inherited scalar channel,
+not a new native compilation.
+
+## Evidence and reproduction
+
+Two separately implemented exact graph checkers agree:
+
+* 1,698 wire intervals in 444 binary subspaces;
+* 1,402 retained transport edges after removing the eight descents;
+* 71,224 directed potential common-frame edges;
+* 853 reachable intervals and zero reachable final targets;
+* restoring any one omitted descent reaches 52 targets; restoring all reaches 104.
+
+The primary implementation uses forward ancestor bitsets and complete XOR
+spans. The second builds per-role traces, reverse descendant sets and reduced
+binary bases; it imports no primary graph code. Both were written with Codex
+assistance, so this is not independent human review.
+
+A deterministic legal retiming moves 3,989 event positions. The full rational
+280-input endpoint replay and independent union-graph invariants still pass.
+Controls restore each omitted edge, inject a forbidden cross-frame bypass,
+remove dirty compensation or cleanup, and reverse frame-basis presentation.
+The complete regenerated receipt is compared with `RESULT.json`.
+
+```sh
+python3 -I -O -B research/p104-commutation-cut/verify.py
+python3 scripts/research_package.py --package research/p104-commutation-cut --check-only
+python3.12 scripts/research_package.py --package research/p104-commutation-cut
+```
+
+The direct check is read-only, standard-library only, and needs no network,
+Git or predecessor executable imports. `--write` deliberately regenerates
+only this package's receipt. Source pins authenticate before calculation.
+The unchanged local profile has mass 2368: 2312 persistent boundary progress
+plus COPY56. No new correction tariff, global owner assignment, precision,
+all-size theorem, selected cold replay or native phase recompilation is
+claimed. In particular, the 96 missing array directions are **not** a
+96-child lower bound for changed frame paths.
+
+## Relation to current work
+
+PR2082 (`60f4e337ffba470e09727dd435b1f1be3b67d03d`) and PR2090
+(`dff116efc2c4ddd7236020ad8316db5c98aa693e`) establish the sharp rank-eight cut
+for the frozen chronological itinerary. Their graph/cut idea and distinction
+between array dimension and child rank are retained here. The new result is
+the union over arbitrary interleavings of the fixed frame paths, after
+discarding all scalar-event dependencies, and its exact certificate. Their terminal-excursion budget arguments are not new claims
+of this package. PR2083 treats the completed terminal cut; PR2089 constructs
+a paid tail correction. Both change the transport list and are outside this
+theorem.
+
+The investigation began as an attempted constructive retiming, after local
+log-reuse and additive-access screens failed. Those exploratory finite-field
+searches are not used to prove this result and are not presented as native
+lower bounds. The public package contains the exact successful certificate,
+not a claim of a successful identity construction.
+
+## Open next questions
+
+Change at least one actual frame path, storage lifetime or permitted
+cross-chart interface. A concrete first experiment is
+to replace one gather or delivery transport so that a source-bearing helper
+can meet a target-bearing helper at a new intermediate frame. Rebuild the
+union graph and require a bypass of this eight-edge cut, then verify dirty
+restoration and a complete native invoice. A bypass alone is not identity
+completion. Retiming or scalar resynthesis along the original per-role frame paths is
+no longer the open case identified here.
+
+## Credit
+
+Rohan Arun / PR1972 (`fd82d172f46933fd253c2c6de4bd5eaff5429cfd`) supplies the
+scalar/frame channel; Chafik Boukhalfa / PR1991
+(`6e222517e182e98499239bc9a4009f540e1c5520`) supplies its native realization;
+Adam Gall / PR1940 supplies the 32-chain schedule. Retain Josie Elliston /
+PR1071, Ali Romman / PR1125, and the PR968/717/446/595/620 geometry and decoder
+lineage. David Arias / PR2082 and Adam Gall / PR2090 supply the immediate
+frozen-itinerary obstructions. No predecessor source is modified or copied.
+
+New work by Jeremy Diviney with substantial OpenAI Codex assistance in
+mathematics, code, verification and prose. Apache-2.0. No formal-kernel proof,
+independent human review or exhaustive novelty guarantee is claimed.

research/p104-commutation-cut/RESULT.json

@@ -0,0 +1,83 @@
+{
+  "controls": {
+    "all_cross_role_overlaps_granted": true,
+    "basis_invariance": true,
+    "cross_frame_bypass": true,
+    "intact_graph": true,
+    "nontrivial_retiming": true,
+    "scalar_mutations": [
+      "omitted compensation/cleanup at 0",
+      "omitted compensation/cleanup at 4057"
+    ],
+    "single_descent_restorations": 8
+  },
+  "cut_original_event_indices": [
+    2463,
+    2472,
+    2479,
+    2487,
+    2495,
+    2503,
+    2510,
+    2518
+  ],
+  "formal_columns": 280,
+  "graph": {
+    "causal_edges": 1402,
+    "cut_events": [
+      734,
+      737,
+      740,
+      743,
+      746,
+      749,
+      752,
+      755
+    ],
+    "cut_ranks": [
+      7,
+      7,
+      7,
+      7,
+      7,
+      7,
+      7,
+      7
+    ],
+    "frames": 444,
+    "nodes": 1698,
+    "potential_common_frame_edges": 71224,
+    "reachable_nodes": 853,
+    "single_edge_reopened_targets": [
+      52,
+      52,
+      52,
+      52,
+      52,
+      52,
+      52,
+      52
+    ]
+  },
+  "original_events": 4058,
+  "original_transfer_rank": 8,
+  "paid_profile": {
+    "1": 1074,
+    "2": 58,
+    "3": 86,
+    "4": 104,
+    "5": 48,
+    "6": 24,
+    "7": 8,
+    "8": 8
+  },
+  "rank_mass": 2368,
+  "removed_original_scalar_events": 2632,
+  "required_identity_rank": 104,
+  "retimed_events_moved": 3989,
+  "retimed_order_sha256": "af3ba729bda1034687ba450a2805b47d6dafd7327482818a38dea41e5cdf8c19",
+  "scope": "Arbitrary interleaving of the original per-role transport/lifetime chains; all original scalar reads/writes and their cross-role dependencies discarded. Arbitrary common-frame linear resynthesis on existing live roles. No new frame path, storage, native correction price, global owner, precision or kappa claim.",
+  "source_witness_sha256": "0f541bef7f19fdeffd67157684e9f03d785f42c89973632f508fc1a0452b580e",
+  "status": "PASS_P104_ALL_COMMUTATIONS_CUT",
+  "transport_lifetime_events": 1426
+}

research/p104-commutation-cut/SOURCES.json

@@ -0,0 +1,36 @@
+{
+  "schema_version": 1,
+  "base_commit": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2",
+  "files": [
+    {
+      "path": "certificates/selected-result.json",
+      "usage": "provenance",
+      "git_blob": "ae6a99f28aa468649eb66a361e764d769363bf11",
+      "sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32"
+    },
+    {
+      "path": "docs/research/agent-task-catalog.json",
+      "usage": "provenance",
+      "git_blob": "e8870e5917057d59b730eb14721a778639eca050",
+      "sha256": "d46eb6d5b3e279428753d770653663fbdf1063e55c255ea073d768f344927ef7"
+    },
+    {
+      "path": "research/p104-native-channel/inputs/LOWRANK-RESULT.json",
+      "usage": "input",
+      "git_blob": "cbd1c6bdc9e34b25c64b2636ccd6acd2392232d4",
+      "sha256": "7143ec7780f6f38a8c294df8009c3621936b281d05ae79946ce22f581b73d1b1"
+    },
+    {
+      "path": "research/p104-native-channel/inputs/LOWRANK-WITNESS.json",
+      "usage": "input",
+      "git_blob": "86beaf424e9f0f800ae3a62797d94ec9386b7706",
+      "sha256": "0f541bef7f19fdeffd67157684e9f03d785f42c89973632f508fc1a0452b580e"
+    },
+    {
+      "path": "research/p104-native-channel/inputs/P104-FIXTURE.json",
+      "usage": "input",
+      "git_blob": "2e16f99b295bb386fd13bd8fbd57b42ef54143a9",
+      "sha256": "516c06f6ec3cb84be588c546108de897650288576dd5fbf5fe44b9c5546ad8a4"
+    }
+  ]
+}

research/p104-commutation-cut/TASK.json

@@ -0,0 +1,87 @@
+{
+  "schema_version": 1,
+  "task_id": "p104-side-correction",
+  "priority_revision": 4,
+  "base_commit": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2",
+  "original_card": {
+    "id": "p104-side-correction",
+    "question": "Can the native P104 low-rank channel be completed with a legal, fully charged I-G/2 side correction?",
+    "starting_points": [
+      "research/p104-native-channel/README.md",
+      "research/p104-native-channel/PROOF.md",
+      "docs/research/community-efficient1000-review.md"
+    ],
+    "methods": [
+      "Construct one side-correction word at an explicit chronological cut with the needed frames still available.",
+      "Derive a lower bound on the side correction and hosting costs that decides whether this channel can beat the selected budget."
+    ],
+    "acceptance_gate": "An exact arbitrary-input identity, source/target frame availability and restoration at the chosen cut, plus the complete channel+correction+idle/hosting bill or an explicit favorable bound. The native channel alone is not a supplier.",
+    "first_step": {
+      "command": [
+        "python3",
+        "-B",
+        "scripts/research_baseline.py"
+      ],
+      "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY",
+      "inspect": "Read the P104 open next questions and its fixed local histogram; inspect why appending I-G/2 after source completion is not justified. #1991 supplies the checked native channel, not the missing correction.",
+      "scope": "Source-bound orientation only. Read the named package and review before relying on its local evidence; this command is not its replay or supplier admission."
+    },
+    "first_experiment": "Choose one exact side-correction cut and bound its allowed cost from a favorable completed moment at a declared target. Stop or hand off if the necessary source/target access cannot be justified or even the optimistic total misses the target.",
+    "bottleneck_link": "Completing an already realized changed channel tests a concrete construction opportunity, instead of refining the incumbent packing. A positive local result still needs global and all-size admission.",
+    "allowed_variations": [
+      "One correction factorization, one chronological cut, or one explicit hosting obstruction.",
+      "A changed correction schedule with an updated full bill and native frame contract."
+    ],
+    "scope_change_triggers": [
+      "Recompiling the already certified low-rank channel without closing a new obligation.",
+      "Treating a pending ancestor, local histogram or unpriced side correction as an admitted global supplier."
+    ],
+    "overlap_terms": [
+      "P104",
+      "I-G/2",
+      "side correction",
+      "native channel",
+      "1972",
+      "1991"
+    ]
+  },
+  "scope_status": "changed",
+  "actual_scope": "Sharp eight-array communication cut for arbitrary interleaving of the pinned P104 per-role transport/lifetime chains, with every original ADD/COPY and scalar access dependency discarded and arbitrary common-frame linear resynthesis.",
+  "scope_change_reason": "Constructive timing and scalar-access screens failed. PR2082/2090 cover one frozen chronology; the exact stronger union graph discards every original scalar dependency, retaining only per-role frame paths and existing storage lifetimes. This is a scoped obstruction, not the card construction gate.",
+  "bottleneck_link": "Identity completion needs rank104 source-to-target transfer. Showing rank8 under all timing and scalar redesign along these frame paths forces a changed native path/storage/interface before further supplier work.",
+  "budget_minutes": 60,
+  "stop_rule": "Accept only an exact source-bound union-graph cut checked by two separate implementations, with all cross-role equal-frame overlaps granted. Do not infer a native tariff or kappa from this communication rank.",
+  "outcome": "negative-result",
+  "evidence": "README.md proof; RESULT.json canonical replay from verify.py; two independent graph constructions, 280-column scalar replay and semantic controls.",
+  "author": "Jeremy Diviney",
+  "ai_assistance": "Substantial OpenAI Codex assistance in research, proof, implementation, tests and prose. No subagents, independent human review or formal proof assistant.",
+  "open_questions": [
+    {
+      "question": "Can a changed frame path or storage lifetime bypass the eight descending-copy edges cheaply?",
+      "why_it_matters": "Pure commutations and added common-frame operations cannot complete identity transfer.",
+      "first_step": "Change one gather/delivery helper transport, recompute the union graph, then derive restored arbitrary-input endpoints and fully paid native profile.",
+      "blocked_by": "No such modified native word or invoice is supplied; crossing the cut alone does not prove identity completion."
+    }
+  ],
+  "selection": "Explicit continuing user task; no random task draw or advance public reservation.",
+  "overlap": {
+    "utc": "2026-10-14T19:36:00Z",
+    "open_pr_snapshot_count": 376,
+    "discussion_records": 762,
+    "complete_pagination": true,
+    "nearest_prs": [
+      2082,
+      2090,
+      2083,
+      2089
+    ],
+    "difference": "Arbitrary interleavings of per-role frame paths, removing all original scalar access dependencies; prior PR2082/2090 fix one chronological word.",
+    "limits": "Bodies, discussion records and relevant READMEs; no exhaustive closed-code or literature search.",
+    "discussion_snapshot_utc": "2026-10-14T19:29:00Z"
+  },
+  "upstream_checkpoint": {
+    "commit": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2",
+    "utc": "2026-10-14T19:34:00Z",
+    "guidance_changes": "None relative to scientific base; priority revision4 and selected record unchanged."
+  }
+}