Research UT3(F4) central commutator costs

research/ut3-f4-central-pair-seedfcd785a2/CERTIFICATE.json

@@ -0,0 +1,68 @@
+{
+  "alphabet_factor_count": 24,
+  "ball_sha256": "e36fec3f8f374c799dc4a973a56e6948c26b396eae88d980ccc0949a692bfbf3",
+  "central_targets": {
+    "Z_1": 16,
+    "Z_w": 32
+  },
+  "controls": {
+    "all_eight_single_deletions_fail": true,
+    "all_factor_involutions": true,
+    "direct_pair_positive": true,
+    "mutated_Z_w_to_Z_w2_fails": true,
+    "single_commutator_positive": true
+  },
+  "dependent_three_role_block_pivot": {
+    "all_fourteen_single_deletions_fail": true,
+    "block_alphabet_size": 56,
+    "block_family_hit_through_three": false,
+    "block_family_scope": "concatenations of at most three D_N(Z_1) or D_N(Z_w) blocks, each expanded to four paid source factors",
+    "central_block_pair_product_checks": 3136,
+    "direct_coordinate_calls": 14,
+    "direct_word_full_and_generic_endpoints_match": true,
+    "four_call_block_endpoint_checks": 56,
+    "raw_block_sequences_total": 178808,
+    "raw_ordered_block_sequences_checked_by_depth": [
+      56,
+      3136,
+      175616
+    ],
+    "target": [
+      16,
+      32,
+      48
+    ]
+  },
+  "direct_pair_word_length": 8,
+  "distinct_ball_states": 6877,
+  "distinct_state_layer_sizes": [
+    1,
+    24,
+    412,
+    6440
+  ],
+  "field_polynomial": "w^2+w+1=0",
+  "group_law": "(a,b,c)(a',b',c')=(a+a',b+b',c+c'+ab')",
+  "group_order": 64,
+  "labels": {
+    "X_1": 1,
+    "X_w": 2,
+    "Y_1": 4,
+    "Y_w": 8
+  },
+  "layer_sha256": [
+    "33679eedd86f9637ab73892a064cdab3d82365cf5063b145affb2272327a6ddc",
+    "1529586f6030051053c39c1cdd30eeb49b1db0ca5872056600f6c4338f4f6f97",
+    "b3cdc922678436ab83a6967b11acc88dacc1fc83af7e71d9391e87660566008c",
+    "44af81e7aaf93307c0f3ede1dfef162b8d2665ab2ffb6a4c71229ff62f197372"
+  ],
+  "minimum_pair_word_length": 8,
+  "model": "F2[UT3(F4)]",
+  "packed_vs_generic_transitions": 10488,
+  "parity_lemma": "Every label occurs an even number of times because the target is trivial mod I^2 and each rank-one idempotent has trace one.",
+  "radius": 3,
+  "rank_one_idempotent_count": 6,
+  "raw_words_through_radius": 14425,
+  "shared_pair_word_through_six": false,
+  "single_output_positive_word_length": 4
+}

research/ut3-f4-central-pair-seedfcd785a2/README.md

