Research: exact D16 two-register central-pair cost (no new kappa)

research/bit-d16-central-pair-seed1f8b/CERTIFICATE.json

@@ -0,0 +1,67 @@
+{
+  "group": "D16=<r,s | r^8=s^2=1, srs=r^-1>",
+  "encoding": "element 2*i+e represents r^i s^e",
+  "labels": {
+    "x": 1,
+    "y": 3,
+    "z": 8
+  },
+  "registers": 2,
+  "projector_count": 6,
+  "paid_generator_count": 12,
+  "identity_depth": 7,
+  "target_depth": 8,
+  "state_cap_per_ball": 4000000,
+  "direct_paid_calls": 16,
+  "direct_word": [
+    0,
+    6,
+    0,
+    6,
+    0,
+    6,
+    0,
+    6,
+    2,
+    8,
+    2,
+    8,
+    2,
+    8,
+    2,
+    8
+  ],
+  "direct_exact": true,
+  "status": "EXACT_MINIMUM_16",
+  "identity_layers": [
+    1,
+    12,
+    80,
+    472,
+    2465,
+    12476,
+    61828,
+    300168
+  ],
+  "identity_discovery_sha256": "627b96d39fe7f2df6c65a9c869ed0e56265509fb32578467e7985a08dcf69c8d",
+  "target_layers": [
+    1,
+    12,
+    80,
+    472,
+    2465,
+    12476,
+    61828,
+    300168,
+    1442306
+  ],
+  "target_discovery_sha256": "5aa38a6d28f75bfcfc768b7401d60e5e2935c2cfd48c9ac49c096381d20ce09f",
+  "common_states": 0,
+  "meeting_length_histogram": {},
+  "depths_cover_all_words_at_most_15": true,
+  "no_word_at_most_15": true,
+  "lower_bound": 16,
+  "exact_full_group_algebra": true,
+  "scalar_mixing": "all six rank-one idempotents; GL2(F2) conjugation is transitive on them",
+  "supplier_mapping": "not established; no kappa claim"
+}

research/bit-d16-central-pair-seed1f8b/OVERLAP.json

@@ -0,0 +1,34 @@
+{
+  "searched_at": "2026-10-14T10:51:15Z",
+  "status": "POSSIBLE_OVERLAP_NOT_A_NOVELTY_CERTIFICATE",
+  "refresh": true,
+  "coverage": {
+    "open_prs": {"complete_pagination": true, "records": 481},
+    "discussions": {"complete_pagination": true, "records": 456}
+  },
+  "warnings": [],
+  "relevant_results": [
+    {
+      "number": 1738,
+      "kind": "discussion",
+      "url": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1738",
+      "scope": "third dirty register for the D8 central commutator",
+      "relationship": "Nearest thematic overlap; keeps D8 and changes register count, while this package keeps two registers and changes to the order-16 dihedral group and r^4 endpoint."
+    },
+    {
+      "number": 1759,
+      "kind": "discussion",
+      "url": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1759",
+      "scope": "UT4 noncentral root pair through four calls",
+      "relationship": "Different address group, endpoint, and bounded call question."
+    },
+    {
+      "number": 1818,
+      "kind": "discussion",
+      "url": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1818",
+      "scope": "this package's claim",
+      "relationship": "Own active claim."
+    }
+  ],
+  "limits": "The helper searches open PR titles and bodies, discussion bodies and comments, top-level package READMEs/TASK metadata, and the local ledger; it does not search every code diff. No overlap check proves novelty."
+}

research/bit-d16-central-pair-seed1f8b/PR-BODY.md

@@ -0,0 +1,26 @@
+## Scope and result
+
+**Scoped negative result; no new kappa.** In `F2[D16]`, with the order-16 dihedral presentation `r^8=s^2=1, srs=r^-1`, paid reflections `x=s` and `y=rs`, and target central involution `z=r^4=(xy)^4`, the exact minimum for `diag([z],[z])` on two arbitrary dirty scalar registers is 16 rank-one calls. Every one of the six rank-one idempotents in `M2(F2)` is allowed for each paid label.
+
+The direct word gives 16 calls. An exact meet-in-the-middle search finds no common state between identity radius 7 and target radius 8, excluding every word of length at most 15. The state spaces are the full coefficient matrices over `F2[D16]`, not a selected representation. The independent tuple-state verifier reproduces all layer counts and discovery-order hashes.
+
+This is a new bounded group/endpoint relative to the local two-register D8 result. Live claim #1738 changes the register count but retains D8; #1759 concerns a UT4 endpoint. Neither is treated as superseded or resolved here.
+
+## Reproduce
+
+```sh
+python3 -I -B research/bit-d16-central-pair-seed1f8b/verify.py
+python3 scripts/research_package.py --package research/bit-d16-central-pair-seed1f8b --check-only
+```
+
+The independent verifier and metadata/pin check passed locally under Python 3.14.7. The registered package runner requests Python 3.12, which is not installed in this environment.
+
+## Pins, costs, and limits
+
+- Base: `0b1cccf86e2f5132ed286a26ef0a681a495740ea`.
+- Selected record SHA-256: `10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32`.
+- Predecessor note: `research/bit-dihedral-commutator/README.md`, SHA-256 `4f3f9df6d6d96a26ccb0fcd2ef947cce5d53b0d992da22e866f1e025be4c0492`.
+- Direct paid bill: 16. For this optimistic formal model, helper, frame, copy, restoration, hosting, precision, and recursive-interface charges are zero.
+- No mapping to the selected supplier is supplied; this cannot imply a new multiplication exponent or `kappa`.
+
+Prepared by woklerx with substantial OpenAI Codex assistance. No independent human review is claimed. Apache-2.0.

