diff --git a/research/ut4-noncentral-commutator-seedbfe59/BASELINE.json b/research/ut4-noncentral-commutator-seedbfe59/BASELINE.json new file mode 100644 index 0000000000..23b30ba63c --- /dev/null +++ b/research/ut4-noncentral-commutator-seedbfe59/BASELINE.json @@ -0,0 +1,18 @@ +{ + "command": "python3 -B scripts/research_baseline.py", + "status": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "selected_record_sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32", + "selected_kappa": "836330098538459/500000000000000000", + "review": "docs/research/community-batch1099-review.md", + "certificate": "research/community-frontier1094-audit/ASSEMBLY.json", + "full_replay": "make frontier1094-verify", + "bit_saving": "1733427039589844234749/1000000000000000000000000", + "complex_saving": "67018507072324140917/40000000000000000000000", + "binding_primitive": "complex", + "ideal_balanced_cap": "67018507072324140917/40067018507072324140917", + "target_kappa": "1/100", + "target_primitive_under_retained_transfer": "1/99", + "required_bit_multiplier": 5.827190801985042, + "required_complex_multiplier": 6.028788489788009, + "scope": "Selected source bindings and arithmetic only. The a/(1+a) transfer is a planning model under retained hypotheses, not a universal requirement or supplier verification." +} diff --git a/research/ut4-noncentral-commutator-seedbfe59/README.md b/research/ut4-noncentral-commutator-seedbfe59/README.md new file mode 100644 index 0000000000..a3de0db4b4 --- /dev/null +++ b/research/ut4-noncentral-commutator-seedbfe59/README.md @@ -0,0 +1,148 @@ +# Four-call barrier for a noncentral UT4 root pair + +**Exact scoped negative result; no new supplier or kappa.** In the full formal +group algebra F2[UT4(F2)], with paid labels restricted to the three adjacent +transvections, the endpoint + +~~~text +diag([xyxy], [yzyz], [1], [1]) +~~~ + +has no realization in at most four calls +D_N(g) = I + ([g]+[1])N, even when every binary rank-one idempotent +N in M4(F2) is allowed on every call. The exact search covers all ordered +words through length four. A direct eight-call word realizes the endpoint, so +the minimum in this fixed formal model is between five and eight. Lengths +five through seven were not searched. + +## Model and cost screen + +Encode a group element by its six strict-upper entries in the order +(12,13,14,23,24,34). Let x=I+E12, y=I+E23, and z=I+E34; these involutions +generate the 64-element group UT4(F2). Their commutators +u=xyxy=I+E13 and v=yzyz=I+E24 are noncentral. The target is +diag([u],[v],[1],[1]) over the formal group algebra. +Indeed, u and z have commutator I+E14, as do x and v; these nonidentity +commutators are checked in the executable structural validation. + +There are 120 rank-one idempotents: each is ab^T for nonzero a,b in F2^4 +with b^T a=1. This gives 360 allowed call matrices. Because each paid label +is an involution and N^2=N, every call is itself an involution: +(I+([g]+[1])N)^2=I. + +The direct construction uses x,y,x,y on register one and y,z,y,z on +register two, for eight unit-priced formal calls. In the natural +16-dimensional representation of the four-register group-algebra matrix, the +target displacement has rank two. Each allowed call has displacement rank +one, since it is a tensor product of a rank-one idempotent and a rank-one +generator displacement. Thus one call is excluded by rank, while the +optimistic rank floor is two. This formal count assigns one unit per call. +Source, helper, recursive, hosting, restoration, precision, and interface +charges do not exist in this abstract identity model; treating them as zero +would only make a hypothetical short word cheaper. A formal identity alone +would still need a realized supplier and complete interface bill before it +could affect the selected conditional bound. + +## Exact search + +For each of the 360 allowed factors, form the full 4-by-4 matrix over +F2[G], where a group-algebra coefficient vector is a 64-bit mask. The exact +ordered two-factor table contains 129,600 words and 87,016 distinct matrix +products (42,584 ordered collisions). + +The exhaustive split is: + +1. Length two: test the target against the complete pair table. +2. Length three: for each of 360 final calls C, test target*C against the + pair table, using C^-1=C. +3. Length four: for each ordered suffix (C,D) among all 129,600 pairs, test + target*D*C against the pair table, using (CD)^-1=DC. + +The diagonal target makes each right-side multiplication an exact row +translation in the group algebra. The script nevertheless stores and compares +all 16 matrix-entry coefficient masks; it does not project to a representation +or quotient. The certificate records the full pair-table digest and the +complete candidate counts. It also checks the direct eight-call construction, +an omitted-call corruption, and a wrong-label corruption. + +## Reproduce + +Python 3.10+ and the standard library suffice: + +~~~sh +python3 -I -B research/ut4-noncentral-commutator-seedbfe59/verify.py +~~~ + +Expected output: + +~~~text +PASS_UT4_NONCENTRAL_Q4 factors=360 pair_words=129600 distinct_pairs=87016 q3=360 q4=129600 outcome=no_word_of_length_at_most_4 baseline=complex +~~~ + +To regenerate certificate.json explicitly: + +~~~sh +python3 -I -B research/ut4-noncentral-commutator-seedbfe59/search.py --write-certificate +~~~ + +search.py constructs the group table, all legal factors, full group-algebra +matrix products, and the exhaustive meet-in-the-middle search. +verify.py recomputes the result and requires exact certificate equality. +certificate.json pins the seed, base, selected-record digest, table counts, +rank screen, outcome, and direct/corruption controls. Before searching, the +script cross-checks every one of the 4,096 ordered UT4 group products against +ordinary 4-by-4 binary matrix multiplication. The verifier also reruns the +selected baseline binding control and requires exact equality with BASELINE.json. + +## Scope, overlap, and attribution + +This refines catalogue task bit-new-register-model to one four-register +nonabelian group, one fixed three-label alphabet, one noncentral two-root +target, and the predeclared q<=4 search. It does not settle q=5..8, arbitrary +nonabelian groups, arbitrary target tuples, or a physical supplier. Closed +PR #1333 established a rank-sum minimum with the full rank-one affine-label +alphabet; this result restricts to three fixed generators and uses a +different noncentral target. Open UT4 PRs #1662, #1680, and #1690 concern +central targets. Active Discussion #1738 concerns a three-register UT3 +central pair; #1740 concerns an S4 pair; #1743 concerns helper-star costs. +These are nearby search families, not the target and endpoint proved here. + +The live overlap refresh paginated all 434 open PRs and all 392 Discussions +with no warnings. Direct checks of active claims #1738, #1740, and #1743 found +different groups, targets, and mechanisms. The claim was kept local during +the initial GraphQL rate limit, then posted after reset as +[Discussion #1759](https://github.com/CrocSwap/integer-mult-bounds/discussions/1759). +The finding and handoff comment links this package's [PR #1761](https://github.com/CrocSwap/integer-mult-bounds/pull/1761). +TASK.json records exact refresh timestamps, active heads, and limits. + +The current selected record is a maintainer-reviewed conditional finite +construction, with kappa 836330098538459/500000000000000000. Its review is +docs/research/community-batch1099-review.md, its selected source manifest is +research/community-frontier1094-audit/SELECTED-SOURCE.json, and its assembly +certificate is research/community-frontier1094-audit/ASSEMBLY.json (SHA-256 +1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045). The +selected record names the integration receipt and reproduces with +make frontier1094-verify. Exact base-commit Git blob and SHA-256 pins for +these artifacts and the selected record are in SOURCES.json. No selected +result, upstream source, or pre-existing certificate was changed; this +package adds its own certificate.json. + +The task's baseline positive control returned +PASS_RESEARCH_BASELINE_BINDINGS_ONLY: the complex primitive remains binding. +Under the retained planning transfer, the baseline arithmetic reports a +required bit multiplier of 5.827190801985042 for the target kappa 1/100. +This is source-binding and arithmetic evidence only, not a full supplier +replay or a universal transfer bound. The exact output is preserved in +BASELINE.json, and the baseline script is pinned in SOURCES.json. Consequently +this finite bit-model result does not change the selected frontier. + +Prepared by Cinna Davis (@1337isnot1337) with substantial OpenAI Codex +assistance in mathematics, implementation, verification, and writing. + +## Open next questions + +Does this fixed endpoint have a word of length five, six, or seven in the same +full group-algebra alphabet? Start from the q<=4 pair table and use a +three-factor split, with a cost screen before retaining any new construction. +Even a positive formal word would need a complete supplier, recursive-moment, +and assembly argument before any kappa claim. diff --git a/research/ut4-noncentral-commutator-seedbfe59/SOURCES.json b/research/ut4-noncentral-commutator-seedbfe59/SOURCES.json new file mode 100644 index 0000000000..95f1a2c2dc --- /dev/null +++ b/research/ut4-noncentral-commutator-seedbfe59/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": "research/bit-three-register-lower-bound/README.md", + "usage": "input", + "git_blob": "25e41c370c101a33a6deb978de08b03ed7539b79", + "sha256": "c12b33ef388deece0cbf891505a2ce2c0779a0c3a6cf1f0f7f7039bab59cbebd" + }, + { + "path": "research/community-frontier1094-audit/SELECTED-SOURCE.json", + "usage": "provenance", + "git_blob": "6a75493790b4eff9c4a98051ef8b01d6aad0d5a8", + "sha256": "79b3de5db3dbcb9829789ba58e9e45758926031e2a7d80667a08429d369be53b" + }, + { + "path": "research/community-frontier1094-audit/ASSEMBLY.json", + "usage": "provenance", + "git_blob": "5fd676df060f3b450782fdf5ff5f6beb63a5eeb0", + "sha256": "1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045" + }, + { + "path": "docs/research/community-batch1099-review.md", + "usage": "provenance", + "git_blob": "6cb6ec061a071a06a2d18cd4dc3e9a2b05d28099", + "sha256": "7e76d2c38e5fce30587835b7251df1430488ae4dd372611ef69a3f03f476b6cb" + }, + { + "path": "docs/research/community-batch1099-integration.json", + "usage": "provenance", + "git_blob": "9d60e86c0e494d17bec5e28eda41b275c9ede64e", + "sha256": "684c50d1ac69863e1fcc0a34bf76c54bac576f6bbde79b3c67d8432a495c8c1c" + }, + { + "path": "Makefile", + "usage": "provenance", + "git_blob": "448f13b58fbe3492e2ea6b2005c8822aefe2765c", + "sha256": "029076ba6558f4c97d59d508baeb47847e0fad3545ed1fd22943ab9d6c84c2b9" + }, + { + "path": "scripts/research_baseline.py", + "usage": "input", + "git_blob": "6b607b36eefd65718120ade3c8187681f11bf879", + "sha256": "59d9b04dc33e1bb3f81506d187243435de4902138a038b935e36ebaa5f37db67" + } + ] +} diff --git a/research/ut4-noncentral-commutator-seedbfe59/TASK.json b/research/ut4-noncentral-commutator-seedbfe59/TASK.json new file mode 100644 index 0000000000..af55752887 --- /dev/null +++ b/research/ut4-noncentral-commutator-seedbfe59/TASK.json @@ -0,0 +1,144 @@ +{ + "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": "Exact q<=4 search in F2[UT4(F2)] for diag([xyxy],[yzyz],[1],[1]) using exactly the three paid labels x=I+E12, y=I+E23, z=I+E34 and any binary rank-one idempotent N in M4(F2).", + "scope_change_reason": "The catalogue question is broad. This run fixes the smallest four-register nonabelian triangular group, its three adjacent transvections, a two-root noncentral target, and a q<=4 improvement threshold; it does not claim a universal result for larger or nonabelian models.", + "bottleneck_link": "A q<=4 identity would halve the direct eight-call formal cost in this changed alphabet, but it could affect the conditional bound only after supplier realization and complete interface admission.", + "budget_minutes": 60, + "stop_rule": "Enumerate all 120 rank-one idempotents and three labels, exhaust all ordered q<=4 words by exact full-group-algebra meet-in-the-middle, check the direct eight-call control and two corruptions, then stop without searching q=5..8. Reserve the final quarter of the cycle for verification and handoff.", + "outcome": "negative-result", + "evidence": "search.py independently cross-checks all 4096 UT4 group products by matrix multiplication, checks noncentrality witnesses for both targets, exhausts the complete 360-factor alphabet through q=4, and verifies the direct eight-call word plus omitted-call and wrong-label controls. certificate.json records the exact no-witness result, 129600 ordered pair words, 87016 distinct pair products, 360 q3 candidates, and 129600 q4 candidates. verify.py recomputes the certificate and selected baseline output.", + "author": "Cinna Davis (@1337isnot1337)", + "ai_assistance": "Substantial OpenAI Codex assistance in mathematical framing, exact implementation, verification, and writing.", + "open_questions": [ + { + "question": "Does the fixed target have a word of length five, six, or seven in the same full group-algebra alphabet?", + "why_it_matters": "It would determine whether the formal minimum improves on the direct eight-call word beyond the q<=4 barrier.", + "first_step": "Use a three-factor split against the exact q<=2 product table and calculate the full optimistic call and supplier cost before retaining a search.", + "blocked_by": "The q<=4 result does not cover suffixes of length three, and any formal word still lacks supplier and assembly admission." + } + ], + "seed": "bfe59e1502f6168422d1d522f30c3fba", + "catalogue_sha256": "6686ad58f1fbdbc87134a78901b60fd53a20d3984355e91defbbebc9e9fa8075", + "selected_record_sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32", + "selected_record_resolution": { + "status": "Maintainer-reviewed conditional finite construction", + "kappa": "836330098538459/500000000000000000", + "review": "docs/research/community-batch1099-review.md", + "source_manifest": "research/community-frontier1094-audit/SELECTED-SOURCE.json", + "certificate": "research/community-frontier1094-audit/ASSEMBLY.json", + "certificate_sha256": "1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045", + "integration_receipt": "docs/research/community-batch1099-integration.json", + "reproduce": "make frontier1094-verify" + }, + "baseline_control": { + "command": "python3 -B scripts/research_baseline.py", + "status": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "binding_primitive": "complex", + "required_bit_multiplier_under_retained_transfer": 5.827190801985042, + "result_file": "BASELINE.json", + "limit": "Source bindings and arithmetic only; this does not replay the supplier or establish a universal transfer bound." + }, + "scope_key": "bfe59e1502f6168422d1d522f30c3fba/UT4-F2/noncentral-root-pair/q4", + "predecessors": { + "PR1333": { + "head": "7f25b6d0e1d7e995d4d2840f231d98b1a1a9fec2", + "base": "bce54fb3f895cbe5cd4c0eb477c3afeed100190f", + "status": "merged 2026-10-14", + "scope": "Full rank-one affine-label alphabet rank-sum minimum; current task restricts to three adjacent transvections and the noncentral root-pair target." + }, + "PR1662": { + "head": "01cc02b164ecc4f9d84df3f56a1fe65b88daf390", + "base": "a18b4b0136d647529971e9fcb99fa83f5b9a0b81", + "scope": "Open UT4 central-target tariff theorem; same group alphabet, different central endpoint." + }, + "PR1680": { + "head": "a281330e84e64ad357e35b338796c96144a345ce", + "base": "d78fe4bbb6f6b769e39586f8bb3ba8c31a31fd3a", + "scope": "Open UT4 two-central-target unit-count theorem with dirty workspace." + }, + "PR1690": { + "head": "dfd15686309d26eb98740942c4e84cddeafae7d8", + "base": "0b1cccf86e2f5132ed286a26ef0a681a495740ea", + "scope": "Open UT4 central-target finite endpoint result." + } + }, + "optimistic_budget": "Direct word costs eight formal unit calls. The target has natural-representation displacement rank two and any one call has displacement rank at most one, so the rank floor is two. A hypothetical q<=4 word would halve the formal direct count. No physical supplier, helper schedule, recursive children, frame transitions, copied-information price, hosting, restoration, precision, or interface is specified by this abstract alphabet; treating absent costs as zero is optimistic only and cannot support a kappa claim.", + "required_observable_improvement": "An exact q<=4 endpoint in the full formal group algebra, followed by a separately admitted supplier and complete recursive/assembly cost. The finite q<=4 search found no endpoint.", + "claim_status": "Completed finding and handoff posted as Discussion comment 18920217 at 2026-10-14T09:07:24Z. Original claim was posted at 2026-10-14T09:02:54Z.", + "claim_url": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1759", + "claim_update_url": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1759#discussioncomment-18920217", + "pull_request": { + "number": 1761, + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1761", + "status_at_handoff": "open", + "title": "Research: q<=4 barrier for a noncentral UT4 root pair" + }, + "overlap": { + "searched_at": "2026-10-14T09:05:53Z", + "coverage": { + "open_prs": { + "fetched_at": "2026-10-14T09:04:32Z", + "complete_pagination": true, + "records": 434 + }, + "discussions": { + "fetched_at": "2026-10-14T09:05:52Z", + "complete_pagination": true, + "records": 392 + } + }, + "nearest_open_prs": { + "1662": "01cc02b164ecc4f9d84df3f56a1fe65b88daf390", + "1680": "a281330e84e64ad357e35b338796c96144a345ce", + "1690": "dfd15686309d26eb98740942c4e84cddeafae7d8" + }, + "active_discussions_checked": { + "1738": "UT3 third dirty register for D8 central commutator; updated 2026-10-14T08:27:41Z", + "1740": "S4 four-register sharing for noncommuting 3-cycles; updated 2026-10-14T08:26:56Z", + "1743": "R439 compensated terminal helper-star deferral; updated 2026-10-14T08:28:17Z", + "1759": "This run's bounded UT4 noncentral root-pair claim; posted 2026-10-14T09:02:54Z and updated with FINDING/HANDOFF at 2026-10-14T09:07:24Z" + }, + "warnings": [], + "limits": "Search covered PR bodies and indexed Discussions plus direct relevant pages and local research notes. It did not inspect every code diff and is not a proof of novelty." + } +} diff --git a/research/ut4-noncentral-commutator-seedbfe59/TASK.md b/research/ut4-noncentral-commutator-seedbfe59/TASK.md new file mode 100644 index 0000000000..691fbf4caf --- /dev/null +++ b/research/ut4-noncentral-commutator-seedbfe59/TASK.md @@ -0,0 +1,96 @@ +# Cycle 3 task card: sharing two noncentral UT4 commutators + +- Accepted seed: `bfe59e1502f6168422d1d522f30c3fba` +- Track: `bit-mechanisms` +- Catalogue card: `bit-new-register-model` (one selector suggestion; helper-contract was excluded as saturated R439 scope) +- Catalogue priority revision: 3 +- Catalogue SHA-256: `6686ad58f1fbdbc87134a78901b60fd53a20d3984355e91defbbebc9e9fa8075` +- Exact base: `0b1cccf86e2f5132ed286a26ef0a681a495740ea` +- Selected-record SHA-256: `10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32` +- Refined scope key: `bfe59e1502f6168422d1d522f30c3fba/UT4-F2/r4/noncentral-root-pair/q4` + +## Object and question + +Let `G=UT4(F2)`, with adjacent transvections +`x=I+E12`, `y=I+E23`, and `z=I+E34`. Put +`u=xyxy=I+E13` and `v=yzyz=I+E24`. In the full formal group algebra +`F2[G]`, can +`diag([u],[v],[1],[1])` be realized using at most four paid calls +`D_N(g)=I+([g]+[1])N`, where the paid labels are exactly `{x,y,z}` and +`N` is any rank-one idempotent in `M4(F2)`? Arbitrary dirty registers and free +scalar `GL4(F2)` mixing are allowed by normalization to per-call idempotents. +The target root elements are noncentral in `UT4(F2)`. + +## Changed hypothesis and price screen + +The direct word `xyxy` on role 1 and `yzyz` on role 2 costs 8 calls. In the +natural homogeneous 4-dimensional representation, each target displacement +has rank one, so the combined floor is 2. Each allowed generator displacement +and each `N` have rank one, hence a paid call changes this represented rank by +at most one. A four-call exact word would halve the direct paid-call count and +leave four calls of headroom over the optimistic floor. Charge every scalar +call one unit; no physical, helper, recursive, copying, hosting, precision, +frame, interface, or restoration price is admitted. Even a positive word would +not change kappa without a realized supplier and complete interface bill. + +## Method and stopping rule + +Enumerate all 120 rank-one idempotents and three labels (360 factors) in the +full 64-element group algebra. Use exact meet-in-the-middle multiplication to +exhaust all words of lengths 2, 3, and 4, with rank excluding length 1. Check +the direct 8-call positive control and omitted-call / wrong-label controls. +Stop after q=4 coverage; do not extend to q=5..8 in this cycle. A projected +matrix match alone is not a formal endpoint; any positive candidate must be +replayed in the full group algebra. + +## Predecessors and overlap + +- Closed PR #1333 proves the rank-sum optimum when all rank-one affine labels + are paid. This task restricts the alphabet to three fixed generators. +- Open PR #1662 and PR #1680, plus PR #1690, concern UT4 central targets and + workspace tariffs. This target uses the noncentral roots E13 and E24. +- Active Discussion #1738 is a three-register UT3 central pair; Discussion + #1740 is a four-register S4 noncommuting 3-cycle pair. Neither has this + group or these target elements. +- The helper-contract suggestion was not selected: overlap found many prior + R439 boundary packages, and the active Discussion #1743 concerns a related + helper-star boundary. + +The live PR refresh at 08:40 UTC covered 428 open PRs with complete +pagination. GitHub GraphQL rate limiting blocked a fresh Discussion scan; the +last complete scan was 08:34 UTC (383 records). The public Discussions index +was refreshed at 08:41 UTC, and the direct #1738/#1740 pages were checked. + +A GitHub claim could not be posted during the first rate-limit window, so the +local card was used while the search continued. After the API reset, the +refreshed overlap scan covered 434 open PRs and 392 Discussions with no +warnings, and the claim was posted as Discussion #1759 at 09:02:54 UTC. Its +finding and handoff were posted at 09:07:24 UTC after opening PR #1761. + +## Handoff + +- PR #1761 is open: https://github.com/CrocSwap/integer-mult-bounds/pull/1761 +- Discussion finding update: https://github.com/CrocSwap/integer-mult-bounds/discussions/1759#discussioncomment-18920217 +- The q<=4 result is complete; q=5..7 and Python 3.12 hosted replay remain + open questions/validation obligations. No kappa or supplier claim is made. + +## Expected evidence + +One exact full-algebra q<=4 witness with a reproducible product certificate, or +a complete q<=4 no-witness result scoped to this alphabet and tuple. Neither +outcome excludes q=5..8 or changes the selected kappa by itself. + +## Result + +The exact full-algebra search found no word of length at most four. It +enumerated all 129,600 ordered two-factor products, checked all 360 possible +three-factor endpoints and all 129,600 four-factor suffixes, and independently +cross-checked all 4,096 UT4 group products against ordinary matrix +multiplication. The direct eight-call control equals the target; deleting its +last call or replacing its first x-label with z changes the endpoint. + +The formal minimum is therefore between five and eight in this fixed model; +q=5..7 remain unsearched. The result does not provide a supplier or kappa. +Reproduction and the exact certificate are in README.md and certificate.json. +The GitHub claim was kept local while the Discussion API was rate-limited; +refresh and attempt the claim before the recorded expiry. diff --git a/research/ut4-noncentral-commutator-seedbfe59/VALIDATION.md b/research/ut4-noncentral-commutator-seedbfe59/VALIDATION.md new file mode 100644 index 0000000000..eaad143e7d --- /dev/null +++ b/research/ut4-noncentral-commutator-seedbfe59/VALIDATION.md @@ -0,0 +1,41 @@ +# Validation record + +- Environment: CPython 3.14.7, standard library only. +- The exact q<=4 search and certificate generation completed: + +~~~sh +python3 -I -B research/ut4-noncentral-commutator-seedbfe59/search.py --write-certificate +~~~ + +- The direct verifier passed with 360 factors, 129,600 ordered pair words, + 87,016 distinct pair products, all 360 q3 checks, and all 129,600 q4 checks: + +~~~sh +python3 -I -B research/ut4-noncentral-commutator-seedbfe59/verify.py +~~~ + +This verifier also reruns the selected baseline positive control and compares +its complete JSON output to BASELINE.json. + +- Package metadata and exact base/source pins passed: + +~~~sh +python3 scripts/research_package.py --package research/ut4-noncentral-commutator-seedbfe59 --check-only +~~~ + +- The selected bit-task baseline positive control returned + PASS_RESEARCH_BASELINE_BINDINGS_ONLY. Its exact output is preserved in + BASELINE.json; it confirms source bindings and arithmetic only. +- The exact group table was cross-checked in the verifier for all 4,096 + ordered group-element pairs; both noncentrality witnesses and both + corruption controls passed. + +This metadata command does not validate the mathematical result. The package +replay manifest specifies Python 3.12, as required by the repository replay +system. Python 3.12 is not installed here, so the registered Python 3.12 +replay was not run locally. The direct standard-library verifier passed under +Python 3.14.7. + +The run changes no selected result, upstream source, existing certificate, or +repository-wide research allocation. Hosted Python 3.12 replay and maintainer +review remain separate. diff --git a/research/ut4-noncentral-commutator-seedbfe59/VERIFY.json b/research/ut4-noncentral-commutator-seedbfe59/VERIFY.json new file mode 100644 index 0000000000..a7e29b7458 --- /dev/null +++ b/research/ut4-noncentral-commutator-seedbfe59/VERIFY.json @@ -0,0 +1,24 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "certificates/selected-result.json", + "docs/research/agent-task-catalog.json", + "research/bit-three-register-lower-bound/README.md", + "scripts/research_baseline.py" + ], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Cross-checks all 4096 UT4 group products against ordinary matrix multiplication; checks noncentrality witnesses; regenerates all 360 factors and 129600 exact ordered pair products; exhausts q2, q3, and q4 endpoints in the full F2[UT4(F2)] matrix algebra; checks the natural rank floor, direct eight-call endpoint, both corruption controls, exact certificate equality, and exact replay of the selected baseline binding control against BASELINE.json." + } + ] +} diff --git a/research/ut4-noncentral-commutator-seedbfe59/certificate.json b/research/ut4-noncentral-commutator-seedbfe59/certificate.json new file mode 100644 index 0000000000..c8185a4dff --- /dev/null +++ b/research/ut4-noncentral-commutator-seedbfe59/certificate.json @@ -0,0 +1,46 @@ +{ + "base_commit": "0b1cccf86e2f5132ed286a26ef0a681a495740ea", + "controls": { + "direct_8_call_word_equals_target": true, + "first_x_changed_to_z_differs": true, + "omitted_final_call_differs": true + }, + "distinct_pair_products": 87016, + "factors": 360, + "group": "UT4(F2)", + "group_encoding": "six strict-upper bits in order (12,13,14,23,24,34)", + "independent_group_products_checked": 4096, + "maximum_single_call_displacement_rank": 1, + "natural_representation_target_displacement_rank": 2, + "noncentrality_witnesses": { + "u_commutator_z": "0x04", + "x_commutator_v": "0x04" + }, + "ordered_pair_collisions": 42584, + "ordered_pair_words": 129600, + "outcome": "no_word_of_length_at_most_4", + "paid_labels": { + "x": "0x01", + "y": "0x08", + "z": "0x20" + }, + "pair_table_sha256": "468b8177d64ce98cd0557089d50c3c248e12ee7cd5fefba97cda886c74f0c527", + "q2_checked": "membership in complete ordered pair table", + "q3_candidates_checked": 360, + "q4_candidates_checked": 129600, + "rank_exclusion": "target displacement rank 2; one call changes rank by at most 1", + "rank_one_idempotents": 120, + "seed": "bfe59e1502f6168422d1d522f30c3fba", + "selected_record_sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32", + "targets": { + "diagonal": [ + "0x02", + "0x10", + "0x00", + "0x00" + ], + "u": "0x02", + "v": "0x10" + }, + "witness": null +} diff --git a/research/ut4-noncentral-commutator-seedbfe59/search.py b/research/ut4-noncentral-commutator-seedbfe59/search.py new file mode 100644 index 0000000000..7534bcd5ae --- /dev/null +++ b/research/ut4-noncentral-commutator-seedbfe59/search.py @@ -0,0 +1,382 @@ +#!/usr/bin/env python3 +"""Exact q<=4 search for a three-generator UT4 group-algebra word.""" + +from __future__ import annotations + +import hashlib +import argparse +import json +import struct +from pathlib import Path + + +N = 4 +POSITIONS = ((0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (2, 3)) +POS_INDEX = {p: i for i, p in enumerate(POSITIONS)} +IDENTITY = 0 +GROUP_SIZE = 64 +ALGEBRA_ONE = 1 << IDENTITY +SEED = "bfe59e1502f6168422d1d522f30c3fba" +BASE = "0b1cccf86e2f5132ed286a26ef0a681a495740ea" +SELECTED_SHA256 = "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32" + + +def group_multiply(a: int, b: int) -> int: + """Multiply UT4(F2) elements encoded by their six strict-upper bits.""" + out = 0 + for bit, (i, j) in enumerate(POSITIONS): + value = ((a >> bit) ^ (b >> bit)) & 1 + for k in range(i + 1, j): + value ^= ((a >> POS_INDEX[(i, k)]) & 1) & ((b >> POS_INDEX[(k, j)]) & 1) + out |= value << bit + return out + + +MUL = tuple(tuple(group_multiply(a, b) for b in range(GROUP_SIZE)) for a in range(GROUP_SIZE)) + + +def group_inverse(a: int) -> int: + for b in range(GROUP_SIZE): + if MUL[a][b] == IDENTITY and MUL[b][a] == IDENTITY: + return b + raise AssertionError("group inverse missing") + + +INV = tuple(group_inverse(a) for a in range(GROUP_SIZE)) + + +def word(*letters: int) -> int: + result = IDENTITY + for letter in letters: + result = MUL[result][letter] + return result + + +X = 1 << POS_INDEX[(0, 1)] +Y = 1 << POS_INDEX[(1, 2)] +Z = 1 << POS_INDEX[(2, 3)] +U = word(X, Y, X, Y) +V = word(Y, Z, Y, Z) +TARGET_DIAGONAL = (U, V, IDENTITY, IDENTITY) + + +def matrix_bits_product(a: int, b: int) -> int: + """Product of two 4x4 binary matrices encoded row-major in 16 bits.""" + out = 0 + for i in range(N): + for j in range(N): + value = 0 + for k in range(N): + value ^= ((a >> (i * N + k)) & 1) & ((b >> (k * N + j)) & 1) + out |= value << (i * N + j) + return out + + +def rank_binary_rows(rows: list[int], columns: int) -> int: + """Rank over F2 for row vectors stored as integer bitsets.""" + work = rows[:] + rank = 0 + for column in range(columns): + pivot = next((r for r in range(rank, len(work)) if (work[r] >> column) & 1), None) + if pivot is None: + continue + work[rank], work[pivot] = work[pivot], work[rank] + for r in range(len(work)): + if r != rank and ((work[r] >> column) & 1): + work[r] ^= work[rank] + rank += 1 + if rank == len(work): + break + return rank + + +def rank4(matrix: int) -> int: + return rank_binary_rows([(matrix >> (4 * i)) & 0xF for i in range(4)], 4) + + +def natural_displacement(group_element: int) -> int: + result = 0 + for bit, (i, j) in enumerate(POSITIONS): + if (group_element >> bit) & 1: + result |= 1 << (4 * i + j) + return result + + +def natural_matrix(group_element: int) -> int: + identity = sum(1 << (4 * i + i) for i in range(4)) + return identity ^ natural_displacement(group_element) + + +def group_code_from_matrix(matrix: int) -> int: + return sum(((matrix >> (4 * i + j)) & 1) << bit + for bit, (i, j) in enumerate(POSITIONS)) + + +def rank_one_idempotents() -> list[int]: + matrices: list[int] = [] + for column in range(1, 1 << N): + for row in range(1, 1 << N): + if (column & row).bit_count() % 2 != 1: + continue + matrix = 0 + for i in range(N): + for j in range(N): + if ((column >> i) & 1) and ((row >> j) & 1): + matrix |= 1 << (i * N + j) + assert matrix_bits_product(matrix, matrix) == matrix + assert rank4(matrix) == 1 + matrices.append(matrix) + assert len(matrices) == 120 and len(set(matrices)) == 120 + return matrices + + +IDEMPOTENTS = rank_one_idempotents() +LABELS = (("x", X), ("y", Y), ("z", Z)) + + +def make_factor(label: int, nbits: int) -> tuple[int, ...]: + """Matrix for I + ([label]+[1])N over F2[G].""" + delta = ALGEBRA_ONE | (1 << label) + return tuple((ALGEBRA_ONE if i == j else 0) ^ (delta if ((nbits >> (i * N + j)) & 1) else 0) + for i in range(N) for j in range(N)) + + +FACTORS: list[tuple[int, ...]] = [] +FACTOR_META: list[tuple[str, int]] = [] +for label_name, label in LABELS: + for nbits in IDEMPOTENTS: + FACTORS.append(make_factor(label, nbits)) + FACTOR_META.append((label_name, nbits)) + + +def algebra_product(a: int, b: int) -> int: + """Product in F2[G], using 64-bit masks for coefficients.""" + result = 0 + left = a + while left: + low_a = left & -left + ga = low_a.bit_length() - 1 + left ^= low_a + right = b + while right: + low_b = right & -right + gb = low_b.bit_length() - 1 + right ^= low_b + result ^= 1 << MUL[ga][gb] + return result + + +def matrix_product(a: tuple[int, ...], b: tuple[int, ...]) -> tuple[int, ...]: + result = [] + for i in range(N): + for j in range(N): + entry = 0 + for k in range(N): + entry ^= algebra_product(a[i * N + k], b[k * N + j]) + result.append(entry) + return tuple(result) + + +def pack_matrix(matrix: tuple[int, ...]) -> bytes: + return struct.pack("<16Q", *matrix) + + +def diagonal_target() -> tuple[int, ...]: + return tuple(1 << TARGET_DIAGONAL[i] if i == j else 0 + for i in range(N) for j in range(N)) + + +TARGET = diagonal_target() +TARGET_KEY = pack_matrix(TARGET) + + +def translate_algebra(left_group_element: int, value: int) -> int: + result = 0 + while value: + low = value & -value + g = low.bit_length() - 1 + value ^= low + result ^= 1 << MUL[left_group_element][g] + return result + + +def left_multiply_diagonal(diagonal: tuple[int, ...], matrix: tuple[int, ...]) -> tuple[int, ...]: + """Left multiply by a diagonal matrix of single group elements.""" + out = [] + for i in range(N): + for j in range(N): + out.append(translate_algebra(diagonal[i * N + i].bit_length() - 1, matrix[i * N + j])) + return tuple(out) + + +def direct_word(indices: tuple[int, ...]) -> tuple[int, ...]: + result = tuple(ALGEBRA_ONE if i == j else 0 for i in range(N) for j in range(N)) + for factor_index in indices: + result = matrix_product(result, FACTORS[factor_index]) + return result + + +def direct_control_indices() -> tuple[int, ...]: + # Rank-one coordinate projectors e1e1^T and e2e2^T, labels x,y,y,z. + def factor_id(name: str, nbits: int) -> int: + label_index = next(k for k, (label_name, _) in enumerate(LABELS) if label_name == name) + return label_index * len(IDEMPOTENTS) + IDEMPOTENTS.index(nbits) + e1 = 1 << 0 + e2 = 1 << (N + 1) + # x,y,x,y on role 1 then y,z,y,z on role 2. + return tuple(factor_id(name, nbits) for name, nbits in ( + ("x", e1), ("y", e1), ("x", e1), ("y", e1), + ("y", e2), ("z", e2), ("y", e2), ("z", e2), + )) + + +def validate_structural_facts() -> None: + assert len(FACTORS) == 360 + # Independently reconstruct the full group table by ordinary 4x4 matrix + # multiplication, checking all 64*64 ordered pairs. + for a in range(GROUP_SIZE): + for b in range(GROUP_SIZE): + product_matrix = matrix_bits_product(natural_matrix(a), natural_matrix(b)) + assert group_code_from_matrix(product_matrix) == MUL[a][b] + assert product_matrix == natural_matrix(MUL[a][b]) + assert all(MUL[g][g] == IDENTITY for _, g in LABELS) + assert INV[X] == X and INV[Y] == Y and INV[Z] == Z + assert U == 1 << POS_INDEX[(0, 2)] + assert V == 1 << POS_INDEX[(1, 3)] + central_root = 1 << POS_INDEX[(0, 3)] + assert word(U, Z, U, Z) == central_root + assert word(X, V, X, V) == central_root + # In the natural representation the two target displacements have rank one each. + # The 16x16 target is block diagonal, so its displacement rank is two. + assert rank4(natural_displacement(U)) == 1 and rank4(natural_displacement(V)) == 1 + target_rows = [0] * 16 + target_rows[0] |= 1 << 2 # E13 in register 1 + target_rows[4 + 1] |= 1 << (4 + 3) # E24 in register 2 + assert rank_binary_rows(target_rows, 16) == 2 + # Each represented paid call has displacement N tensor (rho(g)+I), + # whose rank is rank(N)*rank(rho(g)+I)=1. + for label_name, label in LABELS: + assert rank4(natural_displacement(label)) == 1, label_name + # Every call is an involution because (g+1)^2=0 and N^2=N. + identity = tuple(ALGEBRA_ONE if i == j else 0 for i in range(N) for j in range(N)) + for f in FACTORS: + assert matrix_product(f, f) == identity + + +def search() -> dict: + validate_structural_facts() + pair_map: dict[bytes, tuple[int, int]] = {} + duplicate_pairs = 0 + for i, left in enumerate(FACTORS): + for j, right in enumerate(FACTORS): + key = pack_matrix(matrix_product(left, right)) + if key in pair_map: + duplicate_pairs += 1 + else: + pair_map[key] = (i, j) + + pair_words = len(FACTORS) ** 2 + assert pair_words == 129_600 + # Length 2, then 3. Each factor is self-inverse, so target*last is the + # required two-factor prefix for length 3. + witness = None + if TARGET_KEY in pair_map: + witness = ("q2", pair_map[TARGET_KEY]) + q3_checked = 0 + if witness is None: + for k, factor in enumerate(FACTORS): + needed_prefix = pack_matrix(left_multiply_diagonal(TARGET, factor)) + q3_checked += 1 + if needed_prefix in pair_map: + witness = ("q3", (*pair_map[needed_prefix], k)) + break + + # For a q4 word P*(a*b)=target, P=target*(b*a), since each + # individual call is an involution. Enumerate every ordered (a,b). + q4_checked = 0 + if witness is None: + for a, factor_a in enumerate(FACTORS): + for b, factor_b in enumerate(FACTORS): + inverse_suffix = matrix_product(factor_b, factor_a) + needed_prefix = pack_matrix(left_multiply_diagonal(TARGET, inverse_suffix)) + q4_checked += 1 + if needed_prefix in pair_map: + witness = ("q4", (*pair_map[needed_prefix], a, b)) + break + if witness is not None: + break + + direct_indices = direct_control_indices() + direct_result = direct_word(direct_indices) + assert direct_result == TARGET + omitted_result = direct_word(direct_indices[:-1]) + assert omitted_result != TARGET + wrong_label_indices = list(direct_indices) + # Replace the first x coordinate call by z on the same idempotent. + wrong_label_indices[0] += 2 * len(IDEMPOTENTS) + wrong_label_result = direct_word(tuple(wrong_label_indices)) + assert wrong_label_result != TARGET + + if witness is None: + assert q3_checked == 360 and q4_checked == pair_words + q1_rank_exclusion = "target displacement rank 2; one call changes rank by at most 1" + outcome = "no_word_of_length_at_most_4" + witness_data = None + else: + length_name, indices = witness + witness_data = [ + {"factor_index": i, "label": FACTOR_META[i][0], "N_bits": f"0x{FACTOR_META[i][1]:04x}"} + for i in indices + ] + assert direct_word(indices) == TARGET + q1_rank_exclusion = "target displacement rank 2; one call changes rank by at most 1" + outcome = f"witness_{length_name}" + + canonical = { + "seed": SEED, + "base_commit": BASE, + "selected_record_sha256": SELECTED_SHA256, + "group": "UT4(F2)", + "group_encoding": "six strict-upper bits in order (12,13,14,23,24,34)", + "paid_labels": {name: f"0x{g:02x}" for name, g in LABELS}, + "targets": {"u": f"0x{U:02x}", "v": f"0x{V:02x}", "diagonal": [f"0x{g:02x}" for g in TARGET_DIAGONAL]}, + "noncentrality_witnesses": {"u_commutator_z": f"0x{word(U, Z, U, Z):02x}", "x_commutator_v": f"0x{word(X, V, X, V):02x}"}, + "rank_one_idempotents": len(IDEMPOTENTS), + "independent_group_products_checked": GROUP_SIZE * GROUP_SIZE, + "factors": len(FACTORS), + "ordered_pair_words": pair_words, + "distinct_pair_products": len(pair_map), + "ordered_pair_collisions": duplicate_pairs, + "q2_checked": "membership in complete ordered pair table", + "q3_candidates_checked": q3_checked, + "q4_candidates_checked": q4_checked, + "outcome": outcome, + "witness": witness_data, + "natural_representation_target_displacement_rank": 2, + "maximum_single_call_displacement_rank": 1, + "rank_exclusion": q1_rank_exclusion, + "controls": { + "direct_8_call_word_equals_target": True, + "omitted_final_call_differs": True, + "first_x_changed_to_z_differs": True, + }, + "pair_table_sha256": hashlib.sha256(b"".join(sorted(pair_map))).hexdigest(), + } + return canonical + + +def main() -> None: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--write-certificate", action="store_true", + help="write the deterministic result to certificate.json") + args = parser.parse_args() + result = search() + encoded = json.dumps(result, indent=2, sort_keys=True) + "\n" + if args.write_certificate: + out_path = Path(__file__).with_name("certificate.json") + out_path.write_text(encoded, encoding="utf-8") + print(encoded, end="") + + +if __name__ == "__main__": + main() diff --git a/research/ut4-noncentral-commutator-seedbfe59/verify.py b/research/ut4-noncentral-commutator-seedbfe59/verify.py new file mode 100644 index 0000000000..681bfffa94 --- /dev/null +++ b/research/ut4-noncentral-commutator-seedbfe59/verify.py @@ -0,0 +1,40 @@ +#!/usr/bin/env python3 +"""Recompute and compare the exact bounded UT4 search certificate.""" + +import json +import importlib.util +from pathlib import Path +import subprocess +import sys + +HERE = Path(__file__).resolve().parent +SPEC = importlib.util.spec_from_file_location("ut4_noncentral_search", HERE / "search.py") +if SPEC is None or SPEC.loader is None: + raise SystemExit("cannot load search.py") +MODULE = importlib.util.module_from_spec(SPEC) +SPEC.loader.exec_module(MODULE) +expected = json.loads((HERE / "certificate.json").read_text(encoding="utf-8")) +actual = MODULE.search() +if actual != expected: + raise SystemExit("certificate mismatch") + +root = HERE.parents[1] +baseline_expected = json.loads((HERE / "BASELINE.json").read_text(encoding="utf-8")) +assert baseline_expected.pop("command") == "python3 -B scripts/research_baseline.py" +baseline_run = subprocess.run( + [sys.executable, "-B", "scripts/research_baseline.py"], + cwd=root, + capture_output=True, + check=True, + text=True, +) +if json.loads(baseline_run.stdout) != baseline_expected: + raise SystemExit("selected baseline positive-control receipt mismatch") + +print( + "PASS_UT4_NONCENTRAL_Q4 " + f"factors={actual['factors']} pair_words={actual['ordered_pair_words']} " + f"distinct_pairs={actual['distinct_pair_products']} " + f"q3={actual['q3_candidates_checked']} q4={actual['q4_candidates_checked']} " + f"outcome={actual['outcome']} baseline={baseline_expected['binding_primitive']}" +)