@@ -0,0 +1,91 @@
+# Two independent central commutators still cost eight calls
+
+**Scoped exact minimum in a new nonabelian address model; no new kappa.** In the full group algebra `F2[UT_3(F_4)]`, two independent central commutator outputs on two arbitrary dirty registers have exact minimum eight paid factors. The direct construction costs eight, the complete exact search excludes every word through six, and an augmentation-ideal parity argument excludes seven. The result tests whether separate commutators can share calls through rank-one register mixing; this target profile has no saving.
+
+The selected result remains the conditional `kappa = 0.001672660197076918` from #1094. Its complex side binds (`0.001675462676808103...` versus bit `0.001733427039589844...`). This formal word result has no physical supplier mapping and changes no selected primitive budget.
+
+## Model and construction
+
+Let `F_4 = F_2[w]/(w^2+w+1)` and write the unitriangular group as
+
+```text
+H = UT_3(F_4) = {(a,b,c): a,b,c in F_4}
+(a,b,c)(a',b',c') = (a+a', b+b', c+c'+a b').
+```
+
+The group has order 64 and abelianization `F_4 x F_4`, an elementary abelian group of rank four. The four paid labels are
+
+```text
+X_1 = (1,0,0), X_w = (w,0,0), Y_1 = (0,1,0), Y_w = (0,w,0).
+```
+
+Each label is an involution. Their central commutators include
+
+```text
+Z_1 = [X_1,Y_1] = (0,0,1),
+Z_w = [X_w,Y_1] = (0,0,w).
+```
+
+A paid factor is `D_N(g) = I + ([g]+[e])N`, where `g` is one of those four labels and `N` is any rank-one idempotent in `M_2(F_2)`. There are six such idempotents and 24 paid factors. Every factor costs one call; the identity must hold coefficientwise in all 64 group elements, so it applies to arbitrary dirty register values.
+
+For `E_11` and `E_22`, the eight-call word
+
+```text
+D_E11(X_1) D_E11(Y_1) D_E11(X_1) D_E11(Y_1)
+D_E22(X_w) D_E22(Y_1) D_E22(X_w) D_E22(Y_1)
+```
+
+is exactly `diag([Z_1],[Z_w])`. Each four-factor block is one central commutator on its coordinate. This is a fully charged upper bound: no call, clean role, copy, frame change or restoration is free in the model.
+
+## Exact lower bound
+
+Let `I` be the augmentation ideal of `F_2[H]`. Since `H/[H,H]` has the four paid labels as an `F_2` basis, `I/I^2` has four independent label coordinates. Both central target elements lie in `[H,H]`, so the target matrix is the identity modulo `M_2(I^2)`.
+
+For a word of paid factors, multiplication modulo `I^2` gives
+
+```text
+I + sum_i ([g_i]+[e]) N_i.
+```
+
+Independence of the four label coordinates forces `sum_{i:g_i=g} N_i = 0` for each label `g`. Every rank-one idempotent over `F_2` has trace one, so each label occurs an even number of times. Thus every word for this target has even length. The only possible improvement on the eight-call upper bound is therefore a word of length at most six.
+
+The verifier builds the complete radius-three ball for the 24-factor alphabet, merging only equal exact `2 x 2` matrices over the full group algebra. Its new-state layer sizes are `[1, 24, 412, 6440]`, for 6,877 states total; the 14,425 raw words of lengths zero through three are all represented. For every left state `A`, it computes `A^{-1} target` exactly and checks whether that state lies in the same ball. Since each factor is an involution, any word of length at most six splits into two radius-three words. No match exists. Together with parity and the direct word, this proves the exact minimum eight in this finite model.
+
+The certificate records the exact state-layer SHA-256 digests. The packed transition implementation is cross-checked against generic group-algebra matrix multiplication on 10,488 transitions. The group law is checked on all 64^3 triples; all six idempotents, all factor inverses, the four-call one-output commutator, and the direct eight-call pair are checked. All eight one-factor deletions of the direct word and a mutation of `Z_w` to `Z_{w^2}` fail their endpoint controls.
+
+## One bounded pivot: a dependent three-output target
+
+The central relation `Z_{w^2}=Z_1 Z_w` suggests a separate three-role construction. The direct coordinate bill is 14 calls: four for `Z_1`, four for `Z_w`, and six for `Z_{w^2}` using the composite label `X_{w^2}=X_1 X_w`, which is not a primitive label.
+
+I tested the specific sharing mechanism that first builds commutators and then combines their rank-one updates. For each rank-one idempotent `N` in `M_3(F_2)`,
+
+```text
+D_N(X_1) D_N(Y_1) D_N(X_1) D_N(Y_1) = D_N(Z_1)
+D_N(X_w) D_N(Y_1) D_N(X_w) D_N(Y_1) = D_N(Z_w).
+```
+
+Each is a fully charged four-call block. The complete ordered family of up to three such blocks has 56 block choices and 178,808 total candidate sequences. Exact multiplication in the central four-element group algebra finds no sequence for `diag([Z_1],[Z_w],[Z_{w^2}])`. This rules out only that block family; it is not a lower bound for arbitrary words of 12 calls or fewer.
+
+An explicit 14-call control applies the first commutator on role 1, the second on role 2, and
+`X_1 X_w Y_1 X_1 X_w Y_1` on role 3. The full group-algebra endpoint matches the target under both the packed engine and generic matrix multiplication. The verifier also checks all 56 four-call block endpoints, 3,136 pairwise block products against full group-algebra multiplication, and all 14 single-factor deletions of the direct word.
+
+## Reproduce
+
+From the repository root, standard library only:
+
+```sh
+python3 -I -B research/ut3-f4-central-pair-seedfcd785a2/verify.py
+python3 -I -O -B research/ut3-f4-central-pair-seedfcd785a2/verify.py
+```
+
+Both print `PASS_UT3_F4_CENTRAL_PAIR` and the certificate summary. `CERTIFICATE.json` contains the state counts and exact layer digests. `SOURCES.json` pins the base, selected-result chain and predecessor notes.
+
+## Scope and attribution
+
+This is a finite group-algebra result for this exact order-64 group and four-label alphabet: an exact two-role minimum plus a bounded three-role block-family obstruction. All paid matrices use the listed rank-one idempotents; the three-role pivot uses the 28 rank-one idempotents of M3(F2). It changes the address group and commutator geometry from the `Q8` central-pair result by Aaron Wang, while retaining the scalar-idempotent register model descended from eumemic's PR #288 and woklerx's PR #1443. It is distinct from the three-register abelian rational-frame obstruction and the `GL_2(F_2)` mixed-target census. It says nothing about larger alphabets, other groups, a physical bit supplier, or the multiplication exponent.
+
+## Open next questions
+
+Can an arbitrary word of at most 12 paid factors realize the dependent central triple `diag([Z_1],[Z_w],[Z_{w^2}])` outside the tested commutator-block family? A witness would reduce the 14-call direct bill. The first step is to derive a quotient bound or a small structured extension that admits noncentral intermediate factors, then screen its complete cost. The blocker is the 112-factor alphabet in `M_3(F_2)` and its larger exact state space.
+
+Prepared by Cinna Davis with substantial OpenAI Codex assistance. No independent human or proof-assistant review is claimed. Apache-2.0.