research/bit-d16-central-pair-seed1f8b/README.md

@@ -0,0 +1,66 @@
+# The two-register D16 central pair requires 16 paid calls
+
+Review: [PR #1821](https://github.com/CrocSwap/integer-mult-bounds/pull/1821). Coordination handoff: [Discussion #1818](https://github.com/CrocSwap/integer-mult-bounds/discussions/1818).
+
+## Result and exact model
+
+Let
+
+```text
+D16 = <r,s | r^8 = s^2 = 1, srs = r^-1>,
+x = s, y = r s, z = r^4 = (xy)^4.
+```
+
+On two arbitrary dirty scalar registers, a paid call is
+
+```text
+I + ([g] + 1) N,   g in {x,y},   N = u v^T in M2(F2),   v^T u = 1.
+```
+
+All six rank-one idempotents are allowed. A free scalar change can be pushed through a paid factor by conjugating its projector, and conjugation permutes this complete six-projector set. The net free scalar map must be the identity because the target's augmentation is the identity. The desired formal boundary is `diag([z],[z])` in the full group algebra `F2[D16]`.
+
+**The exact minimum is 16 paid calls.** Applying `x,y` four times to each register gives the 16-call upper bound. Exact meet in the middle finds no common state between the identity ball through radius 7 and the target ball through radius 8. The complete layer counts are:
+
+| Radius | Identity ball | Target ball |
+|---:|---:|---:|
+| 0 | 1 | 1 |
+| 1 | 12 | 12 |
+| 2 | 80 | 80 |
+| 3 | 472 | 472 |
+| 4 | 2,465 | 2,465 |
+| 5 | 12,476 | 12,476 |
+| 6 | 61,828 | 61,828 |
+| 7 | 300,168 | 300,168 |
+| 8 | — | 1,442,306 |
+
+Each generator is an involution: with `q=[g]+1`, `q^2=0` over `F2` because `g^2=1`; and `N^2=N`, so `(I+qN)^2=I`. Any word of length at most 15 can be split into a prefix of length at most 7 and a suffix of length at most 8. Reversing the suffix from the target would put a state in both complete balls, which do not intersect. Thus no word of at most 15 calls realizes the target, and the direct 16-call word is minimal.
+
+This is a scoped exact word metric result for one nonabelian address group and two registers. It changes the group and target relation from the local D8 two-register result. The live D8 third-register claim #1738 retains D8 and changes the register count; the UT4 root-pair claim #1759 uses another group and endpoint. This package does not resolve either claim.
+
+## Cost and limits
+
+The direct cost is 16 paid calls. For this favorable formal model, helper, frame, copy, restoration, hosting, precision, and recursive-interface expenses are all zero; the search tests whether any paid-call saving exists before those expenses. No implementation mapping this nonabelian address group to the selected integer-multiplication supplier is established. There is no new supplier profile or `kappa` claim, and no conclusion for other groups or register counts.
+
+The exact discovery-order hashes are:
+
+```text
+identity radius 7: 627b96d39fe7f2df6c65a9c869ed0e56265509fb32578467e7985a08dcf69c8d
+target radius 8:   5aa38a6d28f75bfcfc768b7401d60e5e2935c2cfd48c9ac49c096381d20ce09f
+```
+
+The full certificate and source pins are in this directory. Reproduce the independent tuple-state replay with:
+
+```sh
+python3 -I -B research/bit-d16-central-pair-seed1f8b/verify.py
+python3 scripts/research_package.py --package research/bit-d16-central-pair-seed1f8b --check-only
+```
+
+Expected status: `PASS_D16_TWO_REGISTER_MINIMUM`. The independent verifier passed locally under Python 3.14.7. The registered package runner is configured for Python 3.12, which is not installed in this environment; that replay remains unrun here.
+
+## Open next questions
+
+Does the two-register central-involution floor scale with the central word depth in the next generalized dihedral group, `D32`? This could show whether the D16 minimum reflects a reusable structural rule or a single finite case. A feasible first step is to pin the `D32` group and paid labels, derive its 32-call direct target, and search for a one-call saving with an explicit state cap. The larger group algebra may exhaust the exact search budget, and a supplier mapping remains an independent blocker.
+
+## Credit
+
+The exact two-register D8 comparison is preserved in `research/bit-dihedral-commutator/`; its scalar-idempotent normalization follows the retained three-register result and the PR288 lineage. This D16 group table, endpoint, state census, and tuple-state replay are specific to the present package. Prepared by woklerx with substantial OpenAI Codex assistance; no independent human review is claimed. Apache-2.0.

research/bit-d16-central-pair-seed1f8b/SOURCES.json

@@ -0,0 +1,24 @@
+{
+  "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/bit-dihedral-commutator/README.md",
+      "usage": "input",
+      "git_blob": "b7619a5d56f32daf7f48d6cc3a0e260c5a333510",
+      "sha256": "4f3f9df6d6d96a26ccb0fcd2ef947cce5d53b0d992da22e866f1e025be4c0492"
+    }
+  ]
+}

