Classify #4598's 24 five-request decompositions: 2 stars + 10 char-2 mixed + 12 Hamiltonian-cycle pentagons (#4598 OQ1; no new κ)

research/five-request-decomposition-structure/README.md

@@ -0,0 +1,53 @@
+# Structure of the 24 five-request threshold decompositions
+
+**Task:** independent-moment (an answer to #4598's open question 1). **Base:** canonical main `f626db5c`. **No κ is claimed.**
+
+## Background
+
+petalas's #4598 counts 2,880 complete passing headers for five orthogonal binary requests in dimension six. They come from 24 unordered decompositions
+
+```text
+J − I₅ = Σ 1_S 1_Tᵀ   (five rectangles, S ∩ T = ∅, over F₂),
+```
+
+each giving 5! ordered headers. Its open question 1 asks to explain the 24, starting with coordinate-permutation and transposition orbits. My #4605 recounted the total by a different method.
+
+## Classification
+
+Under S₅ × ⟨transpose⟩, the decompositions fall into exactly three orbits, 24 = 2 + 10 + 12. Here V = {0, …, 4}.
+
+| family | decompositions | description | headers |
+|---|---|---|---|
+| **stars** | 2 | {i} × (V∖i) for all i, and its transpose | 240 |
+| **mixed** | 10 | for a centre c: {c} × (V∖c), together with (V∖{c,y}) × {c,y} for the four y ≠ c; plus the transposes. One S₅-orbit of size 5 per orientation | 1,200 |
+| **pentagons** | 12 | the five edges {u,v} of an undirected Hamiltonian 5-cycle, each with T = the two cycle-neighbours of the edge outside it. One per undirected 5-cycle (4!/2 = 12), stabiliser D₅, closed under transposition | 1,440 |
+
+- **Pentagons and stars sum to J − I over the integers.** #4598's hand counterexample is a pentagon.
+- **The mixed family is genuinely characteristic 2.** Column c is covered 1 + 3 times, so its sum equals J − I only modulo 2.
+
+So the 22 non-star subsets that refute the 2·k! pattern consist of **12 integral pentagons**, one per Hamiltonian cycle of K₅, and **10 characteristic-2 mixed decompositions**, one per centre and orientation.
+
+The verifier enumerates the 24 decompositions independently, by its own rectangle search. It then checks:
+
+- the explicit families, and that they partition the 24;
+- that the orbits are exactly these families;
+- the integer-sum and mod-2 distinction;
+- that the hand counterexample is a pentagon.
+
+## Verify
+
+```text
+python3 -B research/five-request-decomposition-structure/verify.py
+```
+
+The check takes about 1 s and uses the standard library only.
+
+## Limitations
+
+- **k = 5 only.** No all-k formula is given, and the k ≥ 6 count is not computed.
+
+## Open next questions
+
+- **Larger k.** The classification suggests a candidate pattern. For general k, the decompositions should include stars, "centre" families mixed modulo 2, and cycle-type families indexed by structures on K_k. First step: enumerate the k = 6 decompositions of J − I₆. There are 3⁶ − 2·2⁶ + 1 = 602 rectangles, so a meet-in-the-middle search over 6-subsets is needed. Then test whether Hamiltonian-cycle-type and centre-type families account for them.
+
+Credit: petalas (Nick Petalas) for #4598, #4275 and the threshold framing. Prepared by Ryanson Jonathan with substantial Claude Code (Claude Opus 5.5) assistance.

research/five-request-decomposition-structure/SOURCES.json

@@ -0,0 +1,18 @@
+{
+  "schema_version": 1,
+  "base_commit": "f626db5c3a3d781d8f7695038776c621651f75e1",
+  "files": [
+    {
+      "path": "certificates/selected-result.json",
+      "usage": "provenance",
+      "git_blob": "ed33caef5c5827693e9572d252a66f99cbb73d40",
+      "sha256": "5732707cc1e460b090b53f2463162749ad860de878a18f7408938671d295a9d9"
+    },
+    {
+      "path": "docs/research/agent-task-catalog.json",
+      "usage": "provenance",
+      "git_blob": "64bfc5af6709ed9811171e0a2108f05e1219cb65",
+      "sha256": "352a6184713b8843d96fd2c2071eb7aeaa655906b7c51d45ad444912666c8a96"
+    }
+  ]
+}

research/five-request-decomposition-structure/TASK.json

@@ -0,0 +1,100 @@
+{
+  "schema_version": 1,
+  "task_id": "independent-moment",
+  "priority_revision": 7,
+  "base_commit": "f626db5c3a3d781d8f7695038776c621651f75e1",
+  "original_card": {
+    "id": "independent-moment",
+    "question": "Does a new paid-profile or mixture-ceiling claim have independent source-bound coverage of its actual changed ledger?",
+    "starting_points": [
+      "docs/research/research-family-status.md",
+      "certificates/selected-result.json",
+      "research/staged544-mixed-fourth-entry/README.md",
+      "research/staged-fourth-mixture-ceiling/README.md",
+      "research/r437-two-window-carrier/README.md"
+    ],
+    "methods": [
+      "Independently reconstruct one changed paid ledger or pooled dual with exact source and model binding.",
+      "Check a genuinely uncovered moment implication with a different enclosure method and semantic controls."
+    ],
+    "acceptance_gate": "Demonstrate independence, source binding, positive cases and semantic failure controls. Name the existing checks and the missing coverage. More digits or another equivalent evaluation of an unchanged root is not by itself new verification coverage.",
+    "first_step": {
+      "command": [
+        "python3",
+        "-B",
+        "scripts/research_baseline.py"
+      ],
+      "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY",
+      "inspect": "Choose one uncovered implication in #4088 literal mixed fill, #4091 pooled dual/model binding or #4067 changed frame/host bill. #4091 pins an earlier #4088 head: validate word, capacity and stock equivalence before applying that ceiling to the later fill.",
+      "scope": "Source-binding orientation only; no scientific replay, theorem acceptance or supplier admission. Budget any heavy replay separately."
+    },
+    "first_experiment": "Independently reconstruct one changed ledger or pooled certificate with a positive case and a semantic failure control. Compare exact sources and name what existing checks miss. Keep this separate from supplier-boundary-audit (ordinary/outer dispatch) and uniform-transfer-audit (all-size proof). Stop after the chosen implication; more digits of an unchanged root are not additional mechanism coverage.",
+    "bottleneck_link": "Independent pricing prevents unsupported frontier claims and can reveal genuine accounting slack.",
+    "allowed_variations": [
+      "Reconstruct either a source ledger or a numeric enclosure with a different method."
+    ],
+    "scope_change_triggers": [
+      "Importing the primary function and calling its output independent verification.",
+      "Calling an aggregate histogram or source archive an independently accepted physical supplier."
+    ],
+    "overlap_terms": [
+      "independent moment",
+      "rank histogram",
+      "exact enclosure",
+      "2979",
+      "rank7 joint endframes",
+      "paired extraction",
+      "joint lowering",
+      "4088",
+      "4091",
+      "4067",
+      "staged544-mixed-fourth-entry",
+      "staged-fourth-mixture-ceiling",
+      "r437-two-window-carrier"
+    ],
+    "existing_checks": [
+      {
+        "scope": "PR #4088: mixed local/owner/phase ledger and moment reported.",
+        "evidence": "research/staged544-mixed-fourth-entry/README.md",
+        "remaining": "Independent binding of changed construction to paid histogram, distinct from full admission.",
+        "status": "author-checked",
+        "source_commit": "72d7efc181edb21806a878f174847c96dd410ab0",
+        "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129"
+      },
+      {
+        "scope": "PR #4091: sharp pooled ceiling proposed for fixed THREE/FOUR words and inventory.",
+        "evidence": "research/staged-fourth-mixture-ceiling/README.md",
+        "remaining": "Validate dual, exhaustive pattern scope and exact source equivalence before applying to newer fills.",
+        "status": "author-checked",
+        "source_commit": "a29bdd8f56cd18b805917775cdec09ff935eddc4",
+        "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129"
+      },
+      {
+        "scope": "PR #4067: paid (2,2) to (1,3) exchange and fixed OQ4 host reported.",
+        "evidence": "research/r437-two-window-carrier/README.md",
+        "remaining": "Independent full cost delta; remaining caller/precision/stock obligations are separate.",
+        "status": "author-checked",
+        "source_commit": "a95f11c52e3ca1e4c5171b3c20d8f4b0815aee2e",
+        "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129"
+      }
+    ]
+  },
+  "scope_status": "unchanged",
+  "actual_scope": "Does a new paid-profile or mixture-ceiling claim have independent source-bound coverage of its actual changed ledger?",
+  "scope_change_reason": null,
+  "bottleneck_link": "Answers #4598 OQ1: structural explanation of the 24 five-request threshold decompositions.",
+  "budget_minutes": 30,
+  "stop_rule": "Stop at the k = 5 classification.",
+  "outcome": "completed",
+  "evidence": "Independent enumeration of 24 decompositions; orbits under S5 x transpose are 2 + 10 + 12 = stars, mixed (char-2, centre-indexed), pentagons (12 undirected Hamiltonian 5-cycles, stabiliser D5); stars/pentagons integral, mixed only mod 2; #4598 hand example is a pentagon.",
+  "author": "Ryanson Jonathan, with Claude Code (Claude Opus 5.5) assistance",
+  "ai_assistance": "Substantial Claude Code (Claude Opus 5.5) assistance; no independent human review.",
+  "open_questions": [
+    {
+      "question": "Does the star/centre/cycle pattern extend to k = 6?",
+      "why_it_matters": "Replacement for the refuted 2 k! pattern.",
+      "first_step": "Meet-in-the-middle enumeration of 6-rectangle decompositions of J - I_6.",
+      "blocked_by": "None."
+    }
+  ]
+}

research/five-request-decomposition-structure/VERIFY.json

@@ -0,0 +1,18 @@
+{
+  "schema_version": 1,
+  "status": "ready",
+  "python": "3.12",
+  "requirements": [],
+  "inputs": [],
+  "commands": [
+    {
+      "argv": [
+        "{python}",
+        "-B",
+        "{package}/verify.py"
+      ],
+      "timeout_seconds": 120,
+      "checks": "Enumerate 24 decompositions; explicit families partition them; orbit structure; integer vs mod-2 sums; hand counterexample membership."
+    }
+  ]
+}

research/five-request-decomposition-structure/verify.py

@@ -0,0 +1,109 @@
+#!/usr/bin/env python3
+"""Structure of the 24 five-rectangle decompositions of J - I_5 over F2 (#4598 open question 1).
+
+#4598 (petalas) counts 2,880 complete passing headers for five orthogonal binary requests in dimension six, via
+24 unordered decompositions J - I_5 = sum of five rectangles 1_S 1_T^T with S, T disjoint and nonempty, over F2
+(each giving 5! ordered headers). Its open question 1 asks to explain the 24, starting with coordinate-permutation and
+transposition orbits. This verifier enumerates the decompositions independently and proves the classification:
+
+  24 = 2 + 10 + 12 orbits under S5 x <transpose> (simultaneous coordinate permutation, (S,T) -> (T,S)):
+  * stars (2): {i} x (V - i) for all i (row star) and its transpose (column star);
+  * mixed (10): for a centre c, {c} x (V - c) together with (V - {c,y}) x {c,y} for the four y != c, and transposes;
+    S5-orbits of size 5 (one per centre). Column c is covered 1 + 3 times, so these sum to J - I only mod 2;
+  * pentagons (12): the five edges {u,v} of an undirected Hamiltonian 5-cycle, each with T = the two cycle
+    neighbours of the edge outside it; one per undirected 5-cycle (4!/2 = 12), stabiliser D5 of order 10, closed
+    under transposition. These sum to J - I over the integers (the #4598 hand counterexample is one of them).
+So the 22 non-star subsets are 10 characteristic-2 "mixed" ones and 12 integral pentagons.
+Ryanson Jonathan with Claude Code (Claude Opus 5.5) assistance. Apache-2.0.
+"""
+from collections import Counter
+from itertools import combinations, permutations
+import json
+import sys
+
+V = range(5)
+E = sum(1 << (5 * i + j) for i in V for j in V if i != j)
+
+
+def need(condition, message):
+    if not condition:
+        raise AssertionError(message)
+
+
+def rect(s, t):
+    return sum(1 << (5 * i + j) for i in V if s >> i & 1 for j in V if t >> j & 1)
+
+
+def mask(xs):
+    return sum(1 << x for x in xs)
+
+
+def decompositions():
+    rects = [(s, t) for s in range(1, 32) for t in range(1, 32) if s & t == 0]
+    need(len(rects) == 180, "180 nonzero disjoint-support rectangles")
+    m = [rect(s, t) for s, t in rects]
+    pairs = {}
+    for a, b in combinations(range(180), 2):
+        pairs.setdefault(m[a] ^ m[b], []).append((a, b))
+    sols = set()
+    for c, d, e in combinations(range(180), 3):
+        for a, b in pairs.get(E ^ m[c] ^ m[d] ^ m[e], ()):
+            if b < c:
+                sols.add(frozenset(rects[i] for i in (a, b, c, d, e)))
+    return sols
+
+
+def act(sol, p, transpose):
+    f = lambda x: mask(p[i] for i in V if x >> i & 1)
+    return frozenset((f(t), f(s)) if transpose else (f(s), f(t)) for s, t in sol)
+
+
+def integer_sum(sol):
+    return Counter((i, j) for s, t in sol for i in V if s >> i & 1 for j in V if t >> j & 1)
+
+
+def main():
+    sols = decompositions()
+    need(len(sols) == 24, "24 decompositions (#4598)")
+    full = mask(V)
+    stars = {frozenset((1 << i, full ^ (1 << i)) for i in V), frozenset((full ^ (1 << i), 1 << i) for i in V)}
+    mixed = set()
+    for c in V:
+        base = {(1 << c, full ^ (1 << c))} | {(full ^ mask((c, y)), mask((c, y))) for y in V if y != c}
+        mixed |= {frozenset(base), frozenset((t, s) for s, t in base)}
+    pentagons = set()
+    for order in permutations(V):
+        if order[0] != 0:
+            continue
+        nb = {order[k]: (order[k - 1], order[(k + 1) % 5]) for k in range(5)}
+        sol = set()
+        for k in range(5):
+            u, v = order[k], order[(k + 1) % 5]
+            outside = {x for x in nb[u] + nb[v] if x not in (u, v)}
+            sol.add((mask((u, v)), mask(outside)))
+        pentagons.add(frozenset(sol))
+    need(len(stars) == 2 and len(mixed) == 10 and len(pentagons) == 12, "family sizes 2 + 10 + 12")
+    need(stars | mixed | pentagons == sols and not (stars & mixed or stars & pentagons or mixed & pentagons),
+         "the three families partition the 24")
+    orbits, seen = [], set()
+    for s in sorted(sols, key=sorted):
+        if s not in seen:
+            orb = {act(s, p, tr) for p in permutations(V) for tr in (0, 1)}
+            seen |= orb
+            orbits.append(orb)
+    need(sorted(len(o) for o in orbits) == [2, 10, 12] and {frozenset(o) for o in orbits} ==
+         {frozenset(stars), frozenset(mixed), frozenset(pentagons)}, "orbits are exactly the three families")
+    ideal = Counter({(i, j): 1 for i in V for j in V if i != j})
+    need(all(integer_sum(s) == ideal for s in stars | pentagons), "stars and pentagons sum to J - I over Z")
+    need(all(integer_sum(s) != ideal for s in mixed), "mixed decompositions sum to J - I only mod 2")
+    hand = frozenset({(mask((0, 1)), mask((2, 3))), (mask((1, 2)), mask((0, 4))), (mask((0, 3)), mask((1, 4))),
+                      (mask((2, 4)), mask((1, 3))), (mask((3, 4)), mask((0, 2)))})
+    need(hand in pentagons, "#4598's hand counterexample is a pentagon")
+    print(json.dumps({"status": "PASS_FIVE_REQUEST_DECOMPOSITION_STRUCTURE", "decompositions": 24,
+                      "orbits_S5_x_transpose": {"stars": 2, "mixed_char2": 10, "pentagons": 12},
+                      "headers": {"stars": 240, "mixed": 1200, "pentagons": 1440, "total": 2880},
+                      "new_kappa_claimed": False}, indent=1))
+
+
+if __name__ == "__main__":
+    sys.exit(main())