research/ut3-f4-central-pair-seedfcd785a2/SOURCES.json

@@ -0,0 +1,54 @@
+{
+  "schema_version": 1,
+  "base_commit": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2",
+  "files": [
+    {
+      "path": "certificates/selected-result.json",
+      "usage": "input",
+      "git_blob": "ae6a99f28aa468649eb66a361e764d769363bf11",
+      "sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32"
+    },
+    {
+      "path": "docs/research/agent-task-catalog.json",
+      "usage": "provenance",
+      "git_blob": "e8870e5917057d59b730eb14721a778639eca050",
+      "sha256": "d46eb6d5b3e279428753d770653663fbdf1063e55c255ea073d768f344927ef7"
+    },
+    {
+      "path": "docs/research/community-batch1099-review.md",
+      "usage": "input",
+      "git_blob": "6cb6ec061a071a06a2d18cd4dc3e9a2b05d28099",
+      "sha256": "7e76d2c38e5fce30587835b7251df1430488ae4dd372611ef69a3f03f476b6cb"
+    },
+    {
+      "path": "research/bit-gl3-mixed-targets-length10/README.md",
+      "usage": "input",
+      "git_blob": "59ac7008af69ffb41e10e6574308d68c33d44c48",
+      "sha256": "f1f88a618fa998baa2bb5e8bc69c225405b6106b4c0a5646d84c42166cd4aff5"
+    },
+    {
+      "path": "research/bit-three-register-lower-bound/README.md",
+      "usage": "input",
+      "git_blob": "25e41c370c101a33a6deb978de08b03ed7539b79",
+      "sha256": "c12b33ef388deece0cbf891505a2ce2c0779a0c3a6cf1f0f7f7039bab59cbebd"
+    },
+    {
+      "path": "research/community-frontier1094-audit/ASSEMBLY.json",
+      "usage": "input",
+      "git_blob": "5fd676df060f3b450782fdf5ff5f6beb63a5eeb0",
+      "sha256": "1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045"
+    },
+    {
+      "path": "research/community-frontier1094-audit/SELECTED-SOURCE.json",
+      "usage": "input",
+      "git_blob": "6a75493790b4eff9c4a98051ef8b01d6aad0d5a8",
+      "sha256": "79b3de5db3dbcb9829789ba58e9e45758926031e2a7d80667a08429d369be53b"
+    },
+    {
+      "path": "research/q8-central-commutator-pair/README.md",
+      "usage": "input",
+      "git_blob": "7a6277dc860ea5440ab39b06160c337f93353357",
+      "sha256": "ee819ee843e1a93d7d320d02ccd5f47af0d912295de9d9c379ccc22c90093948"
+    }
+  ]
+}

