Research: Heisenberg central-pair call floor (no new kappa)

research/heisenberg-central-pair-seed0154/EXPECTED.json

@@ -0,0 +1,139 @@
+{
+  "schema_version": 1,
+  "group": "UT3(F3)",
+  "group_order": 27,
+  "coefficient_field": "F2",
+  "registers": 2,
+  "paid_labels": [
+    "x",
+    "x^-1",
+    "y",
+    "y^-1"
+  ],
+  "rank_one_idempotents": 6,
+  "target": "diag([z],[z]) where z=[x,y]",
+  "direct_witness": [
+    "x",
+    "y",
+    "x^-1",
+    "y^-1",
+    "x",
+    "y",
+    "x^-1",
+    "y^-1"
+  ],
+  "direct_calls": 8,
+  "max_excluded_length": 7,
+  "minimum": 8,
+  "layers": [
+    {
+      "depth": 0,
+      "raw_words": 1,
+      "unique_states": 1,
+      "sha256_sorted_states": "288b1793833bb59673891be54d485696d3f7d8ff9a9168758ef9d00b1bca8985"
+    },
+    {
+      "depth": 1,
+      "raw_words": 24,
+      "unique_states": 24,
+      "sha256_sorted_states": "1ff8bf8693e35e212e976ec03752819f62a1533dfe648a7e0f232e15ddd6c26d"
+    },
+    {
+      "depth": 2,
+      "raw_words": 576,
+      "unique_states": 413,
+      "sha256_sorted_states": "5d0f334f0ed44b3c126df7b80c426dbfe5f5003624e80044bdb00939393f481a"
+    },
+    {
+      "depth": 3,
+      "raw_words": 13824,
+      "unique_states": 5927,
+      "sha256_sorted_states": "ab25c7dee773421bf8747865d325c920dc379e6e7e58389e9e9c39b5a290c52b"
+    },
+    {
+      "depth": 4,
+      "raw_words": 331776,
+      "unique_states": 82063,
+      "sha256_sorted_states": "508a4fe9671ee72e2c3ddd45296736d1f510e69cfb3b9df3b6f82657440cc8df"
+    }
+  ],
+  "length_splits": [
+    {
+      "length": 0,
+      "left_depth": 0,
+      "right_depth": 0,
+      "left_states": 1,
+      "right_states": 1,
+      "prefixes_checked": 1,
+      "target_found": false
+    },
+    {
+      "length": 1,
+      "left_depth": 0,
+      "right_depth": 1,
+      "left_states": 1,
+      "right_states": 24,
+      "prefixes_checked": 1,
+      "target_found": false
+    },
+    {
+      "length": 2,
+      "left_depth": 1,
+      "right_depth": 1,
+      "left_states": 24,
+      "right_states": 24,
+      "prefixes_checked": 24,
+      "target_found": false
+    },
+    {
+      "length": 3,
+      "left_depth": 1,
+      "right_depth": 2,
+      "left_states": 24,
+      "right_states": 413,
+      "prefixes_checked": 24,
+      "target_found": false
+    },
+    {
+      "length": 4,
+      "left_depth": 2,
+      "right_depth": 2,
+      "left_states": 413,
+      "right_states": 413,
+      "prefixes_checked": 413,
+      "target_found": false
+    },
+    {
+      "length": 5,
+      "left_depth": 2,
+      "right_depth": 3,
+      "left_states": 413,
+      "right_states": 5927,
+      "prefixes_checked": 413,
+      "target_found": false
+    },
+    {
+      "length": 6,
+      "left_depth": 3,
+      "right_depth": 3,
+      "left_states": 5927,
+      "right_states": 5927,
+      "prefixes_checked": 5927,
+      "target_found": false
+    },
+    {
+      "length": 7,
+      "left_depth": 3,
+      "right_depth": 4,
+      "left_states": 5927,
+      "right_states": 82063,
+      "prefixes_checked": 5927,
+      "target_found": false
+    }
+  ],
+  "controls": {
+    "construction_mutations": 2,
+    "group_and_algebra_checks": 4,
+    "matrix_update_crosschecks": 144
+  }
+}