research/bit-d16-central-pair-seed1f8b/TASK.json

@@ -0,0 +1,86 @@
+{
+  "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": "changed",
+  "actual_scope": "Exact formal F2[D16] word synthesis on two arbitrary dirty scalar registers. G=<r,s | r^8=s^2=1, srs=r^-1>; paid labels x=s and y=rs; target diag([r^4],[r^4]); every rank-one idempotent N in M2(F2) is allowed.",
+  "scope_change_reason": "Change the address group and central-target relation depth from the local two-register D8 result: the target central involution r^4 has shortest paid label word length 8 per target. Keep two registers. The live D8 third-register claim #1738 changes register count while retaining D8; this result fixes two registers and changes the group relation and target.",
+  "bottleneck_link": "This is a deliberately optimistic scalar-call mechanism screen in a nonabelian address model; any saving would still require an actual supplier mapping. The exact minimum shows no saving in this bounded D16 mechanism.",
+  "budget_minutes": 60,
+  "stop_rule": "Complete identity radius 7 and target radius 8 or stop at 4,000,000 states per ball. Report only complete layers if capped. A candidate is useful only if its exact paid call count is at most 15.",
+  "outcome": "negative-result",
+  "evidence": "CERTIFICATE.json; independently implemented tuple-state group-algebra replay in verify.py; all 16 direct-call omissions and label/endpoint mutations rejected.",
+  "author": "woklerx",
+  "ai_assistance": "Substantial OpenAI Codex assistance in derivation, implementation, verification, and writing; no independent human review claimed.",
+  "open_questions": [
+    {
+      "question": "For the next generalized dihedral group with rotation order 16, can the two-register central-involution target be implemented below its direct 32-call bill?",
+      "why_it_matters": "This would distinguish a one-off D16 floor from a structural relation between central-word depth and paid rank-one calls.",
+      "first_step": "Define D32=<r,s | r^16=s^2=1, srs=r^-1>, use x=s,y=rs and target diag([r^8],[r^8]); derive its exact direct word, then start a capped full-group-algebra meet-in-the-middle at the depths needed to test a one-call saving.",
+      "blocked_by": "The group algebra doubles in dimension, exact state growth may hit the cap, and no mapping to the selected integer-multiplication supplier is known."
+    }
+  ],
+  "seed": "1f8b0e71668765ab2db464db5f28907f",
+  "track": "bit-mechanisms",
+  "catalog_sha256": "6686ad58f1fbdbc87134a78901b60fd53a20d3984355e91defbbebc9e9fa8075",
+  "selected_record_sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32",
+  "scope_key": "7f5f4426ef796683c485/D16-two-register-central-involution-r4/paid-reflections-only/length-at-most-15",
+  "discussion_claim": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1818",
+  "claim_expires_utc": "2026-10-14T12:45:00Z",
+  "predecessors": [
+    "research/bit-dihedral-commutator/README.md",
+    "https://github.com/CrocSwap/integer-mult-bounds/discussions/1738",
+    "https://github.com/CrocSwap/integer-mult-bounds/discussions/1759"
+  ],
+  "optimistic_cost": {
+    "direct_paid_calls": 16,
+    "candidate_threshold": 15,
+    "helper_calls": 0,
+    "frame_changes": 0,
+    "copies": 0,
+    "restoration_calls": 0,
+    "hosting_precision_recursive_interface": 0,
+    "supplier_mapping": "not established; no kappa claim"
+  },
+  "overlap_snapshot": "research/bit-d16-central-pair-seed1f8b/OVERLAP.json",
+  "final_overlap_refreshed_at": "2026-10-14T10:51:15Z",
+  "pull_request": "https://github.com/CrocSwap/integer-mult-bounds/pull/1821",
+  "discussion_handoff": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1818#discussioncomment-18922194"
+}

research/bit-d16-central-pair-seed1f8b/VERIFY.json

@@ -0,0 +1,21 @@
+{
+  "schema_version": 1,
+  "status": "ready",
+  "python": "3.12",
+  "requirements": [],
+  "inputs": [
+    "research/bit-dihedral-commutator/README.md"
+  ],
+  "commands": [
+    {
+      "argv": [
+        "{python}",
+        "-I",
+        "-B",
+        "{package}/verify.py"
+      ],
+      "timeout_seconds": 180,
+      "checks": "Source pins; D16 group axioms; complete 12-generator two-register alphabet; exact direct word; 16 omission, paid-label and endpoint mutation controls; independent tuple-state replay of both complete balls and their hashes."
+    }
+  ]
+}