From eb28a5a152772a532ba1c9a6052edef52128228f Mon Sep 17 00:00:00 2001 From: Cinna Davis <1337isnot1337@users.noreply.github.com> Date: Wed, 14 Oct 2026 03:25:37 -0500 Subject: [PATCH 1/2] Add exact GL3 order-seven dirty-register census --- .../CLAIM.md | 12 + .../OVERLAP.json | 71 ++++ .../README.md | 90 +++++ .../RESULT.json | 84 ++++ .../SOURCES.json | 60 +++ .../TASK.json | 67 ++++ .../VERIFY.json | 28 ++ .../verify.py | 373 ++++++++++++++++++ 8 files changed, 785 insertions(+) create mode 100644 research/gl3-order7-dirty-register-seed39ae/CLAIM.md create mode 100644 research/gl3-order7-dirty-register-seed39ae/OVERLAP.json create mode 100644 research/gl3-order7-dirty-register-seed39ae/README.md create mode 100644 research/gl3-order7-dirty-register-seed39ae/RESULT.json create mode 100644 research/gl3-order7-dirty-register-seed39ae/SOURCES.json create mode 100644 research/gl3-order7-dirty-register-seed39ae/TASK.json create mode 100644 research/gl3-order7-dirty-register-seed39ae/VERIFY.json create mode 100644 research/gl3-order7-dirty-register-seed39ae/verify.py diff --git a/research/gl3-order7-dirty-register-seed39ae/CLAIM.md b/research/gl3-order7-dirty-register-seed39ae/CLAIM.md new file mode 100644 index 0000000000..c6e9d66ad2 --- /dev/null +++ b/research/gl3-order7-dirty-register-seed39ae/CLAIM.md @@ -0,0 +1,12 @@ +# Local claim: GL3 order-seven target pair with one dirty register + +- **Track / seed / task:** `bit-mechanisms`, `39ae4eb03387f147b3cd06da8e84b83e`, `bit-new-register-model`, catalogue scope key `7f5f4426ef796683c485`, refined scope key `06ec42af57445d26ed9d`, priority revision 3. +- **Base / selected record:** `0b1cccf86e2f5132ed286a26ef0a681a495740ea`; selected-record SHA256 `10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32`. +- **Object / question:** `G=GL3(F2)`, all six coordinate-CNOT labels `Cij=I+Eij`, and `C=C01*C12*C20` (order seven, direct length three). In the formal algebra `F2[G]`, with exactly three scalar registers and free `GL3(F2)` scalar mixing, can paid factors `I+([g]+1)N`, `g` among all six labels and `N=uv^T`, `v^Tu=1`, realize `diag([C],[C],1)` in at most five calls? +- **Changed assumption / budget:** the address algebra is the explicit nonabelian group algebra and a third arbitrary dirty role is allowed and restored. The direct witness costs six calls (three per target); improvement requires five. All six coordinate-CNOT labels and every inverse are priced as paid calls; no free address maps or clean storage are admitted. +- **Method / bounded domain:** enumerate all 168 legal (address label, rank-one idempotent) factors. Build the complete identity-side ball through radius two and stream every formal target-side word of length at most three. This covers every word through five paid factors. Check the formal group-algebra endpoint, the six-call witness, all factor inverses and controls. +- **Overlap:** the live public REST census paginated all 419 open PR records through 2026-10-14 08:22 UTC. #1567 covers two-register GL3 target pairs of direct cost at most nine using all six labels; this adds one restored dirty role. #1495 covers the same three-role/all-six-label shape for order-two swaps; #1496 covers two order-four GL3 targets at two roles; #1491 covers GL2 swap targets; #1720 uses an S4 order-four target. The latest complete cached Discussion snapshot had 371 records, fetched 08:16 UTC; the exact GL3 order-seven three-register query returned no match. Live Discussion refresh failed because the authenticated GitHub API rate limit was exceeded. See [OVERLAP.json](OVERLAP.json) for exact heads, coverage and limits. +- **Finding:** the identity-side radius-two ball contains 22,051 states; all 4,770,025 target-side words were checked with zero intersections. No five-call word exists. The direct six-call construction passes all 504 regular-action basis rows. The exact minimum is six in this scoped model. +- **Claim expiry:** 2026-10-14T10:11:00Z. Remote posting was unavailable under the API rate limit, so this file is the local coordination claim and handoff. + +No selected supplier, new `kappa`, or multiplication theorem is claimed. diff --git a/research/gl3-order7-dirty-register-seed39ae/OVERLAP.json b/research/gl3-order7-dirty-register-seed39ae/OVERLAP.json new file mode 100644 index 0000000000..6679513399 --- /dev/null +++ b/research/gl3-order7-dirty-register-seed39ae/OVERLAP.json @@ -0,0 +1,71 @@ +{ + "schema_version": 1, + "searched_at_utc": "2026-10-14T08:22:19Z", + "scope_query": "GL3 order-seven target pair exactly three registers full coordinate-CNOT alphabet", + "open_prs": { + "source": "GitHub public REST API /repos/CrocSwap/integer-mult-bounds/pulls?state=open&per_page=100", + "pages_checked": [ + 1, + 2, + 3, + 4, + 5 + ], + "page_counts": [ + 100, + 100, + 100, + 100, + 19 + ], + "complete_pagination": true, + "records": 419, + "exact_scope_match": false, + "relevant_neighbors": [ + { + "number": 1567, + "title": "Scoped negative result: mixed GL3 targets have 27,308 exact minima; 624 natural aliases", + "head": "fd7f1a434da543e3fb4e1efbb6056dbdc3a292af", + "scope_difference": "Two scalar registers, full six-coordinate-CNOT alphabet, target pairs of direct cost at most nine. This package adds one arbitrary restored dirty scalar role for the same order-seven target pair." + }, + { + "number": 1495, + "title": "Finite certificate: a third address coordinate does not cheapen two coordinate swaps (no new kappa)", + "head": "d5f8745962597a2e5d5bf2deeb7925705c37db8e", + "scope_difference": "Three scalar roles and all six labels, but two order-two swap targets. This package uses the order-seven target pair." + }, + { + "number": 1496, + "title": "Finite certificate: two order-four GL3 targets need eight coordinate-CNOT calls (no new kappa)", + "head": "0b1420fcc47e2137c5f0a5b9aa347cd001fff9cd", + "scope_difference": "Two scalar roles and an order-four target with all six labels. This package adds one arbitrary dirty role and changes the target order." + }, + { + "number": 1491, + "title": "Finite certificate: three coordinate swaps need nine paid calls on three registers (no new kappa)", + "head": "69638b36c691d3e1b8463526fd68c849e8d1aef9", + "scope_difference": "GL2 address group and order-two swap targets." + }, + { + "number": 1720, + "title": "Scoped S4 result: two 4-cycle targets need six calls at r=3", + "head": "edb4a289a5f32c8209140144e384dcd3fa8cbfd1", + "scope_difference": "Adjacent-transposition S4 alphabet and order-four target." + } + ], + "refresh_through_utc": "2026-10-14T08:22:19Z" + }, + "discussions": { + "source": "scripts/find_overlap.py cached snapshot", + "fetched_at_utc": "2026-10-14T08:16:34.312283Z", + "complete_pagination": true, + "records": 371, + "exact_scope_matches": 0, + "live_refresh": "Unavailable: authenticated GitHub API rate limit exceeded. The exact-scope search used the latest complete cached snapshot." + }, + "limits": [ + "Open PR records were searched by title and body; relevant bodies were inspected, but every code diff was not searched.", + "Discussion content was complete in the cached snapshot, not live-refreshed during this search.", + "No literature-priority or universal novelty claim is made." + ] +} diff --git a/research/gl3-order7-dirty-register-seed39ae/README.md b/research/gl3-order7-dirty-register-seed39ae/README.md new file mode 100644 index 0000000000..1dbb6772b4 --- /dev/null +++ b/research/gl3-order7-dirty-register-seed39ae/README.md @@ -0,0 +1,90 @@ +# A dirty register does not shorten a GL3 order-seven target pair + +**Scoped exact minimum in a finite formal register model. No selected supplier or new `kappa` is claimed.** + +## Model and result + +Work over the formal group algebra `R = F2[GL3(F2)]`. The six paid address labels are all coordinate CNOTs + +```text +C01 = I + E01, C12 = I + E12, C20 = I + E20, +C10 = I + E10, C21 = I + E21, C02 = I + E02. +``` + +They generate all 168 elements of `GL3(F2)`. Let + +```text +C = C01 C12 C20 = [[0,1,1], [1,1,1], [1,0,1]]. +``` + +`C` has order seven and shortest coordinate-CNOT word length three. There are exactly three scalar registers. The endpoint is + +```text +diag([C], [C], 1) +``` + +on arbitrary inputs, including an arbitrary dirty third register restored exactly. Scalar `GL3(F2)` mixing is free. Every paid call has the form + +```text +F(g,N) = I + ([g] + 1) N, +``` + +where `g` is one of the six labels and `N=uv^T` is a rank-one idempotent over `F2` (`v^T u=1`). In characteristic two these calls are involutions. There are 28 allowed `N` and 168 paid factors total. + +The exact minimum is **six paid calls**. Three calls implement `C` on the first register, three on the second, and the third stays fixed. Exhaustive formal group-algebra search finds no five-call word, even with the free scalar mixing and dirty register. + +The free mixing normalization is exact: augmentation sends every address `[g]` to 1, so the scalar matrices in any successful boundary word multiply to the identity. Moving them through the paid calls conjugates each standard rank-one projector into some `uv^T` with `v^T u=1`. The census includes all 28 such projectors at each of the six paid labels. It includes every free scalar mixing pattern without charging or fixing a frame. + +## Complete finite evidence + +The verifier stores every coefficient in the 168-element group basis of `F2[GL3(F2)]`; it never accepts equality from the natural three-dimensional representation. A radius-two identity ball has unique-state shells `1, 168, 21,882`, for 22,051 states. On the target side, the verifier streams every raw word of length zero through three rather than storing duplicate states: + +| Target-side suffix length | Words checked | +|---:|---:| +| 0 | 1 | +| 1 | 168 | +| 2 | 28,224 | +| 3 | 4,741,632 | + +None of the 4,770,025 target-side endpoints lies in the identity-side ball. Any word of length at most five splits into a prefix of length at most two and a suffix of length at most three. Every paid factor is its own inverse, so a target factorization would put `target * suffix^-1` in both sets. This excludes every word through length five. + +The six-call direct word is checked on all `3*168 = 504` basis rows in the faithful regular action. The verifier checks all 168 factor inverses, confirms the join logic with one-target three-call and identity positive controls, rejects the wrong CNOT order, and rejects omission of each direct call. + +## Scope and overlap + +This refines the `bit-new-register-model` card by changing the address algebra from rational abelian frames to the nonabelian formal algebra `F2[GL3(F2)]`, and by adding one arbitrary dirty scalar role to a two-target order-seven endpoint. + +The closest work is: + +- [PR #1567](https://github.com/CrocSwap/integer-mult-bounds/pull/1567) gives exact minima for all 27,308 two-register GL3 target pairs with the full six-label coordinate-CNOT alphabet and direct cost at most nine. This package asks whether a restored third role changes one such order-seven target pair. +- [PR #1495](https://github.com/CrocSwap/integer-mult-bounds/pull/1495) adds a third role for two order-two swap targets using all six labels. The target order differs. +- [PR #1496](https://github.com/CrocSwap/integer-mult-bounds/pull/1496) covers two order-four GL3 targets with two scalar registers and all six labels. +- [PR #1491](https://github.com/CrocSwap/integer-mult-bounds/pull/1491) covers three GL2 coordinate swaps; [PR #1720](https://github.com/CrocSwap/integer-mult-bounds/pull/1720) uses an S4 adjacent-transposition alphabet and a four-cycle target. + +The live REST census covered all 419 open PR records through 2026-10-14 08:22 UTC. The latest complete cached Discussion snapshot had 371 records, fetched 08:16 UTC; the exact GL3 order-seven three-register query returned no match. [OVERLAP.json](OVERLAP.json) records the heads, coverage and API refresh limit. No literature-priority claim is made. + +This is a finite model result, not a multiplication supplier. It establishes no physical source access, selected-supplier occurrence, compiler or hosting cost, precision contract, recursive-moment change, new `kappa`, or full multiplication theorem. The selected record and its inherited assumptions are unchanged. + +## Reproduce + +From the repository root with Python 3.12 and the standard library: + +```sh +python3.12 -I -B research/gl3-order7-dirty-register-seed39ae/verify.py +python3.12 scripts/research_package.py --package research/gl3-order7-dirty-register-seed39ae --check-only +python3.12 scripts/research_package.py --package research/gl3-order7-dirty-register-seed39ae +``` + +Expected direct result line: + +```text +PASS_GL3_ORDER7_DIRTY_REGISTER registers=3 factors=168 prefix=22051 suffix_words=4770025 hits=0 minimum=6 +``` + +## Open next questions + +Can a second dirty role change the minimum for this same order-seven target and all six labels? First derive the fully charged target and direct bill for exactly four registers, then use an optimistic bound to decide whether a radius search can affect that bill. The larger rank-one projector inventory and target-side ball are the main blockers. + +## Credit + +Prepared by Cinna Davis with substantial OpenAI Codex assistance in task refinement, algebra, exact search, verification and writing. No independent human review or proof-assistant formalization is claimed. New work is Apache-2.0. Predecessor work is attributed above and pinned in [SOURCES.json](SOURCES.json). diff --git a/research/gl3-order7-dirty-register-seed39ae/RESULT.json b/research/gl3-order7-dirty-register-seed39ae/RESULT.json new file mode 100644 index 0000000000..d1591dec73 --- /dev/null +++ b/research/gl3-order7-dirty-register-seed39ae/RESULT.json @@ -0,0 +1,84 @@ +{ + "base_commit": "0b1cccf86e2f5132ed286a26ef0a681a495740ea", + "conclusion": "The exact minimum is six paid calls in this finite three-register full-coordinate-CNOT model; no scalar-mixing saving is found.", + "exact_search": { + "identity_side_ball_size": 22051, + "identity_side_sha256": "eeb9d169471466c9f1676d144d114883f4d5630d23d427ef15c1670a06e80cf4", + "identity_side_shells": [ + 1, + 168, + 21882 + ], + "intersection_hits": 0, + "maximum_word_length": 5, + "split": [ + 2, + 3 + ], + "target_side_raw_word_counts": [ + 1, + 168, + 28224, + 4741632 + ], + "target_side_transitions": 4770024 + }, + "limitations": [ + "This result covers only the full six-coordinate-CNOT alphabet, the stated order-seven target, and exactly three scalar registers.", + "No selected supplier, physical compilation, recursive moment change, new kappa, or multiplication theorem is established.", + "No human independent review or proof-assistant formalization is claimed." + ], + "model": { + "C_direct_word": [ + "C01", + "C12", + "C20" + ], + "C_matrix_rows": [ + [ + 0, + 1, + 1 + ], + [ + 1, + 1, + 1 + ], + [ + 1, + 0, + 1 + ] + ], + "C_order": 7, + "address_group_order": 168, + "direct_paid_calls": 6, + "free_scalar_mixing": "GL3(F2)", + "paid_address_labels": [ + "C01", + "C12", + "C20", + "C10", + "C21", + "C02" + ], + "paid_factors": 168, + "rank_one_idempotents": 28, + "scalar_registers": 3, + "target": "diag([C],[C],1)" + }, + "negative_controls": { + "omitted_direct_calls_rejected": 6, + "wrong_CNOT_order_rejected": true + }, + "positive_checks": { + "direct_regular_basis_columns": 504, + "factor_inverse_checks": 168, + "identity_join_hits": 1, + "one_target_join_hits": 1 + }, + "seed": "39ae4eb03387f147b3cd06da8e84b83e", + "selected_record_sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32", + "status": "PASS_GL3_ORDER7_DIRTY_REGISTER_FLOOR" +} diff --git a/research/gl3-order7-dirty-register-seed39ae/SOURCES.json b/research/gl3-order7-dirty-register-seed39ae/SOURCES.json new file mode 100644 index 0000000000..e209abd8f6 --- /dev/null +++ b/research/gl3-order7-dirty-register-seed39ae/SOURCES.json @@ -0,0 +1,60 @@ +{ + "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": "docs/research/community-batch1099-review.md", + "usage": "input", + "git_blob": "6cb6ec061a071a06a2d18cd4dc3e9a2b05d28099", + "sha256": "7e76d2c38e5fce30587835b7251df1430488ae4dd372611ef69a3f03f476b6cb" + }, + { + "path": "research/bit-three-register-lower-bound/README.md", + "usage": "input", + "git_blob": "25e41c370c101a33a6deb978de08b03ed7539b79", + "sha256": "c12b33ef388deece0cbf891505a2ce2c0779a0c3a6cf1f0f7f7039bab59cbebd" + }, + { + "path": "research/community-frontier1094-audit/SELECTED-SOURCE.json", + "usage": "input", + "git_blob": "6a75493790b4eff9c4a98051ef8b01d6aad0d5a8", + "sha256": "79b3de5db3dbcb9829789ba58e9e45758926031e2a7d80667a08429d369be53b" + }, + { + "path": "research/coordinate-cnot-register-bound/PROOF.md", + "usage": "input", + "git_blob": "68fee5b5ccff5329e27300e40dcbd483640dd6b7", + "sha256": "bcee89f92dcce8253bd7eae6e924ddff598c900da81979c6171a412f03d765e1" + }, + { + "path": "research/coordinate-cnot-register-bound/README.md", + "usage": "input", + "git_blob": "cdcc5a9e7f11ab3dbf7745a175ddcca208c68211", + "sha256": "e1666512fb71cf34c427c69ffb61a18b61e897a7f8f91f87820edf744e85a9fe" + }, + { + "path": "research/coordinate-cnot-register-bound/SOURCES.json", + "usage": "input", + "git_blob": "d5d9ccd629d3bc6b03f03c1fe0b7776fa183a35a", + "sha256": "a823c7be4e3f9f94991ccfe767dff01028bca2b1bf449841d21d21d72fb99738" + }, + { + "path": "research/coordinate-cnot-register-bound/TASK.json", + "usage": "input", + "git_blob": "a1748f7e8e5a80e74c74eaddcdf34a1f16004062", + "sha256": "6b384f0a6c13b1a48a3557ec4c922bf1c43a1ee8b0e82f73be51115306b13138" + } + ] +} diff --git a/research/gl3-order7-dirty-register-seed39ae/TASK.json b/research/gl3-order7-dirty-register-seed39ae/TASK.json new file mode 100644 index 0000000000..f3356da07d --- /dev/null +++ b/research/gl3-order7-dirty-register-seed39ae/TASK.json @@ -0,0 +1,67 @@ +{ + "schema_version": 1, + "task_id": "bit-new-register-model", + "priority_revision": 3, + "base_commit": "0b1cccf86e2f5132ed286a26ef0a681a495740ea", + "original_card": { + "id": "bit-new-register-model", + "question": "Can an explicitly larger or nonabelian register model escape the scoped three-register obstruction?", + "starting_points": [ + "research/bit-three-register-lower-bound/README.md", + "certificates/selected-result.json" + ], + "methods": [ + "Construct the smallest exact identity in a newly specified legal operation alphabet.", + "Derive a target-specific relaxation bound for that same explicit alphabet." + ], + "acceptance_gate": "Name the changed hypothesis, all counted roles and a uniform identity; finite column tests alone do not certify it.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read Model section 1 of the three-register bound and identify the exact excluded free operations.", + "scope": "Positive control / source-bound orientation only; this is not a new construction or full cold replay." + }, + "first_experiment": "Write a complete operation alphabet outside one named premise and price a baseline before searching identities.", + "bottleneck_link": "A small-width completed saving changes the bit primitive; a finite-address identity alone is insufficient.", + "allowed_variations": [ + "Choose a fixed larger register count or a specified nonabelian operation family." + ], + "scope_change_triggers": [ + "Remaining inside the already-excluded three-register abelian model." + ], + "overlap_terms": [ + "three-register", + "nonabelian", + "group algebra" + ] + }, + "scope_status": "changed", + "actual_scope": "In R=F2[GL3(F2)], use all six coordinate-CNOT address labels Cij=I+Eij, exactly three scalar registers, arbitrary free scalar GL3(F2) mixing, and factors I+([g]+1)N for N=uv^T with v^Tu=1. For C=C01*C12*C20 (order 7, shortest coordinate-CNOT length 3), determine whether diag([C],[C],1) has a formal word of at most five paid factors; its direct word costs six.", + "scope_change_reason": "The two-register GL3 version of this Singer target is covered by the recent all-six-coordinate-CNOT exact census for target-pair direct cost <=9 (PR #1567). This extends that target to one arbitrary dirty scalar role, keeping the full six-label alphabet so the changed hypothesis is the additional register. Related three-role work #1495 uses order-two swap targets; the S4 order-four result #1720 uses a different address group.", + "bottleneck_link": "A five-call endpoint would show that one arbitrary dirty role and free register mixing can share paid bit operations for two noncommuting address targets. A six-call floor closes this exact route. The result remains a finite model, not an admitted supplier or a kappa change.", + "budget_minutes": 60, + "stop_rule": "Enumerate the complete formal group algebra for every word through five paid factors using all 168 legal (six address labels, 28 rank-one idempotents) factors. Build the identity-side radius-two ball and stream all target-side words through radius three; stop after complete coverage or an exact five-call witness. Verify the direct six-call witness, all factor inverses, the complete 504-column regular action, and positive/negative controls. Do not expand to another register count or target in this cycle.", + "outcome": "negative-result", + "evidence": "Exact formal GL3(F2) group-algebra replay enumerates all 168 paid factors. The identity-side radius-two shells are 1,168,21882 (22,051 states); the target-side raw word layers are 1,168,28224,4741632, totaling 4,770,025 endpoints. No endpoint lies in the identity ball, excluding every word through length five. The direct six-call witness is checked on all 504 faithful regular-action basis rows. All 168 inverse checks, identity and one-target join controls, wrong-order control, and six omitted-call controls pass. The exact minimum is six in the stated three-register full-coordinate-CNOT model; no supplier or new kappa is established.", + "author": "Cinna Davis", + "ai_assistance": "Substantial OpenAI Codex assistance in task refinement, algebra, exact-search implementation, verification and writing. No independent human review or proof-assistant formalization is claimed.", + "open_questions": [ + { + "question": "Can a second arbitrary dirty role lower this same two-target order-seven endpoint in the full six-label model?", + "why_it_matters": "That would test whether a second surplus scalar role can create sharing unavailable with one dirty role, under the same address target and operation alphabet.", + "first_step": "Pin the same target in exactly four scalar registers, derive the six-call direct witness and favorable lower-cost threshold, then estimate the exact 2+3 meet before implementing it.", + "blocked_by": "There are 120 rank-one idempotents and 720 one-call factors at four roles; the target-side search is much larger and may not meet the contribution budget." + } + ], + "seed": "39ae4eb03387f147b3cd06da8e84b83e", + "track": "bit-mechanisms", + "scope_key": "06ec42af57445d26ed9d", + "selector_scope_key": "7f5f4426ef796683c485", + "catalogue_revision": 3, + "selected_record_sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32", + "finished_utc": "2026-10-14T08:25:07Z" +} diff --git a/research/gl3-order7-dirty-register-seed39ae/VERIFY.json b/research/gl3-order7-dirty-register-seed39ae/VERIFY.json new file mode 100644 index 0000000000..dd7be61e5c --- /dev/null +++ b/research/gl3-order7-dirty-register-seed39ae/VERIFY.json @@ -0,0 +1,28 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "certificates/selected-result.json", + "docs/research/community-batch1099-review.md", + "research/bit-three-register-lower-bound/README.md", + "research/coordinate-cnot-register-bound/PROOF.md", + "research/coordinate-cnot-register-bound/README.md", + "research/coordinate-cnot-register-bound/SOURCES.json", + "research/coordinate-cnot-register-bound/TASK.json", + "research/community-frontier1094-audit/SELECTED-SOURCE.json" + ], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 180, + "checks": "Pin selected-result and predecessor inputs; enumerate GL3(F2) and the shortest order-seven target word; construct all 168 formal paid factors; exhaust the radius-two identity ball and stream every target-side word through radius three; verify zero intersections; check all factor inverses, the six-call direct endpoint on 504 regular-action basis rows, join controls, and wrong-order/call-omission controls." + } + ] +} diff --git a/research/gl3-order7-dirty-register-seed39ae/verify.py b/research/gl3-order7-dirty-register-seed39ae/verify.py new file mode 100644 index 0000000000..9d3c84ccd9 --- /dev/null +++ b/research/gl3-order7-dirty-register-seed39ae/verify.py @@ -0,0 +1,373 @@ +#!/usr/bin/env python3 +"""Exact three-register paid-word census for a cyclic GL3(F2) alphabet.""" +from collections import deque +import hashlib +import json +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[2] +PACKAGE = Path(__file__).resolve().parent +BASE = "0b1cccf86e2f5132ed286a26ef0a681a495740ea" +SELECTED_SHA256 = "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32" +I3 = (1, 0, 0, 0, 1, 0, 0, 0, 1) +RING_BITS = 168 +RING_MASK = (1 << RING_BITS) - 1 +STATE_BITS = 9 * RING_BITS +STATE_BYTES = (STATE_BITS + 7) // 8 + + +def need(ok, message): + if not ok: + raise AssertionError(message) + + +def mat3_mul(a, b): + return tuple((a[3 * i] * b[j] + a[3 * i + 1] * b[3 + j] + + a[3 * i + 2] * b[6 + j]) & 1 + for i in range(3) for j in range(3)) + + +def address_generators(): + rows = [] + names = [] + for i, j, name in ((0, 1, "C01"), (1, 2, "C12"), (2, 0, "C20"), + (1, 0, "C10"), (2, 1, "C21"), (0, 2, "C02")): + a = list(I3) + a[3 * i + j] = 1 + rows.append(tuple(a)) + names.append(name) + return tuple(rows), tuple(names) + + +def enumerate_address_group(generators): + elements = [I3] + paths = {I3: ()} + queue = deque([I3]) + while queue: + x = queue.popleft() + for j, g in enumerate(generators): + y = mat3_mul(x, g) + if y not in paths: + paths[y] = paths[x] + (j,) + elements.append(y) + queue.append(y) + need(len(elements) == 168, "cyclic CNOT labels must generate GL3(F2)") + return elements, paths + + +def rank_one_idempotents(): + rows = [] + for u in range(1, 8): + for v in range(1, 8): + if (u & v).bit_count() & 1: + rows.append((u, v)) + need(len(rows) == 28, "three-register rank-one idempotent inventory") + return tuple(rows) + + +def make_right_translation_tables(multiplication, label_indices): + """Byte LUTs for right multiplication in the formal group basis.""" + tables = [] + byte_count = (RING_BITS + 7) // 8 + for g in label_indices: + by_position = [] + for pos in range(byte_count): + by_value = [0] * 256 + for value in range(1, 256): + bits = value + output = 0 + while bits: + bit = (bits & -bits).bit_length() - 1 + source = 8 * pos + bit + if source < RING_BITS: + output |= 1 << multiplication[source][g] + bits &= bits - 1 + by_value[value] = output + by_position.append(by_value) + tables.append(tuple(by_position)) + return tuple(tables) + + +def right_translate(value, table): + encoded = value.to_bytes((RING_BITS + 7) // 8, "little") + result = 0 + for pos, byte in enumerate(encoded): + if byte: + result ^= table[pos][byte] + return result + + +def projectors(): + return tuple((u, v) for u, v in rank_one_idempotents()) + + +def pack_identity(): + result = 0 + for i in range(3): + result |= 1 << (RING_BITS * (3 * i + i)) + return result + + +def pack_target(c_index): + result = 1 << (RING_BITS * 0 + c_index) + result |= 1 << (RING_BITS * 4 + c_index) + result |= 1 << (RING_BITS * 8) + return result + + +def apply_factor(state, factor, translation_tables): + """Right multiply a formal 3x3 matrix by I+([g]+1)uv^T.""" + g, u, v = factor + entries = [(state >> (RING_BITS * k)) & RING_MASK for k in range(9)] + table = translation_tables[g] + for i in range(3): + row = 0 + for k in range(3): + if (u >> k) & 1: + row ^= entries[3 * i + k] + delta = row ^ right_translate(row, table) + for j in range(3): + if (v >> j) & 1: + entries[3 * i + j] ^= delta + return sum(value << (RING_BITS * k) for k, value in enumerate(entries)) + + +def ball(start, depth, factors, translation_tables): + seen = {start} + frontier = {start} + shells = [1] + for _ in range(depth): + following = {apply_factor(state, factor, translation_tables) + for state in frontier for factor in factors} - seen + seen.update(following) + frontier = following + shells.append(len(frontier)) + return seen, shells + + +def target_side_search(target, depth, left_ball, factors, translation_tables): + """Check every raw target-side word; no deduplication can hide a path.""" + word_counts = [1] + [len(factors) ** d for d in range(1, depth + 1)] + transitions = 0 + hits = 0 + + def visit(state, current_depth): + nonlocal transitions, hits + if current_depth == depth: + return + for factor in factors: + following = apply_factor(state, factor, translation_tables) + transitions += 1 + hits += int(following in left_ball) + visit(following, current_depth + 1) + + if target in left_ball: + hits += 1 + visit(target, 0) + return hits, word_counts, transitions + + +def state_digest(states): + digest = hashlib.sha256() + for state in sorted(states): + digest.update(state.to_bytes(STATE_BYTES, "little")) + return digest.hexdigest() + + +def apply_row_factor(row, factor, translation_tables): + g, u, v = factor + source = 0 + for k in range(3): + if (u >> k) & 1: + source ^= row[k] + delta = source ^ right_translate(source, translation_tables[g]) + result = list(row) + for j in range(3): + if (v >> j) & 1: + result[j] ^= delta + return result + + +def apply_row_word(row, word, translation_tables): + result = list(row) + for factor in word: + result = apply_row_factor(result, factor, translation_tables) + return result + + +def regular_basis_replay(word, c_index, multiplication, translation_tables): + """Check the direct witness on all 3*168 regular-action basis rows.""" + checked = 0 + for register in range(3): + for address in range(RING_BITS): + row = [0, 0, 0] + row[register] = 1 << address + got = apply_row_word(row, word, translation_tables) + expected = [0, 0, 0] + if register < 2: + expected[register] = 1 << multiplication[address][c_index] + else: + expected[register] = 1 << address + need(got == expected, "six-call direct witness regular-basis mismatch") + checked += 1 + return checked + + +def join_control(target, left_radius, right_radius, factors, translation_tables): + left, _ = ball(pack_identity(), left_radius, factors, translation_tables) + right, _ = ball(target, right_radius, factors, translation_tables) + return len(left & right) + + +def check_sources(): + source = json.loads((PACKAGE / "SOURCES.json").read_text(encoding="utf-8")) + need(source["base_commit"] == BASE, "source base drift") + import hashlib as _hashlib + import subprocess + for row in source["files"]: + path = row["path"] + expression = BASE + ":" + path + blob = subprocess.check_output(["git", "rev-parse", expression], cwd=ROOT, text=True).strip() + data = subprocess.check_output(["git", "show", expression], cwd=ROOT) + need(blob == row["git_blob"], "Git blob mismatch: " + path) + need(_hashlib.sha256(data).hexdigest() == row["sha256"], "source SHA256 mismatch: " + path) + if row["usage"] == "input": + need((ROOT / path).read_bytes() == data, "working input drift: " + path) + selected_bytes = (ROOT / "certificates/selected-result.json").read_bytes() + need(_hashlib.sha256(selected_bytes).hexdigest() == SELECTED_SHA256, + "selected record SHA mismatch") + + +def calculate(): + generators, names = address_generators() + elements, shortest = enumerate_address_group(generators) + index = {element: i for i, element in enumerate(elements)} + need(len(index) == 168, "duplicate address group element") + multiplication = [[index[mat3_mul(a, b)] for b in elements] for a in elements] + identity_index = index[I3] + need(identity_index == 0, "group identity enumeration order") + for i, g in enumerate(generators): + gi = index[g] + need(multiplication[gi][gi] == identity_index, "CNOT label is not involutive") + + x, y, z = (index[g] for g in generators[:3]) + c_matrix = mat3_mul(mat3_mul(generators[0], generators[1]), generators[2]) + c_index = index[c_matrix] + power = I3 + for _ in range(7): + power = mat3_mul(power, c_matrix) + need(power == I3 and mat3_mul(I3, c_matrix) != I3, "target address is not order seven") + need(len(shortest[c_matrix]) == 3, "target direct word cost") + + projectors_list = projectors() + factors = tuple((generator_number, u, v) + for generator_number in range(len(generators)) for u, v in projectors_list) + need(len(factors) == 168, "paid-factor inventory") + tables = make_right_translation_tables(multiplication, + tuple(index[g] for g in generators)) + identity = pack_identity() + target = pack_target(c_index) + + # Each factor is an involution in characteristic two: g^2=1 and N^2=N. + for factor in factors: + need(apply_factor(apply_factor(identity, factor, tables), factor, tables) == identity, + "paid factor failed its inverse check") + + direct = tuple((generator_number, 1 << register, 1 << register) + for register in (0, 1) for generator_number in range(3)) + direct_state = identity + for factor in direct: + direct_state = apply_factor(direct_state, factor, tables) + need(direct_state == target, "six-call direct witness formal endpoint") + basis_columns = regular_basis_replay(direct, c_index, multiplication, tables) + need(basis_columns == 504, "regular-action basis coverage") + + # Exhaust every formal word of length <=5 by the 2+3 radius split. + left, left_shells = ball(identity, 2, factors, tables) + hit_count, right_word_counts, right_transitions = target_side_search( + target, 3, left, factors, tables) + need(hit_count == 0, "a word of at most five paid calls exists") + + # Positive controls establish the join orientation and catch a lost role. + one_target = pack_target_one(c_index) + one_target_hits = join_control(one_target, 1, 2, factors, tables) + need(one_target_hits > 0, "one-target three-call join control failed") + identity_hits = join_control(identity, 0, 0, factors, tables) + need(identity_hits == 1, "identity join control failed") + + # Mutating a label order or omitting a call must break the direct endpoint. + wrong_direct = tuple((generator_number, 1 << register, 1 << register) + for register in (0, 1) for generator_number in (0, 2, 1)) + wrong_state = identity + for factor in wrong_direct: + wrong_state = apply_factor(wrong_state, factor, tables) + need(wrong_state != target, "wrong CNOT order escaped the endpoint control") + omissions = 0 + for omitted in range(len(direct)): + state = identity + for j, factor in enumerate(direct): + if j != omitted: + state = apply_factor(state, factor, tables) + need(state != target, "omitted-call control escaped") + omissions += 1 + + return { + "status": "PASS_GL3_ORDER7_DIRTY_REGISTER_FLOOR", + "base_commit": BASE, + "seed": "39ae4eb03387f147b3cd06da8e84b83e", + "selected_record_sha256": SELECTED_SHA256, + "model": { + "address_group_order": len(elements), + "paid_address_labels": list(names), + "scalar_registers": 3, + "free_scalar_mixing": "GL3(F2)", + "rank_one_idempotents": len(projectors_list), + "paid_factors": len(factors), + "target": "diag([C],[C],1)", + "C_matrix_rows": [list(c_matrix[0:3]), list(c_matrix[3:6]), list(c_matrix[6:9])], + "C_order": 7, + "C_direct_word": list(names[:3]), + "direct_paid_calls": len(direct), + }, + "exact_search": { + "maximum_word_length": 5, + "split": [2, 3], + "identity_side_shells": left_shells, + "identity_side_ball_size": len(left), + "target_side_raw_word_counts": right_word_counts, + "target_side_transitions": right_transitions, + "intersection_hits": hit_count, + "identity_side_sha256": state_digest(left), + }, + "positive_checks": { + "factor_inverse_checks": len(factors), + "direct_regular_basis_columns": basis_columns, + "one_target_join_hits": one_target_hits, + "identity_join_hits": identity_hits, + }, + "negative_controls": { + "wrong_CNOT_order_rejected": True, + "omitted_direct_calls_rejected": omissions, + }, + "conclusion": "The exact minimum is six paid calls in this finite three-register full-coordinate-CNOT model; no scalar-mixing saving is found.", + "limitations": [ + "This result covers only the full six-coordinate-CNOT alphabet, the stated order-seven target, and exactly three scalar registers.", + "No selected supplier, physical compilation, recursive moment change, new kappa, or multiplication theorem is established.", + "No human independent review or proof-assistant formalization is claimed." + ] + } + + +def pack_target_one(c_index): + result = 1 << c_index + result |= 1 << (RING_BITS * 4) + result |= 1 << (RING_BITS * 8) + return result + + +if __name__ == "__main__": + check_sources() + result = calculate() + out = PACKAGE / "RESULT.json" + out.write_text(json.dumps(result, indent=2, sort_keys=True) + "\n", encoding="utf-8") + print("PASS_GL3_ORDER7_DIRTY_REGISTER registers=3 factors=168 prefix=22051 suffix_words=4770025 hits=0 minimum=6") From bf29e15b2e5987d3a824e2563835a7ed94451c96 Mon Sep 17 00:00:00 2001 From: Cinna Davis <1337isnot1337@users.noreply.github.com> Date: Wed, 14 Oct 2026 03:26:41 -0500 Subject: [PATCH 2/2] Record GL3 dirty-register PR handoff --- research/gl3-order7-dirty-register-seed39ae/CLAIM.md | 4 ++-- research/gl3-order7-dirty-register-seed39ae/TASK.json | 3 ++- 2 files changed, 4 insertions(+), 3 deletions(-) diff --git a/research/gl3-order7-dirty-register-seed39ae/CLAIM.md b/research/gl3-order7-dirty-register-seed39ae/CLAIM.md index c6e9d66ad2..d9f06dbb8a 100644 --- a/research/gl3-order7-dirty-register-seed39ae/CLAIM.md +++ b/research/gl3-order7-dirty-register-seed39ae/CLAIM.md @@ -6,7 +6,7 @@ - **Changed assumption / budget:** the address algebra is the explicit nonabelian group algebra and a third arbitrary dirty role is allowed and restored. The direct witness costs six calls (three per target); improvement requires five. All six coordinate-CNOT labels and every inverse are priced as paid calls; no free address maps or clean storage are admitted. - **Method / bounded domain:** enumerate all 168 legal (address label, rank-one idempotent) factors. Build the complete identity-side ball through radius two and stream every formal target-side word of length at most three. This covers every word through five paid factors. Check the formal group-algebra endpoint, the six-call witness, all factor inverses and controls. - **Overlap:** the live public REST census paginated all 419 open PR records through 2026-10-14 08:22 UTC. #1567 covers two-register GL3 target pairs of direct cost at most nine using all six labels; this adds one restored dirty role. #1495 covers the same three-role/all-six-label shape for order-two swaps; #1496 covers two order-four GL3 targets at two roles; #1491 covers GL2 swap targets; #1720 uses an S4 order-four target. The latest complete cached Discussion snapshot had 371 records, fetched 08:16 UTC; the exact GL3 order-seven three-register query returned no match. Live Discussion refresh failed because the authenticated GitHub API rate limit was exceeded. See [OVERLAP.json](OVERLAP.json) for exact heads, coverage and limits. -- **Finding:** the identity-side radius-two ball contains 22,051 states; all 4,770,025 target-side words were checked with zero intersections. No five-call word exists. The direct six-call construction passes all 504 regular-action basis rows. The exact minimum is six in this scoped model. -- **Claim expiry:** 2026-10-14T10:11:00Z. Remote posting was unavailable under the API rate limit, so this file is the local coordination claim and handoff. +- **Finding:** the identity-side radius-two ball contains 22,051 states; all 4,770,025 target-side words were checked with zero intersections. No five-call word exists. The direct six-call construction passes all 504 regular-action basis rows. The exact minimum is six in this scoped model. Focused PR [#1741](https://github.com/CrocSwap/integer-mult-bounds/pull/1741) is open for review. +- **Claim expiry:** 2026-10-14T10:11:00Z. Remote Discussion posting was unavailable under the API rate limit, so this file remains the local claim and finding; PR [#1741](https://github.com/CrocSwap/integer-mult-bounds/pull/1741) is the review handoff. No selected supplier, new `kappa`, or multiplication theorem is claimed. diff --git a/research/gl3-order7-dirty-register-seed39ae/TASK.json b/research/gl3-order7-dirty-register-seed39ae/TASK.json index f3356da07d..20512b7b1b 100644 --- a/research/gl3-order7-dirty-register-seed39ae/TASK.json +++ b/research/gl3-order7-dirty-register-seed39ae/TASK.json @@ -63,5 +63,6 @@ "selector_scope_key": "7f5f4426ef796683c485", "catalogue_revision": 3, "selected_record_sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32", - "finished_utc": "2026-10-14T08:25:07Z" + "finished_utc": "2026-10-14T08:27:00Z", + "pr_url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1741" }