From 679f3624a0a41ed14942825dd7f413132412d1e3 Mon Sep 17 00:00:00 2001 From: Cinna Davis <1337isnot1337@users.noreply.github.com> Date: Wed, 14 Oct 2026 03:25:30 -0500 Subject: [PATCH] research: bound D8 central pair with a third register --- .../CERTIFICATE.json | 43 +++ research/d8-third-register-seed89de/CLAIM.md | 15 + .../d8-third-register-seed89de/OVERLAP.json | 267 ++++++++++++++++++ research/d8-third-register-seed89de/README.md | 130 +++++++++ .../d8-third-register-seed89de/SOURCES.json | 42 +++ research/d8-third-register-seed89de/TASK.json | 75 +++++ .../d8-third-register-seed89de/VERIFY.json | 23 ++ research/d8-third-register-seed89de/verify.py | 250 ++++++++++++++++ 8 files changed, 845 insertions(+) create mode 100644 research/d8-third-register-seed89de/CERTIFICATE.json create mode 100644 research/d8-third-register-seed89de/CLAIM.md create mode 100644 research/d8-third-register-seed89de/OVERLAP.json create mode 100644 research/d8-third-register-seed89de/README.md create mode 100644 research/d8-third-register-seed89de/SOURCES.json create mode 100644 research/d8-third-register-seed89de/TASK.json create mode 100644 research/d8-third-register-seed89de/VERIFY.json create mode 100644 research/d8-third-register-seed89de/verify.py diff --git a/research/d8-third-register-seed89de/CERTIFICATE.json b/research/d8-third-register-seed89de/CERTIFICATE.json new file mode 100644 index 0000000000..9ba792e563 --- /dev/null +++ b/research/d8-third-register-seed89de/CERTIFICATE.json @@ -0,0 +1,43 @@ +{ + "status": "PASS_D8_THIRD_REGISTER", + "seed": "89dea4bc3a42ef85f785169cd2b6977e", + "base_commit": "0b1cccf86e2f5132ed286a26ef0a681a495740ea", + "selected_record_sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32", + "group": "UT3(F2)", + "target": "diag([xyxy],[xyxy],[1])", + "registers": 3, + "rank_one_idempotents": 28, + "generators": 56, + "identity_layers": [ + 1, + 56, + 1750, + 45424 + ], + "target_layers": [ + 1, + 56, + 1750, + 45424 + ], + "identity_states_radius3": 47231, + "target_states_radius3": 47231, + "identity_ball_sha256": "2d66bf31796711244a41efc678d433da22b9ee110855ec00d21c34c332f54de5", + "target_ball_sha256": "1e9e3dac8b229db93c6ee82ef19d165ce7a9ceb475b2b1a59815b48f136b5e92", + "radius3_intersection_states": 0, + "target_radius4_edges_checked": 2543744, + "radius4_intersection_edges": 0, + "maximum_paid_word_searched": 7, + "direct_upper_bound_calls": 8, + "exact_minimum_in_model": 8, + "free_gl3_mixing": "normalized by augmentation into the complete 56-generator alphabet", + "controls": { + "full_group_associativity": true, + "all_generators_involutive": true, + "direct_word_exact": true, + "all_eight_single_omissions_rejected": true, + "compact_transition_matches_full_algebra": true, + "changed_third_target_rejected": true + }, + "new_kappa": false +} diff --git a/research/d8-third-register-seed89de/CLAIM.md b/research/d8-third-register-seed89de/CLAIM.md new file mode 100644 index 0000000000..14dc16b1f3 --- /dev/null +++ b/research/d8-third-register-seed89de/CLAIM.md @@ -0,0 +1,15 @@ +CLAIM + +**Track / assignment:** `bit-mechanisms`; accepted OS seed `89dea4bc3a42ef85f785169cd2b6977e`; task `bit-new-register-model`, refined and changed to `D8-UT3(F2)-r3-central-pair`; priority revision 3; catalogue SHA-256 `6686ad58f1fbdbc87134a78901b60fd53a20d3984355e91defbbebc9e9fa8075`. Exact base `0b1cccf86e2f5132ed286a26ef0a681a495740ea`; selected-record SHA-256 `10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32`. + +**Question / object:** Let `G=UT3(F2)` with `x=(1,0,0)`, `y=(0,1,0)`, and central commutator `z=xyxy=(0,0,1)`. On three arbitrary dirty scalar registers, can a word of at most seven paid factors `I+([g]+1)N`, `g in {x,y}`, `N=uv^T` any rank-one idempotent in `M3(F2)`, realize `diag([z],[z],[1])` exactly in `F2[G]`? This asks whether one restored dirty register can share work across the two duplicate central targets. + +**Changed hypothesis and full optimistic charge:** The predecessor fixes two registers and proves minimum eight; this scope adds exactly one arbitrary dirty register, which must return unchanged. Every paid factor is charged one unit, including all restoration. The direct two-register construction costs eight, so a useful candidate must use at most seven. Arbitrary interleaved `GL3(F2)` scalar mixing is allowed at zero price only as the explicit favorable normalization by augmentation; no COPY, clean state, frame operation, or additional role is available in this formal model. Any physical hosting/recursive cost for the added register is outside this scalar construction and would still be needed for supplier adoption. No immediate kappa claim is possible from this abstraction. + +**Method / stopping rule:** Enumerate all 28 rank-one idempotents and both labels (56 paid generators). Use exact packed coefficient matrices over the full eight-element group algebra. Exhaust words of length at most seven by a radius-3 identity ball and radius-4 target-side enumeration, checking every expanded state against the exact opposite ball. A meeting yields an exact candidate and its paid word; no meeting excludes only this stated alphabet/role model through seven calls. Stop after all depth-four expansions and exact direct-word/control replays. + +**Predecessors and overlap:** The exact two-register predecessor is `research/bit-dihedral-commutator/README.md` and its pinned verifier; it establishes the eight-call baseline and explicitly leaves a restored third dirty register open. The refreshed overlap search at 2026-10-14 08:12 UTC had complete pagination (415 open PRs, 328 discussion records, no warnings) and found no exact D8/UT3 third-register claim. Nearest structurally related work is PR #1720 (three-register S4 4-cycle targets) and Discussion #1317 (coordinate-CNOT labels), which use different groups/targets; active #1700 and #1727 use four-register rational/AGL2 objects. This scope changes the group object and target from those results. + +**Expected evidence:** A source-pinned package with the complete radius counts and hashes, a direct eight-call positive control, exact independent endpoint multiplication, and altered-target/omitted-call negative controls. Outcome is either a seven-call formal construction or a bounded no-seven-call result; neither would establish physical supplier admission or a multiplication bound. + +Claim expiry: 2026-10-14 10:15 UTC. diff --git a/research/d8-third-register-seed89de/OVERLAP.json b/research/d8-third-register-seed89de/OVERLAP.json new file mode 100644 index 0000000000..05b862178e --- /dev/null +++ b/research/d8-third-register-seed89de/OVERLAP.json @@ -0,0 +1,267 @@ +{ + "status": "POSSIBLE_OVERLAP_NOT_A_NOVELTY_CERTIFICATE", + "searched_at": "2026-10-14T08:24:25.461835+00:00", + "terms": [ + "D8 central commutator", + "UT3(F2) third dirty register", + "rank-one idempotents" + ], + "coverage": { + "open_prs": { + "fetched_at": "2026-10-14T08:22:31.829423+00:00", + "complete_pagination": true, + "records": 419 + }, + "discussions": { + "fetched_at": "2026-10-14T08:24:25.411937+00:00", + "complete_pagination": true, + "records": 374 + } + }, + "local_records": 873, + "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.", + "matches_total": 24, + "matches": [ + { + "number": 1738, + "title": "CLAIM: third dirty register for the D8 central commutator (seed 89dea4bc)", + "kind": "discussion", + "url": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1738", + "updated_at": "2026-10-14T08:14:00Z", + "matched_terms": [ + "d8 central commutator", + "rank-one idempotents" + ], + "score": 4, + "excerpt": "ediate kappa claim is possible from this abstraction.\n\n**Method / stopping rule:** Enumerate all 28 rank-one idempotents and both labels (56 paid generators). Use exact packed coefficient matrices over the full eight-element group algebra. Exhaust words of length at most seven by a radius-3 identity ball and radius-4 target-side enumeration, checking every expanded state against the exact opposite ball. A meeting yields an exact candidate and its paid word; no meeting excludes only this stated a" + }, + { + "number": 1727, + "title": "CLAIM: mixed four-register affine targets with standalone translations (seed 5638c49a)", + "kind": "discussion", + "url": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1727", + "updated_at": "2026-10-14T08:03:13Z", + "matched_terms": [ + "rank-one idempotents" + ], + "score": 1, + "excerpt": "cal supplier or \u03ba change follows from this formal model alone.\n\n**Bounded method:** Exhaust all 120 rank-one idempotents and all four labels in the homogeneous affine representation. Enumerate every rank trajectory that can reach identity from the target in six or seven calls (six strict rank drops for length 6; six drops and one neutral step for length 7). A found word will be replayed in the full formal group algebra. If no word appears, report only the scoped q=6/7 exclusion; q=8..10 remain o" + }, + { + "number": 1700, + "title": "CLAIM: two-relation four-register rational bit mechanism (seed 52ca0472)", + "kind": "discussion", + "url": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1700", + "updated_at": "2026-10-14T08:13:22Z", + "matched_terms": [ + "rank-one idempotents" + ], + "score": 1, + "excerpt": "g is nonbinding at the current selected record.\n\nMethod and bounded domain:\nFirst enumerate all 120 rank-one idempotents on four scalar registers, their directed off-diagonal patterns, and every two-dimensional F2 pattern subspace whose three nonzero elements are realized. Use the nontriangular pattern pools as the bounded candidate class for the fixed 15-address word, then accept any candidate only after exact sparse group-algebra expansion and a complete role invoice. Stop after this finite ce" + }, + { + "number": 1317, + "title": "Binary affine addresses: exact paid-call floor with arbitrary dirty registers", + "kind": "discussion-comment", + "url": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1317#discussioncomment-18911765", + "updated_at": "2026-10-14T00:30:32Z", + "matched_terms": [ + "rank-one idempotents" + ], + "score": 1, + "excerpt": "ain: an exact bidirectional exhaustive word census through five paid calls. It covers all 28 binary rank-one idempotents on three registers and both coordinate-CNOT labels a and b (56 generators), with scalar GL_3(F2) mixing normalized by augmentation. We check the six-call direct formal witness. If a shorter word exists, we verify every formal coefficient and report its complete paid bill. The two-register restriction is a positive comparison, and no numerical representation stands in for forma" + }, + { + "number": 1317, + "title": "Binary affine addresses: exact paid-call floor with arbitrary dirty registers", + "kind": "discussion-comment", + "url": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1317#discussioncomment-18915962", + "updated_at": "2026-10-14T05:43:07Z", + "matched_terms": [ + "rank-one idempotents" + ], + "score": 1, + "excerpt": "mplementations cross-check. Ranges: `r = 4`, `t = 4`, `q` in {8, 10}, `g` in {a, b}, all 120 binary rank-one idempotents of `F2^4`, free `GL_4(F2)` mixing at zero cost anywhere (strongest convention).\n\n**Overlap.** `find_overlap.py` complete pagination (531 open PRs / 299 discussion records, 2026-10-14T05:24Z) for `four coordinate swaps`, `four SWAP`, `coordinate-CNOT`, `GL_2(F2)`, `four targets`, `12 calls` found no four-target coordinate-CNOT claim. This does not establish literature priority." + }, + { + "number": 1317, + "title": "Binary affine addresses: exact paid-call floor with arbitrary dirty registers", + "kind": "discussion-comment", + "url": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1317#discussioncomment-18918046", + "updated_at": "2026-10-14T07:09:58Z", + "matched_terms": [ + "rank-one idempotents" + ], + "score": 1, + "excerpt": "one of the two coordinate CNOTs or two coordinate translations, each priced 1, and N any of the six rank-one idempotents in M2(F2). Free scalar GL2 mixing is retained under the inherited normalization; no other address labels or workspace are allowed. The direct word abav costs 8 total; rank([A_h-I|b_h])=2 per target, so the complete optimistic headroom is 4 calls.\n\nMethod/domain: exact formal group-algebra products and a complete radius-seven 3+4 meet-in-the-middle join over all 24 paid factors" + }, + { + "number": 1317, + "title": "Binary affine addresses: exact paid-call floor with arbitrary dirty registers", + "kind": "discussion-comment", + "url": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1317#discussioncomment-18919080", + "updated_at": "2026-10-14T08:01:53Z", + "matched_terms": [ + "rank-one idempotents" + ], + "score": 1, + "excerpt": "ds), and a bounded seeded feasibility search of the balanced (5,5) layer system over the 120 binary rank-one idempotents and all 252 interleavings, with any hit replayed at full formal level.\n\nExpected artifact: `research/four-swap-balanced-j3-layer/` \u2014 exact certificate + written lemmas + `python3 -B research/four-swap-balanced-j3-layer/verify.py`. Outcome is either an exact layer-infeasibility certificate for the balanced profile or an explicit layer-satisfying balanced assignment recording th" + }, + { + "number": 1317, + "title": "Binary affine addresses: exact paid-call floor with arbitrary dirty registers", + "kind": "discussion-comment", + "url": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1317#discussioncomment-18919458", + "updated_at": "2026-10-14T08:20:36Z", + "matched_terms": [ + "rank-one idempotents" + ], + "score": 1, + "excerpt": "Magnus) invariants including the `F2[G]` kernel correction; `t = r in {2,3,4}`, all 6/28/120 binary rank-one idempotents, both labels. Positive controls must reproduce PR1705's recorded `r = 4` ball sizes `240 / 32,651 / 3,639,920`, the minima 2 at `t=1` and 6 for two SWAP targets at `r=2`, and a drop-one-call mutation must fail on the attaining word.\n\nExpected artifact: `research/even-target-cnot-census/` with README, receipts, source pins and `verify.py`. No kappa, supplier or selected-frontie" + }, + { + "number": 1700, + "title": "CLAIM: two-relation four-register rational bit mechanism (seed 52ca0472)", + "kind": "discussion-comment", + "url": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1700#discussioncomment-18919321", + "updated_at": "2026-10-14T08:13:21Z", + "matched_terms": [ + "rank-one idempotents" + ], + "score": 1, + "excerpt": "ds/pull/1733\n\nFor the fixed ordered 15-address, two-relation family, the certificate covers all 120 rank-one idempotents, 105 off-diagonal patterns, 196 realizable pattern planes, and all 120 exceptional-plane/signature prefixes for the specified first-seven-prefix ansatz. It finds no diagonal singleton endpoint. The 16-call positive control passes and both negative controls are rejected. This does not rule out arbitrary exact words or other address schedules, and it supplies no kappa improvemen" + }, + { + "number": 1630, + "title": "Closed fixed-weight conic slice: eleven calls cannot realize four full targets", + "kind": "discussion-comment", + "url": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1630#discussioncomment-18916680", + "updated_at": "2026-10-14T06:16:22Z", + "matched_terms": [ + "rank-one idempotents" + ], + "score": 1, + "excerpt": "s; the elementary two-projector lemma is checked on all 14,280 distinct ordered pairs among all 120 rank-one idempotents. No finite-field fingerprint is used as the proof.\n\nThe operator/rank argument is included below for independent review. Exact integer characters and the finite target boundaries are essential. The address-gate receipt SHA256 is c2b7d6d1feb464393a30251593505582779485c6674d2272b40b30f4c3d4e2e5. Broader weights, missing directions, nonsymmetric frames and larger pools remain ope" + }, + { + "number": 1594, + "title": "Ternary half-integral bit frames: eight-call obstruction with arbitrary dirty registers", + "kind": "discussion-comment", + "url": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1594#discussioncomment-18914574", + "updated_at": "2026-10-14T04:07:53Z", + "matched_terms": [ + "rank-one idempotents" + ], + "score": 1, + "excerpt": "nitely generated subgroup (not all of M3(Q)), then classify scalar spaces generated by at most four rank-one idempotents containing the rank-three target projector. The delicate cases are target divisibility in that subgroup and the low-dimensional rational frame span. Existing #468 and #1456 remain predecessors and are not being reproved as new.\n\nBase main 81e81af67714bdc8d1693b0bf5c29468b92f62ff; side result toward avoiding larger alphabet searches, not a positive supplier or new kappa. Expect" + }, + { + "kind": "local-readme", + "title": "research/bit-one-relation-any-registers/README.md", + "path": "research/bit-one-relation-any-registers/README.md", + "sha256": "1f2899320e646a4158531c3f8260ba32b4761ae883fdb5bce4d3e3b0a4d8cb8c", + "matched_terms": [ + "rank-one idempotents" + ], + "score": 1, + "excerpt": "python -I -O -B research/bit-one-relation-any-registers/verify.py`\n\nThe checker exhausts all binary rank-one idempotents for W = 1 through 5:\n1, 6, 28, 120 and 496 projectors. It checks the common-pattern classification\nand all 3,057 coordinate-idempotent Laurent conjugations. Forty-eight exact\nfour-register placement fixtures exercise the one-relation block argument,\nincluding cyclic projectors with incoming and outgoing tails. A torsion\ncountercontrol passes after unsafe reduction modulo 2 but" + }, + { + "kind": "local-readme", + "title": "research/bit-one-relation-seed04/README.md", + "path": "research/bit-one-relation-seed04/README.md", + "sha256": "38c823584621d2cbd6cd1899dca04c53ca93bab1435056a28b1d5a2e001d4a0d", + "matched_terms": [ + "rank-one idempotents" + ], + "score": 1, + "excerpt": "implementation.\nBoth compare every formal coefficient of all thirteen word fixtures.\n\n| Registers | Rank-one idempotents | Off-diagonal patterns | Cyclic patterns | Conjugations |\n|---|---:|---:|---:|---:|\n| 1 | 1 | 1 | 0 | 1 |\n| 2 | 6 | 3 | 0 | 12 |\n| 3 | 28 | 20 | 1 | 84 |\n| 4 | 120 | 105 | 12 | 480 |\n\n[CERTIFICATE.json](CERTIFICATE.json) records the complete finite census,\ncatalogue and formal-product digests, frame nullities and target ranks.\nControls catch a wrong relation sign, active-fact" + }, + { + "kind": "local-readme", + "title": "research/bit-three-register-lower-bound/README.md", + "path": "research/bit-three-register-lower-bound/README.md", + "sha256": "c12b33ef388deece0cbf891505a2ce2c0779a0c3a6cf1f0f7f7039bab59cbebd", + "matched_terms": [ + "rank-one idempotents" + ], + "score": 1, + "excerpt": "mathbb Q}A=1,\\qquad\nN=xy^T,\\quad x,y\\in\\mathbb F_2^3,\\quad y^Tx=1.\n$$\n\nThere are 28 possible binary rank-one idempotents $N$. We ask whether\n\n$$\n\\prod_{j=1}^{8}D_{N_j}([A_j])\n =\\operatorname{diag}([C_1],[C_2],[C_3]),\n\\qquad C_w\\in M_3(\\mathbb Q)\n\\text{ invertible and lower triangular}. \\tag{1}\n$$\n\nFactor order matters. Rational frame entries are not reduced modulo two.\nEquation (1) requires equality of every formal coefficient. An identity at\none finite address size does not suffice.\n\nThis is th" + }, + { + "kind": "local-readme", + "title": "research/d8-third-register-seed89de/README.md", + "path": "research/d8-third-register-seed89de/README.md", + "sha256": "76dc135ada67c5b29f3c6fc62ff6aafa4e28307f2d4c5900fd623683747580bf", + "matched_terms": [ + "rank-one idempotents" + ], + "score": 1, + "excerpt": "habet consists\nof\n\n`D_N(g) = I + ([g]+[1])N`,\n\nwhere `g` is `x` or `y` and `N=uv^T` ranges over all rank-one idempotents in\n`M3(F2)`. There are 28 such idempotents and 56 paid gates. The target is\n`diag([z],[z],[1])`; equality in the full group algebra ensures that the third\nregister is restored and that the endpoint identity holds for arbitrary dirty\nregister contents.\n\nEach paid gate costs one unit, including every gate in the direct comparison.\nThe direct word applies `x,y,x,y` on each of the" + }, + { + "kind": "local-readme", + "title": "research/idempotent-path-rank-audit/README.md", + "path": "research/idempotent-path-rank-audit/README.md", + "sha256": "d245a72ae3782fe1e80b90b32b6c2976ced4e8884a7a7926da984af8ac23eb5b", + "matched_terms": [ + "rank-one idempotents" + ], + "score": 1, + "excerpt": "nk-product-core \u00a71](../../docs/research/rank-product-core.md): general,\n possibly non-self-adjoint rank-one idempotents with **mutual** annihilation;\n- [block-core](../../docs/research/block-core.md): uniform higher-rank labels;\n- `check_projector_core`, `check_block_projectors`, and the actual time-2 and\n time-5 matrices in `scripts/experiments/rank_product_core.py::_compile`.\n\n[SOURCES.json](SOURCES.json) pins the audited documents, selected-record\ncontext, complete inherited Python import c" + }, + { + "kind": "local-task", + "title": "research/bit-one-relation-seed04/TASK.json", + "path": "research/bit-one-relation-seed04/TASK.json", + "sha256": "4182f0d83062d8f10cc2900c24f788e6fe05c6e607fa801aa18f660d078fbfa9", + "matched_terms": [ + "rank-one idempotents" + ], + "score": 1, + "excerpt": "m.\",\n \"first_step\": \"Classify two-dimensional off-diagonal pattern spaces among the 120 binary rank-one idempotents on four registers, looking for nontriangular pools.\",\n \"blocked_by\": \"A uniform argument for rational frame relations, not additional random search.\"\n },\n {\n \"question\": \"Can the scalar-pattern and conjugation lemmas be formalized?\",\n \"why_it_matters\": \"The universal claim currently relies on a written proof, separately from its finite supporting replay.\"," + }, + { + "kind": "local-task", + "title": "research/d8-third-register-seed89de/TASK.json", + "path": "research/d8-third-register-seed89de/TASK.json", + "sha256": "9ff8973fc98c800d7dc620756eb2ea25d5a697e6be0c50c47082b5ffb22d1b31", + "matched_terms": [ + "rank-one idempotents" + ], + "score": 1, + "excerpt": " gate count for diag([xyxy],[xyxy],[1]) on three arbitrary dirty registers using labels x,y, all 28 rank-one idempotents of M3(F2), and arbitrary free GL3(F2) mixing normalized by augmentation.\",\n \"scope_change_reason\": \"The catalogue card is broad. This narrows it to the explicit unresolved third-dirty-register extension of the exact two-register D8 central-commutator result, changing the role count from two to three while fixing the group, target, and paid alphabet.\",\n \"bottleneck_link\": \"A " + }, + { + "kind": "pr", + "number": 1495, + "title": "Finite certificate: a third address coordinate does not cheapen two coordinate swaps (no new kappa)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1495", + "head": "d5f8745962597a2e5d5bf2deeb7925705c37db8e", + "updated_at": "2026-10-14T01:46:11Z", + "draft": false, + "state": "open", + "matched_terms": [ + "rank-one idempotents" + ], + "score": 1, + "excerpt": "s are reduced modulo two.\n- **Method and complete domain:** all six coordinate CNOTs and all binary rank-one idempotents (6 at r = 2, 28 at r = 3). Every word through length five is exhausted by a radius-two/three intersection.\n- **Optimistic budget:** six paid calls, including all undo calls, with scalar GL_r mixing free only as an explicit relaxation. A saving needs at most five calls, and every such word is excluded.\n- **Nearest work:**\n - PR #1414 uses only the two GL_2 labels and proves an" + }, + { + "kind": "pr", + "number": 1491, + "title": "Finite certificate: three coordinate swaps need nine paid calls on three registers (no new kappa)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1491", + "head": "69638b36c691d3e1b8463526fd68c849e8d1aef9", + "updated_at": "2026-10-14T01:42:55Z", + "draft": false, + "state": "open", + "matched_terms": [ + "rank-one idempotents" + ], + "score": 1, + "excerpt": "te CNOTs. No rational frame data are reduced modulo two.\n- **Method and domain:**\n - all 28 binary rank-one idempotents `N=uv^T` with `v^Tu=1`;\n - all 56 paid calls `I+([g]+1)N`, with `g` in {a, b};\n - exact balls through radius four, with no symmetry quotient, heuristic or floating-point pruning;\n - scalar operations normalized by augmentation;\n - no additional register, free address map, copy, erasure or clean allocation.\n- **Optimistic budget:** the direct `aba` on each coordinate projec" + } + ] +} diff --git a/research/d8-third-register-seed89de/README.md b/research/d8-third-register-seed89de/README.md new file mode 100644 index 0000000000..5540345179 --- /dev/null +++ b/research/d8-third-register-seed89de/README.md @@ -0,0 +1,130 @@ +# A third dirty register does not shorten the D8 central pair + +**Exact scoped negative result; minimum remains eight paid calls.** In the +three-register formal model over `F2[UT3(F2)]`, the target +`diag([xyxy],[xyxy],[1])` has no word of seven or fewer paid rank-one factors, +even with arbitrary free `GL3(F2)` scalar mixing. The direct eight-call word +therefore remains optimal after adding one arbitrary dirty register to the +two-register model. This is a result about the named finite alphabet and target, +not a universal bound on bit circuits or the multiplication exponent. + +## Model and cost + +Write group elements as triples with + +`(a,b,c)(a',b',c') = (a+a', b+b', c+c'+ab')` over `F2`. + +Let `x=(1,0,0)`, `y=(0,1,0)`, and `z=xyxy=(0,0,1)`. The paid alphabet consists +of + +`D_N(g) = I + ([g]+[1])N`, + +where `g` is `x` or `y` and `N=uv^T` ranges over all rank-one idempotents in +`M3(F2)`. There are 28 such idempotents and 56 paid gates. The target is +`diag([z],[z],[1])`; equality in the full group algebra ensures that the third +register is restored and that the endpoint identity holds for arbitrary dirty +register contents. + +Each paid gate costs one unit, including every gate in the direct comparison. +The direct word applies `x,y,x,y` on each of the first two diagonal roles and +costs eight. The proposed saving had to reach seven or fewer. No COPY, clean +state, frame operation, or extra role is in the model. Free scalar `GL3(F2)` +mixing is an explicit favorable relaxation: augmentation sends every paid gate +and the target to the identity, so all interleaved scalar maps multiply to the +identity. Moving them through the paid factors conjugates `N`; conjugation +preserves the complete set of rank-one idempotents. Thus the 56-gate alphabet +already covers every word with such free mixing. + +## Exact search and proof + +For `g=x,y`, `([g]+[1])^2=0` in characteristic two, and `N^2=N`, so every +paid gate is an involution. Any word of at most seven calls can be split into a +prefix of length at most three and a suffix of length at most four. After +inverting the suffix, its middle state must lie both in the identity ball of +radius three and the target ball of radius four. + +The verifier stores exact 3-by-3 matrices with all eight group-algebra +coefficients per entry. It exhausts the unique-state identity and target balls +through radius three, then checks every outgoing gate from each exact +radius-three target state. Those edges cover every target state first reached +at radius four. The complete counts are: + +| Evidence | Count | +|---|---:| +| Paid generators | 56 | +| New states by identity radius | 1, 56, 1,750, 45,424 | +| New states by target radius | 1, 56, 1,750, 45,424 | +| Identity/target intersection through radius three | 0 | +| Target radius-four edges checked against the identity ball | 2,543,744 | +| Radius-four intersection edges | 0 | + +The certificate includes SHA-256 digests of the canonically sorted radius-three +balls. A separate coefficient-convolution routine checks the full eight-call +direct identity. The verifier also checks associativity, all 56 gate +involutions, all eight one-call omissions, an altered third target, and +agreement between the compact transition and full coefficient multiplication +on fixed reproducible states. + +Therefore the exact minimum in this model is eight. The failure of the +seven-call search is not an impossibility claim outside the fixed `UT3(F2)` +labels, three roles, rank-one gates, and free-scalar convention. + +## Reproduce + +From the repository root, with Python 3.12 and the standard library: + +```sh +python3 -B scripts/research_package.py --package research/d8-third-register-seed89de +``` + +Expected output includes: + +```text +PASS_D8_THIRD_REGISTER min=8 identity_layers=1,56,1750,45424 right_radius4_edges=2543744 +PASS_REGISTERED_RESEARCH_PACKAGE research/d8-third-register-seed89de outcome=negative-result +``` + +`CERTIFICATE.json` is regenerated only with `python3 -B research/d8-third-register-seed89de/verify.py --write` after reviewing the result. `SOURCES.json` pins the selected record, catalogue, and exact predecessor files; `TASK.json` records the accepted seed, refined scope, stopping rule, and limitations. + +## Scope and predecessor + +The task narrows `bit-new-register-model` to the explicit open question in +`research/bit-dihedral-commutator/README.md`: whether a restored third dirty +register helps the same D8 central target. That predecessor proves the exact +eight-call minimum with two registers. Its source files are pinned here, and +the predecessor package records base `bce54fb3f895cbe5cd4c0eb477c3afeed100190f`; +the current research base is `0b1cccf86e2f5132ed286a26ef0a681a495740ea`. + +The refreshed pre-submission overlap snapshot is `OVERLAP.json`; at 2026-10-14 +08:24 UTC it covered 419 open PRs and 374 discussion records with complete +pagination and no warnings. It includes this claim, #1738. Nearby work includes +PR #1720's three-register S4 target and Discussion #1317's coordinate-CNOT +model; both use different groups and target words. No other exact D8/UT3 +third-register claim appeared. The active four-register claims #1700 and #1727 +also use different group objects. The claim and status are recorded in +[Discussion #1738](https://github.com/CrocSwap/integer-mult-bounds/discussions/1738). + +This formal mechanism does not supply a bit-supplier word, price physical +hosting for the third role, change the selected recursive profile, or improve +the selected conditional `κ`. It is an exact local obstruction to one +specific workspace-sharing idea. + +## Open next questions + +Can a fourth arbitrary dirty register lower the paid minimum for the same D8 +target and `{x,y}` alphabet? This is the next role count after the exact +three-register obstruction and could supply additional shared workspace. A +feasible first step is to count the 120 rank-one idempotents in `M4(F2)`, derive +an optimistic displacement-rank path budget, and estimate a memory cap for an +exact meet-in-the-middle search. The main blocker is the 240-generator search +growth; even a formal saving would still need a physical interpretation and a +full role invoice. + +## Credit + +The two-register model, proof and source code are by woklerx, recorded in +commit `965ff75aabb16cdd0978f4bf9222bcdedf514021`. This contribution adds the +three-register extension and its bounded exact result. Prepared by Cinna Davis +with substantial OpenAI Codex assistance in the derivation, implementation, +verification and writing. No independent human review or multiplication +theorem proof is claimed. Apache-2.0. diff --git a/research/d8-third-register-seed89de/SOURCES.json b/research/d8-third-register-seed89de/SOURCES.json new file mode 100644 index 0000000000..5f3c8d7388 --- /dev/null +++ b/research/d8-third-register-seed89de/SOURCES.json @@ -0,0 +1,42 @@ +{ + "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" + }, + { + "path": "research/bit-dihedral-commutator/verify.py", + "usage": "input", + "git_blob": "30c04afbc7f457f381143f57fc87a479dc9a36fa", + "sha256": "dff2985bc4ec27d0e527d017471f6e6d43bb7855e555385fc80027aad499735d" + }, + { + "path": "research/bit-dihedral-commutator/SOURCES.json", + "usage": "input", + "git_blob": "853900add7c066a31a47d5e50a854b2843798baa", + "sha256": "8b54ff152eaa87502cb88da77da0e73a2606e60f83c69ca5b9b60ff42f526ccd" + }, + { + "path": "research/bit-dihedral-commutator/CERTIFICATE.json", + "usage": "input", + "git_blob": "a52cee87ee16903ccd95a6872788e66a7a029202", + "sha256": "8ec4519a34ab5c6eca6dea92b90aa317c851c566040caf89d822d1d96c70a8c5" + } + ] +} diff --git a/research/d8-third-register-seed89de/TASK.json b/research/d8-third-register-seed89de/TASK.json new file mode 100644 index 0000000000..227636440d --- /dev/null +++ b/research/d8-third-register-seed89de/TASK.json @@ -0,0 +1,75 @@ +{ + "schema_version": 1, + "task_id": "bit-new-register-model", + "priority_revision": 3, + "base_commit": "0b1cccf86e2f5132ed286a26ef0a681a495740ea", + "original_card": { + "id": "bit-new-register-model", + "question": "Can an explicitly larger or nonabelian register model escape the scoped three-register obstruction?", + "starting_points": [ + "research/bit-three-register-lower-bound/README.md", + "certificates/selected-result.json" + ], + "methods": [ + "Construct the smallest exact identity in a newly specified legal operation alphabet.", + "Derive a target-specific relaxation bound for that same explicit alphabet." + ], + "acceptance_gate": "Name the changed hypothesis, all counted roles and a uniform identity; finite column tests alone do not certify it.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read Model section 1 of the three-register bound and identify the exact excluded free operations.", + "scope": "Positive control / source-bound orientation only; this is not a new construction or full cold replay." + }, + "first_experiment": "Write a complete operation alphabet outside one named premise and price a baseline before searching identities.", + "bottleneck_link": "A small-width completed saving changes the bit primitive; a finite-address identity alone is insufficient.", + "allowed_variations": [ + "Choose a fixed larger register count or a specified nonabelian operation family." + ], + "scope_change_triggers": [ + "Remaining inside the already-excluded three-register abelian model." + ], + "overlap_terms": [ + "three-register", + "nonabelian", + "group algebra" + ] + }, + "scope_status": "refined", + "actual_scope": "For G=UT3(F2), determine the exact minimum paid rank-one gate count for diag([xyxy],[xyxy],[1]) on three arbitrary dirty registers using labels x,y, all 28 rank-one idempotents of M3(F2), and arbitrary free GL3(F2) mixing normalized by augmentation.", + "scope_change_reason": "The catalogue card is broad. This narrows it to the explicit unresolved third-dirty-register extension of the exact two-register D8 central-commutator result, changing the role count from two to three while fixing the group, target, and paid alphabet.", + "bottleneck_link": "A third dirty role could in principle let a bit supplier share paid work. This result is a formal scalar-cost side bound only: it finds no saving even with free GL3 mixing, and does not price physical hosting or alter the selected recursive profile.", + "budget_minutes": 60, + "stop_rule": "Exhaust the identity ball through radius 3 and all outgoing edges from the target ball frontier at exact radius 3, which covers the target ball through radius 4. Stop after checking the full 2,543,744 radius-four edges against the identity ball; do not extend the word-length ceiling if no intersection occurs.", + "outcome": "negative-result", + "evidence": "Exact F2[UT3(F2)] search: 56 paid generators; identity and target layer counts [1,56,1750,45424]; zero radius-three intersections; all 2,543,744 edges from target radius-three frontier checked with zero identity-ball hits. Exact direct eight-call word verified independently by coefficient convolution, so the minimum in this model is eight. See CERTIFICATE.json and verify.py.", + "author": "Cinna Davis", + "ai_assistance": "Substantial OpenAI Codex assistance in the mathematical derivation, exact search implementation, verification, packaging, and writing.", + "open_questions": [ + { + "question": "Can a fourth arbitrary dirty register lower the paid minimum for the same D8 central-pair target and {x,y} alphabet?", + "why_it_matters": "The three-register minimum stays at the direct eight-call cost; a fourth role is the next possible source of shared workspace in this formal mechanism.", + "first_step": "Count the 120 rank-one idempotents in M4(F2), derive an optimistic displacement-rank path budget, and estimate an exact meet-in-the-middle memory cap before implementing a search.", + "blocked_by": "The 240-generator depth growth is much larger, and any formal saving would still need a physical interpretation and a full added-role invoice." + } + ], + "accepted_seed": "89dea4bc3a42ef85f785169cd2b6977e", + "track": "bit-mechanisms", + "scope_key": "7f5f4426ef796683c485/D8-UT3(F2)-r3-central-pair/radius3x4", + "catalog_sha256": "6686ad58f1fbdbc87134a78901b60fd53a20d3984355e91defbbebc9e9fa8075", + "selected_record_sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32", + "predecessor_commit": "965ff75aabb16cdd0978f4bf9222bcdedf514021", + "discussion_url": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1738", + "pre_submission_overlap": { + "checked_at_utc": "2026-10-14T08:24:25Z", + "open_prs": 419, + "discussions": 374, + "complete_pagination": true, + "warnings": [], + "own_claim": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1738" + } +} diff --git a/research/d8-third-register-seed89de/VERIFY.json b/research/d8-third-register-seed89de/VERIFY.json new file mode 100644 index 0000000000..984065b609 --- /dev/null +++ b/research/d8-third-register-seed89de/VERIFY.json @@ -0,0 +1,23 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/bit-dihedral-commutator/README.md", + "research/bit-dihedral-commutator/verify.py", + "research/bit-dihedral-commutator/SOURCES.json", + "research/bit-dihedral-commutator/CERTIFICATE.json" + ], + "commands": [ + { + "argv": [ + "{python}", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Exact three-register word search through seven paid factors, direct eight-call coefficient identity, source pins, all generator involutions, transition cross-check, and positive/negative controls." + } + ] +} diff --git a/research/d8-third-register-seed89de/verify.py b/research/d8-third-register-seed89de/verify.py new file mode 100644 index 0000000000..777954f119 --- /dev/null +++ b/research/d8-third-register-seed89de/verify.py @@ -0,0 +1,250 @@ +#!/usr/bin/env python3 +"""Exact D8 central-pair search with three arbitrary dirty registers.""" +from __future__ import annotations + +import hashlib +import itertools +import json +import random +import sys +from pathlib import Path + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] + + +def group_mul(a: int, b: int) -> int: + """UT3(F2): (a,b,c)(a',b',c')=(a+a',b+b',c+c'+a b').""" + return (a ^ b) ^ (((a & 1) & ((b >> 1) & 1)) << 2) + + +TABLE = tuple(tuple(group_mul(a, b) for b in range(8)) for a in range(8)) +GENERATORS = tuple( + (g, u, v) + for g in (1, 2) + for u in range(1, 8) + for v in range(1, 8) + if (u & v).bit_count() & 1 +) + + +def left_permutation(g: int) -> tuple[int, ...]: + result = [0] * 256 + for value in range(256): + moved = 0 + for j in range(8): + if (value >> j) & 1: + moved ^= 1 << TABLE[g][j] + result[value] = moved + return tuple(result) + + +LEFT = {g: left_permutation(g) for g in (1, 2)} +DELTA = {g: tuple(value ^ LEFT[g][value] for value in range(256)) for g in (1, 2)} + + +def fast_step(state: bytes, gate: tuple[int, int, int]) -> bytes: + """Apply (I+([g]+[1])uv^T) on the left to a 3x3 F2[G] matrix.""" + g, u, v = gate + out = bytearray(state) + for col in range(3): + value = 0 + for row in range(3): + if (v >> row) & 1: + value ^= state[3 * row + col] + delta = DELTA[g][value] + for row in range(3): + if (u >> row) & 1: + out[3 * row + col] ^= delta + return bytes(out) + + +IDENTITY = bytes((1, 0, 0, 0, 1, 0, 0, 0, 1)) +TARGET = bytes((16, 0, 0, 0, 16, 0, 0, 0, 1)) + + +def ball(start: bytes, depth: int) -> tuple[set[bytes], list[bytes], list[int]]: + seen = {start} + frontier = [start] + layers = [1] + for _ in range(depth): + next_frontier: list[bytes] = [] + for state in frontier: + for gate in GENERATORS: + candidate = fast_step(state, gate) + if candidate not in seen: + seen.add(candidate) + next_frontier.append(candidate) + frontier = next_frontier + layers.append(len(frontier)) + return seen, frontier, layers + + +def conv(a: int, b: int) -> int: + """Independent coefficient convolution in the full eight-element algebra.""" + out = 0 + for i in range(8): + if (a >> i) & 1: + for j in range(8): + if (b >> j) & 1: + out ^= 1 << TABLE[i][j] + return out + + +def matrix_mul(a: tuple[int, ...], b: tuple[int, ...]) -> tuple[int, ...]: + out = [] + for row in range(3): + for col in range(3): + value = 0 + for k in range(3): + value ^= conv(a[3 * row + k], b[3 * k + col]) + out.append(value) + return tuple(out) + + +def gate_matrix(gate: tuple[int, int, int]) -> tuple[int, ...]: + g, u, v = gate + out = [] + for row in range(3): + for col in range(3): + value = int(row == col) + if ((u >> row) & 1) and ((v >> col) & 1): + value ^= 1 ^ (1 << g) + out.append(value) + return tuple(out) + + +def slow_apply(word: tuple[int, ...], initial: tuple[int, ...]) -> tuple[int, ...]: + state = initial + gates = tuple(map(gate_matrix, GENERATORS)) + for index in word: + state = matrix_mul(gates[index], state) + return state + + +def sha_states(states: set[bytes]) -> str: + return hashlib.sha256(b"".join(sorted(states))).hexdigest() + + +def run() -> dict: + # Check all declared predecessor pins before using their model and baseline. + sources = json.loads((HERE / "SOURCES.json").read_text()) + for item in sources["files"]: + if item["usage"] != "input": + continue + raw = (ROOT / item["path"]).read_bytes() + if hashlib.sha256(raw).hexdigest() != item["sha256"]: + raise ValueError(f"source pin changed: {item['path']}") + + if len(GENERATORS) != 56: + raise ValueError("the complete two-label/rank-one-idempotent alphabet has size 56") + idempotents = { + tuple(((u >> row) & 1) & ((v >> col) & 1) for row in range(3) for col in range(3)) + for u in range(1, 8) + for v in range(1, 8) + if (u & v).bit_count() & 1 + } + if len(idempotents) != 28: + raise ValueError("the rank-one idempotent parameterization is not complete and duplicate-free") + if group_mul(1, 1) != 0 or group_mul(2, 2) != 0: + raise ValueError("x and y must be involutions") + z = group_mul(group_mul(group_mul(1, 2), 1), 2) + if z != 4 or any(group_mul(z, h) != group_mul(h, z) for h in range(8)): + raise ValueError("the declared xyxy label must be the central commutator") + for a, b, c in itertools.product(range(8), repeat=3): + if TABLE[TABLE[a][b]][c] != TABLE[a][TABLE[b][c]]: + raise ValueError("the group table is not associative") + + # The direct word uses four paid factors per duplicated central target. + direct = tuple( + GENERATORS.index((g, 1 << row, 1 << row)) + for row in (0, 1) + for g in (1, 2, 1, 2) + ) + expected = (16, 0, 0, 0, 16, 0, 0, 0, 1) + changed_target = (16, 0, 0, 0, 16, 0, 0, 0, 16) + identity_matrix = (1, 0, 0, 0, 1, 0, 0, 0, 1) + if len(direct) != 8 or slow_apply(direct, identity_matrix) != expected: + raise ValueError("the eight-call direct upper bound failed") + if any(slow_apply(direct[:i] + direct[i + 1 :], identity_matrix) == expected for i in range(8)): + raise ValueError("an omitted direct call unexpectedly retains the target") + if slow_apply(direct, identity_matrix) == changed_target: + raise ValueError("the direct word unexpectedly matches the changed third target") + for index in range(len(GENERATORS)): + if matrix_mul(gate_matrix(GENERATORS[index]), gate_matrix(GENERATORS[index])) != identity_matrix: + raise ValueError("a paid gate is not an involution") + + # Cross-check the compact transition against full coefficient convolution. + rng = random.Random(0xD8_3) + for _ in range(5): + state = bytes(rng.randrange(256) for _ in range(9)) + for index, gate in enumerate(GENERATORS): + fast = fast_step(state, gate) + slow = matrix_mul(gate_matrix(gate), tuple(state)) + if fast != bytes(slow): + raise ValueError(f"transition disagreement at gate {index}") + + left, _, left_layers = ball(IDENTITY, 3) + right, right_frontier, right_layers = ball(TARGET, 3) + radius_three_meet = left & right + radius_four_edges = len(right_frontier) * len(GENERATORS) + radius_four_hits = 0 + for state in right_frontier: + for gate in GENERATORS: + if fast_step(state, gate) in left: + radius_four_hits += 1 + + hit = bool(radius_three_meet or radius_four_hits) + if hit: + raise ValueError("a word of at most seven paid factors exists; update the claim and witness") + if radius_four_edges != 2_543_744: + raise ValueError("unexpected exact radius-four edge coverage") + + return { + "status": "PASS_D8_THIRD_REGISTER", + "seed": "89dea4bc3a42ef85f785169cd2b6977e", + "base_commit": "0b1cccf86e2f5132ed286a26ef0a681a495740ea", + "selected_record_sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32", + "group": "UT3(F2)", + "target": "diag([xyxy],[xyxy],[1])", + "registers": 3, + "rank_one_idempotents": len(idempotents), + "generators": 56, + "identity_layers": left_layers, + "target_layers": right_layers, + "identity_states_radius3": len(left), + "target_states_radius3": len(right), + "identity_ball_sha256": sha_states(left), + "target_ball_sha256": sha_states(right), + "radius3_intersection_states": len(radius_three_meet), + "target_radius4_edges_checked": radius_four_edges, + "radius4_intersection_edges": radius_four_hits, + "maximum_paid_word_searched": 7, + "direct_upper_bound_calls": len(direct), + "exact_minimum_in_model": 8, + "free_gl3_mixing": "normalized by augmentation into the complete 56-generator alphabet", + "controls": { + "full_group_associativity": True, + "all_generators_involutive": True, + "direct_word_exact": True, + "all_eight_single_omissions_rejected": True, + "compact_transition_matches_full_algebra": True, + "changed_third_target_rejected": slow_apply(direct, identity_matrix) != changed_target, + }, + "new_kappa": False, + } + + +if __name__ == "__main__": + result = run() + receipt = HERE / "CERTIFICATE.json" + if "--write" in sys.argv: + receipt.write_text(json.dumps(result, indent=2) + "\n") + elif json.loads(receipt.read_text()) != result: + raise SystemExit("receipt differs; use --write after reviewing the regenerated evidence") + print( + result["status"], + "min=" + str(result["exact_minimum_in_model"]), + "identity_layers=" + ",".join(map(str, result["identity_layers"])), + "right_radius4_edges=" + str(result["target_radius4_edges_checked"]), + )