research/heisenberg-central-pair-seed0154/README.md

@@ -0,0 +1,84 @@
+# The order-27 central pair costs its direct bill
+
+**Scoped exact register-model result; no new κ.** In the nonabelian group algebra `F2[UT3(F3)]`, two dirty scalar registers cannot jointly apply the central commutator with fewer calls than applying it to each register separately. The exact minimum is eight calls in the stated alphabet.
+
+## Model and target
+
+Represent `UT3(F3)` by triples `(a,b,c)` with multiplication
+
+```text
+(a,b,c)(a',b',c') = (a+a', b+b', c+c'+a*b')    in F3.
+```
+
+Let `x=(1,0,0)`, `y=(0,1,0)`, and `z=[x,y]=xyx^-1y^-1=(0,0,1)`. The group has order 27; `x`, `y`, and `z` have order three, and `z` is central. Work in the exact formal group algebra `F2[UT3(F3)]`.
+
+For two scalar registers, a paid call is
+
+```text
+D_N(g) = I + ([g] + [e]) N,
+```
+
+where `g` is one of the four paid labels `x`, `x^-1`, `y`, `y^-1`, and `N=u v^T` is a binary rank-one idempotent (`v^T u=1`). There are six such `N`, hence 24 complete paid operations. The endpoint is
+
+```text
+diag([z], [z])
+```
+
+as a formal group-algebra matrix, so it is correct for arbitrary dirty register inputs. No extra register, free address operation, copy, clean allocation, or precision change is allowed. A call costs one unit.
+
+A direct schedule applies `x y x^-1 y^-1` to the first register and then to the second: eight calls. Four letters are necessary for one copy of `z`: in the abelianization `C3 × C3`, a word for `z` has zero x and y exponents modulo three; every shorter such word either is the identity or has nonzero abelianization. The displayed commutator attains four.
+
+Free scalar `GL2(F2)` changes of register basis do not enlarge the search. Since scalar matrices commute with the group algebra, they can be pushed through each factor, conjugating `N` to another rank-one idempotent. All six idempotents are enumerated. Any net scalar at the endpoint must be identity after augmentation, because every paid factor augments to `I` and the target augments to `I`.
+
+## Exact lower bound by complete state splitting
+
+Each factor is invertible:
+
+```text
+D_N(g) = (I-N) + [g]N
+D_N(g)^-1 = (I-N) + [g^-1]N.
+```
+
+The verifier builds the exact set of 2×2 group-algebra product matrices for every word length through four. Equal matrices at the same length are merged; this preserves all possible continuations because future multiplication depends only on the current matrix. For each total length `n=0,...,7`, split a word into prefix `P` and suffix `S`, with lengths `floor(n/2)` and `ceil(n/2)`. The endpoint equation `P S=T` is equivalent to `S=P^-1 T`. The verifier checks every prefix state against the complete suffix-state set at that length. No match occurs at any length through seven.
+
+`EXPECTED.json` retains the exact state counts and SHA-256 digests of the sorted states in each layer, plus every split's prefix/suffix coverage and result. The verifier regenerates these receipts and compares them exactly. The direct eight-call word gives the matching upper bound, so the minimum is exactly eight in this group, alphabet, register count and endpoint.
+
+| Word length | Raw words | Distinct exact product states | Sorted-state SHA-256 |
+|---:|---:|---:|---|
+| 0 | 1 | 1 | `288b1793833bb59673891be54d485696d3f7d8ff9a9168758ef9d00b1bca8985` |
+| 1 | 24 | 24 | `1ff8bf8693e35e212e976ec03752819f62a1533dfe648a7e0f232e15ddd6c26d` |
+| 2 | 576 | 413 | `5d0f334f0ed44b3c126df7b80c426dbfe5f5003624e80044bdb00939393f481a` |
+| 3 | 13,824 | 5,927 | `ab25c7dee773421bf8747865d325c920dc379e6e7e58389e9e9c39b5a290c52b` |
+| 4 | 331,776 | 82,063 | `508a4fe9671ee72e2c3ddd45296736d1f510e69cfb3b9df3b6f82657440cc8df` |
+
+The split sizes for lengths 0 through 7 are respectively `1×1`, `1×24`, `24×24`, `24×413`, `413×413`, `413×5,927`, `5,927×5,927`, and `5,927×82,063`. Every target lookup is negative. The full receipt, including exact per-length lookups, is in [EXPECTED.json](EXPECTED.json).
+
+## Reproduce
+
+From the repository root, with Python 3.10+ and no dependencies:
+
+```sh
+python3 -B research/heisenberg-central-pair-seed0154/verify.py
+python3 -I -O -B research/heisenberg-central-pair-seed0154/verify.py
+python3 scripts/research_package.py --package research/heisenberg-central-pair-seed0154 --check-only
+```
+
+Expected verifier line:
+
+```text
+PASS_HEISENBERG_CENTRAL_PAIR minimum=8 excluded_lengths=0..7 group_order=27 characteristic=2 registers=2 generators=4 idempotents=6 controls=6 matrix_crosschecks=144 state_counts=[(0, 1), (1, 24), (2, 413), (3, 5927), (4, 82063)]
+```
+
+The controls include the group presentation and noncommuting order, the inverse of every paid factor, an eight-call two-target positive word, a four-call one-target positive word, recovery of that one-target word by the split search, and rejection of its omitted-letter mutation. A separate 144-case check compares the optimized update with literal matrix multiplication. Equality is checked coefficient by coefficient in all 27 group coordinates.
+
+## Result boundary and overlap
+
+This answers only whether two registers can share a central-commutator implementation in this exact order-27 alphabet. It does not establish a general lower bound for nonabelian groups or another register count. The group algebra is an optimistic formal address model; no physical compiler, hosting, recursive supplier or analytic transfer is supplied. The result makes no κ or integer-multiplication claim. The selected construction remains unchanged and its complex supplier still binds.
+
+The closest predecessor is [PR #1822](https://github.com/CrocSwap/integer-mult-bounds/pull/1822), which treats central/noncommuting pairs in Q8. Here the group has odd order 27 over coefficient field F2, the central target has order three, and its shortest generator word has length four. Other nearby work includes [PR #1716](https://github.com/CrocSwap/integer-mult-bounds/pull/1716) on the order-six coordinate-CNOT alphabet and active claims on D8, UT4 and four-register affine/rational targets. The final 15:22 UTC overlap refresh completely paginated 535 open PRs and 594 discussions without warnings; it found no Heisenberg-group scope. Exact base and source pins are in [SOURCES.json](SOURCES.json). The superseded Q16 screen and its corrected direct baseline are recorded in the released claim at [Discussion #1167](https://github.com/CrocSwap/integer-mult-bounds/discussions/1167#discussioncomment-18926868).
+
+Prepared by Cinna Davis with substantial OpenAI Codex assistance. No predecessor implementation is copied. New work is Apache-2.0.
+
+## Open next questions
+
+[TASK.json](TASK.json) records one follow-up: test whether another odd-order class-two group has a central target whose direct generator word leaves room for register sharing. The first step is to specify the group and compute the exact direct word metric before building any register search. This is blocked until a group/target outside the active Q8, D8 and UT4 work has both a sufficiently long direct target word and a plausible shorter commutator schedule.

research/heisenberg-central-pair-seed0154/SOURCES.json

@@ -0,0 +1,42 @@
+{
+  "schema_version": 1,
+  "base_commit": "0b1cccf86e2f5132ed286a26ef0a681a495740ea",
+  "files": [
+    {
+      "path": "certificates/selected-result.json",
+      "usage": "input",
+      "git_blob": "ae6a99f28aa468649eb66a361e764d769363bf11",
+      "sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32"
+    },
+    {
+      "path": "docs/research/agent-task-catalog.json",
+      "usage": "provenance",
+      "git_blob": "06c96f5579bb67ed1b86d334e78fbed7da6945f1",
+      "sha256": "6686ad58f1fbdbc87134a78901b60fd53a20d3984355e91defbbebc9e9fa8075"
+    },
+    {
+      "path": "research/binary-affine-register-bound/README.md",
+      "usage": "input",
+      "git_blob": "7b68583becf8be6f3cf666b05b0943e7eb99270c",
+      "sha256": "7951868efdf35fdb2aacdd302ca825cbde0586a5fae6df23aee78e29f30c332a"
+    },
+    {
+      "path": "research/bit-dihedral-commutator/README.md",
+      "usage": "input",
+      "git_blob": "b7619a5d56f32daf7f48d6cc3a0e260c5a333510",
+      "sha256": "4f3f9df6d6d96a26ccb0fcd2ef947cce5d53b0d992da22e866f1e025be4c0492"
+    },
+    {
+      "path": "research/bit-three-register-lower-bound/README.md",
+      "usage": "input",
+      "git_blob": "25e41c370c101a33a6deb978de08b03ed7539b79",
+      "sha256": "c12b33ef388deece0cbf891505a2ce2c0779a0c3a6cf1f0f7f7039bab59cbebd"
+    },
+    {
+      "path": "research/coordinate-cnot-register-bound/README.md",
+      "usage": "input",
+      "git_blob": "cdcc5a9e7f11ab3dbf7745a175ddcca208c68211",
+      "sha256": "e1666512fb71cf34c427c69ffb61a18b61e897a7f8f91f87820edf744e85a9fe"
+    }
+  ]
+}

research/heisenberg-central-pair-seed0154/TASK.json

@@ -0,0 +1,71 @@
+{
+  "schema_version": 1,
+  "task_id": "bit-new-register-model",
+  "priority_revision": 3,
+  "base_commit": "0b1cccf86e2f5132ed286a26ef0a681a495740ea",
+  "original_card": {
+    "id": "bit-new-register-model",
+    "question": "Can an explicitly larger or nonabelian register model escape the scoped three-register obstruction?",
+    "starting_points": [
+      "research/bit-three-register-lower-bound/README.md",
+      "certificates/selected-result.json"
+    ],
+    "methods": [
+      "Construct the smallest exact identity in a newly specified legal operation alphabet.",
+      "Derive a target-specific relaxation bound for that same explicit alphabet."
+    ],
+    "acceptance_gate": "Name the changed hypothesis, all counted roles and a uniform identity; finite column tests alone do not certify it.",
+    "first_step": {
+      "command": [
+        "python3",
+        "-B",
+        "scripts/research_baseline.py"
+      ],
+      "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY",
+      "inspect": "Read Model section 1 of the three-register bound and identify the exact excluded free operations.",
+      "scope": "Positive control / source-bound orientation only; this is not a new construction or full cold replay."
+    },
+    "first_experiment": "Write a complete operation alphabet outside one named premise and price a baseline before searching identities.",
+    "bottleneck_link": "A small-width completed saving changes the bit primitive; a finite-address identity alone is insufficient.",
+    "allowed_variations": [
+      "Choose a fixed larger register count or a specified nonabelian operation family."
+    ],
+    "scope_change_triggers": [
+      "Remaining inside the already-excluded three-register abelian model."
+    ],
+    "overlap_terms": [
+      "three-register",
+      "nonabelian",
+      "group algebra"
+    ]
+  },
+  "scope_status": "refined",
+  "actual_scope": "For two dirty registers and the 24 paid rank-one shears over F2[UT3(F3)] generated by x, x^-1, y, y^-1, is the exact minimum call count for diag([z],[z]) equal to the eight-call direct schedule, where z=[x,y]?",
+  "scope_change_reason": "The selector card allows one specified nonabelian address group. The first candidate Q16 was released after direct pricing showed x^4=y^2, so two targets cost four calls. This refinement uses the order-27 exponent-three Heisenberg group, where its central commutator has shortest generator word length four and the two-target direct bill is eight.",
+  "bottleneck_link": "A shorter exact nonabelian register word could lower a bit primitive call count. The exact eight-call lower bound rules out this particular cross-register mechanism in a changed address group; it does not alter the selected supplier or kappa.",
+  "budget_minutes": 60,
+  "stop_rule": "Exhaust exact product states at every word length 0 through 7 over all 24 operations (six rank-one idempotents times four generator labels). Compare against the explicit eight-call word and stop there. Do not vary group, register count, target, or operation prices in this cycle.",
+  "outcome": "negative-result",
+  "evidence": "python3 -B research/heisenberg-central-pair-seed0154/verify.py passes. It constructs exact F2[UT3(F3)] product-state layers, proves no endpoint match for lengths 0..7 by complete meet-in-the-middle, and verifies the direct length-8 witness. Layer state counts are 1, 24, 413, 5927, 82063 with pinned SHA-256 receipts; six controls and 144 optimized-versus-literal matrix checks pass.",
+  "author": "Cinna Davis",
+  "ai_assistance": "OpenAI Codex provided substantial assistance with the scope screening, exact model, exhaustive state search, proof explanation, and verifier/package preparation.",
+  "open_questions": [
+    {
+      "question": "Can an odd-order class-two address group outside Q8/D8 admit a central target whose two-register shared word is shorter than its direct per-register words?",
+      "why_it_matters": "This package shows no sharing gain for the smallest exponent-three Heisenberg target; a different group may have a longer direct commutator word and leave room for a real call reduction.",
+      "first_step": "Specify one finite group and generator alphabet, then prove the target word metric and direct multi-register bill before searching rank-one register words.",
+      "blocked_by": "The next candidate must avoid the current Q8, D8, UT4 and affine-register overlaps and must have an explicit physical or supplier-level relevance."
+    }
+  ],
+  "assignment": {
+    "seed": "015429fd754bd0937d8449b9ae413a6b",
+    "track": "bit-mechanisms",
+    "task_id": "bit-new-register-model",
+    "priority_revision": 3,
+    "catalogue_sha256": "6686ad58f1fbdbc87134a78901b60fd53a20d3984355e91defbbebc9e9fa8075",
+    "base_commit": "0b1cccf86e2f5132ed286a26ef0a681a495740ea",
+    "selected_record_sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32",
+    "selected_kappa": "836330098538459/500000000000000000",
+    "discussion_claim": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1167#discussioncomment-18926907"
+  }
+}

research/heisenberg-central-pair-seed0154/VERIFY.json

@@ -0,0 +1,24 @@
+{
+  "schema_version": 1,
+  "status": "ready",
+  "python": "3.12",
+  "requirements": [],
+  "inputs": [
+    "certificates/selected-result.json",
+    "research/bit-three-register-lower-bound/README.md",
+    "research/bit-dihedral-commutator/README.md",
+    "research/binary-affine-register-bound/README.md",
+    "research/coordinate-cnot-register-bound/README.md"
+  ],
+  "commands": [
+    {
+      "argv": [
+        "{python}",
+        "-B",
+        "{package}/verify.py"
+      ],
+      "timeout_seconds": 120,
+      "checks": "Exact UT3(F3) group multiplication; complete F2 group-algebra product layers; meet-in-the-middle exclusion for all 0..7-call words; direct 8-call witness; one-target positive and mutation controls; exact receipt comparison; 144 optimized matrix-update crosschecks."
+    }
+  ]
+}