diff --git a/research/gl3-nilpotent-coupling-seeda9ab7bd2/CERTIFICATE.json b/research/gl3-nilpotent-coupling-seeda9ab7bd2/CERTIFICATE.json new file mode 100644 index 0000000000..29d89a4432 --- /dev/null +++ b/research/gl3-nilpotent-coupling-seeda9ab7bd2/CERTIFICATE.json @@ -0,0 +1,57 @@ +{ + "base_commit": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2", + "catalogue_sha256": "d46eb6d5b3e279428753d770653663fbdf1063e55c255ea073d768f344927ef7", + "couplings": { + "idempotent": 6, + "nilpotent": 3, + "packed_M2_F2": [ + "1", + "2", + "3", + "4", + "5", + "8", + "a", + "c", + "f" + ], + "total_rank_one": 9 + }, + "direct_cost_histogram": { + "0": 1, + "1": 12, + "2": 84, + "3": 288, + "4": 576 + }, + "direct_positive_controls": 961, + "endpoint_count_per_role": 31, + "endpoint_radius_per_role": 2, + "factor_alphabet_size": 54, + "group": "GL3(F2)", + "group_order": 168, + "labels": [ + "113", + "115", + "119", + "131", + "151", + "191" + ], + "ordered_endpoint_pairs": 961, + "raw_words_through_length_3": 160435, + "register_roles": 2, + "register_state_scope": "arbitrary dirty inputs; exact diagonal endpoints", + "result": "NO_SHORTER_ENDPOINT_WORDS", + "schema": 1, + "seed": "a9ab7bd2bdc2d83089d7ee5ca0948454", + "selected_record_sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32", + "shorter_endpoint_hits": [], + "transition_evaluations": 126900, + "unique_state_counts_by_shortest_length": [ + 1, + 54, + 2295, + 89358 + ] +} diff --git a/research/gl3-nilpotent-coupling-seeda9ab7bd2/PROOF.md b/research/gl3-nilpotent-coupling-seeda9ab7bd2/PROOF.md new file mode 100644 index 0000000000..f30c3ce8c9 --- /dev/null +++ b/research/gl3-nilpotent-coupling-seeda9ab7bd2/PROOF.md @@ -0,0 +1,51 @@ +# Exact search argument and certificate scope + +## Reversible expanded alphabet + +Let `G = GL3(F2)` and let `g` be one of the six coordinate transvections, so `g^2=e`. Work in the full group algebra `F2[G]`. Put `a=[g]+[e]`. Then + +```text +a^2 = [g^2] + [g] + [g] + [e] = [e]+[e] = 0. +``` + +For every matrix `N` (in particular every rank-one idempotent or nilpotent), + +```text +(I+aN)^2 = I + a(N+N) + a^2 N^2 = I. +``` + +Thus all nine nonzero rank-one matrices in `M2(F2)` give legal reversible factors for these labels. The six idempotents are exactly those `N=uv^T` with `v^T u=1`; the three other rank-one matrices have `v^T u=0` and are nilpotent. + +## Complete coefficient-state recurrence + +Represent a transfer matrix `P` by its four entries `P_ri in F2[G]`. For an entry, write its coefficient support as a subset `S_ri` of the 168 group elements. Addition is symmetric difference. On appending `D_N(g)` on the right, + +```text +P' = P(I+([g]+[e])N) + = P + (P[g]+P)N. +``` + +For output column `j`, form `V_rj = symmetric_difference_i S_ri` over exactly those `i` with `N_ij=1`. Its added support is `(V_rj g) symmetric_difference V_rj`, where every `h` in `V_rj` maps to `hg`. The new entry support is the old support symmetric-differenced with that set. The search implementation packs each support into a 168-bit integer; the independent verifier stores explicit sets of 3-by-3 binary matrices and recomputes the group products. + +The address group is constructed by closure from the identity under right multiplication by the six transvections. The resulting Cayley distances give 31 endpoints at distance at most two. Their 961 ordered pairs have direct-cost histogram `1,12,84,288,576` for costs zero through four. + +## Exhaustion and minimum claim + +There are nine rank-one couplings and six labels, hence 54 factors. Breadth-first expansion from the identity transfer yields the exact distinct-state counts + +```text +depth 0: 1 +depth 1: 54 +depth 2: 2,295 +depth 3: 89,358 +``` + +The implementation evaluates 126,900 distinct-state transitions. The raw word count through length three is `1+54+54^2+54^3 = 160,435`. Equal full coefficient states can be deduplicated: any suffix applied to equal states produces equal states, and breadth-first order retains a shortest representative. For every endpoint pair with direct bill `d<=4`, any strict improvement has length at most `d-1<=3`. The exhaustive radius-three state set therefore covers every possible improvement in the declared endpoint domain. It contains no such target below its direct bill. + +For the upper bound, each CNOT letter in a shortest word for `p` is applied with register projector `E11`, and each letter in a shortest word for `q` with `E22`. These factors act on the two roles independently and produce `diag([p],[q])`. The independent verifier checks this construction for all 961 pairs. Consequently the exact minimum in the stated finite model is `d(p)+d(q)` for every pair in this domain. + +## Independent controls and limits + +The set-coefficient verifier independently rebuilds `GL3(F2)`, the 54 factor types and every state through depth three. It checks all 36,288 applications of the 54 factors to the 672 single-coefficient basis transfers; each factor squares to the identity on every basis element. Its direct-word positive controls cover all 961 targets. A noncommuting-label control rejects reversed chronology, and a changed-coupling control rejects an altered register map. + +This is an exact finite enumeration, not a proof-assistant theorem and not a universal no-sharing result. The conclusion ends at two roles, six GL3 coordinate-CNOT labels, all nine rank-one 2-by-2 F2 couplings, and target radius two per role. It assumes the new nilpotent coupling has the same one-call price as an idempotent coupling. Native implementation, supplier translation, and any effect on the selected multiplication bound remain open. diff --git a/research/gl3-nilpotent-coupling-seeda9ab7bd2/README.md b/research/gl3-nilpotent-coupling-seeda9ab7bd2/README.md new file mode 100644 index 0000000000..3cf7ffa68b --- /dev/null +++ b/research/gl3-nilpotent-coupling-seeda9ab7bd2/README.md @@ -0,0 +1,65 @@ +# Nilpotent rank-one couplings do not shorten shallow GL3 bit targets + +**Scoped exact negative result; no new `kappa`.** In the two-role formal model over `F2[GL3(F2)]`, adding every rank-one nilpotent coupling to the six rank-one idempotent couplings does not reduce the direct CNOT bill for any ordered target pair whose two outputs are each at CNOT distance at most two. The complete domain contains 961 pairs. Every pair has exact minimum equal to its independent direct bill, which is at most four calls. + +## Model and cost + +The address group is `GL3(F2)`, generated by its six coordinate transvections `g_ij = I + E_ij`. A paid factor is + +```text +D_N(g) = I + ([g] + [e]) N, +``` + +acting on two arbitrary dirty scalar roles, where `N = u v^T` ranges over all nine nonzero rank-one matrices in `M2(F2)`. Six are idempotent and three are nilpotent. If `g^2=e`, then `([g]+[e])^2=0` in characteristic two, so every factor is an involution even when `N^2=0`. + +Each factor is charged one call, just as in the idempotent-only comparison. The two roles are the endpoint outputs; there is no clean helper, copied role, inter-call frame change, or restoration operation. This is the complete bill **inside the stated finite primitive model**. A native supplier implementation for nilpotent couplings is not established, and there is no selected-supplier mapping or multiplication-exponent claim. + +## Exact result + +For all `p,q` in the radius-two CNOT ball, compare `diag([p],[q])` with direct cost `d(p)+d(q)`. The packed search covers all 54 factors through length three: 160,435 raw words, reduced by exact transfer-state equality to 91,708 states over depths zero through three. It checks all 168 address-group coefficients in every transfer-matrix entry. No target appears below its direct cost. All 961 independent direct words are positive controls. + +| Direct cost | Ordered target pairs | Shorter expanded-alphabet words | +|---:|---:|---:| +| 0 | 1 | 0 | +| 1 | 12 | 0 | +| 2 | 84 | 0 | +| 3 | 288 | 0 | +| 4 | 576 | 0 | + +Thus this bounded expansion of the register-coupling alphabet does not beat independent execution on shallow GL3 CNOT pairs. It says nothing about targets beyond CNOT radius two, more than two roles, other address groups, or other cost models. + +The selector's first-step baseline command, `python3 -B scripts/research_baseline.py`, was attempted. It stops at `Invalid package root: research/complex-sw4-frame8` because the isolated checkout is sparse. The selected source manifest pins 1,579 files; the checkout was kept sparse rather than materializing the full selected package inventory. The selected review, source manifest, assembly certificate, hashes and `make frontier1094-verify` instructions are pinned in [TASK.md](TASK.md) and [SOURCES.json](SOURCES.json). The selected cold replay was not run because this experiment does not change that supplier. + +The exact search and independent verifier passed locally on CPython 3.14.7. The package metadata check passed. The repository replay launcher requests Python 3.12, which is unavailable in this environment; its Python 3.12 replay remains for hosted CI. + +## Reproduce + +From the repository root: + +```sh +python3 -I -B research/gl3-nilpotent-coupling-seeda9ab7bd2/search.py --check +python3 -I -B research/gl3-nilpotent-coupling-seeda9ab7bd2/verify.py +python3 scripts/research_package.py --package research/gl3-nilpotent-coupling-seeda9ab7bd2 --check-only +``` + +The first command recomputes the packed-state certificate without rewriting it. The second independently enumerates coefficient supports as sets of explicit group matrices, checks all direct witnesses and every factor's involution action on a coefficient basis, and includes chronology and coupling mutation controls. `CERTIFICATE.json` records the exact counts; `PROOF.md` gives the recurrence and scope. + +Expected search output: + +```text +PASS_EXPANDED_RANKONE_GL3 group=168 labels=6 factors=54 couplings=6+3 endpoints=31 pairs=961 direct=961 states=1,54,2295,89358 transitions=126900 shorter=0 result=NO_SHORTER_ENDPOINT_WORDS +``` + +Expected independent replay output: + +```text +PASS_EXPANDED_RANKONE_GL3_INDEPENDENT group=168 labels=6 factors=54 couplings=6+3 endpoints=31 pairs=961 states=1,54,2295,89358 transitions=126900 involution_basis_checks=36288 shorter=0 controls=2 result=NO_SHORTER_ENDPOINT_WORDS +``` + +## Open next questions + +Can the same no-saving result extend to two-role GL3 CNOT endpoint pairs with direct cost five or more under all nine rank-one couplings? This would show whether nilpotent shears remain redundant beyond the first shallow layer. First derive coefficient constraints for the direct-cost-five targets and screen the optimistic word bound; the current certificate stops at cost four, and a deeper search needs a new bound. + +## Credit + +This changed-scope experiment builds on Josie Elliston's idempotent-only GL3 census (PR #1974) and Gareth Davidson's UT4(F2) mixed-root tariff using nilpotent couplings (PR #2027). Wayne Nilsen's clean-ancilla result (PR #2167) is a nearby two-register comparison. Exact heads and source hashes are listed in [TASK.md](TASK.md) and [SOURCES.json](SOURCES.json). Prepared by Cinna Davis with substantial OpenAI Codex assistance in scope selection, implementation and verification. No independent human review is claimed. diff --git a/research/gl3-nilpotent-coupling-seeda9ab7bd2/SOURCES.json b/research/gl3-nilpotent-coupling-seeda9ab7bd2/SOURCES.json new file mode 100644 index 0000000000..0ad725730c --- /dev/null +++ b/research/gl3-nilpotent-coupling-seeda9ab7bd2/SOURCES.json @@ -0,0 +1,48 @@ +{ + "base_commit": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2", + "files": [ + { + "git_blob": "ae6a99f28aa468649eb66a361e764d769363bf11", + "path": "certificates/selected-result.json", + "sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32", + "usage": "input" + }, + { + "git_blob": "e8870e5917057d59b730eb14721a778639eca050", + "path": "docs/research/agent-task-catalog.json", + "sha256": "d46eb6d5b3e279428753d770653663fbdf1063e55c255ea073d768f344927ef7", + "usage": "input" + }, + { + "git_blob": "6cb6ec061a071a06a2d18cd4dc3e9a2b05d28099", + "path": "docs/research/community-batch1099-review.md", + "sha256": "7e76d2c38e5fce30587835b7251df1430488ae4dd372611ef69a3f03f476b6cb", + "usage": "provenance" + }, + { + "git_blob": "59ac7008af69ffb41e10e6574308d68c33d44c48", + "path": "research/bit-gl3-mixed-targets-length10/README.md", + "sha256": "f1f88a618fa998baa2bb5e8bc69c225405b6106b4c0a5646d84c42166cd4aff5", + "usage": "provenance" + }, + { + "git_blob": "25e41c370c101a33a6deb978de08b03ed7539b79", + "path": "research/bit-three-register-lower-bound/README.md", + "sha256": "c12b33ef388deece0cbf891505a2ce2c0779a0c3a6cf1f0f7f7039bab59cbebd", + "usage": "provenance" + }, + { + "git_blob": "5fd676df060f3b450782fdf5ff5f6beb63a5eeb0", + "path": "research/community-frontier1094-audit/ASSEMBLY.json", + "sha256": "1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045", + "usage": "provenance" + }, + { + "git_blob": "6a75493790b4eff9c4a98051ef8b01d6aad0d5a8", + "path": "research/community-frontier1094-audit/SELECTED-SOURCE.json", + "sha256": "79b3de5db3dbcb9829789ba58e9e45758926031e2a7d80667a08429d369be53b", + "usage": "provenance" + } + ], + "schema_version": 1 +} diff --git a/research/gl3-nilpotent-coupling-seeda9ab7bd2/TASK.json b/research/gl3-nilpotent-coupling-seeda9ab7bd2/TASK.json new file mode 100644 index 0000000000..c0237dbbf2 --- /dev/null +++ b/research/gl3-nilpotent-coupling-seeda9ab7bd2/TASK.json @@ -0,0 +1,86 @@ +{ + "accepted_seed": "a9ab7bd2bdc2d83089d7ee5ca0948454", + "actual_scope": "In F2[GL3(F2)] with two dirty roles, six coordinate-CNOT labels and every nonzero rank-one 2x2 F2 coupling, determine whether any endpoint pair at CNOT radius at most two per role and direct total at most four has a shorter exact full-coefficient word.", + "ai_assistance": "Substantial OpenAI Codex assistance was used for scope selection, exact search and independent verifier implementation; the contributor should review the proof and attribution before submission.", + "author": "Cinna Davis", + "base_commit": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2", + "bottleneck_link": "A strict one-call saving would improve a local bit-mechanism cost in the stated two-role model. The selected multiplication result remains complex-bound, and no supplier translation is established, so this is a scoped mechanism result with no kappa claim.", + "budget_minutes": 60, + "evidence": "CERTIFICATE.json records exact packed-state coverage. search.py produced zero shorter hits; verify.py independently re-enumerated full F2[GL3(F2)] coefficients using sets, checked all 961 direct words, all factor involutions on the coefficient basis, and chronology/coupling mutation controls. See README.md and PROOF.md. No supplier mapping or kappa change is claimed. Local direct replay ran on CPython 3.14.7; repository package metadata check passed, but the generic Python 3.12 runner is unavailable locally and is left to hosted CI.", + "open_questions": [ + { + "blocked_by": "The current exact certificate stops at direct cost four; the next search has a larger word radius and needs a new optimistic bound.", + "first_step": "Derive coefficient constraints for the first direct-cost-five target layer and identify a bound before launching a deeper state search.", + "question": "Can the one-call no-sharing result extend to GL3 CNOT endpoint pairs with direct cost five or more under the same nine rank-one couplings?", + "why_it_matters": "That would determine whether nilpotent register shears are only locally redundant or fail to improve the two-role bit mechanism more broadly." + } + ], + "original_card": { + "acceptance_gate": "Name the changed hypothesis, all counted roles and a uniform identity; finite column tests alone do not certify it.", + "allowed_variations": [ + "Choose a fixed larger register count or a specified nonabelian operation family." + ], + "bottleneck_link": "A small-width completed saving changes the bit primitive; a finite-address identity alone is insufficient.", + "first_experiment": "First compare the alphabet, role count and length with the fully replayed #1974 census and #2027 mixed-root tariff. Identify a changed premise and a legal native implementation; then price one smallest completed instance before searching larger words.", + "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." + }, + "id": "bit-new-register-model", + "methods": [ + "Construct the smallest exact identity in a newly specified legal operation alphabet.", + "Derive a target-specific relaxation bound for that same explicit alphabet." + ], + "overlap_terms": [ + "three-register", + "nonabelian", + "group algebra" + ], + "question": "Can an explicitly larger or nonabelian register model escape the scoped three-register obstruction?", + "scope_change_triggers": [ + "Remaining inside the already-excluded three-register abelian model.", + "Repeating the two-register GL3 census or a covered three-register length without changing a hypothesis; a formal group-algebra word without native conversion is a partial result." + ], + "starting_points": [ + "research/bit-three-register-lower-bound/README.md", + "certificates/selected-result.json", + "research/bit-gl3-mixed-targets-length10/README.md", + "docs/research/community-efficient1000-review.md" + ] + }, + "outcome": "negative-result", + "predecessors": [ + { + "author": "Josie Elliston", + "head": "a4992da8e4e81a74cf1fd2b2d3af948662476d6e", + "reference": "PR #1974", + "relation": "The two-role GL3 mixed-target census uses the idempotent coupling alphabet; this task adds all three nilpotent rank-one couplings." + }, + { + "author": "Gareth Davidson", + "head": "cd37822ee3523e53b645848644e0dae42d47abe7", + "reference": "PR #2027", + "relation": "Uses nilpotent rank-one couplings in a UT4(F2) mixed-root tariff, with different address group and targets." + }, + { + "author": "Wayne Nilsen", + "head": "cea5d7be431b09877848354f04d5f2ba512339fd", + "reference": "PR #2167", + "relation": "Clean-ancilla two-register m=3 scope, not the all-dirty expanded coupling alphabet here." + } + ], + "priority_revision": 4, + "refined_scope_key": "GL3-F2-two-dirty-rank-one-couplings-radius2-direct4", + "schema_version": 1, + "scope_change_reason": "The catalogue card points to another larger-register or nonabelian target family. Current open PRs and Discussions are dense across small finite-group targets. This changes the excluded coupling condition instead: permit the three rank-one nilpotent register shears, test their reversible one-call alphabet on the established GL3 CNOT family, and stop at the complete direct-cost-four boundary.", + "scope_status": "changed", + "selector_scope_key": "7f5f4426ef796683c485", + "stop_rule": "Enumerate all 54 factors through length three and every ordered target pair from the 31 GL3(F2) elements at CNOT distance at most two. Stop after that complete one-call-saving boundary; do not extend the radius or change the group this cycle.", + "task_id": "bit-new-register-model" +} diff --git a/research/gl3-nilpotent-coupling-seeda9ab7bd2/TASK.md b/research/gl3-nilpotent-coupling-seeda9ab7bd2/TASK.md new file mode 100644 index 0000000000..73643ec96e --- /dev/null +++ b/research/gl3-nilpotent-coupling-seeda9ab7bd2/TASK.md @@ -0,0 +1,44 @@ +# Cycle 46 task card: expanded rank-one couplings + +## Assignment pins + +- Track `bit-mechanisms`; accepted OS seed `a9ab7bd2bdc2d83089d7ee5ca0948454`. +- Selector task `bit-new-register-model`, first suggested method: construct/test the smallest exact identity in a newly specified legal operation alphabet. +- Selector scope key `7f5f4426ef796683c485`; priority revision 4; catalogue SHA-256 `d46eb6d5b3e279428753d770653663fbdf1063e55c255ea073d768f344927ef7`. +- Exact base `0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2`; selected-record SHA-256 `10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32`. +- Canonical claim: [Discussion #2285](https://github.com/CrocSwap/integer-mult-bounds/discussions/2285), expires 2026-10-15 05:29 UTC. Hub pointer: [#1167 comment](https://github.com/CrocSwap/integer-mult-bounds/discussions/1167#discussioncomment-18939789). +- Selected conditional result: `836330098538459/500000000000000000`, binding side complex. Review `docs/research/community-batch1099-review.md` (SHA-256 `7e76d2c38e5fce30587835b7251df1430488ae4dd372611ef69a3f03f476b6cb`); source manifest `research/community-frontier1094-audit/SELECTED-SOURCE.json` (SHA-256 `79b3de5db3dbcb9829789ba58e9e45758926031e2a7d80667a08429d369be53b`, 1,579 entries); certificate `research/community-frontier1094-audit/ASSEMBLY.json` (SHA-256 `1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045`). Reproduction command is `make frontier1094-verify`, which runs `selected-record-check` then `scripts/verify_frontier1094.py --work /replay`. The selected cold replay was not run in this sparse worktree. + +## Refined object and changed premise + +Scope status: **changed**. The catalogue points toward another larger-register/nonabelian target family. The live board and open PRs show dense coverage of small finite-group target searches. This experiment instead changes the excluded register-coupling restriction and asks whether the added operations enable sharing in the already-specified GL3 CNOT address group. + +Let `G = GL3(F2)`, with the six coordinate transvections `g_ij = I + E_ij` as paid labels. There are two arbitrary dirty scalar roles. A paid factor is + +```text +D_N(g) = I + ([g] + [e]) N +``` + +where `N` is any nonzero rank-one matrix in `M2(F2)`: six rank-one idempotents and three rank-one nilpotents. Every such factor is an involution because `g^2=e` and the group-algebra characteristic is two. The changed operation assumption is that every rank-one conditional register update has equal one-call cost; no nilpotent helper or clean state is introduced. + +For every ordered endpoint pair `(p,q)` whose coordinate-CNOT distances satisfy `d(p) <= 2`, `d(q) <= 2`, and `d(p)+d(q) <= 4`, test whether `diag([p],[q])` has a full-coefficient word shorter than its independent direct bill `d(p)+d(q)`. There are at most 31 endpoints per role (961 pairs total). A strict saving of one call is the experiment's target. + +## Optimistic complete cost and stop rule + +The direct bill is at most four charged rank-one calls. The optimistic candidate bill charges every expanded-alphabet factor exactly one call, all two roles are outputs, and no helper, copy, source-access, frame-transition, restoration, precision, or recursive-child expense is omitted inside this declared finite word model. A candidate with three or fewer factors saves at least one call. External supplier placement and any implementation cost beyond the stipulated rank-one primitive are not included; no `kappa` claim can follow from this package. + +The alphabet has `6 * 9 = 54` factors. Exhaust all words through length three (at most `1 + 54 + 54^2 + 54^3 = 160,435` words) and compare exact coefficients in all 168 elements of `F2[G]`. Stop after this complete boundary: report a verified witness if one exists, or only the scoped floor over the declared endpoint set if none exists. Do not expand to longer targets or other groups this cycle. + +## Predecessors and overlap + +- PR #1974 (Josie Elliston), head `a4992da8e4e81a74cf1fd2b2d3af948662476d6e`, supplies the two-role GL3 mixed-target census and bounded three-register probe. Its relevant packages are `research/bit-gl3-mixed-targets-length10/README.md` (SHA-256 `f1f88a618fa998baa2bb5e8bc69c225405b6106b4c0a5646d84c42166cd4aff5`) and `research/bit-three-register-lower-bound/README.md` (SHA-256 `c12b33ef388deece0cbf891505a2ce2c0779a0c3a6cf1f0f7f7039bab59cbebd`); the scalar couplings are idempotent. This experiment adds the three nilpotent rank-one couplings and restricts endpoints to direct cost at most four. +- PR #2027 (Gareth Davidson), head `cd37822ee3523e53b645848644e0dae42d47abe7`, uses all nonzero rank-one couplings in a UT4(F2) mixed-root tariff. Its group, targets, register dimension, and proof obligation differ; it is the closest precedent for charging nilpotent couplings as native factors. +- PR #2167 (Wayne Nilsen), head `cea5d7be431b09877848354f04d5f2ba512339fd`, treats clean ancillas in the two-register `m=3` model, not this all-dirty expanded alphabet. Other close open PRs include #2246 (A5 conjugate 5-cycles), #2248 (Q8 three-role minima), #2261 (UT3(F4) commutator), and #2187 (C4 root lift); none matches this GL3/nilpotent-coupling endpoint domain. +- The latest complete cached overlap snapshot used 505 open PRs (fetched 2026-10-15 03:22:59 UTC) and 990 Discussions/comments (fetched 2026-10-15 03:26:31 UTC). A live GraphQL `gh pr list` immediately before submission returned 508 open PRs; title/body search found no GL3 nilpotent-coupling target match. A live Discussion search for `GL3 nilpotent` found this claim #2285, the UT4 tariff thread #1647, and the hub #1167. The fresh `find_overlap --refresh` process did not return within 78 seconds and was stopped; an earlier refresh had reported the REST API limit response. Cached helper results are labelled as potentially stale. The recent A5 claim in Discussion #2242 subsequently posted a FINDING/HANDOFF releasing its claim and is a different group/target. + +## Evidence plan + +- Enumerate the full 54-factor alphabet and all target pairs in the stated endpoint domain using packed exact coefficient states. +- Recheck the certificate with a separately written full-coefficient evaluator, including the direct positive witnesses, chronological-order negative control, and a control that removes nilpotent factors from the alphabet. +- Run the package check and the relevant repository metadata/certificate checks. Report the exact finite coverage, environment, selected-source limits, and any unproved native-supplier mapping. +- Any resulting contribution will disclose substantial OpenAI Codex assistance and preserve predecessor attribution. diff --git a/research/gl3-nilpotent-coupling-seeda9ab7bd2/VERIFY.json b/research/gl3-nilpotent-coupling-seeda9ab7bd2/VERIFY.json new file mode 100644 index 0000000000..f12df6b20c --- /dev/null +++ b/research/gl3-nilpotent-coupling-seeda9ab7bd2/VERIFY.json @@ -0,0 +1,33 @@ +{ + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/search.py", + "--check" + ], + "checks": "Recompute the packed exact BFS and compare the full deterministic certificate without rewriting it.", + "timeout_seconds": 60 + }, + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/verify.py" + ], + "checks": "Independent set-of-group-elements replay through depth three; all target, direct, involution, chronology and coupling controls.", + "timeout_seconds": 60 + } + ], + "inputs": [ + "certificates/selected-result.json", + "docs/research/agent-task-catalog.json" + ], + "python": "3.12", + "requirements": [], + "schema_version": 1, + "status": "ready" +} diff --git a/research/gl3-nilpotent-coupling-seeda9ab7bd2/search.py b/research/gl3-nilpotent-coupling-seeda9ab7bd2/search.py new file mode 100644 index 0000000000..3a7a6a68a1 --- /dev/null +++ b/research/gl3-nilpotent-coupling-seeda9ab7bd2/search.py @@ -0,0 +1,250 @@ +#!/usr/bin/env python3 +"""Exact radius-three search for rank-one couplings in GL3(F2).""" + +from __future__ import annotations + +import hashlib +import json +import argparse +from collections import deque +from pathlib import Path + + +ROOT = Path(__file__).resolve().parents[2] +HERE = Path(__file__).resolve().parent + + +def mul3(a: int, b: int) -> int: + """Multiply packed 3x3 binary matrices; row r occupies bits 3r..3r+2.""" + out = 0 + for i in range(3): + row = (a >> (3 * i)) & 7 + for j in range(3): + col = ((b >> j) & 1) | (((b >> (3 + j)) & 1) << 1) | (((b >> (6 + j)) & 1) << 2) + if (row & col).bit_count() & 1: + out |= 1 << (3 * i + j) + return out + + +def cnot_generators() -> tuple[int, ...]: + eye = sum(1 << (4 * i) for i in range(3)) + return tuple(eye ^ (1 << (3 * i + j)) for i in range(3) for j in range(3) if i != j) + + +def address_group(): + eye = sum(1 << (4 * i) for i in range(3)) + gens = cnot_generators() + order = [eye] + distance = {eye: 0} + words = {eye: ()} + todo = deque([eye]) + while todo: + a = todo.popleft() + for g in gens: + b = mul3(a, g) + if b not in distance: + distance[b] = distance[a] + 1 + words[b] = words[a] + (g,) + order.append(b) + todo.append(b) + if len(order) != 168: + raise AssertionError(f"GL3(F2) order: {len(order)}") + index = {g: i for i, g in enumerate(order)} + return order, index, distance, words, gens + + +def rank_one_couplings(): + out = set() + for u in range(1, 4): + for v in range(1, 4): + n = 0 + for i in range(2): + for j in range(2): + if ((u >> i) & 1) and ((v >> j) & 1): + n |= 1 << (2 * i + j) + out.add(n) + if len(out) != 9: + raise AssertionError(f"rank-one coupling count: {len(out)}") + return tuple(sorted(out)) + + +def right_permutations(group, index): + return tuple(tuple(index[mul3(h, g)] for h in group) for g in cnot_generators()) + + +def permute(bits: int, permutation: tuple[int, ...]) -> int: + out = 0 + while bits: + low = bits & -bits + out |= 1 << permutation[low.bit_length() - 1] + bits ^= low + return out + + +def step(state, label_index: int, n: int, permutations): + p = permutations[label_index] + out = list(state) + for row in range(2): + a, b = state[2 * row], state[2 * row + 1] + for col in range(2): + source = 0 + if (n >> col) & 1: # N[0,col] + source ^= a + if (n >> (2 + col)) & 1: # N[1,col] + source ^= b + out[2 * row + col] ^= permute(source, p) ^ source + return tuple(out) + + +def target_state(p: int, q: int, index): + out = [0, 0, 0, 0] + out[0] = 1 << index[p] + out[3] = 1 << index[q] + return tuple(out) + + +def rank_one_type_counts(couplings): + idempotents = sum(1 for n in couplings if (n & 1) ^ ((n >> 3) & 1)) + return idempotents, len(couplings) - idempotents + + +def reconstruct(state, parents, factors): + word = [] + while state in parents: + state, fidx = parents[state] + word.append(factors[fidx]) + word.reverse() + return word + + +def main(): + ap = argparse.ArgumentParser() + ap.add_argument("--check", action="store_true", help="recompute and compare without rewriting the certificate") + args = ap.parse_args() + + group, index, distance, words, generators = address_group() + eye = group[0] + couplings = rank_one_couplings() + idempotents, nilpotents = rank_one_type_counts(couplings) + if (idempotents, nilpotents) != (6, 3): + raise AssertionError((idempotents, nilpotents)) + + perm_by_label = right_permutations(group, index) + label_index = {g: i for i, g in enumerate(generators)} + factors = tuple((label_index[g], n) for g in generators for n in couplings) + identity = (1 << index[eye], 0, 0, 1 << index[eye]) + + endpoints = [g for g in group if distance[g] <= 2] + pairs = [(p, q) for p in endpoints for q in endpoints] + direct = {(p, q): distance[p] + distance[q] for p, q in pairs} + targets = {target_state(p, q, index): (p, q) for p, q in pairs} + + seen = {identity} + frontier = {identity} + parents = {} + first_depth = {identity: 0} + transitions = 0 + states_at_depth = [1] + for depth in range(1, 4): + following = set() + for state in frontier: + for fidx, (li, n) in enumerate(factors): + transitions += 1 + child = step(state, li, n, perm_by_label) + if child in seen: + continue + seen.add(child) + first_depth[child] = depth + parents[child] = (state, fidx) + following.add(child) + frontier = following + states_at_depth.append(len(frontier)) + + hits = [] + for state, (p, q) in targets.items(): + d = direct[(p, q)] + got = first_depth.get(state) + if got is not None and got < d: + word = reconstruct(state, parents, factors) + hits.append({ + "p": f"{p:03x}", "q": f"{q:03x}", "direct": d, + "found": got, + "word": [[f"{generators[li]:03x}", f"{n:x}"] for li, n in word], + }) + + direct_checks = 0 + e11 = 1 # [[1,0],[0,0]] + e22 = 8 # [[0,0],[0,1]] + for p, q in pairs: + state = identity + for g in words[p]: + state = step(state, label_index[g], e11, perm_by_label) + for g in words[q]: + state = step(state, label_index[g], e22, perm_by_label) + if state != target_state(p, q, index): + raise AssertionError(f"direct positive control failed for {(p, q)}") + direct_checks += 1 + + histogram = {} + for d in direct.values(): + histogram[str(d)] = histogram.get(str(d), 0) + 1 + + task = json.loads((HERE / "TASK.json").read_text()) + sources = json.loads((HERE / "SOURCES.json").read_text()) + base = sources["base_commit"] + if task["base_commit"] != base: + raise AssertionError("TASK/SOURCES base mismatch") + pinned = {item["path"]: item["sha256"] for item in sources["files"]} + for path in ("docs/research/agent-task-catalog.json", "certificates/selected-result.json"): + live_sha = hashlib.sha256((ROOT / path).read_bytes()).hexdigest() + if pinned.get(path) != live_sha: + raise AssertionError(f"pinned input changed: {path}") + catalogue_sha = pinned["docs/research/agent-task-catalog.json"] + selected_sha = pinned["certificates/selected-result.json"] + cert = { + "schema": 1, + "seed": "a9ab7bd2bdc2d83089d7ee5ca0948454", + "base_commit": base, + "catalogue_sha256": catalogue_sha, + "selected_record_sha256": selected_sha, + "group": "GL3(F2)", + "group_order": len(group), + "labels": [f"{g:03x}" for g in generators], + "register_roles": 2, + "register_state_scope": "arbitrary dirty inputs; exact diagonal endpoints", + "couplings": { + "total_rank_one": len(couplings), + "idempotent": idempotents, + "nilpotent": nilpotents, + "packed_M2_F2": [f"{n:x}" for n in couplings], + }, + "endpoint_radius_per_role": 2, + "endpoint_count_per_role": len(endpoints), + "ordered_endpoint_pairs": len(pairs), + "direct_cost_histogram": histogram, + "factor_alphabet_size": len(factors), + "raw_words_through_length_3": sum(len(factors) ** i for i in range(4)), + "unique_state_counts_by_shortest_length": states_at_depth, + "transition_evaluations": transitions, + "direct_positive_controls": direct_checks, + "shorter_endpoint_hits": hits, + "result": "NO_SHORTER_ENDPOINT_WORDS" if not hits else "SHORTER_WORDS_FOUND", + } + encoded = json.dumps(cert, indent=2, sort_keys=True) + "\n" + if args.check: + if (HERE / "CERTIFICATE.json").read_text() != encoded: + raise AssertionError("recomputed certificate differs from committed CERTIFICATE.json") + else: + (HERE / "CERTIFICATE.json").write_text(encoded) + print( + "PASS_EXPANDED_RANKONE_GL3" + f" group={len(group)} labels={len(generators)} factors={len(factors)}" + f" couplings={idempotents}+{nilpotents} endpoints={len(endpoints)}" + f" pairs={len(pairs)} direct={direct_checks}" + f" states={','.join(map(str, states_at_depth))}" + f" transitions={transitions} shorter={len(hits)} result={cert['result']}" + ) + + +if __name__ == "__main__": + main() diff --git a/research/gl3-nilpotent-coupling-seeda9ab7bd2/verify.py b/research/gl3-nilpotent-coupling-seeda9ab7bd2/verify.py new file mode 100644 index 0000000000..6cd3e9f654 --- /dev/null +++ b/research/gl3-nilpotent-coupling-seeda9ab7bd2/verify.py @@ -0,0 +1,278 @@ +#!/usr/bin/env python3 +"""Independent set-coefficient replay for the expanded-coupling certificate.""" + +from __future__ import annotations + +import hashlib +import json +from collections import deque +from pathlib import Path + + +ROOT = Path(__file__).resolve().parents[2] +HERE = Path(__file__).resolve().parent +Matrix3 = tuple[int, int, int] # Three binary rows, each in [0,7]. +Polynomial = frozenset[Matrix3] # Coefficients in F2: membership means coefficient one. +Transfer = tuple[Polynomial, Polynomial, Polynomial, Polynomial] + + +def identity3() -> Matrix3: + return (1, 2, 4) + + +def multiply3(a: Matrix3, b: Matrix3) -> Matrix3: + out = [] + for row in a: + value = 0 + for col in range(3): + column = ((b[0] >> col) & 1) | (((b[1] >> col) & 1) << 1) | (((b[2] >> col) & 1) << 2) + value |= ((row & column).bit_count() & 1) << col + out.append(value) + return tuple(out) + + +def generators() -> tuple[Matrix3, ...]: + result = [] + for i in range(3): + for j in range(3): + if i == j: + continue + rows = [1, 2, 4] + rows[i] ^= 1 << j + result.append(tuple(rows)) + return tuple(result) + + +def build_group(): + e = identity3() + gs = generators() + order = [e] + distance = {e: 0} + path = {e: ()} + todo = deque([e]) + while todo: + a = todo.popleft() + for g in gs: + b = multiply3(a, g) + if b not in distance: + distance[b] = distance[a] + 1 + path[b] = path[a] + (g,) + order.append(b) + todo.append(b) + if len(order) != 168: + raise AssertionError(f"expected 168 group elements, got {len(order)}") + return tuple(order), distance, path, gs + + +def couplings(): + result = set() + for u in (1, 2, 3): + for v in (1, 2, 3): + result.add((v if u & 1 else 0, v if u & 2 else 0)) + if len(result) != 9: + raise AssertionError(f"expected nine rank-one matrices, got {len(result)}") + return tuple(sorted(result, key=lambda n: n[0] | (n[1] << 2))) + + +def add(a: Polynomial, b: Polynomial) -> Polynomial: + return a.symmetric_difference(b) + + +def right_shift(poly: Polynomial, g: Matrix3) -> Polynomial: + return frozenset(multiply3(h, g) for h in poly) + + +def factor_step(state: Transfer, g: Matrix3, n: tuple[int, int]) -> Transfer: + result = list(state) + for r in range(2): + source_columns = (state[2 * r], state[2 * r + 1]) + for j in range(2): + v = frozenset() + for k in range(2): + if (n[k] >> j) & 1: + v = add(v, source_columns[k]) + delta = add(right_shift(v, g), v) + result[2 * r + j] = add(state[2 * r + j], delta) + return tuple(result) + + +def target(p: Matrix3, q: Matrix3) -> Transfer: + return (frozenset({p}), frozenset(), frozenset(), frozenset({q})) + + +def type_counts(ns): + idem = sum(1 for n in ns if ((n[0] & 1) ^ ((n[1] >> 1) & 1))) + return idem, len(ns) - idem + + +def direct_word(state, p, q, paths, gs): + e11 = (1, 0) + e22 = (0, 2) + label_set = set(gs) + for g in paths[p]: + if g not in label_set: + raise AssertionError("endpoint path contains an unknown label") + state = factor_step(state, g, e11) + for g in paths[q]: + state = factor_step(state, g, e22) + return state + + +def verify_involutions(group, ns, gs): + e = identity3() + labels = set(gs) + factors = [(g, n) for g in gs for n in ns] + # Basis transfers span the complete four-entry group-algebra matrix space. + for entry in range(4): + for h in group: + basis = [frozenset() for _ in range(4)] + basis[entry] = frozenset({h}) + basis = tuple(basis) + for g, n in factors: + if g not in labels or factor_step(factor_step(basis, g, n), g, n) != basis: + raise AssertionError("rank-one factor failed involution control") + return len(factors) * 4 * len(group) + + +def main(): + group, distance, paths, gs = build_group() + e = identity3() + ns = couplings() + idem, nilp = type_counts(ns) + if (idem, nilp) != (6, 3): + raise AssertionError((idem, nilp)) + + endpoints = [g for g in group if distance[g] <= 2] + endpoint_pairs = [(p, q) for p in endpoints for q in endpoints] + histogram = {} + target_pairs = {} + for p, q in endpoint_pairs: + cost = distance[p] + distance[q] + histogram[str(cost)] = histogram.get(str(cost), 0) + 1 + target_pairs[target(p, q)] = (p, q, cost) + + zero: Transfer = (frozenset({e}), frozenset(), frozenset(), frozenset({e})) + seen = {zero} + frontier = {zero} + depth_counts = [1] + found_depth = {} + if zero in target_pairs: + found_depth[zero] = 0 + transitions = 0 + for depth in range(1, 4): + following = set() + for state in frontier: + for g in gs: + for n in ns: + transitions += 1 + child = factor_step(state, g, n) + if child in seen: + continue + seen.add(child) + following.add(child) + if child in target_pairs: + found_depth[child] = depth + frontier = following + depth_counts.append(len(frontier)) + + shorter = [] + for state, (p, q, direct_cost) in target_pairs.items(): + reached = found_depth.get(state) + if reached is not None and reached < direct_cost: + shorter.append((p, q, direct_cost, reached)) + + direct_checks = 0 + for p, q in endpoint_pairs: + got = direct_word(zero, p, q, paths, gs) + if got != target(p, q): + raise AssertionError(f"direct positive control failed: {p},{q}") + direct_checks += 1 + + # Chronology mutation: the 0->1 and 1->2 transvections do not commute. + x, y = gs[0], gs[3] + xy, yx = multiply3(x, y), multiply3(y, x) + if xy == yx: + raise AssertionError("chronology control selected commuting labels") + correct = zero + for g in (x, y): + correct = factor_step(correct, g, (1, 0)) + for g in (y, x): + correct = factor_step(correct, g, (0, 2)) + if correct != target(xy, yx): + raise AssertionError("chronology positive control failed") + reversed_word = zero + for g in (y, x): + reversed_word = factor_step(reversed_word, g, (1, 0)) + for g in (x, y): + reversed_word = factor_step(reversed_word, g, (0, 2)) + if reversed_word == target(xy, yx): + raise AssertionError("reversed chronology was not rejected") + + # Coupling mutation: route the first role's parity into the other role. + wrong_coupling = factor_step(zero, x, (1, 1)) + if wrong_coupling == factor_step(zero, x, (1, 0)): + raise AssertionError("coupling mutation was not detected") + + expected = json.loads((HERE / "CERTIFICATE.json").read_text()) + task = json.loads((HERE / "TASK.json").read_text()) + sources = json.loads((HERE / "SOURCES.json").read_text()) + base = sources["base_commit"] + if task["base_commit"] != base: + raise AssertionError("TASK/SOURCES base mismatch") + pinned = {item["path"]: item["sha256"] for item in sources["files"]} + for path in ("docs/research/agent-task-catalog.json", "certificates/selected-result.json"): + live_sha = hashlib.sha256((ROOT / path).read_bytes()).hexdigest() + if pinned.get(path) != live_sha: + raise AssertionError(f"pinned input changed: {path}") + catalogue_sha = pinned["docs/research/agent-task-catalog.json"] + selected_sha = pinned["certificates/selected-result.json"] + checks = { + "base_commit": base, + "catalogue_sha256": catalogue_sha, + "selected_record_sha256": selected_sha, + "group_order": len(group), + "labels": [f"{sum(row << (3*i) for i, row in enumerate(g)):03x}" for g in gs], + "couplings": { + "total_rank_one": len(ns), + "idempotent": idem, + "nilpotent": nilp, + "packed_M2_F2": [ + f"{n[0] | (n[1] << 2):x}" for n in ns + ], + }, + "endpoint_count_per_role": len(endpoints), + "ordered_endpoint_pairs": len(endpoint_pairs), + "direct_cost_histogram": histogram, + "factor_alphabet_size": len(gs) * len(ns), + "raw_words_through_length_3": sum((len(gs) * len(ns)) ** i for i in range(4)), + "unique_state_counts_by_shortest_length": depth_counts, + "transition_evaluations": transitions, + "direct_positive_controls": direct_checks, + "shorter_endpoint_hits": [], + "result": "NO_SHORTER_ENDPOINT_WORDS", + } + if shorter: + checks["shorter_endpoint_hits"] = [ + {"p": p, "q": q, "direct": dc, "found": got} + for p, q, dc, got in shorter + ] + checks["result"] = "SHORTER_WORDS_FOUND" + for key, value in checks.items(): + if expected.get(key) != value: + raise AssertionError(f"certificate mismatch for {key}: {expected.get(key)!r} != {value!r}") + if len(endpoint_pairs) != 961 or len(seen) != sum(depth_counts): + raise AssertionError("coverage count mismatch") + + involution_basis_checks = verify_involutions(group, ns, gs) + print( + "PASS_EXPANDED_RANKONE_GL3_INDEPENDENT" + f" group={len(group)} labels={len(gs)} factors={len(gs)*len(ns)}" + f" couplings={idem}+{nilp} endpoints={len(endpoints)}" + f" pairs={direct_checks} states={','.join(map(str, depth_counts))}" + f" transitions={transitions} involution_basis_checks={involution_basis_checks}" + f" shorter={len(shorter)} controls=2 result={checks['result']}" + ) + + +if __name__ == "__main__": + main()