Research: exact four-call floor for a D8 rotation/inverse pair

research/d8-rotation-pair-seedff568/CERTIFICATE.json

@@ -0,0 +1,55 @@
+{
+  "status": "PASS_D8_ROTATION_PAIR_EXACT_MINIMUM",
+  "group_presentation": "D8=<s,t | s^2=t^2=1,(st)^4=1>",
+  "target": "diag([st],[ts])",
+  "registers": 2,
+  "paid_labels": [
+    "s",
+    "t"
+  ],
+  "rank_one_idempotents_per_label": 6,
+  "direct_upper_bound": 4,
+  "exact_minimum": 4,
+  "excluded_lengths": [
+    {
+      "length": 0,
+      "factor_words_checked": 1,
+      "expected": 1,
+      "complete": true
+    },
+    {
+      "length": 1,
+      "factor_words_checked": 12,
+      "expected": 12,
+      "complete": true
+    },
+    {
+      "length": 2,
+      "factor_words_checked": 144,
+      "expected": 144,
+      "complete": true
+    },
+    {
+      "length": 3,
+      "factor_words_checked": 1728,
+      "expected": 1728,
+      "complete": true
+    }
+  ],
+  "factorizations_at_or_below_3": [],
+  "direct_word": [
+    "s:u01v01",
+    "t:u01v01",
+    "t:u10v10",
+    "s:u10v10"
+  ],
+  "regular_representation_ranks": {
+    "reflection_difference": 4,
+    "rotation_difference": 6,
+    "inverse_rotation_difference": 6,
+    "target_difference": 12,
+    "calls_required_by_rank_floor": 3
+  },
+  "free_GL2_normalization": "All interspersed free scalar matrices conjugate paid rank-one idempotents; augmentation of target and paid factors is I.",
+  "scope_limit": "Exactly two roles, this reflection alphabet, and this endpoint; no kappa or supplier claim."
+}

research/d8-rotation-pair-seedff568/CLAIM.md

@@ -0,0 +1,5 @@
+CLAIM — `bit-mechanisms` / `bit-new-register-model`; accepted OS seed `ff568c3e5cf8605fe719bcb7533b22f8`; priority revision 3, catalogue SHA-256 `6686ad58f1fbdbc87134a78901b60fd53a20d3984355e91defbbebc9e9fa8075`. Exact base `0b1cccf86e2f5132ed286a26ef0a681a495740ea`; selected-record SHA-256 `10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32`.
+
+**Refined question:** In `F2[D8]`, with `D8=<s,t | s^2=t^2=1,(st)^4=1>` and `r=st`, can `diag([r],[r^-1])` on exactly two arbitrary dirty scalar roles be factored in three paid calls `I+([g]+1)N`, `g in {s,t}`, `N` any rank-one idempotent over `F2`, allowing free `GL2(F2)` changes? The direct bill is four calls. Search every word of length 0–3 over the 12 factors with exact full-group-algebra multiplication. A regular-representation rank relaxation leaves three calls feasible: target rank 12, each call rank at most 4.
+
+The object is the noncentral rotation/inverse pair. Direct predecessor PR #1443 (merged, head `965ff75aabb16cdd0978f4bf9222bcdedf514021`) uses the same `F2[D8]` two-role reflection alphabet but targets the central pair `diag([r^2],[r^2])`; this work changes the target class and runs an exhaustive 0–3 word search rather than radius-four balls. Related work: open PR #1822 (Q8 central pairs); Discussion #1738 was released and linked PR #1792; Discussion #1759 concluded in PR #1761 (UT4); Discussion #1818 concluded in PR #1821 (D16); PRs #1705/#1716 and Discussion #1167. Full task refresh at 13:08 UTC covered 537 open PRs and 521 Discussions with full pagination. Refresh again before handoff. This alphabet is not the selected supplier and the complex side binds, so no selected moment or `kappa` change is claimed. Expected result: a three-call exact identity and controls, or a complete bounded negative result through length three. Expiry: 2026-10-14 14:52 UTC. Substantial OpenAI Codex assistance; predecessor attribution above.