research/ut3-f4-central-pair-seedfcd785a2/TASK.json

@@ -0,0 +1,65 @@
+{
+  "schema_version": 1,
+  "task_id": "bit-new-register-model",
+  "priority_revision": 4,
+  "base_commit": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2",
+  "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",
+      "research/bit-gl3-mixed-targets-length10/README.md",
+      "docs/research/community-efficient1000-review.md"
+    ],
+    "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": "First compare the alphabet, role count and length with the fully replayed #1974 census and #2027 mixed-root tariff. Identify a changed premise and a legal native implementation; then price one smallest completed instance before searching larger words.",
+    "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.",
+      "Repeating the two-register GL3 census or a covered three-register length without changing a hypothesis; a formal group-algebra word without native conversion is a partial result."
+    ],
+    "overlap_terms": [
+      "three-register",
+      "nonabelian",
+      "group algebra"
+    ]
+  },
+  "scope_status": "refined",
+  "actual_scope": "Exact minimum for diag([Z_1],[Z_w]) in F2[UT_3(F_4)] on two dirty roles, plus one bounded constructive pivot testing at most three four-call commutator blocks against the dependent three-role central target diag([Z_1],[Z_w],[Z_{w^2}]).",
+  "scope_change_reason": "The selected random method was a target-specific relaxation, while this session requires a construction-focused assignment. I used the other constructive method listed on the same card, refining its general nonabelian-model question to a class-two order-64 group with a two-dimensional central commutator subgroup and a fixed two-output target.",
+  "bottleneck_link": "A shorter exact word would reduce the fully charged local bit-call profile; this formal model has no selected-supplier mapping, so even a saving would remain conditional local evidence.",
+  "budget_minutes": 60,
+  "stop_rule": "The exact two-role search stops after the complete radius-three ball. The single pivot stops after all ordered sequences of up to three four-call central commutator blocks are checked; do not infer a bound on arbitrary three-role words or search longer.",
+  "outcome": "negative-result",
+  "evidence": "For the two-role target, exact MITM excludes all words through six, the I/I^2 trace lemma excludes seven, and a direct word attains eight. The one bounded pivot enumerates all 178,808 ordered sequences of up to three D_N(Z_1/Z_w) blocks in M3(F2); none reaches the dependent triple, while a 14-call direct word passes full and generic endpoints. Exact state digests and positive/deletion/mutation controls are in CERTIFICATE.json.",
+  "author": "Cinna Davis",
+  "ai_assistance": "Substantial OpenAI Codex assistance in mathematical derivation, implementation, verification and writing; no independent human or proof-assistant review.",
+  "open_questions": [
+    {
+      "question": "Can an arbitrary word of at most 12 paid factors realize diag([Z_1],[Z_w],[Z_{w^2}]) outside the tested commutator-block family?",
+      "why_it_matters": "A witness would reduce the 14-call direct bill and would test whether noncentral intermediates exploit the F2-linear relation among central commutators.",
+      "first_step": "Derive a quotient bound or a small structured extension that admits noncentral intermediate factors, then screen its fully charged cost before any broad search.",
+      "blocked_by": "The 112-factor alphabet in M3(F2) and its larger exact state space; no physical supplier mapping is known."
+    }
+  ],
+  "selected_method": "Construct the smallest exact identity in a newly specified legal operation alphabet.",
+  "discussion": "https://github.com/CrocSwap/integer-mult-bounds/discussions/2256"
+}

