From 009ed860f34ed5d7b0d626098ce93c4c2a7eb4df Mon Sep 17 00:00:00 2001 From: Cinna Davis <1337isnot1337@users.noreply.github.com> Date: Wed, 14 Oct 2026 08:51:24 -0500 Subject: [PATCH] Research Q8 mixed-target rank-one call floor --- .../EXPECTED.json | 232 ++++++++++++++ .../README.md | 163 ++++++++++ .../SOURCES.json | 48 +++ .../TASK.json | 162 ++++++++++ .../TASK.md | 16 + .../VERIFY.json | 19 ++ .../verify.py | 300 ++++++++++++++++++ 7 files changed, 940 insertions(+) create mode 100644 research/q8-mixed-three-register-seedcbd5ebc4/EXPECTED.json create mode 100644 research/q8-mixed-three-register-seedcbd5ebc4/README.md create mode 100644 research/q8-mixed-three-register-seedcbd5ebc4/SOURCES.json create mode 100644 research/q8-mixed-three-register-seedcbd5ebc4/TASK.json create mode 100644 research/q8-mixed-three-register-seedcbd5ebc4/TASK.md create mode 100644 research/q8-mixed-three-register-seedcbd5ebc4/VERIFY.json create mode 100644 research/q8-mixed-three-register-seedcbd5ebc4/verify.py diff --git a/research/q8-mixed-three-register-seedcbd5ebc4/EXPECTED.json b/research/q8-mixed-three-register-seedcbd5ebc4/EXPECTED.json new file mode 100644 index 0000000000..fd8a22e5bb --- /dev/null +++ b/research/q8-mixed-three-register-seedcbd5ebc4/EXPECTED.json @@ -0,0 +1,232 @@ +{ + "model": "F2[Q8]", + "generators": [ + "i", + "j" + ], + "relations": [ + "i^2=j^2=-1", + "ij=k", + "ji=-k" + ], + "target_profile": [ + 2, + 1, + 1 + ], + "target_triples": [ + [ + "-1", + "i", + "i" + ], + [ + "-1", + "i", + "j" + ], + [ + "-1", + "j", + "i" + ], + [ + "-1", + "j", + "j" + ], + [ + "i", + "-1", + "i" + ], + [ + "i", + "-1", + "j" + ], + [ + "i", + "i", + "-1" + ], + [ + "i", + "i", + "k" + ], + [ + "i", + "i", + "-k" + ], + [ + "i", + "j", + "-1" + ], + [ + "i", + "j", + "k" + ], + [ + "i", + "j", + "-k" + ], + [ + "i", + "k", + "i" + ], + [ + "i", + "k", + "j" + ], + [ + "i", + "-k", + "i" + ], + [ + "i", + "-k", + "j" + ], + [ + "j", + "-1", + "i" + ], + [ + "j", + "-1", + "j" + ], + [ + "j", + "i", + "-1" + ], + [ + "j", + "i", + "k" + ], + [ + "j", + "i", + "-k" + ], + [ + "j", + "j", + "-1" + ], + [ + "j", + "j", + "k" + ], + [ + "j", + "j", + "-k" + ], + [ + "j", + "k", + "i" + ], + [ + "j", + "k", + "j" + ], + [ + "j", + "-k", + "i" + ], + [ + "j", + "-k", + "j" + ], + [ + "k", + "i", + "i" + ], + [ + "k", + "i", + "j" + ], + [ + "k", + "j", + "i" + ], + [ + "k", + "j", + "j" + ], + [ + "-k", + "i", + "i" + ], + [ + "-k", + "i", + "j" + ], + [ + "-k", + "j", + "i" + ], + [ + "-k", + "j", + "j" + ] + ], + "target_count": 36, + "target_triples_sha256": "b40193ed3d9c5cbd685b928ae20d4f43fa95b73b6d30070fc0ce326fddb4d50f", + "r3": { + "roles": 3, + "rank_one_idempotents": 28, + "paid_factors": 56, + "depth1_states": 56, + "depth2_states": 2324, + "depth3_transitions": 130144, + "target_hits": 0, + "direct_calls": 4 + }, + "r4": { + "roles": 4, + "rank_one_idempotents": 120, + "paid_factors": 240, + "depth1_states": 240, + "depth2_states": 41800, + "depth3_transitions": 10032000, + "target_hits": 0, + "direct_calls": 4 + }, + "structural_split": { + "k_or_minus_k": 24, + "minus_one": 12, + "uniform_min_calls_for_k_or_minus_k": "4 for every finite r >= 3", + "reason": "rank_x=1+n_i and rank_y=1+n_j, with n_i+n_j=2", + "rank_profiles": { + "1,3": 6, + "2,2": 12, + "3,1": 6 + } + } +} diff --git a/research/q8-mixed-three-register-seedcbd5ebc4/README.md b/research/q8-mixed-three-register-seedcbd5ebc4/README.md new file mode 100644 index 0000000000..37c0772a68 --- /dev/null +++ b/research/q8-mixed-three-register-seedcbd5ebc4/README.md @@ -0,0 +1,163 @@ +# Q8 mixed targets retain the four-call direct tariff through one extra dirty role + +**Exact finite group-algebra obstruction; no new κ.** In the specified `F2[Q8]` +register model, the 36 mixed target triples below need four paid rank-one calls +both with three roles and with one additional arbitrary dirty identity-target +role. The exact search rules out a three-call shortcut. This does not exclude +other Q8 targets, more roles for the 12 `-1` cases, another operation +alphabet, or a physical bit supplier improvement. + +## Model and target family + +Write + +\[ +Q_8=\{\pm1,\pm i,\pm j,\pm k\},\qquad i^2=j^2=-1, +\quad ij=k,\quad ji=-k. +\] +All equality is in the formal group algebra over `F2`, with one basis symbol +`[g]` for each of the eight group elements. For `r=3` or `r=4`, one paid call +is + +\[ +D_N(g)=I+([g]+[1])N,\qquad g\in\{i,j\},\qquad N=uv^T, +\quad v^Tu=1, +\] +where `u,v` are nonzero binary `r`-vectors. Thus `N` is a rank-one +idempotent. Every register input is arbitrary dirty data; the required exact +boundary is `diag([g1],[g2],[g3])` for `r=3` and +`diag([g1],[g2],[g3],[1])` for `r=4`. + +The endpoint family is all 36 ordered triples in which one target lies in +`{-1,k,-k}` and the other two independently lie in `{i,j}`. The positive +`{i,j}` word-length profile is `(2,1,1)`, so every endpoint has a four-call +direct construction. The illustrative member is `diag([i],[j],[k])`. +`EXPECTED.json` lists and hashes the complete family. + +The paid-factor counts are complete: `(2^r-1)2^(r-1)` binary rank-one +idempotents, times two labels, giving 56 factors at `r=3` and 240 at `r=4`. +A three-call witness would save one paid call (25%) in this local unit-cost +model. The extra fourth role is explicitly arbitrary and must return through an +identity target. Its storage and any physical hosting cost are outside this +formal call count. + +The model allows free scalar `GL_r(F2)` basis changes. They do not enlarge +this enumeration: conjugating a paid factor sends `N` to another rank-one +idempotent in the listed complete alphabet. Under augmentation `[g] -> 1`, +each paid factor becomes `I` and the required diagonal target becomes `I`, so +any remaining terminal scalar basis map is forced to be the identity. + +## Exact result + +No endpoint in the 36-member family is reachable with zero, one, two, or three +paid factors, either at `r=3` or at `r=4`. Since every endpoint has a verified +direct four-call word, the minimum is exactly four in these two finite models. + +For the 24 tuples whose length-two entry is `k` or `-k`, there is also a +uniform lower bound for every finite register count `r >= 3`. Let `J_Q` be +the augmentation ideal of `F2[Q8]`. The quotient by the commutator subgroup +`{1,-1}` is `C2 x C2`; in its group algebra the augmentation ideal modulo its +square has basis `x=[i]+[1]`, `y=[j]+[1]`. Modulo `J_Q^2`, an `i`-label call +contributes `xN`, a `j`-label call contributes `yN`, and a target entry `k` or +`-k` contributes both `x` and `y`. Let `n_i,n_j` count the two other target +entries equal to `i,j`; then `n_i+n_j=2`, and the diagonal coefficient +matrices of `x,y` have ranks `1+n_i` and `1+n_j`. If a word uses `q_i` +`i`-calls and `q_j` `j`-calls, these matrices are sums of at most `q_i` or +`q_j` rank-one matrices. Thus `q_i+q_j >= (1+n_i)+(1+n_j)=4`; four calls are +necessary for every tuple in this subfamily, including the repeated-`i` and +repeated-`j` cases. The direct word meets the bound. + +For the remaining 12 tuples, the length-two target is `-1`. It is killed by +the abelianization, so the two first-order coefficient ranks are `n_i,n_j` +with `n_i+n_j=2`; this does not rule out a three-call word. The exact search +supplies the additional, scoped result: these 12 tuples have minimum four at +`r=3` and `r=4`. It does not settle them for arbitrary extra roles. + +The verifier stores each group-algebra coefficient array as an eight-bit mask. +For a state matrix `M`, it applies the exact right update +`M <- M D_N(g)` by multiplying each selected row entry by `[g]+[1]` and +forming the rank-one outer-product update. Equal states at depths one and two +are merged; all suffix transitions are deterministic, so this preserves the +complete reachable set. Every depth-three extension of every distinct +depth-two state is then checked against all target matrices. + +| Roles | Rank-one idempotents | Paid factors | Distinct depth-1 states | Distinct depth-2 states | Depth-3 transitions checked | Target hits through depth 3 | +|---:|---:|---:|---:|---:|---:|---:| +| 3 | 28 | 56 | 56 | 2,324 | 130,144 | 0 | +| 4 | 120 | 240 | 240 | 41,800 | 10,032,000 | 0 | + +The two-call target `diag([i],[j],[1],...)` is a positive control for the +state search. Every family member is replayed through its direct four-call +word. The verifier also rejects a direct word with its last call dropped and +confirms that replacing the illustrative `k` target by `-k` changes the exact +boundary. The 36 target tuples partition into 24 `k/-k` cases covered by the +uniform first-order rank argument and 12 `-1` cases covered by finite search +through `r=4`. + +## Why this is a scoped negative result + +Navinor's PR #1822 (head `ee736b4b11bbd63b04d94c8edafb3790161ebdea`) studies +two roles with the repeated central commutator `diag([xyxy],[xyxy])` over Q8. +This package changes to three mixed generator/product targets, then +adds one arbitrary identity-target role as a single bounded pivot. No +predecessor code is imported. The final overlap snapshot at +2026-10-14T13:57:45Z covered 573 open PRs and 542 Discussion records with +complete pagination and no warnings. The scanner found this cycle's own +Discussion #1167 claim, PR #1822's two-role repeated central commutator, and +other bit-mechanism records, but no remote same-scope claim. The current +four-register AGL2 mixed-target claim in Discussion #1727, the UT4 claim in +Discussion #1759, the D16 claim in Discussion #1818, and the AGL2 results +PR #1716/#1763 and Discussion #1774 have different groups or target families. + +The current selected construction remains conditional finite, complex-binding +at `836330098538459/500000000000000000`. Its review, selected-source manifest, +assembly certificate, and reproduction target are pinned in +[SOURCES.json](SOURCES.json). The selected bit supplier is not changed here. +The current review is +[`community-batch1099-review.md`](../../docs/research/community-batch1099-review.md); +the source manifest is +[`SELECTED-SOURCE.json`](../community-frontier1094-audit/SELECTED-SOURCE.json), +and the assembly certificate is +[`ASSEMBLY.json`](../community-frontier1094-audit/ASSEMBLY.json), SHA-256 +`1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045`. Its +pinned reproduction remains `make frontier1094-verify`; it was not rerun because +this package changes none of its inputs. +The binding-only baseline `python3 -B scripts/research_baseline.py` passed at +the pinned base and reported `binding_primitive=complex`; that is not a full +selected-assembly replay. +There is no κ gain, complete multiplication theorem, or supplier placement +claim. No rank savings in this finite family does not imply a universal +no-sharing theorem. + +## Reproduce + +From the repository root: + +```sh +python3 -I -B research/q8-mixed-three-register-seedcbd5ebc4/verify.py +python3 -B scripts/research_package.py --package research/q8-mixed-three-register-seedcbd5ebc4 --check-only +``` + +The exact search is standard-library Python and uses the formal eight-element +Q8 table, not a natural matrix representation. The run in this environment used +CPython 3.14.7; the registered package runner specifies Python 3.12. The +selected assembly was not rerun because no selected input changed. + +## Open next questions + +Can the 12 central `-1` target triples be proved to need four calls for every +finite number of dirty roles, rather than only for `r=3,4`? A uniform +second-order augmentation invariant would extend the finite obstruction. +First derive the coefficient constraints in `J_Q^2/J_Q^3` while retaining the +rank-one idempotent relations; the current first-order quotient is too weak. +This is a new domain requiring its own overlap check. Neither result +establishes physical supplier realization, and the selected complex-side +moment remains binding. + +## Attribution + +The Q8 register model and central-commutator predecessor are from the authors +of PR #1822; the earlier rank-one formal-frame lineage is summarized in the +pinned predecessor package. This work adds no imported code and makes no +priority claim about broader group-algebra register models. Prepared by Cinna +Davis with substantial OpenAI Codex assistance. New work is Apache-2.0. diff --git a/research/q8-mixed-three-register-seedcbd5ebc4/SOURCES.json b/research/q8-mixed-three-register-seedcbd5ebc4/SOURCES.json new file mode 100644 index 0000000000..b673f49dc3 --- /dev/null +++ b/research/q8-mixed-three-register-seedcbd5ebc4/SOURCES.json @@ -0,0 +1,48 @@ +{ + "schema_version": 1, + "base_commit": "0b1cccf86e2f5132ed286a26ef0a681a495740ea", + "files": [ + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "06c96f5579bb67ed1b86d334e78fbed7da6945f1", + "sha256": "6686ad58f1fbdbc87134a78901b60fd53a20d3984355e91defbbebc9e9fa8075" + }, + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "ae6a99f28aa468649eb66a361e764d769363bf11", + "sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32" + }, + { + "path": "docs/research/community-batch1099-review.md", + "usage": "provenance", + "git_blob": "6cb6ec061a071a06a2d18cd4dc3e9a2b05d28099", + "sha256": "7e76d2c38e5fce30587835b7251df1430488ae4dd372611ef69a3f03f476b6cb" + }, + { + "path": "research/community-frontier1094-audit/SELECTED-SOURCE.json", + "usage": "provenance", + "git_blob": "6a75493790b4eff9c4a98051ef8b01d6aad0d5a8", + "sha256": "79b3de5db3dbcb9829789ba58e9e45758926031e2a7d80667a08429d369be53b" + }, + { + "path": "research/community-frontier1094-audit/ASSEMBLY.json", + "usage": "provenance", + "git_blob": "5fd676df060f3b450782fdf5ff5f6beb63a5eeb0", + "sha256": "1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045" + }, + { + "path": "research/bit-dihedral-commutator/README.md", + "usage": "provenance", + "git_blob": "b7619a5d56f32daf7f48d6cc3a0e260c5a333510", + "sha256": "4f3f9df6d6d96a26ccb0fcd2ef947cce5d53b0d992da22e866f1e025be4c0492" + }, + { + "path": "research/bit-dihedral-commutator/CERTIFICATE.json", + "usage": "provenance", + "git_blob": "a52cee87ee16903ccd95a6872788e66a7a029202", + "sha256": "8ec4519a34ab5c6eca6dea92b90aa317c851c566040caf89d822d1d96c70a8c5" + } + ] +} diff --git a/research/q8-mixed-three-register-seedcbd5ebc4/TASK.json b/research/q8-mixed-three-register-seedcbd5ebc4/TASK.json new file mode 100644 index 0000000000..da0199f69a --- /dev/null +++ b/research/q8-mixed-three-register-seedcbd5ebc4/TASK.json @@ -0,0 +1,162 @@ +{ + "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": "In F2[Q8], for r=3 and r=4 arbitrary dirty scalar roles, classify whether any diagonal target (g1,g2,g3,1,...,1), with g1,g2,g3 all nonidentity and positive {i,j}-word-length profile a permutation of (2,1,1), is realizable in at most 3 paid rank-one factors D_N(g), g in {i,j}; compare with the exact 4-call direct construction. Q8 has i^2=j^2=-1 and ij=-ji. The complete endpoint set has 36 triples. Exact coefficient search finds none at depth <=3 for either role count, so the local minimum is 4 in these two models.", + "scope_change_reason": "The selector allows a specified nonabelian operation family. Refine it to Q8 and a fully enumerated mixed target family rather than repeat PR #1822’s two-role repeated central-commutator target. After the complete r=3 census found no three-call construction, make one evidence-driven pivot to r=4 by adding exactly one arbitrary dirty identity-target role. The target tuple and call threshold remain fixed.", + "bottleneck_link": "A 3-call realization would reduce the local paid rank-one bit-call count from 4 to 3 for a mixed nonabelian target tuple. The result is a formal group-algebra mechanism or obstruction only; the selected bit supplier remains nonbinding, so no selected kappa change follows.", + "budget_minutes": 60, + "stop_rule": "Enumerate exact reachability through length 3 for all 36 target tuples at r=3 and with one extra dirty role at r=4, over every rank-one idempotent and both paid labels. Stop after these two finite domains; no group or role-count generalization.", + "outcome": "negative-result", + "evidence": "For the 24 k/-k tuples, Q8 abelianization gives first-order coefficient matrix ranks rank_x=1+n_i and rank_y=1+n_j, where n_i+n_j=2; the rank bounds sum to four, so at least four paid calls are needed for every finite r>=3. For the other 12 (-1) tuples this invariant is weaker; exact coefficient search finds no word through depth 3 at r=3 or r=4. Search counts: r=3 has 56 factors, 56/2,324 depth-1/2 states, 130,144 depth-3 transitions; r=4 has 240 factors, 240/41,800 depth-1/2 states, 10,032,000 depth-3 transitions. All 36 direct four-call words replay exactly. Full-convolution update cross-checks, a two-call positive control, dropped-call and wrong-target controls pass.", + "author": "Cinna Davis", + "ai_assistance": "Substantial OpenAI Codex assistance in scope selection, exact state search, proof explanation, and packaging.", + "open_questions": [ + { + "question": "Can the 12 central -1 target triples be proved to need four calls for every finite number of dirty roles, rather than only r=3,4?", + "why_it_matters": "A uniform second-order augmentation invariant would remove the remaining role-count restriction in this Q8 mixed-target family.", + "first_step": "Derive the coefficient constraints in J_Q^2/J_Q^3 while retaining the rank-one idempotent relations.", + "blocked_by": "The first-order quotient is too weak, and any larger finite-role search needs a fresh overlap check; the result still would not establish physical supplier realization." + } + ], + "accepted_seed": "cbd5ebc4789dc7dac5f7f824ab9561fc", + "catalogue_sha256": "6686ad58f1fbdbc87134a78901b60fd53a20d3984355e91defbbebc9e9fa8075", + "selected_record_sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32", + "scope_key": "7084092dd726e7ba1f2f", + "accepted_scope": { + "r3": { + "roles": 3, + "rank_one_idempotents": 28, + "paid_factors": 56, + "depth_counts": [ + 56, + 2324 + ], + "depth3_transitions": 130144, + "target_hits": 0 + }, + "r4_pivot": { + "roles": 4, + "rank_one_idempotents": 120, + "paid_factors": 240, + "depth_counts": [ + 240, + 41800 + ], + "depth3_transitions": 10032000, + "target_hits": 0 + }, + "target_tuples": 36, + "direct_calls": 4, + "tested_calls": "0..3", + "structural_split": { + "k_or_minus_k": 24, + "uniform_min_calls": "4 for all finite r>=3", + "rank_profiles": { + "1,3": 6, + "2,2": 12, + "3,1": 6 + }, + "minus_one": 12, + "exact_finite_role_counts": [ + 3, + 4 + ] + } + }, + "overlap": { + "checked_at": "2026-10-14T13:57:45.787111Z", + "coverage": { + "open_prs": 573, + "discussions": 542, + "complete_pagination": true, + "warnings": [] + }, + "exact_terms": [ + "Q8 mixed three-register", + "Q8 mixed target tuple", + "Q8 heterogeneous target", + "quaternion mixed targets", + "D_i D_j Q8 role", + "bit-new-register-model", + "three-register", + "nonabelian", + "group algebra", + "bit-three-register-lower-bound" + ], + "result": "Complete refreshed scan found this cycle's own Discussion #1167 claim and no remote same-scope claim. PR #1822 remains the nearest Q8 result: two-role repeated central commutator. Other hits are different targets/groups: Discussion #1727 and PR #1716/#1763/Discussion #1774 use AGL2; Discussion #1759 uses UT4; Discussion #1818 uses D16. Pagination complete across 573 open PRs and 542 Discussions, with no warnings.", + "claim_url": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1167#discussioncomment-18925071" + }, + "predecessors": [ + { + "reference": "PR #1822", + "head": "ee736b4b11bbd63b04d94c8edafb3790161ebdea", + "scope": "two-role repeated Q8 central-commutator target; no source code imported" + }, + { + "reference": "PR #1763", + "head": "07910c7bee862dadbb3b3d30ea5dfcdbbbe23fda", + "scope": "even order-three GL2 targets; different group and endpoint tuple" + }, + { + "reference": "Discussion #1774", + "url": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1774", + "scope": "five-role GL2 inverse order-three tuple; different group and role profile" + } + ], + "candidate_scopes": [ + { + "scope": "bit-helper-contract: multi-writer compensation for a deferred helper-star restoration", + "decision": "rejected-overlap", + "reason": "Active in Discussion #1884." + }, + { + "scope": "bit-new-register-model: D16 or UT4 central/noncentral root-pair register words", + "decision": "rejected-overlap", + "reason": "Recent active claims in Discussions #1818 and #1759; Q8 central pair is also covered by PR #1822." + }, + { + "scope": "bit-new-register-model: Q8 three-role mixed generator/product target tuple, then one arbitrary identity-target role", + "decision": "chosen", + "reason": "The target family and role contract differ from the two-role repeated central Q8 target; complete exact-term overlap search found no same-scope remote claim." + } + ] +} diff --git a/research/q8-mixed-three-register-seedcbd5ebc4/TASK.md b/research/q8-mixed-three-register-seedcbd5ebc4/TASK.md new file mode 100644 index 0000000000..3f8823fbd0 --- /dev/null +++ b/research/q8-mixed-three-register-seedcbd5ebc4/TASK.md @@ -0,0 +1,16 @@ +# Cycle 13 task card + +- Selector: `bit-mechanisms`, accepted OS seed `cbd5ebc4789dc7dac5f7f824ab9561fc`, task `bit-new-register-model`, priority revision 3. +- Catalogue SHA-256: `6686ad58f1fbdbc87134a78901b60fd53a20d3984355e91defbbebc9e9fa8075`. +- Base: `0b1cccf86e2f5132ed286a26ef0a681a495740ea`; selected record SHA-256: `10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32`. +- Refined scope: Q8 three-register mixed-target tuple family. Q8 has generators `i,j`, relations `i^2=j^2=-1`, `ij=-ji`. Paid calls are `D_N(g)=I+([g]+[1])N`, `g in {i,j}` and every binary rank-one idempotent `N` on each role space. Inputs are arbitrary dirty group-algebra registers; the endpoint is exact formal `F2[Q8]` equality. Candidate endpoints are all 36 ordered diagonal triples of three nonidentity target elements with minimum positive `{i,j}` word-length sum exactly 4: one role from `{−1, ij, ji}` (cost 2), the others independently from `{i,j}` (cost 1 each). +- One evidence-driven pivot: after the full three-role census found no three-call word, test whether one additional arbitrary dirty register changes the answer for the same target family, embedded as `diag([g1],[g2],[g3],[1])`. No other parameter changes. +- Question: does any endpoint in the family admit a complete word of at most three paid factors, against its four-call direct construction, with exactly three roles or with one additional identity-target dirty role? Illustrative tuple: `diag([i],[j],[ij])` (and `diag([i],[j],[ij],[1])` after the pivot). +- Changed from predecessor: PR #1822 studies the two-register repeated central-commutator target `diag([xyxy],[xyxy])`. This changes to three mixed generator/product targets, then one extra dirty role; no code is imported. Active Discussion #1884's bit claim uses the infinite dihedral reflection alphabet, not Q8. +- Candidate scopes: the selector's helper-star route was passed over because #1884 has an active multi-writer/deferred-restoration claim; D16/UT4 root-pair scopes were passed over because of active #1818/#1759 claims and the recent Q8 central-pair PR #1822. The selected mixed Q8 tuple has no exact same-scope remote hit. +- Optimistic full budget: direct profile is 4 rank-one calls; the target is a 3-call word (saving one call, 25% in this local unit-cost model), with one additional dirty role for the pivot. All frame/role operations are represented by the full rank-one-idempotent alphabet. No recursive supplier mapping or selected-kappa effect is assumed; the selected complex supplier remains binding. +- Exact domain: initial three-role alphabet has 56 factors; pivot alphabet has 240 factors (120 rank-one idempotents × `{i,j}`). Search all call words of length 0–3 against all 36 target triples in each role dimension. Stop after complete exact group-algebra enumeration. A positive result needs a full coefficient certificate, arbitrary-dirty interpretation, a direct four-call control and wrong-target / dropped-call controls. If none is realized, hand off only the scoped negative result; do not generalize. +- Overlap: refreshed 2026-10-14T13:26:49Z; 543 open PRs and 529 Discussion records, complete pagination, no warnings. Exact terms `Q8 three-register mixed generators`, `quaternion heterogeneous targets`, `diag i j ij`, and `mixed quaternion target` found no remote result. PR #1822 head `ee736b4b11bbd63b04d94c8edafb3790161ebdea` is the nearest result but has a different two-role central target. Discussion #1774 has a five-role GL2 inverse-order-three target, a different group and tuple; #1884's bit candidate is infinite dihedral. +- Claim posted and pivot recorded in [Discussion #1167 comment](https://github.com/CrocSwap/integer-mult-bounds/discussions/1167#discussioncomment-18925071); expiry 2026-10-14 15:27 UTC. +- Result: exact no-three-call obstruction for all 36 tuples at r=3 and r=4. r=3 checks 130,144 depth-three transitions; the one-helper pivot checks 10,032,000. Each tuple has a direct four-call realization, so minimum is four in both pinned models. No broader or supplier-level conclusion. +- Expected artifact: exact positive construction or exact finite-domain obstruction, reproducible command, explicit limits, predecessor attribution, and substantial Codex assistance disclosure. diff --git a/research/q8-mixed-three-register-seedcbd5ebc4/VERIFY.json b/research/q8-mixed-three-register-seedcbd5ebc4/VERIFY.json new file mode 100644 index 0000000000..89905efbfe --- /dev/null +++ b/research/q8-mixed-three-register-seedcbd5ebc4/VERIFY.json @@ -0,0 +1,19 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 300, + "checks": "Exact Q8 group-algebra reachability through 3 calls for all 36 mixed targets at r=3 and r=4; direct four-call controls, positive depth-2 control, and boundary mutations." + } + ] +} diff --git a/research/q8-mixed-three-register-seedcbd5ebc4/verify.py b/research/q8-mixed-three-register-seedcbd5ebc4/verify.py new file mode 100644 index 0000000000..72707285a0 --- /dev/null +++ b/research/q8-mixed-three-register-seedcbd5ebc4/verify.py @@ -0,0 +1,300 @@ +#!/usr/bin/env python3 +"""Exact reachability through three paid calls in small Q8 register models.""" +import hashlib +import json +from itertools import product +from pathlib import Path + +ONE = (1, 0, 0, 0) +MINUS_ONE = (-1, 0, 0, 0) +I = (0, 1, 0, 0) +MINUS_I = (0, -1, 0, 0) +J = (0, 0, 1, 0) +MINUS_J = (0, 0, -1, 0) +K = (0, 0, 0, 1) +MINUS_K = (0, 0, 0, -1) +GROUP = (ONE, MINUS_ONE, I, MINUS_I, J, MINUS_J, K, MINUS_K) +GID = {g: n for n, g in enumerate(GROUP)} + + +def qmul(x, y): + a, b, c, d = x + e, f, g, h = y + return (a*e-b*f-c*g-d*h, + a*f+b*e+c*h-d*g, + a*g-b*h+c*e+d*f, + a*h+b*g-c*f+d*e) + + +GMUL = tuple(tuple(GID[qmul(x, y)] for y in GROUP) for x in GROUP) + + +def right_delta_table(g): + """Map x to x*([g]+[1]) in the exact F2 group algebra.""" + out = [] + for x in range(256): + translated = 0 + for q in range(8): + if x >> q & 1: + translated ^= 1 << GMUL[q][g] + out.append(x ^ translated) + return tuple(out) + + +DELTA = {"i": right_delta_table(GID[I]), "j": right_delta_table(GID[J])} + + +def ga_mul(x, y): + """Slow reference convolution in F2[Q8], used to check the fast update.""" + out = 0 + for a in range(8): + if x >> a & 1: + for b in range(8): + if y >> b & 1: + out ^= 1 << GMUL[a][b] + return out + + +def matrix_mul(A, B, r): + out = bytearray(r*r) + for i in range(r): + for j in range(r): + value = 0 + for k in range(r): + value ^= ga_mul(A[i*r+k], B[k*r+j]) + out[i*r+j] = value + return bytes(out) + + +def factor_matrix(factor, r): + label, u, v = factor + g = GID[I] if label == "i" else GID[J] + address_delta = (1 << g) ^ 1 + return bytes((1 if i == j else 0) ^ + (address_delta if u[i] and v[j] else 0) + for i in range(r) for j in range(r)) + + +def idempotent_data(r): + """All rank-one N=uv^T with v^T u=1; each has a unique F2 factorization.""" + vectors = tuple(v for v in product((0, 1), repeat=r) if any(v)) + data = [] + for u in vectors: + for v in vectors: + if sum(a*b for a, b in zip(u, v)) % 2: + N = tuple(u[i]*v[j] for i in range(r) for j in range(r)) + data.append((N, u, v)) + assert len({N for N, _u, _v in data}) == len(data) + assert len(data) == (2**r - 1) * 2**(r-1) + return tuple(data) + + +def apply_factor(M, factor, r): + """Right multiply M by D_N(g)=I+([g]+[1])uv^T.""" + label, u, v = factor + delta = DELTA[label] + out = bytearray(M) + for row in range(r): + row_delta = 0 + base = row*r + for k in range(r): + if u[k]: + row_delta ^= delta[M[base+k]] + if row_delta: + for col in range(r): + if v[col]: + out[base+col] ^= row_delta + return bytes(out) + + +def identity(r): + return bytes(1 if i == j else 0 for i in range(r) for j in range(r)) + + +def target_matrix(targets): + r = len(targets) + return bytes((1 << GID[g]) if i == j else 0 + for i, g in enumerate(targets) + for j in range(r)) + + +def candidate_targets(): + """36 ordered triples with positive {i,j} word-length invoice 4.""" + out = set() + for slot in range(3): + for length_two in (MINUS_ONE, K, MINUS_K): + remaining = [p for p in range(3) if p != slot] + for x, y in product((I, J), repeat=2): + target = [None, None, None] + target[slot] = length_two + target[remaining[0]], target[remaining[1]] = x, y + out.add(tuple(target)) + assert len(out) == 36 + return tuple(sorted(out, key=lambda t: tuple(GID[x] for x in t))) + + +def direct_word(targets, r): + """Positive alphabet direct word, using one coordinate projector per role.""" + word = [] + for slot, g in enumerate(targets): + u = tuple(int(i == slot) for i in range(r)) + v = u + if g == I: + word.append(("i", u, v)) + elif g == J: + word.append(("j", u, v)) + elif g == MINUS_ONE: + word.extend((("i", u, v), ("i", u, v))) + elif g == K: + word.extend((("i", u, v), ("j", u, v))) + elif g == MINUS_K: + word.extend((("j", u, v), ("i", u, v))) + elif g == ONE: + continue + else: + raise ValueError("target is outside the declared positive alphabet-length domain") + return word + + +def run_search(r, triples): + targets = tuple(tuple(t) + (ONE,) * (r - 3) for t in triples) + target_map = {target_matrix(t): t for t in targets} + assert len(target_map) == len(triples) + factors = tuple((label, u, v) + for label in ("i", "j") + for _N, u, v in idempotent_data(r)) + assert len(factors) == 2 * (2**r - 1) * 2**(r-1) + + # Check the optimized rank-one update against full coefficient convolution + # for every paid factor on several arbitrary formal matrix states. + samples = [identity(r)] + for seed in range(1, 5): + samples.append(bytes((seed*37 + cell*53 + r) & 255 + for cell in range(r*r))) + for M in samples: + for factor in factors: + assert apply_factor(M, factor, r) == matrix_mul(M, factor_matrix(factor, r), r) + + # Every endpoint has its explicit 4-call direct control. + for t in targets: + assert len(direct_word(t, r)) == 4 + M = identity(r) + for factor in direct_word(t, r): + M = matrix_mul(M, factor_matrix(factor, r), r) + assert M == target_matrix(t) + + # All exact-depth states at depths one and two. State merging is sound: + # every suffix acts deterministically on a group-algebra matrix. + states = {identity(r): ()} + level_counts = [] + found = {} + for depth in (1, 2): + nxt = {} + for M, prefix in states.items(): + for index, factor in enumerate(factors): + P = apply_factor(M, factor, r) + if P not in nxt: + nxt[P] = prefix + (index,) + level_counts.append(len(nxt)) + for P, word in nxt.items(): + if P in target_map: + found.setdefault(target_map[P], (depth, word)) + states = nxt + print(f"r={r} depth={depth} states={len(nxt)} target_hits={len(found)}") + + # Positive engine control at depth two. + easy = (I, J, ONE) + (ONE,) * (r - 3) + easy_target = target_matrix(easy) + assert easy_target in states + M = identity(r) + for factor in direct_word(easy, r): + M = matrix_mul(M, factor_matrix(factor, r), r) + assert M == easy_target + + # Stream every extension of every distinct depth-two state. This is + # complete for all depth-three words but does not retain a huge third layer. + transitions = 0 + depth_three_hits = {} + for M, prefix in states.items(): + for index, factor in enumerate(factors): + P = apply_factor(M, factor, r) + transitions += 1 + if P in target_map: + depth_three_hits.setdefault(target_map[P], prefix + (index,)) + found.update({t: (3, w) for t, w in depth_three_hits.items() if t not in found}) + print(f"r={r} depth=3 transitions={transitions} target_hits={len(depth_three_hits)}") + + # Dropping a call from the illustrative direct path changes its endpoint. + example = (I, J, K) + (ONE,) * (r - 3) + example_target = target_matrix(example) + direct = direct_word(example, r) + partial = identity(r) + for factor in direct[:-1]: + partial = apply_factor(partial, factor, r) + assert partial != example_target + wrong = target_matrix((I, J, MINUS_K) + (ONE,) * (r - 3)) + assert wrong != example_target + assert wrong in target_map + assert wrong not in {target_matrix(t) for t in found} + + return level_counts, transitions, found + + +def main(): + assert len(GROUP) == 8 and len(GID) == 8 + assert len({qmul(x, y) for x in GROUP for y in GROUP}) == 8 + assert all(qmul(qmul(x, y), z) == qmul(x, qmul(y, z)) + for x in GROUP for y in GROUP for z in GROUP) + assert qmul(I, I) == MINUS_ONE and qmul(J, J) == MINUS_ONE + assert qmul(I, J) == K and qmul(J, I) == MINUS_K + assert qmul(K, K) == MINUS_ONE + + triples = candidate_targets() + expected = json.loads(Path(__file__).with_name("EXPECTED.json").read_text()) + names = {ONE: "1", MINUS_ONE: "-1", I: "i", MINUS_I: "-i", + J: "j", MINUS_J: "-j", K: "k", MINUS_K: "-k"} + named_triples = [[names[g] for g in t] for t in triples] + encoded = json.dumps(named_triples, separators=(",", ":")).encode() + assert len(named_triples) == expected["target_count"] == 36 + assert named_triples == expected["target_triples"] + assert hashlib.sha256(encoded).hexdigest() == expected["target_triples_sha256"] + abelianization = {ONE: (0, 0), MINUS_ONE: (0, 0), + I: (1, 0), MINUS_I: (1, 0), + J: (0, 1), MINUS_J: (0, 1), + K: (1, 1), MINUS_K: (1, 1)} + noncentral = [t for t in triples if K in t or MINUS_K in t] + central = [t for t in triples if MINUS_ONE in t] + assert len(noncentral) == expected["structural_split"]["k_or_minus_k"] == 24 + assert len(central) == expected["structural_split"]["minus_one"] == 12 + rank_profile = {} + for t in noncentral: + rank_x = sum(abelianization[g][0] for g in t) + rank_y = sum(abelianization[g][1] for g in t) + assert rank_x == 1 + sum(g == I for g in t) + assert rank_y == 1 + sum(g == J for g in t) + assert rank_x + rank_y == 4 + key = f"{rank_x},{rank_y}" + rank_profile[key] = rank_profile.get(key, 0) + 1 + assert rank_profile == expected["structural_split"]["rank_profiles"] + three_results = run_search(3, triples) + four_results = run_search(4, triples) + assert not three_results[2] + assert not four_results[2] + assert three_results[0] == [56, 2324] + assert three_results[1] == 2324 * 56 + assert four_results[0] == [240, 41800] + assert four_results[1] == 10_032_000 + for key, actual in (("r3", three_results), ("r4", four_results)): + assert actual[0] == [expected[key]["depth1_states"], expected[key]["depth2_states"]] + assert actual[1] == expected[key]["depth3_transitions"] + assert expected[key]["target_hits"] == 0 + print("PASS_Q8_MIXED_TUPLES targets=36 factors_r3=56 factors_r4=240 " + f"states_r3={three_results[0]} transitions_r3={three_results[1]} " + f"states2_r4={four_results[0]} transitions_r4={four_results[1]} " + "min_calls_r3_r4=4 full_convolution_crosscheck=PASS positive_control=2 " + "dropped_call=REJECTED wrong_target=REJECTED") + return 0 + + +if __name__ == "__main__": + raise SystemExit(main())