From 393bdcfc51cd1d9551722f1c5b20efc020f6b73a Mon Sep 17 00:00:00 2001 From: Cinna Davis <1337isnot1337@users.noreply.github.com> Date: Wed, 14 Oct 2026 03:28:36 -0500 Subject: [PATCH 1/2] Research four-label affine rank trajectory obstruction --- .../CERTIFICATE.json | 111 +++++++ .../Q7-OUTPUT.txt | 8 + .../README.md | 129 +++++++++ .../SOURCES.json | 96 ++++++ .../TASK.json | 172 +++++++++++ .../TASK.md | 61 ++++ .../VERIFY.json | 53 ++++ .../q7_trajectory_search.py | 106 +++++++ .../verify.py | 273 ++++++++++++++++++ 9 files changed, 1009 insertions(+) create mode 100644 research/affine-mixed-four-targets-seed5638/CERTIFICATE.json create mode 100644 research/affine-mixed-four-targets-seed5638/Q7-OUTPUT.txt create mode 100644 research/affine-mixed-four-targets-seed5638/README.md create mode 100644 research/affine-mixed-four-targets-seed5638/SOURCES.json create mode 100644 research/affine-mixed-four-targets-seed5638/TASK.json create mode 100644 research/affine-mixed-four-targets-seed5638/TASK.md create mode 100644 research/affine-mixed-four-targets-seed5638/VERIFY.json create mode 100644 research/affine-mixed-four-targets-seed5638/q7_trajectory_search.py create mode 100644 research/affine-mixed-four-targets-seed5638/verify.py diff --git a/research/affine-mixed-four-targets-seed5638/CERTIFICATE.json b/research/affine-mixed-four-targets-seed5638/CERTIFICATE.json new file mode 100644 index 0000000000..4b1df72dea --- /dev/null +++ b/research/affine-mixed-four-targets-seed5638/CERTIFICATE.json @@ -0,0 +1,111 @@ +{ + "schema_version": 1, + "field": "F2", + "target": "diag(h,h^-1,tx,ty) in the homogeneous affine 3x3 representation", + "registers": 4, + "target_displacement_rank": 6, + "paid_labels": [ + "a", + "b", + "tx", + "ty" + ], + "rank_one_idempotents": 120, + "factors": 480, + "q6_frontiers": [ + { + "depth": 1, + "incoming_states": 1, + "strict_drop_edges": 112, + "unique_states": 112, + "states_sha256": "10df2803c837e379a55cb68c5c52b68befe13cb998db0f537ea99e69ff664939" + }, + { + "depth": 2, + "incoming_states": 112, + "strict_drop_edges": 2816, + "unique_states": 960, + "states_sha256": "83d3033330efbec47b7f793a37366bc2414a267517979299f8edcfa65c04a528" + }, + { + "depth": 3, + "incoming_states": 960, + "strict_drop_edges": 4928, + "unique_states": 656, + "states_sha256": "c4e849d46f4ca43aff8f8be6c02ba0f8450bea499f365976011c06e405cae63d" + }, + { + "depth": 4, + "incoming_states": 656, + "strict_drop_edges": 520, + "unique_states": 32, + "states_sha256": "60e95c07370741151cdc96c1a97700f2c7ddb658ce7518ad8c464de1e38b8925" + }, + { + "depth": 5, + "incoming_states": 32, + "strict_drop_edges": 0, + "unique_states": 0, + "states_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + } + ], + "q6_endpoint_found": false, + "controls": { + "direct_word_calls": 10, + "direct_word_endpoint": "target", + "drop_call_control": "rejected", + "wrong_label_control": "rejected", + "all_480_factors_involutive": true + }, + "q7_trajectory": { + "program": "q7_trajectory_search.py", + "program_sha256": "dda3653279bf66b304c6ee0b9622ddae654eb875db2163e8802b96e4ac2b1362", + "output": "Q7-OUTPUT.txt", + "output_sha256": "8263e8941982eaa2840917f743f32db809644a3a2fcc481cea9f3c4f96dcb3d1", + "frontiers": [ + { + "depth": 1, + "states": 352, + "neutral0": 112, + "neutral1": 240, + "goal": false + }, + { + "depth": 2, + "states": 15368, + "neutral0": 960, + "neutral1": 14408, + "goal": false + }, + { + "depth": 3, + "states": 58352, + "neutral0": 656, + "neutral1": 57696, + "goal": false + }, + { + "depth": 4, + "states": 16772, + "neutral0": 32, + "neutral1": 16740, + "goal": false + }, + { + "depth": 5, + "states": 164, + "neutral0": 0, + "neutral1": 164, + "goal": false + }, + { + "depth": 6, + "states": 0, + "neutral0": 0, + "neutral1": 0, + "goal": false + } + ], + "endpoint_found": false + } +} diff --git a/research/affine-mixed-four-targets-seed5638/Q7-OUTPUT.txt b/research/affine-mixed-four-targets-seed5638/Q7-OUTPUT.txt new file mode 100644 index 0000000000..74c45c19eb --- /dev/null +++ b/research/affine-mixed-four-targets-seed5638/Q7-OUTPUT.txt @@ -0,0 +1,8 @@ +G [(3, 2, 4), (1, 3, 4), (5, 2, 4), (1, 6, 4)] uv [((1, 0, 0), (0, 1, 0)), ((0, 1, 0), (1, 0, 0)), ((1, 0, 0), (0, 0, 1)), ((0, 1, 0), (0, 0, 1))] +target [(2, 5, 4), (6, 1, 4), (5, 2, 4), (1, 6, 4)] rank 6 factors 480 +depth 1 states 352 neutral0 112 neutral1 240 goal False +depth 2 states 15368 neutral0 960 neutral1 14408 goal False +depth 3 states 58352 neutral0 656 neutral1 57696 goal False +depth 4 states 16772 neutral0 32 neutral1 16740 goal False +depth 5 states 164 neutral0 0 neutral1 164 goal False +depth 6 states 0 neutral0 0 neutral1 0 goal False diff --git a/research/affine-mixed-four-targets-seed5638/README.md b/research/affine-mixed-four-targets-seed5638/README.md new file mode 100644 index 0000000000..72ff15734f --- /dev/null +++ b/research/affine-mixed-four-targets-seed5638/README.md @@ -0,0 +1,129 @@ +# Four mixed affine targets in a four-register bit model + +This is a seed-pinned construction search in the noncommutative group algebra +of AGL2(F2). It restricts the paid alphabet to four affine labels and tests +whether a mixed four-target tuple can beat its direct ten calls. The closed +PR #1333 theorem gives cost six when all rank-one affine labels are available; +this experiment asks how much this fixed four-label subset costs. + +The paid labels are: + +* a(x0,x1)=(x0+x1,x1) +* b(x0,x1)=(x0,x0+x1) +* tx(x0,x1)=(x0+1,x1) +* ty(x0,x1)=(x0,x1+1) + +The target is diag(h,h^-1,tx,ty), with h(x0,x1)=(x1,x0+1) and +h^-1(x0,x1)=(x1+1,x0). A paid call is D_N(g)=I+([g]+[1])N for any rank-one +idempotent N in M4(F2). Arbitrary dirty registers are allowed. Free GL4(F2) +mixing is represented by conjugating the idempotents while moving scalar maps +through the paid gates; augmentation forces the net scalar map to identity. + +## Cost screen + +The homogeneous 3-by-3 affine representation maps the four target blocks to +displacement ranks 2, 2, 1, and 1, hence rank six total. Each paid generator +has rank-one displacement and each register coefficient has rank one, so one +call can alter the displacement rank by at most one. The direct construction +uses ten calls, leaving at most four calls above this optimistic floor before +any physical, recursive, helper, frame, copying, hosting, or restoration cost. +This local finite model cannot itself change the selected kappa. The full +rank-one affine alphabet in [PR #1333](https://github.com/CrocSwap/integer-mult-bounds/pull/1333) +has exact minimum six for this target; the current four-label subset is +strictly smaller and is the changed hypothesis tested here. The finished +claim for that theorem is [Discussion #1317](https://github.com/CrocSwap/integer-mult-bounds/discussions/1317). + +## Exact q=6 result + +verify.py enumerates all 120 rank-one idempotents in M4(F2) and all four +labels (480 factors). Any six-call identity from this target must lower the +displacement rank at every step. The exhaustive lowering frontiers are +recorded in CERTIFICATE.json; the search reaches no rank-one state after five +drops, so no six-call word exists in this declared model. + +The certificate includes hashes of the complete unique-state frontiers. The +verifier also checks the direct ten-call positive control, a deleted-call +negative control, and a wrong-label negative control. All arithmetic is exact +over F2. + +## Exact q=7 result + +A seven-call word must have exactly six rank drops and one neutral step: +the target starts at displacement rank six, each factor changes rank by at +most one, and seven steps must end at zero. q7_trajectory_search.py covers +all such trajectories, allowing the neutral step at any position. The complete +frontiers are in Q7-OUTPUT.txt: + +| Depth | Incoming states | Next states | Neutral unused | Neutral used | +|---:|---:|---:|---:|---:| +| 1 | 1 | 352 | 112 | 240 | +| 2 | 352 | 15,368 | 960 | 14,408 | +| 3 | 15,368 | 58,352 | 656 | 57,696 | +| 4 | 58,352 | 16,772 | 32 | 16,740 | +| 5 | 16,772 | 164 | 0 | 164 | +| 6 | 164 | 0 | 0 | 0 | + +There are no length-six prefixes in the complete rank-compatible search, +so no seven-call endpoint is possible. This is a necessary-condition +obstruction in the homogeneous affine representation and therefore excludes +an exact group-algebra word in the declared model. Combined with the rank-six +floor and the direct ten-call word, the minimum with this four-label subset is +between eight and ten calls. The exact minimum is unresolved. PR #1333 allows +every rank-one affine displacement as a paid label and proves minimum six; +therefore any six-call attaining word from that theorem must use a label +outside this restricted set. No result here applies to the larger alphabet. + +Run the finite trajectory search with: + + python3 -I -B research/affine-mixed-four-targets-seed5638/q7_trajectory_search.py + +The recorded run took about ten minutes. The q=6 verifier checks the pinned +q=7 script/output hashes and frontier summary; rerunning this command checks +the full q=7 enumeration from scratch. + +## Reproduction + + python3 -I -B research/affine-mixed-four-targets-seed5638/verify.py + +Expected marker: PASS_AFFINE_MIXED_Q6_OBSTRUCTION. The output includes the +certificate SHA-256. + +## Pins and overlap + +* Accepted selector seed: 5638c49abc39ff4644ef875d73a20996 +* Track/task: bit-mechanisms / bit-new-register-model, catalogue revision 3 +* Base commit: 0b1cccf86e2f5132ed286a26ef0a681a495740ea +* Selected-result SHA-256: 10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32 +* Source hashes: SOURCES.json +* Active claim: https://github.com/CrocSwap/integer-mult-bounds/discussions/1727 + +The final pre-submission overlap scan completed at 2026-10-14 08:28:13 UTC: it +covered 419 open PRs and 375 Discussions with complete pagination and no warnings. Direct predecessor [PR #1333](https://github.com/CrocSwap/integer-mult-bounds/pull/1333) +(closed; head 7f25b6d0e1d7e995d4d2840f231d98b1a1a9fec2) proves the exact +six-call optimum for the full rank-one affine alphabet and names restricted +coordinate CNOT/translation alphabets as a next question. This package fixes +the four labels {a,b,tx,ty} and one four-register target tuple. Open PR #1711 +is a two-target affine minimum; open PR #1716 is a restricted three-register +AGL2 triple. Discussion #1738 is a concurrent three-register UT3 central-pair +claim with labels {x,y} and a full group-algebra radius search. Those have +different target tuples, register counts, groups, and methods. Cycle 1's open +[PR #1733](https://github.com/CrocSwap/integer-mult-bounds/pull/1733) concerns +rational address relations rather than this binary-affine label restriction. +Active Discussion #1727 is this task's separate four-register tuple with +standalone translations; it was the original coordination claim for this run. + +The direct ten-call word and the interval 8..10 provide no kappa improvement. +No physical supplier or recursive charge was established. No independent +human review is claimed. Prepared with substantial OpenAI Codex assistance in +framing, finite enumeration, verifier implementation, and writing. + +## Open next questions + +1. Can an exact eight- or nine-call word realize the same tuple? Any positive + candidate needs full formal group-algebra replay and full interface pricing. +2. Can another four-register mixed affine tuple yield a real paid-call saving? + A distinct target would need its own optimistic rank screen and complete + helper, copying, hosting, recursive, frame, precision, and restoration bill. + +The q=6/q=7 obstruction above is the complete stopping point for this seed; +no q=8..10 search was performed. diff --git a/research/affine-mixed-four-targets-seed5638/SOURCES.json b/research/affine-mixed-four-targets-seed5638/SOURCES.json new file mode 100644 index 0000000000..222325702f --- /dev/null +++ b/research/affine-mixed-four-targets-seed5638/SOURCES.json @@ -0,0 +1,96 @@ +{ + "schema_version": 1, + "base_commit": "0b1cccf86e2f5132ed286a26ef0a681a495740ea", + "files": [ + { + "path": "AGENTS.md", + "usage": "provenance", + "git_blob": "860762e04e963e1b163b8fa5267854c0040a9e67", + "sha256": "5f29c7cbf0eb28f4e87f0affa9cffdaef4e39a630a5878c8fed02b544c894d2e" + }, + { + "path": "CONTRIBUTING.md", + "usage": "provenance", + "git_blob": "e51435543687f1bd88ab22248082dc689ce8b853", + "sha256": "df5b5646602f42cb5da5844f04ac925182ddcd0f627b9de1c96a5095bb7a277a" + }, + { + "path": "autoresearch.md", + "usage": "provenance", + "git_blob": "8d5403e0f10f68a61d0cb9294fa2e83e872d1d82", + "sha256": "215b3222f6a943edc69422a28ac21ea1f397ddf54770f1d87ac4195385d73699" + }, + { + "path": "certificates/selected-result.json", + "usage": "input", + "git_blob": "ae6a99f28aa468649eb66a361e764d769363bf11", + "sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "06c96f5579bb67ed1b86d334e78fbed7da6945f1", + "sha256": "6686ad58f1fbdbc87134a78901b60fd53a20d3984355e91defbbebc9e9fa8075" + }, + { + "path": "docs/research/community-batch1099-review.md", + "usage": "input", + "git_blob": "6cb6ec061a071a06a2d18cd4dc3e9a2b05d28099", + "sha256": "7e76d2c38e5fce30587835b7251df1430488ae4dd372611ef69a3f03f476b6cb" + }, + { + "path": "research/binary-affine-register-bound/PROOF.md", + "usage": "input", + "git_blob": "b1152a39b559f7a058489ec74231488e4f8edd83", + "sha256": "36a33434222798434b0a17476ae5f9bc8a2a3891871c46e77cc50ce2e132206b" + }, + { + "path": "research/binary-affine-register-bound/README.md", + "usage": "input", + "git_blob": "7b68583becf8be6f3cf666b05b0943e7eb99270c", + "sha256": "7951868efdf35fdb2aacdd302ca825cbde0586a5fae6df23aee78e29f30c332a" + }, + { + "path": "research/binary-affine-register-bound/SOURCES.json", + "usage": "input", + "git_blob": "1a6ff149a724392dfb829e06c7ad750aa999b590", + "sha256": "b3ecf3d47432eb6eb5271dcae1c9bd5cd97dfabb257006b3e59184ca038989d0" + }, + { + "path": "research/binary-affine-register-bound/TASK.json", + "usage": "input", + "git_blob": "84dc9d73fdb009b91055b6451191d7dae86b7806", + "sha256": "75dbde42b53e785cc969b764d6477ea46eebf25a38946cf1ce56a2ee3c4e50e9" + }, + { + "path": "research/bit-three-register-lower-bound/README.md", + "usage": "input", + "git_blob": "25e41c370c101a33a6deb978de08b03ed7539b79", + "sha256": "c12b33ef388deece0cbf891505a2ce2c0779a0c3a6cf1f0f7f7039bab59cbebd" + }, + { + "path": "research/community-frontier1094-audit/ASSEMBLY.json", + "usage": "input", + "git_blob": "5fd676df060f3b450782fdf5ff5f6beb63a5eeb0", + "sha256": "1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045" + }, + { + "path": "research/community-frontier1094-audit/SELECTED-SOURCE.json", + "usage": "input", + "git_blob": "6a75493790b4eff9c4a98051ef8b01d6aad0d5a8", + "sha256": "79b3de5db3dbcb9829789ba58e9e45758926031e2a7d80667a08429d369be53b" + }, + { + "path": "scripts/choose_research_task.py", + "usage": "provenance", + "git_blob": "695639622a283190948c4187bdbb41997e6e43d7", + "sha256": "f1af1e70858ab1d033ce20ee1968201bc592eb9e3fd05ab8ad78c842c0b028d1" + }, + { + "path": "scripts/research_baseline.py", + "usage": "input", + "git_blob": "6b607b36eefd65718120ade3c8187681f11bf879", + "sha256": "59d9b04dc33e1bb3f81506d187243435de4902138a038b935e36ebaa5f37db67" + } + ] +} diff --git a/research/affine-mixed-four-targets-seed5638/TASK.json b/research/affine-mixed-four-targets-seed5638/TASK.json new file mode 100644 index 0000000000..031215e139 --- /dev/null +++ b/research/affine-mixed-four-targets-seed5638/TASK.json @@ -0,0 +1,172 @@ +{ + "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=6/q=7 rank-trajectory obstruction for target diag(h,h^-1,tx,ty) in four registers when the paid noncommutative F2[AGL2(F2)] alphabet is restricted to {a,b,tx,ty}. Together with the rank-six floor and direct 10-call word, this pins the subset minimum to 8..10; q=8..10 remain unresolved.", + "scope_change_reason": "The catalogue card asks whether a larger/nonabelian model escapes the three-register obstruction. The direct predecessor PR #1333 already proves exact rank-sum cost when all rank-one affine displacements are paid. This cycle tests a strict four-label subset, a fixed mixed target tuple, and a different homogeneous-rank trajectory domain; it does not repeat the full-alphabet theorem.", + "bottleneck_link": "PR #1333 proves a six-call optimum with the full rank-one affine alphabet; this fixed four-label subset has minimum in 8..10. That is a local alphabet-restriction result only. No physical, recursive, helper, frame, copying, hosting, precision, interface, or restoration saving is admitted, and the selected conditional kappa remains complex-bound.", + "budget_minutes": 60, + "stop_rule": "Complete exact q=6 strict-drop coverage and q=7 six-drop/one-neutral coverage in the declared homogeneous affine representation. Stop after depth 6 has empty frontier for q=7. Do not search q=8..10 or infer a universal lower bound.", + "outcome": "negative-result", + "evidence": "CERTIFICATE.json SHA-256 83927854ee05f412319cb234de37c246f924c96e315c413b4819c74ae38ac111. Exact q=6 strict-drop search over all 480 factors has frontier sizes 112, 960, 656, 32, 0; the rank-one frontier is empty after five drops. Exact q=7 six-drop/one-neutral search has sizes 352, 15368, 58352, 16772, 164, 0 at depths 1..6. The direct 10-call word passes; deleted-call and wrong-label controls fail. q7 script SHA-256 dda3653279bf66b304c6ee0b9622ddae654eb875db2163e8802b96e4ac2b1362; output SHA-256 8263e8941982eaa2840917f743f32db809644a3a2fcc481cea9f3c4f96dcb3d1. Minimum in the restricted alphabet is between 8 and 10; no kappa change.", + "author": "OpenAI Codex", + "ai_assistance": "Substantial AI assistance by OpenAI Codex in task selection, mathematical framing, finite affine-representation enumeration, verifier implementation, source analysis, and writing. No independent human review is claimed.", + "open_questions": [ + { + "question": "Can an exact eight- or nine-call word realize the same four affine targets in the declared model?", + "why_it_matters": "A positive word could reduce the local bit mechanism cost, subject to full recursive and physical interface accounting.", + "first_step": "Search q=8 with a representation-aware meet-in-the-middle method, then replay any candidate in the full formal group algebra.", + "blocked_by": "The current exact trajectory screen stops at q=7; q=8 has a larger search space and no formal candidate." + }, + { + "question": "Can a different mixed affine target tuple in four registers yield a genuine paid-call saving?", + "why_it_matters": "The current negative result is tied to this target tuple and cannot establish a general property of larger or nonabelian models.", + "first_step": "Use the rank-six displacement profile to choose one distinct tuple with at most a 10-call direct word and price its complete local interface.", + "blocked_by": "No alternative tuple has been priced or searched in this cycle." + } + ], + "assigned_track": "bit-mechanisms", + "assignment_seed": "5638c49abc39ff4644ef875d73a20996", + "discarded_seeds": [ + "b7968416bea4144aa0ebc623c8c484f0", + "4cdd0654c4363d88f47619ea1f700153" + ], + "scope_key": "7f5f4426ef796683c485/AGL2-F2/r4/mixed-targets-h-hi-tx-ty/rank-saturation-6-7", + "selected_record_sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32", + "selected_kappa": "836330098538459/500000000000000000", + "selected_review": "docs/research/community-batch1099-review.md", + "selected_source_manifest": "research/community-frontier1094-audit/SELECTED-SOURCE.json", + "selected_assembly_certificate": "research/community-frontier1094-audit/ASSEMBLY.json", + "discussion_claim": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1727", + "claim_expires_at_utc": "2026-10-14T08:55:00Z", + "live_overlap_review": { + "searched_at_utc": "2026-10-14T08:28:13Z", + "open_prs": { + "count": 419, + "complete_pagination": true, + "fetched_at_utc": "2026-10-14T08:26:16Z" + }, + "discussions": { + "count": 375, + "complete_pagination": true, + "fetched_at_utc": "2026-10-14T08:28:13Z" + }, + "warnings": [], + "nearest_items": [ + { + "id": "PR #1333", + "scope": "closed direct predecessor; exact minimum six under the full rank-one affine alphabet; pinned head in predecessor_prs" + }, + { + "id": "PR #1711", + "scope": "open; exact two-target affine minimum; different target tuple/register count" + }, + { + "id": "PR #1716", + "scope": "open; restricted three-register AGL2 target triple; different target tuple/register count" + }, + { + "id": "Discussion #1317", + "scope": "completed full binary-affine rank-sum theorem; result submitted in PR #1333" + }, + { + "id": "Discussion #1738", + "scope": "active; three-register UT3 central pair with x,y labels, distinct group, targets, and method" + }, + { + "id": "Discussion #1727", + "scope": "active claim for this task; separate four-register mixed affine tuple with standalone translations" + }, + { + "id": "Discussion #1700", + "scope": "active claim for cycle 1; rational four-register address relations, different alphabet and hypotheses" + } + ], + "distinction": "The direct predecessor allows every rank-one affine displacement as a paid label; this result restricts the alphabet to {a,b,tx,ty}. The other active construction claim uses UT3 on three registers. This package fixes diag(h,h^-1,tx,ty) in four registers and exhausts the necessary rank trajectories through q=7." + }, + "predecessor_prs": [ + { + "id": "PR #1333", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1333", + "status": "closed", + "head": "7f25b6d0e1d7e995d4d2840f231d98b1a1a9fec2", + "scope": "exact rank-sum minimum with all rank-one affine displacement labels; direct predecessor and source of the restricted-alphabet question", + "base": "bce54fb3f895cbe5cd4c0eb477c3afeed100190f", + "mathematical_commit": "9211d72a1b416534909208e4af7a1043244d2a9e" + }, + { + "id": "PR #1711", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1711", + "status": "open", + "head": "c2527419aa030fb71985d99f99e915d192e388bd", + "scope": "two affine targets", + "base": "0b1cccf86e2f5132ed286a26ef0a681a495740ea" + }, + { + "id": "PR #1716", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1716", + "status": "open", + "head": "fdbcd61eea435f9f8d497290a1db6513bb769d51", + "scope": "restricted three-register AGL2 triple", + "base": "0b1cccf86e2f5132ed286a26ef0a681a495740ea" + }, + { + "id": "Discussion #1738", + "url": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1738", + "status": "active claim", + "scope": "three-register UT3 central pair with x,y labels; distinct group, target, register count, and full group-algebra search method" + } + ], + "predecessor_discussions": [ + { + "id": "Discussion #1317", + "url": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1317", + "status": "completed; result submitted in PR #1333", + "scope": "full rank-one affine label theorem; direct predecessor context" + }, + { + "id": "Discussion #1738", + "url": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1738", + "status": "active claim", + "scope": "three-register UT3 central-pair with x,y alphabet; distinct from this four-register AGL2 target" + } + ] +} diff --git a/research/affine-mixed-four-targets-seed5638/TASK.md b/research/affine-mixed-four-targets-seed5638/TASK.md new file mode 100644 index 0000000000..e92a1fdb86 --- /dev/null +++ b/research/affine-mixed-four-targets-seed5638/TASK.md @@ -0,0 +1,61 @@ +# Cycle 2 task card: mixed affine targets in four registers + +- Track: `bit-mechanisms` +- Task: `bit-new-register-model` (selected from the eligible suggestions for the accepted seed) +- Accepted seed: `5638c49abc39ff4644ef875d73a20996` +- Discarded excluded-track draws: `b7968416bea4144aa0ebc623c8c484f0` (`adversarial-audit`), `4cdd0654c4363d88f47619ea1f700153` (`adversarial-audit`) +- Catalogue priority revision: 3 +- Base commit: `0b1cccf86e2f5132ed286a26ef0a681a495740ea` +- Selected-record SHA-256: `10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32` +- Scope key: `7f5f4426ef796683c485/AGL2-F2/r4/mixed-targets-h-hi-tx-ty/rank-saturation-6-7` + +## Question and changed premise + +In the noncommutative group algebra `F2[AGL2(F2)]`, can the four-register target +`diag([h], [h^-1], [t_x], [t_y])` be realized in fewer than its direct 10 paid +calls, where `h(x0,x1)=(x1,x0+1)`, `h^-1(x0,x1)=(x1+1,x0)`, and the paid +labels are exactly `{a,b,t_x,t_y}`, with +`a(x0,x1)=(x0+x1,x1)`, `b(x0,x1)=(x0,x0+x1)`, +`t_x(x0,x1)=(x0+1,x1)`, and `t_y(x0,x1)=(x0,x1+1)`? A call is +`D_N(g)=I+([g]+[1])N` for any rank-one idempotent `N` in `M4(F2)`; free +`GL4(F2)` mixing is included by moving each scalar map through the paid gates, +conjugating its idempotent, and using augmentation to force the net scalar map +to identity. +The target/input registers are arbitrary, with no clean-helper assumption. +This changes the operation alphabet from Cycle 1's rational address-frame +model to a finite nonabelian affine group and changes the target family. + +## Price screen and bounded experiment + +The homogeneous affine 3-by-3 representation gives target displacement rank +`2+2+1+1=6`; each paid generator call changes it by rank one. Thus the +optimistic floor is 6 versus the exact 10-call direct word, leaving at most +four calls of local headroom before physical/supplier charges (which are outside +this finite model). + +Test whether the rank floor is attainable or can be approached at 7 calls. +Enumerate every rank-one idempotent in `M4(F2)` and every one of the four +labels. Search every rank trajectory that can take the exact target from rank +6 to identity in six or seven calls: six strict rank drops for length 6; six +drops and one neutral step for length 7. The evaluated homogeneous-affine +representation is a necessary condition for exact group-algebra equality. +If it finds a word, replay that word in the full formal group algebra. Stop +after this q=6/7 screen and one exact construction attempt; do not claim that +q=8..10 are excluded. + +Positive evidence: a full formal group-algebra endpoint and exact replay. +Negative evidence: complete trajectory coverage for q=6 and q=7 in the declared +representation, a direct 10-call positive control, and dropped-factor/wrong- +target controls. Keep all claims scoped to this tuple and paid alphabet. + +## Nearest work and claim status + +The live overlap refresh at 08:02 UTC covered all 411 open PRs and 359 +Discussions with complete pagination and no warnings. It found PR #1711 +(two-register `h,h` and `h,h^-1` under the four-label alphabet), PR #1716 +(three-register `(a,b,h)` under `{a,b,t_x}`), PR #1705 (four linear +coordinate-SWAP targets in `F2[GL2(F2)]`), and Discussion #1715 (label +saturation for four linear SWAP targets). These differ in target tuple, +operation alphabet, or register count from this mixed affine tuple. +Discussion claim #1727 was posted at 08:04 UTC and expires at 08:55 UTC: +https://github.com/CrocSwap/integer-mult-bounds/discussions/1727. diff --git a/research/affine-mixed-four-targets-seed5638/VERIFY.json b/research/affine-mixed-four-targets-seed5638/VERIFY.json new file mode 100644 index 0000000000..c51fd3defa --- /dev/null +++ b/research/affine-mixed-four-targets-seed5638/VERIFY.json @@ -0,0 +1,53 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "certificates/selected-result.json", + "docs/research/community-batch1099-review.md", + "research/affine-mixed-four-targets-seed5638/CERTIFICATE.json", + "research/affine-mixed-four-targets-seed5638/Q7-OUTPUT.txt", + "research/affine-mixed-four-targets-seed5638/q7_trajectory_search.py", + "research/affine-mixed-four-targets-seed5638/verify.py", + "research/binary-affine-register-bound/PROOF.md", + "research/binary-affine-register-bound/README.md", + "research/binary-affine-register-bound/SOURCES.json", + "research/binary-affine-register-bound/TASK.json", + "research/bit-three-register-lower-bound/README.md", + "research/community-frontier1094-audit/ASSEMBLY.json", + "research/community-frontier1094-audit/SELECTED-SOURCE.json", + "scripts/research_baseline.py" + ], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Recomputes every q=6 rank-lowering frontier over 480 factors, checks the exact 10-call positive word, rejects deleted-call and wrong-label controls, and verifies the q=7 script and output hashes plus the complete empty-frontier summary." + }, + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/q7_trajectory_search.py" + ], + "timeout_seconds": 600, + "checks": "Replays the complete q=7 search over all six-drop/one-neutral rank trajectories; expected depth 6 has zero states and no goal." + }, + { + "argv": [ + "{python}", + "-B", + "scripts/research_baseline.py" + ], + "timeout_seconds": 60, + "checks": "Confirms the selected-result bindings and reports that the complex saving still binds; this local finite result makes no kappa claim." + } + ] +} diff --git a/research/affine-mixed-four-targets-seed5638/q7_trajectory_search.py b/research/affine-mixed-four-targets-seed5638/q7_trajectory_search.py new file mode 100644 index 0000000000..31030b69df --- /dev/null +++ b/research/affine-mixed-four-targets-seed5638/q7_trajectory_search.py @@ -0,0 +1,106 @@ +from itertools import product +R=4; D=3; n=R*D +I2=((1,0),(0,1)); Z=(0,0) +def mul(f,g): + A,b=f; C,d=g + return (tuple(tuple(sum(A[i][k]*C[k][j] for k in range(2))%2 for j in range(2)) for i in range(2)),tuple((sum(A[i][k]*d[k] for k in range(2))+b[i])%2 for i in range(2))) +def act(f,p): + A,b=f + q=tuple(sum(A[i][j]*p[j] for j in range(2))%2 for i in range(2)) + return tuple((q[i]+b[i])%2 for i in range(2)) +a=(((1,1),(0,1)),Z); b=(((1,0),(1,1)),Z); tx=(I2,(1,0)); ty=(I2,(0,1)) +def prod(*fs): + z=(I2,Z) + for f in fs:z=mul(z,f) + return z +def hom(f): + A,b=f; return tuple((sum(A[i][j]<>k)&1)&((B[k]>>j)&1))<>col)&1),None) + if p is None:continue + rows[r],rows[p]=rows[p],rows[r] + for i in range(n): + if i!=r and ((rows[i]>>col)&1):rows[i]^=rows[r] + r+=1 + return r +# affine homogeneous blocks +letters=[a,b,tx,ty] +G=[gmat(x) for x in letters] +# rank one factorization D=G+I as u v^T +def outer_uv(M): + for u in product((0,1),repeat=D): + if not any(u):continue + for v in product((0,1),repeat=D): + if not any(v):continue + if tuple(sum(u[i]*v[j]<>r)&1)*u[d]<<(r*D+d) for r in range(R) for d in range(D)) + wy=sum(((y>>r)&1)*v[d]<<(r*D+d) for r in range(R) for d in range(D)) + factors.append((gi,x,y,vx,wy)) +# target block diagonal +els=[prod(a,b,a,tx),prod(tx,a,b,a),tx,ty] +blocks=[gmat(x) for x in els] +T=[] +for r in range(R): + for d in range(D): + row=0 + for s in range(R): + for e in range(D): + if s==r and ((blocks[r][d]>>e)&1):row|=1<<(s*D+e) + T.append(row) +I=tuple(1<>i)&1 else 0) for i,row in enumerate(M)) +# Complete radius-seven rank trajectory: six rank drops and one neutral step. +T=tuple(T) +layers={(T,0)} +for depth in range(1,8): + nxt=set(); counts={} + for M,neutral_used in layers: + rm=mat_rank(xor(M,I)) + for fac in factors: + P=step(M,fac) + rp=mat_rank(xor(P,I)) + if rp==rm-1: + state=(P,neutral_used) + elif neutral_used==0 and rp==rm: + state=(P,1) + else: + continue + nxt.add(state) + counts[(neutral_used,state[1])]=counts.get((neutral_used,state[1]),0)+1 + layers=nxt + print('depth',depth,'states',len(layers),'neutral0',sum(u==0 for _,u in layers),'neutral1',sum(u==1 for _,u in layers),'goal',any(M==I and u==1 for M,u in layers)) + if not layers:break diff --git a/research/affine-mixed-four-targets-seed5638/verify.py b/research/affine-mixed-four-targets-seed5638/verify.py new file mode 100644 index 0000000000..a71dc57cec --- /dev/null +++ b/research/affine-mixed-four-targets-seed5638/verify.py @@ -0,0 +1,273 @@ +#!/usr/bin/env python3 +"""Exact q=6 trajectory obstruction for four mixed affine targets over F2.""" +from __future__ import annotations + +import argparse +import hashlib +import json +import re +from pathlib import Path + + +R = 4 +D = 3 +N = R * D +I2 = ((1, 0), (0, 1)) +ZERO = (0, 0) + + +def mul(f, g): + a, b = f + c, d = g + return ( + tuple(tuple(sum(a[i][k] * c[k][j] for k in range(2)) % 2 for j in range(2)) for i in range(2)), + tuple((sum(a[i][k] * d[k] for k in range(2)) + b[i]) % 2 for i in range(2)), + ) + + +def prod(*fs): + z = (I2, ZERO) + for f in fs: + z = mul(z, f) + return z + + +def xor(a, b): + return tuple(x ^ y for x, y in zip(a, b)) + + +def mat_rank(rows): + rows = list(rows) + r = 0 + for col in range(N): + p = next((i for i in range(r, N) if (rows[i] >> col) & 1), None) + if p is None: + continue + rows[r], rows[p] = rows[p], rows[r] + for i in range(N): + if i != r and ((rows[i] >> col) & 1): + rows[i] ^= rows[r] + r += 1 + return r + + +def gmat(f): + a, b = f + return tuple(sum(a[i][j] << j for j in range(2)) | (b[i] << 2) for i in range(2)) + (4,) + + +def outer_uv(matrix): + for u in range(1, 1 << D): + for v in range(1, 1 << D): + candidate = tuple( + sum((((u >> i) & 1) * ((v >> j) & 1)) << j for j in range(D)) + for i in range(D) + ) + if candidate == matrix: + return u, v + raise AssertionError("generator displacement did not factor as rank one") + + +def pack_register_vector(register_mask, vector): + return sum( + 1 << (r * D + d) + for r in range(R) + if (register_mask >> r) & 1 + for d in range(D) + if (vector >> d) & 1 + ) + + +def mv(rows, vector): + return sum(((row & vector).bit_count() & 1) << i for i, row in enumerate(rows)) + + +def right_step(matrix, factor): + _label, _x, _y, v, w = factor + mvect = mv(matrix, v) + return tuple(row ^ (w if (mvect >> i) & 1 else 0) for i, row in enumerate(matrix)) + + +def make_data(): + a = (((1, 1), (0, 1)), ZERO) + b = (((1, 0), (1, 1)), ZERO) + tx = (I2, (1, 0)) + ty = (I2, (0, 1)) + labels = [a, b, tx, ty] + assert all(prod(g, g) == (I2, ZERO) for g in labels) + i3 = (1, 2, 4) + uv = [outer_uv(xor(gmat(g), i3)) for g in labels] + + projectors = [(x, y) for x in range(1, 16) for y in range(1, 16) if (x & y).bit_count() & 1] + assert len(projectors) == 120 + factors = [] + for label, (u, v) in enumerate(uv): + for x, y in projectors: + factors.append((label, x, y, pack_register_vector(x, u), pack_register_vector(y, v))) + assert len(factors) == 480 + + h = prod(a, b, a, tx) + h_inv = prod(tx, a, b, a) + blocks = [gmat(g) for g in (h, h_inv, tx, ty)] + target_rows = [] + for r in range(R): + for d in range(D): + row = 0 + for e in range(D): + if (blocks[r][d] >> e) & 1: + row |= 1 << (r * D + e) + target_rows.append(row) + target = tuple(target_rows) + identity = tuple(1 << i for i in range(N)) + return projectors, factors, target, identity + + +def state_digest(states): + payload = b"".join( + b"".join(row.to_bytes(2, "little") for row in state) + for state in sorted(states) + ) + return hashlib.sha256(payload).hexdigest() + + +def q6_frontiers(factors, target, identity): + layers = {target} + result = [] + for depth in range(1, 7): + edges = 0 + nxt = set() + for state in layers: + rank = mat_rank(xor(state, identity)) + assert rank == 7 - depth + for factor in factors: + candidate = right_step(state, factor) + if mat_rank(xor(candidate, identity)) == rank - 1: + edges += 1 + nxt.add(candidate) + result.append({ + "depth": depth, + "incoming_states": len(layers), + "strict_drop_edges": edges, + "unique_states": len(nxt), + "states_sha256": state_digest(nxt), + }) + layers = nxt + if not layers: + break + assert not layers, "unexpected q=6 endpoint frontier" + assert result[-1]["unique_states"] == 0 + return result + + +def direct_controls(factors, target, identity): + factor_map = {(f[0], f[1], f[2]): f for f in factors} + word = [] + for register, labels in enumerate(([0, 1, 0, 2], [2, 0, 1, 0], [2], [3])): + e = 1 << register + word.extend(factor_map[(label, e, e)] for label in labels) + assert len(word) == 10 + direct = identity + for factor in word: + direct = right_step(direct, factor) + assert direct == target + + deleted = identity + for i, factor in enumerate(word): + if i != 5: + deleted = right_step(deleted, factor) + assert deleted != target + + wrong = identity + wrong_word = list(word) + wrong_word[-1] = factor_map[(2, 1 << 3, 1 << 3)] + for factor in wrong_word: + wrong = right_step(wrong, factor) + assert wrong != target + + for factor in factors: + assert right_step(right_step(identity, factor), factor) == identity + return { + "direct_word_calls": len(word), + "direct_word_endpoint": "target", + "drop_call_control": "rejected", + "wrong_label_control": "rejected", + "all_480_factors_involutive": True, + } + + +def q7_evidence(): + root = Path(__file__).parent + program = root / "q7_trajectory_search.py" + output = root / "Q7-OUTPUT.txt" + lines = output.read_text().splitlines() + rows = [] + for line in lines: + match = re.fullmatch( + r"depth (\d+) states (\d+) neutral0 (\d+) neutral1 (\d+) goal (True|False)", + line, + ) + if match: + depth, states, neutral0, neutral1 = map(int, match.groups()[:4]) + rows.append({ + "depth": depth, + "states": states, + "neutral0": neutral0, + "neutral1": neutral1, + "goal": match.group(5) == "True", + }) + assert [row["depth"] for row in rows] == list(range(1, 7)) + assert not any(row["goal"] for row in rows) + assert rows[-1] == { + "depth": 6, + "states": 0, + "neutral0": 0, + "neutral1": 0, + "goal": False, + } + return { + "program": program.name, + "program_sha256": hashlib.sha256(program.read_bytes()).hexdigest(), + "output": output.name, + "output_sha256": hashlib.sha256(output.read_bytes()).hexdigest(), + "frontiers": rows, + "endpoint_found": False, + } + + +def compute_certificate(): + projectors, factors, target, identity = make_data() + target_rank = mat_rank(xor(target, identity)) + assert target_rank == 6 + return { + "schema_version": 1, + "field": "F2", + "target": "diag(h,h^-1,tx,ty) in the homogeneous affine 3x3 representation", + "registers": 4, + "target_displacement_rank": target_rank, + "paid_labels": ["a", "b", "tx", "ty"], + "rank_one_idempotents": len(projectors), + "factors": len(factors), + "q6_frontiers": q6_frontiers(factors, target, identity), + "q6_endpoint_found": False, + "controls": direct_controls(factors, target, identity), + "q7_trajectory": q7_evidence(), + } + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument("--write-certificate", action="store_true") + args = parser.parse_args() + cert_path = Path(__file__).with_name("CERTIFICATE.json") + actual = compute_certificate() + if args.write_certificate: + cert_path.write_text(json.dumps(actual, indent=2) + "\n") + expected = json.loads(cert_path.read_text()) + assert actual == expected, "certificate differs from exact recomputation" + digest = hashlib.sha256(cert_path.read_bytes()).hexdigest() + print("PASS_AFFINE_MIXED_Q6_OBSTRUCTION") + print(json.dumps({"certificate_sha256": digest, "frontiers": actual["q6_frontiers"], "controls": actual["controls"]}, sort_keys=True)) + + +if __name__ == "__main__": + main() From 60f4c042da10aaf702a2f879b0f3cb11940741fc Mon Sep 17 00:00:00 2001 From: Cinna Davis <1337isnot1337@users.noreply.github.com> Date: Wed, 14 Oct 2026 03:29:23 -0500 Subject: [PATCH 2/2] Record affine obstruction PR handoff --- .../README.md | 1 + .../TASK.json | 5 ++- .../TASK.md | 31 ++++++++++++++----- 3 files changed, 28 insertions(+), 9 deletions(-) diff --git a/research/affine-mixed-four-targets-seed5638/README.md b/research/affine-mixed-four-targets-seed5638/README.md index 72ff15734f..67ccbd01b2 100644 --- a/research/affine-mixed-four-targets-seed5638/README.md +++ b/research/affine-mixed-four-targets-seed5638/README.md @@ -96,6 +96,7 @@ certificate SHA-256. * Selected-result SHA-256: 10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32 * Source hashes: SOURCES.json * Active claim: https://github.com/CrocSwap/integer-mult-bounds/discussions/1727 +* Review PR: https://github.com/CrocSwap/integer-mult-bounds/pull/1745 (open) The final pre-submission overlap scan completed at 2026-10-14 08:28:13 UTC: it covered 419 open PRs and 375 Discussions with complete pagination and no warnings. Direct predecessor [PR #1333](https://github.com/CrocSwap/integer-mult-bounds/pull/1333) diff --git a/research/affine-mixed-four-targets-seed5638/TASK.json b/research/affine-mixed-four-targets-seed5638/TASK.json index 031215e139..eb018f668e 100644 --- a/research/affine-mixed-four-targets-seed5638/TASK.json +++ b/research/affine-mixed-four-targets-seed5638/TASK.json @@ -168,5 +168,8 @@ "status": "active claim", "scope": "three-register UT3 central-pair with x,y alphabet; distinct from this four-register AGL2 target" } - ] + ], + "pull_request": "https://github.com/CrocSwap/integer-mult-bounds/pull/1745", + "submission_status": "open", + "submission_head": "393bdcfc51cd1d9551722f1c5b20efc020f6b73a" } diff --git a/research/affine-mixed-four-targets-seed5638/TASK.md b/research/affine-mixed-four-targets-seed5638/TASK.md index e92a1fdb86..e92219a478 100644 --- a/research/affine-mixed-four-targets-seed5638/TASK.md +++ b/research/affine-mixed-four-targets-seed5638/TASK.md @@ -50,12 +50,27 @@ target controls. Keep all claims scoped to this tuple and paid alphabet. ## Nearest work and claim status -The live overlap refresh at 08:02 UTC covered all 411 open PRs and 359 -Discussions with complete pagination and no warnings. It found PR #1711 -(two-register `h,h` and `h,h^-1` under the four-label alphabet), PR #1716 -(three-register `(a,b,h)` under `{a,b,t_x}`), PR #1705 (four linear -coordinate-SWAP targets in `F2[GL2(F2)]`), and Discussion #1715 (label -saturation for four linear SWAP targets). These differ in target tuple, -operation alphabet, or register count from this mixed affine tuple. -Discussion claim #1727 was posted at 08:04 UTC and expires at 08:55 UTC: +The final pre-submission refresh at 08:28 UTC covered all 419 open PRs and +375 Discussions with complete pagination and no warnings. Direct predecessor +PR #1333 (closed, head `7f25b6d0e1d7e995d4d2840f231d98b1a1a9fec2`) proves the +six-call cost when every rank-one affine displacement is paid; this cycle +restricts to `{a,b,t_x,t_y}`. Open PR #1711 uses two affine targets; PR #1716 +uses a restricted three-register AGL2 triple. Active Discussion #1738 concerns +a three-register UT3 central pair with `{x,y}`, a different group, target, and +search method. Cycle 1's PR #1733 is a rational address-frame obstruction and +does not overlap this binary-affine label restriction. Discussion #1317 is +the completed coordination thread for PR #1333. This cycle's claim #1727 was +posted at 08:04 UTC and expires at 08:55 UTC: https://github.com/CrocSwap/integer-mult-bounds/discussions/1727. + +## Outcome and handoff + +The full rank-one affine alphabet has optimum six calls for this target by PR +#1333. In the fixed four-label subalphabet `{a,b,t_x,t_y}`, the q=6 strict-drop +search and q=7 six-drop/one-neutral search both have empty terminal frontiers. +Together with the displacement-rank floor and direct ten-call word, the +restricted-alphabet minimum lies in `[8,10]`; q=8 and q=9 remain open. The +exact package is `research/affine-mixed-four-targets-seed5638/`, submitted as +open PR #1745: +https://github.com/CrocSwap/integer-mult-bounds/pull/1745. No kappa change or +physical supplier admission is claimed.