Research: diagonal rank-16 batches under register commutation, 134 not 8 (audit of #1779; no κ claim)

research/diagonal-batch-commutation/README.md

@@ -0,0 +1,90 @@
+# Diagonal rank-16 batches are not limited by the selected chronology
+
+**Audit of one implication in open PR #1779. No new κ; the selected record is unchanged.**
+
+[PR #1779](https://github.com/CrocSwap/integer-mult-bounds/pull/1779) (1337isnot1337, head `1e3128bf`) batches
+sixteen rank-1 climbs on distinct destinations into one rank-16 diagonal child. In the selected gauge44 provider it
+finds 8 such batches (128 rank-1 climbs). That raises the zero-charge ceiling by 1.72%, below the card's 5% gate.
+Its count uses only **contiguous** runs: any computational event breaks a run, and chunks are 16-aligned.
+
+That restriction, not the provider, makes the count small. A rank-1 climb on `L r` reads and writes only `L r`.
+Inside its own phase it can move past any event that touches no `L r`. Allowing that move, and nothing else,
+gives this:
+
+| | per orientation |
+|---|---:|
+| Disjoint 16-batches on distinct destinations (earliest-deadline greedy) | **134** (2,144 of 2,412 rank-1 climbs) |
+| Per-phase cap ⌊rank-1 count / 16⌋ | 149 |
+| By phase: A / B / cleanup_tail / final | 58/58, 52/67, 4/4, 20/20 |
+| PR #1779's contiguous rule, re-implemented: original → reordered programs | 8 → 134 |
+
+**The retained checker accepts the reordered programs unchanged.** Only rank-1 climbs move; every other event
+keeps its relative order. The [independent local checker](../complex-571-cold14-k492b/code/hpe_audit_local.py)
+replays scalars, frames and wrappers literally and runs 25 mutation controls. It passes both reordered
+orientations with a receipt (`local` block and paid profiles) equal to the original programs'. The original's
+receipt equals the pinned selected `INDEPENDENT-LOCAL-REPLAY.json`. Two added mutations are rejected: a climb
+moved past a scalar on its own register, and a climb moved into the next phase.
+
+## Exact ceilings (#1779's convention)
+
+Rank mass is preserved and every interface charge is waived. Ceilings come from
+[`ceiling.py`](../complex-local-word-ceiling/ceiling.py) with 73 columns, 896 families, nine stages, centre 64 and
+grid 10⁻¹⁵. The gate is `1.05 × 0.001690054109089`.
+
+| rank-16 batches | a ceiling (upper) | gain | +5% gate |
+|---:|---:|---:|---|
+| 8 (#1779) | 0.001719107428154 | +1.72% | fails |
+| 22 | 0.001772433845132 | +4.87% | fails |
+| 23 | 0.001776370006187 | +5.11% | passes |
+| 134 (legal here) | 0.002358018698467 | +39.5% | passes |
+| 149 (phase cap) | 0.002467305908467 | +46.0% | passes |
+
+**Charge headroom.** With 134 batches, at most **1,258 extra rank-1 children per call** keep the gate (1,259
+fail; sharp). That is about 9.4 per batch, under the idle-displacing convention of discussion 1596: extra paid
+work replaces equal idle mass. Charging overhead on top of the idle bill instead, as #1605 does, would give less;
+that convention is not computed here.
+
+## What this does and does not show
+
+- It removes one stated reason the diagonal-batch route fails. The source chronology allows 134 batches, so the
+  zero-charge screen clears the 5% gate by a wide margin.
+- The route is decided by what #1779 waived. Gathering 16 registers at *different* frames into one diagonal
+  rank-16 child needs copies, frames, hosting, output storage, precision and arbitrary-dirty restoration. This
+  package inherits #1779's premise that a diagonal rank-16 child realizes 16 independent rank-1 climbs, and
+  does not examine it.
+- The reorder is checked only at the local level. Every register's frame at each phase marker is unchanged
+  because climbs stay inside their phase. The check does not establish that global hosting and the idle-remainder
+  frame audit (`global/hosted`, `global/audit` in the replay archive) are insensitive to positions inside a phase.
+- Batch counts are a greedy lower bound. 149 is the trivial phase cap, not an attained value.
+- The bit supplier binds well before +39% (#1605), so the complex ceiling alone does not set κ.
+
+## Reproduce
+
+```sh
+python3 -I -B research/diagonal-batch-commutation/verify.py          # ~12 s, PASS_DIAGONAL_BATCH_COMMUTATION
+python3 scripts/research_package.py --package research/diagonal-batch-commutation
+```
+
+`verify.py --write` regenerates `RESULT.json`. `batch.py PROGRAMS CANONICAL-WORD [OUT]` runs the reorder on
+extracted members and can write the reordered programs. Both use the standard library only. Checked on Python
+3.10 and 3.12.
+
+## Open next questions
+
+- **What can a diagonal rank-16 child of frame climbs cost?** Its gathering and restoration charge now decides
+  the route. The first step is to specify the contract for 16 registers at different frames `a_i → b_i`, then
+  price it against the 1,258-unit headroom above. The blocker is that no such contract is written down; #1779's
+  diagonal identity is the only premise.
+- **On-top charge convention.** The same headroom with overhead added on top of the idle bill (#1605's
+  convention) needs a moment term outside `ceiling()`'s local-profile interface.
+- **Exact phase-B maximum (52 ≤ max ≤ 67).** This only moves the zero-charge ceiling between +39.5% and +46%.
+  It is low priority next to the charge question. The windows are already computed by `batch.py`, so it is an
+  interval-stabbing integer program.
+
+## Credit
+
+The diagonal batching premise and the contiguous count are 1337isnot1337's (#1779). The rank-shape budgets are
+Arham Tahir's (#1605, discussion 1596). The packing ceiling is Douglas Colkitt's (#1240), and the coverage law
+is PR1012's. The local checker is from the icekylinx / PR514 / PR433 lineage, retained in
+`complex-571-cold14-k492b`. Selected construction credits are in its review. Prepared for Josie Elliston by
+Claude Code (Claude Opus 5.5) in one donated session, without independent review. Apache-2.0.

research/diagonal-batch-commutation/RESULT.json

@@ -0,0 +1,117 @@
+{
+ "base_ceiling": [
+  "52814190909/31250000000000",
+  "1690054109089/1000000000000000"
+ ],
+ "ceilings_by_batches": {
+  "134": {
+   "a_hi": "2358018698467/1000000000000000",
+   "a_lo": "1179009349233/500000000000000",
+   "gain_pct_hi": "39.5233",
+   "passes_5pct_gate": true
+  },
+  "149": {
+   "a_hi": "2467305908467/1000000000000000",
+   "a_lo": "1233652954233/500000000000000",
+   "gain_pct_hi": "45.9898",
+   "passes_5pct_gate": true
+  },
+  "22": {
+   "a_hi": "443108461283/250000000000000",
+   "a_lo": "1772433845131/1000000000000000",
+   "gain_pct_hi": "4.8744",
+   "passes_5pct_gate": false
+  },
+  "23": {
+   "a_hi": "1776370006187/1000000000000000",
+   "a_lo": "888185003093/500000000000000",
+   "gain_pct_hi": "5.1073",
+   "passes_5pct_gate": true
+  },
+  "8": {
+   "a_hi": "859553714077/500000000000000",
+   "a_lo": "1719107428153/1000000000000000",
+   "gain_pct_hi": "1.7191",
+   "passes_5pct_gate": false
+  }
+ },
+ "charge_headroom": {
+  "a_hi_at_1259": "1774507425129/1000000000000000",
+  "a_lo_at_1258": "1774856134331/1000000000000000",
+  "convention": "idle-displacing extra rank-1 children per call, 134 batches, +5% gate",
+  "max_extra_rank1": 1258,
+  "per_batch": "1258/134"
+ },
+ "checker_controls_rejected": [
+  "climb_past_own_scalar",
+  "climb_across_phase"
+ ],
+ "gate_target_a": "35491136290869/20000000000000000",
+ "orientations": {
+  "backward": {
+   "batches": 134,
+   "per_phase": {
+    "A": {
+     "batches": 58,
+     "cap": 58,
+     "movable": 936,
+     "rank1": 936
+    },
+    "B": {
+     "batches": 52,
+     "cap": 67,
+     "movable": 1072,
+     "rank1": 1072
+    },
+    "cleanup_tail": {
+     "batches": 4,
+     "cap": 4,
+     "movable": 78,
+     "rank1": 78
+    },
+    "final": {
+     "batches": 20,
+     "cap": 20,
+     "movable": 326,
+     "rank1": 326
+    }
+   },
+   "phase_cap": 149,
+   "pr1779_rule_original": 8,
+   "pr1779_rule_reordered": 134
+  },
+  "forward": {
+   "batches": 134,
+   "per_phase": {
+    "A": {
+     "batches": 58,
+     "cap": 58,
+     "movable": 936,
+     "rank1": 936
+    },
+    "B": {
+     "batches": 52,
+     "cap": 67,
+     "movable": 1072,
+     "rank1": 1072
+    },
+    "cleanup_tail": {
+     "batches": 4,
+     "cap": 4,
+     "movable": 78,
+     "rank1": 78
+    },
+    "final": {
+     "batches": 20,
+     "cap": 20,
+     "movable": 326,
+     "rank1": 326
+    }
+   },
+   "phase_cap": 149,
+   "pr1779_rule_original": 8,
+   "pr1779_rule_reordered": 134
+  }
+ },
+ "status": "PASS_DIAGONAL_BATCH_COMMUTATION"
+}

research/diagonal-batch-commutation/SOURCES.json

@@ -0,0 +1,36 @@
+{
+  "schema_version": 1,
+  "base_commit": "0b1cccf86e2f5132ed286a26ef0a681a495740ea",
+  "files": [
+    {
+      "path": "certificates/selected-result.json",
+      "usage": "provenance",
+      "git_blob": "ae6a99f28aa468649eb66a361e764d769363bf11",
+      "sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32"
+    },
+    {
+      "path": "docs/research/agent-task-catalog.json",
+      "usage": "provenance",
+      "git_blob": "06c96f5579bb67ed1b86d334e78fbed7da6945f1",
+      "sha256": "6686ad58f1fbdbc87134a78901b60fd53a20d3984355e91defbbebc9e9fa8075"
+    },
+    {
+      "path": "research/community-frontier1094-audit/selected-replay.tar.gz",
+      "usage": "input",
+      "git_blob": "c24daf067f9c543421d89ca2eeaa4eb78a57fb6f",
+      "sha256": "f1da80610bf33c58527f18ad63b4350d0b864e1d4486141ee17ac9bed4d529d6"
+    },
+    {
+      "path": "research/complex-571-cold14-k492b/code/hpe_audit_local.py",
+      "usage": "input",
+      "git_blob": "17bccb64fdca54f329a3ce16e369449cb76c2802",
+      "sha256": "6bd9a1e279c9c9e4f3767d9f82e537b559292906feb2ddab02f380fb6523a810"
+    },
+    {
+      "path": "research/complex-local-word-ceiling/ceiling.py",
+      "usage": "input",
+      "git_blob": "6c0f54527d879396f689523bfde19928a9b6157c",
+      "sha256": "86a1432870b3b21d8454106ec9162fddc0471472d9214c590a1420f2426cedfc"
+    }
+  ]
+}

research/diagonal-batch-commutation/TASK.json

@@ -0,0 +1,78 @@
+{
+  "schema_version": 1,
+  "task_id": "complex-rank-shape-decoder",
+  "priority_revision": 3,
+  "base_commit": "0b1cccf86e2f5132ed286a26ef0a681a495740ea",
+  "original_card": {
+    "id": "complex-rank-shape-decoder",
+    "question": "Can a decoder deliver the local paid mass in fewer, larger-rank children (block frame climbs instead of rank-1 to rank-3 steps)?",
+    "starting_points": [
+      "research/complex-local-word-ceiling/README.md",
+      "research/complex-decoder-field-extension-seed44/README.md",
+      "research/complex-frame-pair-decoders/README.md"
+    ],
+    "methods": [
+      "Find one exact small decoding identity whose frame path climbs in blocks, and price its complete per-call profile.",
+      "Bound the best effective child rank achievable for one fixed support alphabet, including copies, frames and restoration."
+    ],
+    "acceptance_gate": "A per-call local profile, with all copied information, frames and restoration counted, whose ceiling exceeds the selected word's by at least 5%; masked or overcomplete supports must change an assumption of the eight-term all-pairs bound.",
+    "first_step": {
+      "command": [
+        "python3",
+        "-B",
+        "research/complex-local-word-ceiling/verify.py"
+      ],
+      "expected": "PASS_COMPLEX_LOCAL_WORD_CEILING",
+      "inspect": "Read the selected word's per-call local profile, its packing ceiling and the lever table; run levers.py for the ideal budget of the lever you target.",
+      "scope": "Positive control and planning budget only; this is not a new construction or full cold replay."
+    },
+    "first_experiment": "Before any synthesis, write the candidate per-call local profile (and centre charge / unpaid coordinates if changed) and screen it with ceiling.ceiling(); reject it if even the ideal ceiling does not beat the selected word's by your stated margin. Ideal budget: rank-16 delivery is 2.31x (levers.py).",
+    "bottleneck_link": "Rank-1 children are about half of recursive cost; the selected word's effective child rank is about 3.9. Larger-rank delivery lowers recursive cost per unit of paid mass.",
+    "allowed_variations": [
+      "One masked, overcomplete or block decoder family with exact labels and supports.",
+      "A scoped lower bound on effective rank for one alphabet.",
+      "If the coverage law, template or guard changes, derive an applicable fully charged replacement bound instead of applying the incumbent ceiling outside its scope."
+    ],
+    "scope_change_triggers": [
+      "Repacking idle remainders of an unchanged word (covered by the packing ceiling).",
+      "Repeating the eight-term all-pairs search inside its proved scope."
+    ],
+    "overlap_terms": [
+      "rank shape",
+      "block climb",
+      "masked decoder",
+      "overcomplete",
+      "effective rank"
+    ]
+  },
+  "scope_status": "refined",
+  "actual_scope": "Audit of one implication in open PR1779 (1337isnot1337, head 1e3128bf): its 8-batch maximum counts only contiguous runs of rank-1 climbs in the selected gauge44 provider. Count disjoint 16-batches of rank-1 climbs on distinct destinations when a rank-1 climb may move, inside its phase, past events that do not touch its register; check the reordered programs with the retained independent local checker; price the counts with ceiling.ceiling() under PR1779's zero-charge, mass-preserving convention.",
+  "scope_change_reason": "PR1605/discussion 1596 already price rank-shape budgets; PR1779 presents the source chronology as bounding the diagonal-batch subfamily below the card's 5% gate. Whether that bound is a property of the provider or of the contiguity rule decides whether this route is closed.",
+  "bottleneck_link": "Rank-1 children are about half of the complex recursive cost; this decides whether the selected provider's chronology itself blocks rank-16 batching (it does not: 134 legal batches, +39.5% zero-charge ceiling), moving the question to the waived gathering/restoration charge.",
+  "budget_minutes": 60,
+  "stop_rule": "Stop at a certified legal batch count with checker replay and exact ceilings; do not construct a physical diagonal rank-16 child or price its gathering.",
+  "outcome": "completed",
+  "evidence": "verify.py: archive and member pins; batch.py reorder (non-rank-1 event order unchanged, same multiset) gives 134 batches per orientation, per-phase cap 149; retained hpe_audit_local.py accepts the reordered programs with a receipt equal to the original's (and the original's equals the pinned selected receipt); two mutation controls rejected; PR1779's contiguous rule re-implemented counts 8 -> 134; exact ceilings: 22 batches miss the +5% gate, 23 pass, 134 give a_hi 0.002358018698467.",
+  "author": "Claude Code (Claude Opus 5.5) for JosieElliston",
+  "ai_assistance": "Claude Code (Claude Opus 5.5) wrote the code and text in one donated session; no independent human or Codex review.",
+  "open_questions": [
+    {
+      "question": "What per-batch gathering/restoration charge can 134 diagonal rank-16 batches afford while still passing the +5% gate (and other targets)?",
+      "why_it_matters": "With the chronology no longer binding, the waived charge is what decides the diagonal-batch route.",
+      "first_step": "Specify the contract for 16 registers at different frames a_i -> b_i and price it against the sharp idle-displacing headroom (1,258 extra rank-1 children per call at 134 batches, verify.py).",
+      "blocked_by": "The physical contract of a diagonal rank-16 child over registers at different frames is not specified (inherited unexamined from PR1779)."
+    },
+    {
+      "question": "Charge headroom under PR1605's on-top convention (overhead added on top of the idle bill).",
+      "why_it_matters": "The idle-displacing headroom is an accounting upper bracket; the on-top one is the conservative bracket.",
+      "first_step": "Add the overhead moment term outside ceiling()'s local-profile interface and bisect.",
+      "blocked_by": "ceiling() only takes a local profile; needs a small extension."
+    },
+    {
+      "question": "What is the exact maximum batch count in phase B (greedy 52, cap 67)?",
+      "why_it_matters": "It bounds this route's zero-charge ceiling between +39.5% and +46.0%; small next to the charge question.",
+      "first_step": "Interval-stabbing integer program per phase (windows are already computed by batch.py).",
+      "blocked_by": "Nothing; low priority."
+    }
+  ]
+}

research/diagonal-batch-commutation/VERIFY.json

@@ -0,0 +1,23 @@
+{
+  "schema_version": 1,
+  "status": "ready",
+  "python": "3.12",
+  "requirements": [],
+  "inputs": [
+    "research/community-frontier1094-audit/selected-replay.tar.gz",
+    "research/complex-571-cold14-k492b/code/hpe_audit_local.py",
+    "research/complex-local-word-ceiling/ceiling.py"
+  ],
+  "commands": [
+    {
+      "argv": [
+        "{python}",
+        "-I",
+        "-B",
+        "{package}/verify.py"
+      ],
+      "timeout_seconds": 120,
+      "checks": "Source pins; 134 legal batches per orientation (cap 149); retained local checker accepts reordered programs with an identical receipt; two mutation controls rejected; PR1779 rule 8 -> 134; exact ceilings at 8/22/23/134/149 batches; RESULT.json receipt."
+    }
+  ]
+}