From cb49b12ac1e14f2f206a3823beeed474bffe2822 Mon Sep 17 00:00:00 2001 From: Cinna Davis <1337isnot1337@users.noreply.github.com> Date: Wed, 14 Oct 2026 04:04:08 -0500 Subject: [PATCH 1/3] Add exact UT4 noncentral q4 barrier --- .../BASELINE.json | 18 + .../README.md | 148 +++++++ .../SOURCES.json | 60 +++ .../TASK.json | 136 +++++++ .../TASK.md | 89 ++++ .../VALIDATION.md | 41 ++ .../VERIFY.json | 24 ++ .../certificate.json | 46 +++ .../search.py | 382 ++++++++++++++++++ .../verify.py | 40 ++ 10 files changed, 984 insertions(+) create mode 100644 research/ut4-noncentral-commutator-seedbfe59/BASELINE.json create mode 100644 research/ut4-noncentral-commutator-seedbfe59/README.md create mode 100644 research/ut4-noncentral-commutator-seedbfe59/SOURCES.json create mode 100644 research/ut4-noncentral-commutator-seedbfe59/TASK.json create mode 100644 research/ut4-noncentral-commutator-seedbfe59/TASK.md create mode 100644 research/ut4-noncentral-commutator-seedbfe59/VALIDATION.md create mode 100644 research/ut4-noncentral-commutator-seedbfe59/VERIFY.json create mode 100644 research/ut4-noncentral-commutator-seedbfe59/certificate.json create mode 100644 research/ut4-noncentral-commutator-seedbfe59/search.py create mode 100644 research/ut4-noncentral-commutator-seedbfe59/verify.py 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..35a77830ee --- /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 391 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); +its finding update will carry the PR link. 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..efac43dc10 --- /dev/null +++ b/research/ut4-noncentral-commutator-seedbfe59/TASK.json @@ -0,0 +1,136 @@ +{ + "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": "Posted as Discussion #1759 at 2026-10-14T09:02:54Z; finding update with the PR link will follow after submission. Claim expiry is 2026-10-14T10:30:00Z.", + "claim_url": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1759", + "overlap": { + "searched_at": "2026-10-14T09:02:07Z", + "coverage": { + "open_prs": { + "fetched_at": "2026-10-14T09:00:49Z", + "complete_pagination": true, + "records": 434 + }, + "discussions": { + "fetched_at": "2026-10-14T09:02:07Z", + "complete_pagination": true, + "records": 391 + } + }, + "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" + }, + "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..b7c9b9c1a1 --- /dev/null +++ b/research/ut4-noncentral-commutator-seedbfe59/TASK.md @@ -0,0 +1,89 @@ +# 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 391 Discussions with no +warnings, and the claim was posted as Discussion #1759 at 09:02:54 UTC. Its +expiry is 10:30 UTC; update it with the completed result and PR link. + +## 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']}" +) From da863b396f7326000ffe9933c6ec784fc75d9900 Mon Sep 17 00:00:00 2001 From: Cinna Davis <1337isnot1337@users.noreply.github.com> Date: Wed, 14 Oct 2026 04:06:48 -0500 Subject: [PATCH 2/3] Record live UT4 overlap and claim --- .../ut4-noncentral-commutator-seedbfe59/README.md | 2 +- .../ut4-noncentral-commutator-seedbfe59/TASK.json | 11 ++++++----- research/ut4-noncentral-commutator-seedbfe59/TASK.md | 2 +- 3 files changed, 8 insertions(+), 7 deletions(-) diff --git a/research/ut4-noncentral-commutator-seedbfe59/README.md b/research/ut4-noncentral-commutator-seedbfe59/README.md index 35a77830ee..ea8b30628b 100644 --- a/research/ut4-noncentral-commutator-seedbfe59/README.md +++ b/research/ut4-noncentral-commutator-seedbfe59/README.md @@ -107,7 +107,7 @@ 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 391 Discussions +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 diff --git a/research/ut4-noncentral-commutator-seedbfe59/TASK.json b/research/ut4-noncentral-commutator-seedbfe59/TASK.json index efac43dc10..ef4529b791 100644 --- a/research/ut4-noncentral-commutator-seedbfe59/TASK.json +++ b/research/ut4-noncentral-commutator-seedbfe59/TASK.json @@ -107,17 +107,17 @@ "claim_status": "Posted as Discussion #1759 at 2026-10-14T09:02:54Z; finding update with the PR link will follow after submission. Claim expiry is 2026-10-14T10:30:00Z.", "claim_url": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1759", "overlap": { - "searched_at": "2026-10-14T09:02:07Z", + "searched_at": "2026-10-14T09:05:53Z", "coverage": { "open_prs": { - "fetched_at": "2026-10-14T09:00:49Z", + "fetched_at": "2026-10-14T09:04:32Z", "complete_pagination": true, "records": 434 }, "discussions": { - "fetched_at": "2026-10-14T09:02:07Z", + "fetched_at": "2026-10-14T09:05:52Z", "complete_pagination": true, - "records": 391 + "records": 392 } }, "nearest_open_prs": { @@ -128,7 +128,8 @@ "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" + "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" }, "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 index b7c9b9c1a1..128d7f81be 100644 --- a/research/ut4-noncentral-commutator-seedbfe59/TASK.md +++ b/research/ut4-noncentral-commutator-seedbfe59/TASK.md @@ -63,7 +63,7 @@ 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 391 Discussions with no +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 expiry is 10:30 UTC; update it with the completed result and PR link. From 0f4f6d79b14573116e47d31d012f8e3f7a49cd87 Mon Sep 17 00:00:00 2001 From: Cinna Davis <1337isnot1337@users.noreply.github.com> Date: Wed, 14 Oct 2026 04:08:01 -0500 Subject: [PATCH 3/3] Record UT4 PR and finding handoff --- .../ut4-noncentral-commutator-seedbfe59/README.md | 6 +++--- .../ut4-noncentral-commutator-seedbfe59/TASK.json | 11 +++++++++-- research/ut4-noncentral-commutator-seedbfe59/TASK.md | 9 ++++++++- 3 files changed, 20 insertions(+), 6 deletions(-) diff --git a/research/ut4-noncentral-commutator-seedbfe59/README.md b/research/ut4-noncentral-commutator-seedbfe59/README.md index ea8b30628b..a3de0db4b4 100644 --- a/research/ut4-noncentral-commutator-seedbfe59/README.md +++ b/research/ut4-noncentral-commutator-seedbfe59/README.md @@ -111,9 +111,9 @@ 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); -its finding update will carry the PR link. TASK.json records exact refresh -timestamps, active heads, and limits. +[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 diff --git a/research/ut4-noncentral-commutator-seedbfe59/TASK.json b/research/ut4-noncentral-commutator-seedbfe59/TASK.json index ef4529b791..af55752887 100644 --- a/research/ut4-noncentral-commutator-seedbfe59/TASK.json +++ b/research/ut4-noncentral-commutator-seedbfe59/TASK.json @@ -104,8 +104,15 @@ }, "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": "Posted as Discussion #1759 at 2026-10-14T09:02:54Z; finding update with the PR link will follow after submission. Claim expiry is 2026-10-14T10:30:00Z.", + "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": { @@ -129,7 +136,7 @@ "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" + "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 index 128d7f81be..691fbf4caf 100644 --- a/research/ut4-noncentral-commutator-seedbfe59/TASK.md +++ b/research/ut4-noncentral-commutator-seedbfe59/TASK.md @@ -65,7 +65,14 @@ 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 -expiry is 10:30 UTC; update it with the completed result and PR link. +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