research/d8-rotation-pair-seedff568/CYCLE.md

@@ -0,0 +1,27 @@
+# Cycle 12 scope and pivot record
+
+- Accepted OS seed: `ff568c3e5cf8605fe719bcb7533b22f8`.
+- Track: `bit-mechanisms`.
+- Priority revision: 3.
+- Exact base: `0b1cccf86e2f5132ed286a26ef0a681a495740ea`.
+- Selected record SHA-256: `10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32`.
+
+## First screen, released
+
+The first refined scope was the two-role S4 target `diag([w],[w^-1])` for a
+4-cycle and adjacent-transposition alphabet. The natural permutation
+representation immediately gave target rank six and rank-one effect per paid
+call, forcing six calls and matching its direct bill. Exact meet-in-the-middle
+also returned no word in lengths zero through five. No package or PR was
+proposed. The scope was released at [Discussion #1166 comment 18924236](https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-18924236).
+
+## One evidence-driven pivot
+
+The second scope was claimed in [Discussion #1166 comment 18924259](https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-18924259), then clarified against merged PR #1443 in comment 18924309. It uses the D8 noncentral order-four pair `diag([r],[r^-1])` on
+two dirty roles. Here the regular representation only forces three calls,
+while the direct bill is four, so a genuine saving remained possible. Exact
+search exhausted lengths zero through three and found no saving. The package
+records this scoped negative result and its direct four-call control.
+
+The pivot followed the prescribed stop screen: the first scope had no
+headroom, so it was released before packaging; no further pivot was made.

research/d8-rotation-pair-seedff568/DETAILS.json

@@ -0,0 +1,12 @@
+{
+  "title": "Exact four-call minimum for a noncentral D8 rotation/inverse pair",
+  "scope": "Formal F2[D8], two arbitrary dirty scalar roles, paid reflections s,t, free GL2(F2) mixing, target diag([st],[ts]).",
+  "scope_status": "refined",
+  "reason": "Target-class extension of merged PR #1443 central endpoint diag([r^2],[r^2]); this package proves the noncentral order-four inverse-pair minimum.",
+  "bottleneck": "Check whether a nonabelian inverse pair can share one paid call below the direct four-call bill.",
+  "stop": "Exhaust 12^n factor words for n=0..3; stop on complete coverage.",
+  "checks": "Generic exact group-algebra replay, direct four-call witness, three controls, and regular-representation rank screen.",
+  "result": "No word of length at most three; the direct four-call word is minimal in this exact model.",
+  "limits": "No larger register count, other alphabet, selected supplier substitution, physical invoice, or kappa conclusion.",
+  "credit": "PR #1443 and the prior free-scalar normalization are directly attributed; substantial OpenAI Codex assistance; no independent human review claimed."
+}

research/d8-rotation-pair-seedff568/OVERLAP.json

@@ -0,0 +1,73 @@
+{
+  "status": "POSSIBLE_OVERLAP_NOT_A_NOVELTY_CERTIFICATE",
+  "searched_at": "2026-10-14T13:08:54.048653+00:00",
+  "task_id": "bit-new-register-model",
+  "terms": [
+    "bit-new-register-model",
+    "three-register",
+    "nonabelian",
+    "group algebra",
+    "bit-three-register-lower-bound"
+  ],
+  "coverage": {
+    "open_prs": {
+      "fetched_at": "2026-10-14T13:07:20.690768+00:00",
+      "complete_pagination": true,
+      "records": 537
+    },
+    "discussions": {
+      "fetched_at": "2026-10-14T13:08:53.892628+00:00",
+      "complete_pagination": true,
+      "records": 521
+    }
+  },
+  "local_records": 873,
+  "matches_total": 116,
+  "warnings": [],
+  "limits": "Remote PR scope is open PRs including drafts. Closed work is searched through local READMEs, TASK metadata and ledger only. No code diffs or arbitrary package files are searched. Recheck relevant heads before submission.",
+  "exact_scope_assessment": "No active exact-scope D8 noncentral rotation/inverse pair claim found in the complete open PR and Discussion snapshots. The closest predecessor is merged PR #1443, manually inspected; it uses the same group, labels, role count, and free GL2 mixing but a different central endpoint.",
+  "related_records": [
+    {
+      "kind": "merged-pr",
+      "number": 1443,
+      "head": "965ff75aabb16cdd0978f4bf9222bcdedf514021",
+      "scope": "F2[D8], two roles, reflections, free GL2; central target diag([r^2],[r^2]), exact minimum 8. Direct predecessor; changed endpoint here is diag([r],[r^-1])."
+    },
+    {
+      "kind": "open-pr",
+      "number": 1822,
+      "head": "ee736b4b11bbd63b04d94c8edafb3790161ebdea",
+      "scope": "Q8 central commutator pairs; different group and endpoint."
+    },
+    {
+      "kind": "discussion",
+      "number": 1738,
+      "status": "released / resolved via comment 18921339 and PR #1792",
+      "scope": "D8 central commutator with a third dirty role; different endpoint and width."
+    },
+    {
+      "kind": "discussion",
+      "number": 1759,
+      "status": "completed in PR #1761",
+      "scope": "UT4(F2) noncentral root pair with three registers; different group and width."
+    },
+    {
+      "kind": "discussion",
+      "number": 1818,
+      "status": "completed in PR #1821",
+      "scope": "D16 central pair; different group and endpoint."
+    },
+    {
+      "kind": "open-pr",
+      "number": 1716,
+      "head": "fdbcd61eea435f9f8d497290a1db6513bb769d51",
+      "scope": "AGL2(F2) target triple; different alphabet and target."
+    },
+    {
+      "kind": "discussion",
+      "number": 1167,
+      "scope": "S3 inverse pair; different group and address alphabet."
+    }
+  ],
+  "final_recheck": true
+}

research/d8-rotation-pair-seedff568/PR-BODY.md

@@ -0,0 +1,21 @@
+## Result
+
+In the exact two-role formal `F2[D8]` model with paid reflection labels `s,t` only and arbitrary free `GL2(F2)` mixing, the noncentral rotation/inverse target `diag([r],[r^-1])`, `r=st`, has exact paid-call minimum **four**. The direct four-call word passes; exhaustive full-coefficient enumeration rules out every word of length zero through three.
+
+The regular representation gives only the lower bound three (target difference rank 12; each paid factor has rank 4). The exact word enumeration rules out that remaining three-call possibility.
+
+## Scope and relation to predecessors
+
+This is a target-class extension of merged [PR #1443](https://github.com/CrocSwap/integer-mult-bounds/pull/1443), which uses the same group, two reflection labels, two roles and free scalar mixing but proves an eight-call minimum for the central target `diag([r^2],[r^2])`. This PR concerns the noncentral order-four inverse pair and its four-call bill. It does not restate the central-target result. Other nearby work includes the open quaternion central-pair result in PR #1822 and the D8 third-role central-pair claim in Discussion #1738.
+
+## Reproduction
+
+```sh
+python3 -I -B research/d8-rotation-pair-seedff568/search.py
+python3 -I -B research/d8-rotation-pair-seedff568/verify.py
+python3 scripts/research_package.py --package research/d8-rotation-pair-seedff568 --check-only
+```
+
+The search covers `1, 12, 144, 1728` words at lengths `0,1,2,3`. The independent verifier checks the direct word, complete group-algebra boundary, altered and truncated controls, and the rank screen. The registered package replay requests Python 3.12; direct checks in this environment use Python 3.14.7 because Python 3.12 is unavailable.
+
+This is a scoped abstract address-model result only. The selected supplier and selected moment are unchanged; there is no new `kappa` or physical/compiler admission. Substantial OpenAI Codex assistance; no independent human review is claimed.

research/d8-rotation-pair-seedff568/PROOF.md

@@ -0,0 +1,54 @@
+# Exact finite argument
+
+Let `G=D8={r^i s^e : i in Z/4, e in F2}` with multiplication
+
+`(i,e)(j,f) = (i + (-1)^e j mod 4, e+f mod 2)`.
+
+Set `s=(0,1)` and `t=(3,1)`. Then `s^2=t^2=1`, `st=(1,0)=r`, and
+`ts=(3,0)=r^-1`.
+
+## Paid factors and free scalar maps
+
+For a rank-one idempotent `N=u v^T` over `F2^2`, define
+`F_g(N)=I+([g]+1)N`. The pairs `u,v` with `u!=0`, `v!=0`, and `v^T u=1`
+are exactly the six rank-one idempotents. Therefore the complete paid alphabet
+has 2*6=12 factors.
+
+Suppose free `GL2(F2)` matrices are interspersed with paid factors. Moving a
+free matrix rightward across one paid factor conjugates its idempotent:
+`M F_g(N) = F_g(M N M^-1) M`. Conjugation preserves the rank-one idempotent
+class. After moving all free maps to the right, augmentation sends every paid
+factor to `I` and sends the target `diag([r],[r^-1])` to `I`; hence the remaining
+free product is `I`. The normalized twelve-factor word model is complete.
+
+## Exhaustive coefficient check
+
+Represent a group-algebra coefficient by an eight-bit mask, one bit for each
+`r^i s^e`. Matrix multiplication uses the displayed multiplication rule and
+XOR for coefficient addition. The search tests every length-n word in the
+12-factor alphabet for n=0,1,2,3. The word counts are exactly
+
+`1, 12, 12^2=144, 12^3=1728`.
+
+The independent verifier recomputes every product by generic group-algebra
+convolution and 2x2 matrix multiplication. It finds no target word through
+length three. The four-factor word
+
+`F_s(E11) F_t(E11) F_t(E22) F_s(E22)`
+
+is checked coefficient-for-coefficient to equal `diag([r],[r^-1])`. Thus the
+exact minimum in this finite model is four.
+
+## Rank relaxation
+
+In the left regular representation over `F2`, left multiplication by a
+reflection has four 2-cycles, so `rank(L_s-I)=rank(L_t-I)=4`. Left
+multiplication by `r` or `r^-1` has two 4-cycles, so each difference has rank
+six. Since `rank(A tensor N)=rank(A)rank(N)`, a paid factor changes rank by
+four. For invertible `A,B`,
+
+`rank(AB-I) = rank(A(B-I)+(A-I)) <= rank(B-I)+rank(A-I)`.
+
+The target difference has block-diagonal rank `6+6=12`, so at least three
+calls are necessary. This relaxation leaves three calls feasible; the exact
+coefficient enumeration proves that three do not suffice.

research/d8-rotation-pair-seedff568/README.md

@@ -0,0 +1,115 @@
+# A noncentral D8 rotation pair still costs four calls
+
+## Result
+
+For the exact two-role model over the formal group algebra `F2[D8]`, the target
+`diag([r],[r^-1])`, where `r=st` has order four, needs exactly four paid calls
+when the only paid labels are the reflections `s,t`. Free scalar `GL2(F2)`
+changes do not reduce the minimum. The direct four-call word attains the bound;
+complete exact enumeration rules out every word of length zero through three.
+
+This is a scoped target result, not a change to the selected bit supplier or a
+new multiplication-exponent bound. The selected complex-side moment remains the
+binding one, so no new `kappa` follows.
+
+## Model and complete price
+
+Write the eight elements as `r^i s^e`, with `i mod 4`, `e in {0,1}`, and
+`s r = r^-1 s`. Set `t=r^-1 s`; then `s^2=t^2=1`, `st=r`, and `ts=r^-1`.
+The paid alphabet is exactly
+
+```text
+F_g(N) = I + ([g] + 1) N,   g in {s,t},
+```
+
+over `F2[D8]`. Here `N=u v^T` is a rank-one idempotent on the two scalar
+roles, so `u,v` are nonzero binary two-vectors and `v^T u=1`. There are six
+such projectors, hence twelve paid factors. Both role inputs are arbitrary;
+the exact formal matrix boundary therefore includes restoration of all
+cross-role information. No extra role, address map, copy, clean state, or
+unpriced operation is available.
+
+The direct word is
+
+```text
+F_s(E11) F_t(E11) F_t(E22) F_s(E22)
+  = diag([s][t], [t][s])
+  = diag([r], [r^-1]).
+```
+
+Its complete paid bill is four calls. Every paid call is charged once.
+
+## Exact minimum
+
+Any interspersed free scalar matrices can be pushed to the right through the
+paid factors by conjugating each projector: `M F_g(N) M^-1 = F_g(M N M^-1)`.
+The conjugated matrix is still one of the six rank-one idempotents. Under the
+augmentation `F2[D8] -> F2`, each paid factor maps to the identity and the
+boundary also maps to the identity. Thus the total remaining free scalar map
+must be `I`. The twelve-factor alphabet already covers every allowed sequence
+with arbitrary free `GL2(F2)` changes.
+
+The exact verifier multiplies full 2x2 matrices of eight-bit group-algebra
+coefficients. It enumerates all words at each length `n=0,1,2,3`, checking
+`1, 12, 144, 1728` words respectively. No product equals the target. A second
+implementation in `verify.py` uses generic group-algebra and matrix
+multiplication, rather than the rank-one update used by the search. It repeats
+the full enumeration, confirms the direct four-call word, and checks altered
+and truncated words as negative controls.
+
+A separate rank screen shows why three calls were plausible. In the left
+regular representation on eight group elements, each reflection difference
+`L_g-I` has rank four, while `L_r-I` and `L_(r^-1)-I` each have rank six. The
+target difference has rank twelve; one paid factor changes rank by at most
+four. Subadditivity therefore forces at least three calls, but does not rule
+out three. The exact coefficient search supplies that missing call: the
+minimum is four.
+
+## Relation to prior work
+
+Merged [PR #1443](https://github.com/CrocSwap/integer-mult-bounds/pull/1443)
+uses this same `F2[D8]` group, the same two reflection labels, exactly two
+roles, and free `GL2(F2)` mixing. Identifying its `x,y` with `s,t` gives
+`r=xy`, so its endpoint `diag([xyxy],[xyxy])` is the central target
+`diag([r^2],[r^2])`. It proves an eight-call minimum for that different endpoint. This result changes the endpoint
+to the noncentral order-four inverse pair and tests the shorter, four-call
+bill. It does not re-run or alter PR #1443's central-target result. The related
+open [PR #1822](https://github.com/CrocSwap/integer-mult-bounds/pull/1822)
+uses a quaternion central-pair target; [Discussion #1738](https://github.com/CrocSwap/integer-mult-bounds/discussions/1738)
+concerns a D8 central pair with a third dirty role. Scope and exact overlap
+coverage are recorded in `OVERLAP.json`.
+
+The normalization of free scalar mixing follows the prior D8 and three-register
+work. The exact group law, word domain, target and rank calculation here are
+specified in this package. Substantial OpenAI Codex assistance; no independent
+human review is claimed.
+
+## Reproduce
+
+```sh
+python3 -I -B research/d8-rotation-pair-seedff568/search.py
+python3 -I -B research/d8-rotation-pair-seedff568/verify.py
+python3 scripts/research_package.py --package research/d8-rotation-pair-seedff568 --check-only
+```
+
+The search prints the exact length census and the direct four-call witness. The
+independent verifier prints:
+
+```text
+PASS_D8_ROTATION_PAIR minimum=4 lengths=[1,12,144,1728] regular_ranks=(4,6,6) positive_controls=2 negative_controls=2 no_new_kappa
+```
+
+The registered package replay requests Python 3.12. Direct verification in this
+session was run with the installed Python 3.14.7; the full registered replay
+could not be run because Python 3.12 is unavailable here.
+
+## Open next questions
+
+The result covers exactly two scalar roles, this reflection alphabet, and this
+one target. It establishes no physical/compiler cost, selected supplier
+admission, recursive profile change, or `kappa` improvement. It does not cover
+three or more dirty roles or other group alphabets.
+
+A natural next construction question is whether a third arbitrary dirty scalar
+role can realize `diag([r],[r^-1],1)` in three reflection calls. The regular
+rank screen still permits three, while the two-role exact search rules it out.