research/ut3-f4-central-pair-seedfcd785a2/TASK.md

@@ -0,0 +1,15 @@
+# Cycle AG task card
+
+- **Task ID:** `bit-new-register-model`
+- **Track / accepted selector seed:** `bit-mechanisms` / `fcd785a2bcb2e2eaab8d76cf630ed268`
+- **Selector catalogue:** revision 4; SHA-256 `d46eb6d5b3e279428753d770653663fbdf1063e55c255ea073d768f344927ef7`
+- **Exact base:** `0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2`
+- **Selected record:** SHA-256 `10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32`
+- **Scope status:** refined; use the card's exact-construction method and change from a target-specific lower-bound relaxation to a constructive sharing test, as required by this session's construction-only scope.
+- **Object:** `H=UT_3(F_4)`, with `F_4=F_2[w]/(w^2+w+1)`. Write elements as `(a,b,c)` with product `(a,b,c)(a',b',c')=(a+a',b+b',c+c'+ab')`. Labels are the four involutions `X_1=(1,0,0)`, `X_w=(w,0,0)`, `Y_1=(0,1,0)`, `Y_w=(0,w,0)`.
+- **Question:** In `F_2[H]`, can a word of at most six paid factors `D_N(g)=I+([g]+[e])N`, where `g` is one of those four labels and `N` is any of the six rank-one idempotents of `M_2(F_2)`, equal `diag([Z_1],[Z_w])` on two arbitrary dirty registers? Here `Z_c=(0,0,c)`, `[X_1,Y_1]=Z_1`, and `[X_w,Y_1]=Z_w`. One bounded pivot tests whether the dependent three-role target `diag([Z_1],[Z_w],[Z_{w^2}])` is reachable as a product of at most three four-call `D_N(Z_1)` or `D_N(Z_w)` blocks in `M_3(F_2)`.
+- **Changed hypothesis / cost:** Replace the single-central-involution Q8 model with an exponent-two class-two group whose commutator subgroup is a two-dimensional central vector space, and test two independent central outputs. Every factor costs one. Separate four-call commutators give a fully charged eight-call upper bound; a hit through six saves at least two calls (25%). Setup, clean roles, copies, hosting, restoration and precision are unavailable or zero only because the formal word model has no such operations. No physical supplier mapping or kappa change is claimed.
+- **Method / stop rule:** Exact meet-in-the-middle over the complete 24-factor alphabet, with both halves of length at most three and exact group-algebra matrix equality. Check every element of the radius-three state ball against the exact target quotient. Stop after complete coverage; no search past length six. If absent, prove all valid words have even length using the augmentation ideal modulo its square, giving exact minimum eight together with the direct word.
+- **Overlap:** At 2026-10-15 02:18 UTC the helper covered 482 open PRs and 960 Discussions with complete pagination and no warnings. Search terms `UT3(F4)`, `unitriangular 3x3 F4`, `Heisenberg group order 64`, and `commutator vector` gave zero matches. Adjacent group-word work includes #1999 (binary tetrahedral), #2094 (`UT5(Z)`), #2012 (S3), and the released Cycle AF Q8 work in #2243 / open PR #2248; these differ in group and target profile. The previously named rank-seven COPY handoff in #2198 is covered by open PR #2234; its remaining request is independent review and is outside this assignment.
+- **Expected evidence:** Reproducible exact certificate and verifier, direct eight-call pair word and 14-call triple word, one-output four-call control, parity proof, exact 178,808-sequence block census, endpoint mutation/deletion controls, source and predecessor pins, and complete accounting. Package is at this directory.
+- **Claim expiry:** 2026-10-15 04:20 UTC.