From e88cf26272a5b0363ba1a8f178da2c69834de75b Mon Sep 17 00:00:00 2001 From: Cinna Davis <1337isnot1337@users.noreply.github.com> Date: Wed, 14 Oct 2026 09:55:32 -0500 Subject: [PATCH 1/3] Research: D10 inverse rotations retain four-call minimum --- .../CERTIFICATE.json | 40 ++++ .../README.md | 73 +++++++ .../SOURCES.json | 86 ++++++++ .../TASK.json | 114 ++++++++++ .../d10-reflection-sharing-seeda3def8/TASK.md | 13 ++ .../VERIFY.json | 46 ++++ .../independent.py | 131 +++++++++++ .../test_package.py | 53 +++++ .../verify.py | 206 ++++++++++++++++++ 9 files changed, 762 insertions(+) create mode 100644 research/d10-reflection-sharing-seeda3def8/CERTIFICATE.json create mode 100644 research/d10-reflection-sharing-seeda3def8/README.md create mode 100644 research/d10-reflection-sharing-seeda3def8/SOURCES.json create mode 100644 research/d10-reflection-sharing-seeda3def8/TASK.json create mode 100644 research/d10-reflection-sharing-seeda3def8/TASK.md create mode 100644 research/d10-reflection-sharing-seeda3def8/VERIFY.json create mode 100644 research/d10-reflection-sharing-seeda3def8/independent.py create mode 100644 research/d10-reflection-sharing-seeda3def8/test_package.py create mode 100644 research/d10-reflection-sharing-seeda3def8/verify.py diff --git a/research/d10-reflection-sharing-seeda3def8/CERTIFICATE.json b/research/d10-reflection-sharing-seeda3def8/CERTIFICATE.json new file mode 100644 index 0000000000..368af3bcab --- /dev/null +++ b/research/d10-reflection-sharing-seeda3def8/CERTIFICATE.json @@ -0,0 +1,40 @@ +{ + "schema_version": 1, + "model": { + "group": "D10 of order 10", + "presentation": "", + "encoding_primary": "r^k s^epsilon as index 2*k+epsilon, r=st", + "encoding_independent": "permutations of the five polygon vertices", + "coefficient_field": "F2", + "registers": 3, + "paid_labels": ["s", "t"], + "scalar_factors": "D_N(g)=I+([g]+[e])N; N=xy^T, y^T x=1" + }, + "target": "diag([st],[ts],[e])", + "rank_one_idempotents": 28, + "search": { + "lengths": [0, 1, 2, 3], + "candidate_counts": {"0": 1, "1": 56, "2": 3136, "3": 175616}, + "exact_endpoint_hits": {"0": 0, "1": 0, "2": 0, "3": 0}, + "total_candidates": 178809, + "primary_state_sha256": { + "0": "992d20f65528722d3c9f89c6ecd3876deae0d0084d271d8dffa254f1e21dfeae", + "1": "75d31c5b61a5e4704d487416541aae736b9a7d35a809c094a12b80a465a57194", + "2": "3a734c7f69b67583fd847a2df0919430092d755c757eb9fa2d2aa8dffb71669c", + "3": "32cdd595df3a5b2f39853beceb0f4e395f9e1277b1059204f3aeddd2cbee6258" + }, + "independent_state_sha256": { + "0": "626523c7a23825bc1c716fb9540513bfa1ae0543b5a35e31993a89236e5e4d5e", + "1": "53740396a3f0f73e8392fbb7dae15ec29853e43d507ca3b48051b05fa97e7cb3", + "2": "385b9687ea222aa258066118a956483af8faade44fbf6a88bbfd3403018a5854", + "3": "078453f4249334b2553bb29e8bc7c8041a6f6910dfa112d9b9f4e571e7699c29" + } + }, + "attaining_word": { + "labels": ["s", "t", "t", "s"], + "projectors": ["E00", "E00", "E11", "E11"], + "paid_calls": 4, + "exact_endpoint": true + }, + "conclusion": "Exact minimum 4 for this target, register count, and paid alphabet only." +} diff --git a/research/d10-reflection-sharing-seeda3def8/README.md b/research/d10-reflection-sharing-seeda3def8/README.md new file mode 100644 index 0000000000..b571db1985 --- /dev/null +++ b/research/d10-reflection-sharing-seeda3def8/README.md @@ -0,0 +1,73 @@ +# Finite D10 torsion does not give a three-call inverse-rotation share + +**Scoped exact negative result; no new `kappa`.** In the formal group algebra of the dihedral group of order 10, the target + +`diag([st],[ts],[e])` + +on three arbitrary binary scalar registers has minimum paid-call cost **four** when the only paid address labels are the two reflections `s,t`. The natural three-call overlap word `s,t,s` does not work, and exhaustive exact search rules out every word of at most three calls, with every rank-one idempotent scalar projector allowed. Four calls attain the endpoint directly. + +This is a first finite odd-rotation quotient check beside the all-register `D_infinity` reflection tariff in PR #1911. It does not extend that theorem to other finite dihedral groups or register counts. It provides no native supplier mapping, compiler, hosting/precision invoice, conditional bound or selected-frontier change. + +## Exact model and result + +Let + +`G = ` + +be the dihedral group of order 10. Set `r=st`; then `ts=r^-1`. Work in the full formal group algebra `F2[G]`, whose basis is the ten group elements. Matrix products use the group multiplication in their coefficient convolution. No natural or permutation representation is used as a substitute for formal equality. + +A paid factor is + +`D_N(g) = I + ([g]+[e]) N`, + +where `g` is either `s` or `t`, and `N=xy^T` is a rank-one idempotent in `M3(F2)`, with `y^T x=1`. Each factor costs one paid reflection call. There are exactly 28 such projectors. The endpoint identity is coefficientwise equality in `M3(F2[G])`; its third diagonal entry is `[e]`, so the dirty helper is restored exactly. + +**Theorem for this finite domain.** The minimum is four. The direct word + +`D_E00(s) D_E00(t) D_E11(t) D_E11(s)` + +is `diag([st],[ts],[e])`. For the lower bound, the verifier checks every ordered paid-label word over `{s,t}` of lengths 0 through 3 and every choice of the 28 projectors at each position. There are respectively 1, 56, 3,136 and 175,616 candidates, with zero exact endpoints. Thus no three-call mechanism exists in this declared model; the calculation says nothing about longer alphabets, different groups or more registers. + +The proposed `s,t,s` word has a tempting path interpretation: its first two labels spell `st` and its last two spell `ts`. The complete search shows that no choice of rank-one idempotents can simultaneously route those overlapping subsequences while cancelling all other group-algebra coefficients. + +## Cost accounting and frontier scope + +The baseline direct bill is 2 calls for `st` plus 2 for `ts`, total 4; the identity helper needs no call. Every paid factor, including any call used for cleanup, is included in the formal endpoint. The searched alternative allows arbitrary rank-one idempotents on all three roles, so it grants the full scalar projector alphabet at no additional scalar-operation charge. No other operation is allowed for free. + +This one-unit candidate saving would be a 25% reduction of this tiny reflection bill if it existed. It does not. Even a positive local word would require a separate justified mapping to the selected bit supplier, full interface and hosting costs, precision, and recursive moment before it could affect `kappa`. The selected conditional construction remains `kappa = 836330098538459/500000000000000000`. + +## Evidence and reproduction + +Two separate standard-library engines evaluate the full formal endpoint. `verify.py` stores 3x3 binary matrices as nine-bit integers and multiplies against the precomputed finite matrix table. `independent.py` builds `D10` from its action on the five polygon vertices and stores each coefficient matrix as three row masks; its multiplication by a rank-one projector uses the outer-product identity `(A x)y^T`. Their encodings and per-level state digests differ. Both cover the full 178,809 words through length 3 and agree on zero hits. The exact counters and digests are pinned in `CERTIFICATE.json`. + +Run: + +```sh +python3 -I -B research/d10-reflection-sharing-seeda3def8/verify.py +python3 -I -B research/d10-reflection-sharing-seeda3def8/independent.py +python3 -I -B research/d10-reflection-sharing-seeda3def8/test_package.py +python3 scripts/research_package.py --package research/d10-reflection-sharing-seeda3def8 --check-only +python3 -B scripts/research_baseline.py +make selected-record-check +``` + +Expected markers include `PASS_D10_INVERSE_ROTATION_MINIMUM` and `PASS_D10_INDEPENDENT_PERMUTATION_REPLAY`. `--check-only` validates package metadata and source pins; it does not itself prove the minimum. The two verifiers perform that finite calculation. Registered CI requests Python 3.12; this host's available interpreter at packaging time is CPython 3.14.7. + +## Task, selected record and overlap + +- Accepted cycle seed: `a3def8e7b944810f5d933bfa65cba990`; track `bit-mechanisms`; task `bit-new-register-model`; priority revision 3. +- Exact base commit: `0b1cccf86e2f5132ed286a26ef0a681a495740ea`. +- Selected record SHA-256: `10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32`. +- Selected `kappa`: `836330098538459/500000000000000000`; the baseline checker prints `PASS_RESEARCH_BASELINE_BINDINGS_ONLY`, not a cold selected-construction replay. +- The selected record points to review `docs/research/community-batch1099-review.md`, source manifest `research/community-frontier1094-audit/SELECTED-SOURCE.json`, certificate `research/community-frontier1094-audit/ASSEMBLY.json` (SHA-256 `1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045`), and reproduction target `make frontier1094-verify`; these are pinned in `SOURCES.json`. +- Coordination claim: [Discussion #1167 comment 18926353](https://github.com/CrocSwap/integer-mult-bounds/discussions/1167#discussioncomment-18926353); handoff goes there. +- Nearby work: PR #1911 at head `712593f82739203639d0a169b88c6bcac6f0590c` proves reflection tariffs for `D_infinity`, but explicitly does not descend to finite quotients. PR #1821 at head `a986127fa82b680a5bbb29f49fec4c8c3a944bde` is a D16 central involution; PR #1573 at head `0b8c5a69297c794f2de22c04494c83e41300ae36` is a D8 central-target theorem. PR #1870 at head `538d194e69420a6a773612e0b5ad0c94575f8aaa` exhausts S3 target pairs. Their groups or endpoints differ from this D10 noncentral inverse-rotation pair. +- Overlap limits: the complete refreshed snapshot at 2026-10-14 14:40 UTC covered 597 open PRs and 568 Discussion records; no D10/order-five target claim appeared. The latest mechanism-thread comments were separately re-read at 14:38:49 UTC. Code diffs and closed PRs beyond the local ledger were not globally searched. + +Prepared with substantial OpenAI Codex assistance in scope selection, exact enumeration, independent implementation and writing. No independent human review is claimed. + +## Open next questions + +- Does the same inverse-rotation pair still have the direct four-call minimum in `D_{2p}` for odd primes `p >= 7`, or does another finite torsion order admit a share? +- Can a torsion-aware invariant explain the D10 minimum uniformly for all finite dihedral quotients without reproducing a separate finite census for each order? +- Is there a justified compiler/supplier operation that pays only the two chosen reflections and preserves this exact group-algebra endpoint? Without that link, no exponent change follows. diff --git a/research/d10-reflection-sharing-seeda3def8/SOURCES.json b/research/d10-reflection-sharing-seeda3def8/SOURCES.json new file mode 100644 index 0000000000..0f4f10b66d --- /dev/null +++ b/research/d10-reflection-sharing-seeda3def8/SOURCES.json @@ -0,0 +1,86 @@ +{ + "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": "autoresearch.md", + "usage": "provenance", + "git_blob": "8d5403e0f10f68a61d0cb9294fa2e83e872d1d82", + "sha256": "215b3222f6a943edc69422a28ac21ea1f397ddf54770f1d87ac4195385d73699" + }, + { + "path": "CONTRIBUTING.md", + "usage": "provenance", + "git_blob": "e51435543687f1bd88ab22248082dc689ce8b853", + "sha256": "df5b5646602f42cb5da5844f04ac925182ddcd0f627b9de1c96a5095bb7a277a" + }, + { + "path": "Makefile", + "usage": "provenance", + "git_blob": "448f13b58fbe3492e2ea6b2005c8822aefe2765c", + "sha256": "029076ba6558f4c97d59d508baeb47847e0fad3545ed1fd22943ab9d6c84c2b9" + }, + { + "path": "docs/research/community-batch1099-review.md", + "usage": "input", + "git_blob": "6cb6ec061a071a06a2d18cd4dc3e9a2b05d28099", + "sha256": "7e76d2c38e5fce30587835b7251df1430488ae4dd372611ef69a3f03f476b6cb" + }, + { + "path": "research/community-frontier1094-audit/SELECTED-SOURCE.json", + "usage": "input", + "git_blob": "6a75493790b4eff9c4a98051ef8b01d6aad0d5a8", + "sha256": "79b3de5db3dbcb9829789ba58e9e45758926031e2a7d80667a08429d369be53b" + }, + { + "path": "research/community-frontier1094-audit/ASSEMBLY.json", + "usage": "input", + "git_blob": "5fd676df060f3b450782fdf5ff5f6beb63a5eeb0", + "sha256": "1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045" + }, + { + "path": "research/bit-three-register-lower-bound/README.md", + "usage": "input", + "git_blob": "25e41c370c101a33a6deb978de08b03ed7539b79", + "sha256": "c12b33ef388deece0cbf891505a2ce2c0779a0c3a6cf1f0f7f7039bab59cbebd" + } + ], + "external_predecessors": [ + { + "pr": 1911, + "head": "712593f82739203639d0a169b88c6bcac6f0590c", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1911", + "use": "Infinite-dihedral reflection tariff; explicitly not descended to finite quotients." + }, + { + "pr": 1821, + "head": "a986127fa82b680a5bbb29f49fec4c8c3a944bde", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1821", + "use": "D16 central involution endpoint; not D10 inverse rotations." + }, + { + "pr": 1573, + "head": "0b8c5a69297c794f2de22c04494c83e41300ae36", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1573", + "use": "D8 central target tariff; different group and endpoint." + }, + { + "pr": 1870, + "head": "538d194e69420a6a773612e0b5ad0c94575f8aaa", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1870", + "use": "Exact S3 target-pair census; group and target are different." + } + ] +} diff --git a/research/d10-reflection-sharing-seeda3def8/TASK.json b/research/d10-reflection-sharing-seeda3def8/TASK.json new file mode 100644 index 0000000000..2559a1cd3f --- /dev/null +++ b/research/d10-reflection-sharing-seeda3def8/TASK.json @@ -0,0 +1,114 @@ +{ + "schema_version": 1, + "task_id": "bit-new-register-model", + "priority_revision": 3, + "base_commit": "0b1cccf86e2f5132ed286a26ef0a681a495740ea", + "selected_record_sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32", + "catalogue_sha256": "6686ad58f1fbdbc87134a78901b60fd53a20d3984355e91defbbebc9e9fa8075", + "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 paid-call minimum for diag([st],[ts],[e]) in M3(F2[D10]), D10= of order ten, with paid labels {s,t} and all rank-one idempotents in M3(F2).", + "scope_change_reason": "The first candidate was a W=4 rational two-relation endpoint, close to open PR #1733 and Discussion #1700. The selected refinement changes the address group to a finite nonabelian quotient whose torsion is explicitly outside PR #1911, and asks a single exact three-call sharing question for a noncentral inverse-rotation pair.", + "bottleneck_link": "Tests whether finite torsion enables shared paid reflection calls across dirty register outputs. A positive local word would still need a separate supplier/compiler and full interface-cost mapping before any conditional-bound consequence.", + "budget_minutes": 60, + "stop_rule": "Exhaust all rank-one idempotent choices and all paid-label words of lengths zero through three in the exact ten-element group algebra; check the four-call direct endpoint and mutation controls. Stop this construction after the complete finite cover and do not infer results for other groups or widths.", + "outcome": "negative-result", + "evidence": "Two independently represented standard-library engines exhaust 178,809 words (1, 56, 3,136, 175,616 by length) with zero target hits through three calls. The direct four-call word is exact. Per-level state digests and the attaining word are recorded in CERTIFICATE.json.", + "author": "OpenAI Codex research agent", + "ai_assistance": "Substantial OpenAI Codex assistance in scope selection, exact enumeration, independent implementation and writing. No independent human review is claimed.", + "accepted_seed": "a3def8e7b944810f5d933bfa65cba990", + "assigned_track": "bit-mechanisms", + "assigned_scope_key": "7f5f4426ef796683c485", + "discussion_claim": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1167#discussioncomment-18926353", + "claim_expiry_utc": "2026-10-14T16:45:00Z", + "predecessors": [ + { + "pr": 1911, + "head": "712593f82739203639d0a169b88c6bcac6f0590c", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1911", + "use": "Infinite-dihedral reflection tariff; explicitly not descended to finite quotients." + }, + { + "pr": 1821, + "head": "a986127fa82b680a5bbb29f49fec4c8c3a944bde", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1821", + "use": "D16 central involution endpoint; not D10 inverse rotations." + }, + { + "pr": 1573, + "head": "0b8c5a69297c794f2de22c04494c83e41300ae36", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1573", + "use": "D8 central target tariff; different group and endpoint." + }, + { + "pr": 1870, + "head": "538d194e69420a6a773612e0b5ad0c94575f8aaa", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1870", + "use": "Exact S3 target-pair census; group and target are different." + } + ], + "open_questions": [ + { + "question": "Does the inverse-rotation pair keep its direct four-call tariff in D_{2p} for odd primes p>=7?", + "why_it_matters": "A different finite torsion order may enable a sharing mechanism absent in D10.", + "first_step": "Choose p=7, pin a finite dihedral group table, and test the same target with exact rank-one idempotents at three registers.", + "blocked_by": "No uniform torsion-aware invariant is established by this one finite census." + }, + { + "question": "Can a torsion-aware invariant explain the D10 minimum for all finite dihedral quotients?", + "why_it_matters": "It would replace separate finite censuses with a mechanism-level bound.", + "first_step": "Identify a coefficient-ring invariant that detects finite rotation order and bounds simultaneous endpoint routing.", + "blocked_by": "The D_infinity Laurent proof does not descend through finite rotation relations." + }, + { + "question": "Is there a justified native supplier/compiler for a paid two-reflection alphabet?", + "why_it_matters": "Without it the finite group-algebra cost is not a bit-supplier cost.", + "first_step": "State an admitted bit primitive realizing exactly s and t and invoice its full interface and restoration.", + "blocked_by": "No physical supplier mapping is included here." + } + ], + "selected_result": { + "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", + "reproduce": "make frontier1094-verify" + }, + "pull_request": null +} diff --git a/research/d10-reflection-sharing-seeda3def8/TASK.md b/research/d10-reflection-sharing-seeda3def8/TASK.md new file mode 100644 index 0000000000..fef4caab7b --- /dev/null +++ b/research/d10-reflection-sharing-seeda3def8/TASK.md @@ -0,0 +1,13 @@ +# Cycle 14 task card + +- Task ID / proposed scope key: `bit-new-register-model`; `bit-new-register-model/D10-r3-inverse-rotation-pair/sts-three-call-supersequence` +- Accepted OS seed: `a3def8e7b944810f5d933bfa65cba990`; track `bit-mechanisms`; priority revision 3; catalogue SHA-256 `6686ad58f1fbdbc87134a78901b60fd53a20d3984355e91defbbebc9e9fa8075`; base `0b1cccf86e2f5132ed286a26ef0a681a495740ea`; selected-record SHA-256 `10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32`. +- Scope status: refined, with one evidence-driven change from the first candidate. The first candidate was a W=4 rational two-relation target. PR #1733 and Discussion #1700 already cover a nearby two-relation W=4 family. This card instead tests finite torsion in a nonabelian group model, a stated open direction in PR #1911. +- Concrete object and question: in the formal group algebra `F2[D10]`, with `D10=`, can three paid factors realize `diag([st],[ts],[e])` on three arbitrary dirty scalar registers? The complete paid alphabet for this experiment is `{s,t}`; each factor is `D_N(g)=I+([g]+[e])N` for a rank-one idempotent `N` in `M3(F2)`. The proposed shared schedule is label word `s,t,s`: the first two labels spell `st`, the last two spell `ts`. +- Nearest predecessor/overlap: PR #1911 proves an all-register sharp bill in `D_infinity` and expressly notes its Laurent proof does not descend to finite dihedral quotients; its open next question asks for a torsion-aware finite-quotient invariant. PR #1821 covers a D16 central involution; PR #1573 covers D8 central targets. Neither is the D10 noncentral inverse-rotation pair. The current overlap snapshot (complete pagination at 2026-10-14 14:40 UTC) has no D10/order-five target claim. The broad #1884 thread includes the D-infinity task; claim the finite D10 slice there with the distinction explicit. +- Baseline/full cost: two calls for `st` and two for `ts`, total 4; target helpers are identity and restoration is part of formal equality. Candidate target is 3 calls, so one paid-call saving in this abstract model. No supplier, compiler, hosting, precision or recursive interface mapping is assumed; no kappa claim is available from this experiment alone. +- Method/domain: enumerate all 28 rank-one idempotents in `M3(F2)` for every position and every ordered label word of length at most 3 over `{s,t}`. Exact product in the 10-element formal group algebra, no finite representation substitution. Search candidate `s,t,s` first; then complete the full length-0..3 cover. +- Optimistic cost and gate: direct 4 vs candidate 3, with each factor priced as one paid reflection. If the exact three-factor endpoint fails in the full cover, stop this construction and report the exact finite obstruction only for this group, target, register count and alphabet. +- Success/falsification: full coefficient equality to `diag([st],[ts],[e])`; exact direct four-call positive control; one-call omission, label mutation and role-swap negative controls. Seed-specific domain is finite and fully enumerable. Stop after the complete <=3 search plus controls; no broader quotient claim. +- Intended artifact: self-contained `research/d10-reflection-sharing-seeda3def8/` package with exact replay and scope. Reproduction command planned: `python3 -I -B research/d10-reflection-sharing-seeda3def8/verify.py`. +- Predecessor attribution: PR #1911 (D-infinity reflection tariffs), PR #1821 (D16 central pair), PR #1573 (D8 central pair), and the base three-register rank-one-idempotent model in `research/bit-three-register-lower-bound/README.md`. Prepared with substantial OpenAI Codex assistance; no independent review claimed. diff --git a/research/d10-reflection-sharing-seeda3def8/VERIFY.json b/research/d10-reflection-sharing-seeda3def8/VERIFY.json new file mode 100644 index 0000000000..f35c17e88a --- /dev/null +++ b/research/d10-reflection-sharing-seeda3def8/VERIFY.json @@ -0,0 +1,46 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "docs/research/community-batch1099-review.md", + "research/community-frontier1094-audit/SELECTED-SOURCE.json", + "research/community-frontier1094-audit/ASSEMBLY.json", + "research/bit-three-register-lower-bound/README.md", + "docs/research/agent-task-catalog.json" + ], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Full exact coefficient search over all label words and all 28 rank-one idempotents through length three; verifies zero hits, deterministic state hashes and four-call endpoint." + }, + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/independent.py" + ], + "timeout_seconds": 120, + "checks": "Independent permutation-built D10 and row-mask engine exhausts the same full domain with separate per-level digests." + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/test_package.py" + ], + "timeout_seconds": 120, + "checks": "Optimized-Python positive and negative controls for group relations, direct endpoint, call deletion, label mutation and role swap." + } + ] +} diff --git a/research/d10-reflection-sharing-seeda3def8/independent.py b/research/d10-reflection-sharing-seeda3def8/independent.py new file mode 100644 index 0000000000..4b7398c575 --- /dev/null +++ b/research/d10-reflection-sharing-seeda3def8/independent.py @@ -0,0 +1,131 @@ +#!/usr/bin/env python3 +"""Independent exact replay using permutation-built D10 and row-vector matrices.""" +from __future__ import annotations + +import hashlib +import json +from itertools import product +from pathlib import Path + +RREG = 3 +BITS = 7 +ZERO_M = (0, 0, 0) +ID_M = (1, 2, 4) + + +def as_perm(k: int, e: int) -> tuple[int, ...]: + return tuple((k + (-j if e else j)) % 5 for j in range(5)) + + +PERMS = [as_perm(k, e) for k in range(5) for e in range(2)] +PERM_INDEX = {p: i for i, p in enumerate(PERMS)} + + +def compose(a: tuple[int, ...], b: tuple[int, ...]) -> tuple[int, ...]: + """Permutation product a*b means apply b, then a.""" + return tuple(a[b[i]] for i in range(5)) + + +TABLE = [[PERM_INDEX[compose(a, b)] for b in PERMS] for a in PERMS] +E = PERM_INDEX[(0, 1, 2, 3, 4)] +S = PERM_INDEX[(0, 4, 3, 2, 1)] +T = PERM_INDEX[(4, 3, 2, 1, 0)] +R = PERM_INDEX[(1, 2, 3, 4, 0)] +R_INV = PERM_INDEX[(4, 0, 1, 2, 3)] +assert len(PERMS) == 10 and len(PERM_INDEX) == 10 +assert TABLE[S][T] == R and TABLE[T][S] == R_INV +assert TABLE[S][S] == E and TABLE[T][T] == E +assert TABLE[R][R] == 4 +rot = E +for _ in range(5): + rot = TABLE[rot][R] +assert rot == E +assert all(TABLE[TABLE[a][b]][c] == TABLE[a][TABLE[b][c]] + for a in range(10) for b in range(10) for c in range(10)) + +PROJECTORS = [(x, y) for x in range(1, 8) for y in range(1, 8) + if (x & y).bit_count() & 1] +assert len(PROJECTORS) == 28 +EXPECTED_DIGESTS = { + 0: "626523c7a23825bc1c716fb9540513bfa1ae0543b5a35e31993a89236e5e4d5e", + 1: "53740396a3f0f73e8392fbb7dae15ec29853e43d507ca3b48051b05fa97e7cb3", + 2: "385b9687ea222aa258066118a956483af8faade44fbf6a88bbfd3403018a5854", + 3: "078453f4249334b2553bb29e8bc7c8041a6f6910dfa112d9b9f4e571e7699c29", +} +CERTIFICATE = json.loads(Path(__file__).with_name("CERTIFICATE.json").read_text(encoding="utf-8")) +if CERTIFICATE["search"]["independent_state_sha256"] != { + str(k): v for k, v in EXPECTED_DIGESTS.items()}: + raise RuntimeError("D10 certificate mismatch: independent state digests") +if CERTIFICATE["search"]["total_candidates"] != 178809: + raise RuntimeError("D10 certificate mismatch: total candidates") + +# Algebra matrix state: a ten-tuple of three row bitmasks per group element. +UNIT = tuple(ID_M if g == E else ZERO_M for g in range(10)) +TARGET = tuple((1, 0, 0) if g == R else + (0, 2, 0) if g == R_INV else + (0, 0, 4) if g == E else ZERO_M for g in range(10)) + + +def add_rows(a: tuple[int, ...], b: tuple[int, ...]) -> tuple[int, ...]: + return (a[0] ^ b[0], a[1] ^ b[1], a[2] ^ b[2]) + + +def right_call(state: tuple[tuple[int, ...], ...], label: int, + projector: tuple[int, int]) -> tuple[tuple[int, ...], ...]: + x, y = projector + out = [ZERO_M for _ in range(10)] + for g, rows in enumerate(state): + if rows == ZERO_M: + continue + image = tuple(y if (row & x).bit_count() & 1 else 0 for row in rows) + unchanged = add_rows(rows, image) # multiply by I+N + h = TABLE[g][label] + out[g] = add_rows(out[g], unchanged) + out[h] = add_rows(out[h], image) + return tuple(out) + + +def word_state(labels: tuple[int, ...], projectors: tuple[tuple[int, int], ...]): + state = UNIT + for label, projector in zip(labels, projectors): + state = right_call(state, label, projector) + return state + + +def main() -> None: + expected_counts = {0: 1, 1: 56, 2: 3136, 3: 175616} + counts = {} + hits = {} + digests = {} + for k in range(4): + digest = hashlib.sha256() + count = hit = 0 + for labels in product((S, T), repeat=k): + for projectors in product(PROJECTORS, repeat=k): + state = word_state(labels, projectors) + record = bytes(labels) + record += b"".join(bytes(p) for p in projectors) + record += bytes(row for coeff in state for row in coeff) + digest.update(record) + count += 1 + hit += state == TARGET + counts[k] = count + hits[k] = hit + digests[k] = digest.hexdigest() + assert counts == expected_counts + assert hits == {0: 0, 1: 0, 2: 0, 3: 0} + assert digests == EXPECTED_DIGESTS + + e00 = (1, 1) + e11 = (2, 2) + direct = word_state((S, T, T, S), (e00, e00, e11, e11)) + assert direct == TARGET + assert word_state((T, S, S, T), (e00, e00, e11, e11)) != TARGET + print("INDEPENDENT_SEARCH_COUNTS", counts) + print("INDEPENDENT_SEARCH_HITS", hits) + print("INDEPENDENT_STATE_SHA256", digests) + print("PASS_D10_INDEPENDENT_PERMUTATION_REPLAY min_calls=4 tested_words_le3=178809") + + +if __name__ == "__main__": + main() diff --git a/research/d10-reflection-sharing-seeda3def8/test_package.py b/research/d10-reflection-sharing-seeda3def8/test_package.py new file mode 100644 index 0000000000..cf52a7123d --- /dev/null +++ b/research/d10-reflection-sharing-seeda3def8/test_package.py @@ -0,0 +1,53 @@ +#!/usr/bin/env python3 +"""Small behavioral controls for the D10 package.""" +from __future__ import annotations + +from importlib.util import module_from_spec, spec_from_file_location +from pathlib import Path + +_SPEC = spec_from_file_location("d10_verify", Path(__file__).with_name("verify.py")) +verify = module_from_spec(_SPEC) +_SPEC.loader.exec_module(verify) + + +def require(condition: bool, message: str) -> None: + if not condition: + raise SystemExit("FAIL_D10_PACKAGE_TEST: " + message) + + +def main() -> None: + require(len(verify.PROJECTORS) == 28, "rank-one idempotent census") + require(verify.GROUP_TABLE[verify.S][verify.T] == verify.R, "st=r relation") + require(verify.GROUP_TABLE[verify.T][verify.S] == verify.R_INV, "ts=r^-1 relation") + require(verify.group_mul(verify.S, verify.S) == verify.E, "s involution") + require(verify.group_mul(verify.T, verify.T) == verify.E, "t involution") + + labels, projectors = verify.direct_four_call() + direct = verify.word_state(labels, projectors) + require(direct == verify.TARGET, "four-call direct endpoint") + for drop in range(4): + short_labels = labels[:drop] + labels[drop + 1:] + short_projectors = projectors[:drop] + projectors[drop + 1:] + require(verify.word_state(short_labels, short_projectors) != verify.TARGET, + "one-call omission control " + str(drop)) + + wrong_labels = list(labels) + wrong_labels[1] = verify.S + require(verify.word_state(tuple(wrong_labels), projectors) != verify.TARGET, + "wrong-label control") + swapped_target = tuple((1 << 0) if g == verify.R_INV else + (1 << 4) if g == verify.R else + (1 << 8) if g == verify.E else 0 + for g in range(verify.NGROUP)) + require(direct != swapped_target, "role-swap corruption control") + require(verify.word_state((verify.T, verify.S, verify.S, verify.T), + (1, 1, 16, 16)) == swapped_target, + "role-swapped positive control") + require(verify.word_state((verify.S, verify.T, verify.S), + (1, 1, 1)) != verify.TARGET, + "proposed three-call supersequence control") + print("PASS_D10_PACKAGE_CONTROLS projectors=28 direct_calls=4 mutations=6") + + +if __name__ == "__main__": + main() diff --git a/research/d10-reflection-sharing-seeda3def8/verify.py b/research/d10-reflection-sharing-seeda3def8/verify.py new file mode 100644 index 0000000000..e813a6e5af --- /dev/null +++ b/research/d10-reflection-sharing-seeda3def8/verify.py @@ -0,0 +1,206 @@ +#!/usr/bin/env python3 +"""Exact rank-one-idempotent word search in F2[D10] on three registers.""" +from __future__ import annotations + +import hashlib +import json +from itertools import product +from pathlib import Path + +NREG = 3 +NGROUP = 10 +MASK = (1 << NREG) - 1 +IDENTITY_MATRIX = sum(1 << (i * NREG + i) for i in range(NREG)) + + +def group_mul(a: int, b: int) -> int: + """Encode D10 elements r^k s^e by 2*k+e; r=st, s^2=t^2=1.""" + ka, ea = divmod(a, 2) + kb, eb = divmod(b, 2) + k = (ka + (-kb if ea else kb)) % 5 + return 2 * k + (ea ^ eb) + + +E = 0 +S = 1 +T = 9 # s*r = r^-1*s, since t=s*r and r=st +R = 2 +R_INV = 8 + + +def mat_mul(a: int, b: int) -> int: + """Multiply encoded 3x3 matrices over F2.""" + out = 0 + for i in range(NREG): + row = (a >> (i * NREG)) & MASK + for j in range(NREG): + col = sum(((b >> (k * NREG + j)) & 1) << k for k in range(NREG)) + if (row & col).bit_count() & 1: + out |= 1 << (i * NREG + j) + return out + + +MATMUL = [[mat_mul(a, b) for b in range(1 << 9)] for a in range(1 << 9)] + + +def mat_rank(a: int) -> int: + rows = [(a >> (i * NREG)) & MASK for i in range(NREG)] + rank = 0 + for col in range(NREG): + pivot = next((i for i in range(rank, NREG) if (rows[i] >> col) & 1), None) + if pivot is None: + continue + rows[rank], rows[pivot] = rows[pivot], rows[rank] + for i in range(NREG): + if i != rank and ((rows[i] >> col) & 1): + rows[i] ^= rows[rank] + rank += 1 + return rank + + +def rank_one_idempotents() -> list[int]: + vals = set() + for x in range(1, 1 << NREG): + for y in range(1, 1 << NREG): + if (x & y).bit_count() & 1: + n = sum((((x >> i) & 1) * (((y >> j) & 1)) << (i * NREG + j)) + for i in range(NREG) for j in range(NREG)) + vals.add(n) + result = sorted(vals) + assert len(result) == 28 + assert all(MATMUL[n][n] == n and mat_rank(n) == 1 for n in result) + return result + + +PROJECTORS = rank_one_idempotents() +EXPECTED_PRIMARY_DIGESTS = { + 0: "992d20f65528722d3c9f89c6ecd3876deae0d0084d271d8dffa254f1e21dfeae", + 1: "75d31c5b61a5e4704d487416541aae736b9a7d35a809c094a12b80a465a57194", + 2: "3a734c7f69b67583fd847a2df0919430092d755c757eb9fa2d2aa8dffb71669c", + 3: "32cdd595df3a5b2f39853beceb0f4e395f9e1277b1059204f3aeddd2cbee6258", +} + + +def require(condition: bool, message: str) -> None: + if not condition: + raise RuntimeError("D10 certificate mismatch: " + message) + + +CERTIFICATE = json.loads(Path(__file__).with_name("CERTIFICATE.json").read_text(encoding="utf-8")) +require(CERTIFICATE["search"]["primary_state_sha256"] == + {str(k): v for k, v in EXPECTED_PRIMARY_DIGESTS.items()}, "primary state digests") +require(CERTIFICATE["search"]["candidate_counts"] == + {"0": 1, "1": 56, "2": 3136, "3": 175616}, "candidate counts") +require(CERTIFICATE["search"]["exact_endpoint_hits"] == + {"0": 0, "1": 0, "2": 0, "3": 0}, "hit counts") +require(CERTIFICATE["target"] == "diag([st],[ts],[e])", "target statement") +GROUP_TABLE = [[group_mul(a, b) for b in range(NGROUP)] for a in range(NGROUP)] +assert all(GROUP_TABLE[E][g] == g and GROUP_TABLE[g][E] == g for g in range(NGROUP)) +assert all(GROUP_TABLE[g][GROUP_TABLE[g][E]] == E for g in (S, T)) +assert GROUP_TABLE[S][T] == R and GROUP_TABLE[T][S] == R_INV +assert group_mul(R, R) == 4 and group_mul(group_mul(R, R), group_mul(R, R)) == R_INV +assert group_mul(R, R_INV) == E and group_mul(R_INV, R) == E +assert group_mul(group_mul(R, R), group_mul(group_mul(R, R), R)) == E +assert all(group_mul(group_mul(a, b), c) == group_mul(a, group_mul(b, c)) + for a in range(NGROUP) for b in range(NGROUP) for c in range(NGROUP)) + +# A state is a tuple of ten coefficient matrices, one per group element. +ZERO = (0,) * NGROUP +UNIT = tuple(IDENTITY_MATRIX if g == E else 0 for g in range(NGROUP)) + + +def right_multiply_call(state: tuple[int, ...], label: int, n: int) -> tuple[int, ...]: + """Right multiply by I + ([label]+[e])N in characteristic two.""" + id_part = IDENTITY_MATRIX ^ n + out = [0] * NGROUP + for g, coeff in enumerate(state): + if coeff: + out[g] ^= MATMUL[coeff][id_part] + out[GROUP_TABLE[g][label]] ^= MATMUL[coeff][n] + return tuple(out) + + +def word_state(labels: tuple[int, ...], projectors: tuple[int, ...]) -> tuple[int, ...]: + state = UNIT + for label, n in zip(labels, projectors): + state = right_multiply_call(state, label, n) + return state + + +def target_state() -> tuple[int, ...]: + coeffs = [0] * NGROUP + coeffs[R] = 1 << 0 + coeffs[R_INV] = 1 << (1 * NREG + 1) + coeffs[E] = 1 << (2 * NREG + 2) + return tuple(coeffs) + +TARGET = target_state() + + +def direct_four_call() -> tuple[tuple[int, ...], tuple[int, ...]]: + e00 = 1 << 0 + e11 = 1 << 4 + labels = (S, T, T, S) + projectors = (e00, e00, e11, e11) + assert all(n in PROJECTORS for n in projectors) + return labels, projectors + + +def exhaustive(max_length: int = 3) -> dict[int, tuple[tuple[int, ...], tuple[int, ...]] | None]: + hits = {k: None for k in range(max_length + 1)} + counts = {k: 0 for k in range(max_length + 1)} + hit_counts = {k: 0 for k in range(max_length + 1)} + digests = {k: hashlib.sha256() for k in range(max_length + 1)} + for k in range(max_length + 1): + for labels in product((S, T), repeat=k): + for projectors in product(PROJECTORS, repeat=k): + counts[k] += 1 + state = word_state(labels, projectors) + record = bytes(labels) + record += b"".join(n.to_bytes(2, "little") for n in projectors) + record += b"".join(c.to_bytes(2, "little") for c in state) + digests[k].update(record) + if state == TARGET: + hit_counts[k] += 1 + if hits[k] is None: + hits[k] = (labels, projectors) + expected = {0: 1, 1: 56, 2: 3136, 3: 175616} + assert counts == expected, (counts, expected) + assert hit_counts == {0: 0, 1: 0, 2: 0, 3: 0}, hit_counts + assert {k: d.hexdigest() for k, d in digests.items()} == EXPECTED_PRIMARY_DIGESTS + print("SEARCH_COUNTS", counts) + print("SEARCH_HITS", hit_counts) + print("SEARCH_STATE_SHA256", {k: d.hexdigest() for k, d in digests.items()}) + return hits + + +def main() -> None: + hits = exhaustive(3) + direct_labels, direct_projectors = direct_four_call() + direct = word_state(direct_labels, direct_projectors) + assert direct == TARGET + assert all(hits[k] is None for k in range(4)) + # The supplied four-call word is a positive control; every one-factor + # deletion and one label mutation fails exact full-group-algebra equality. + for drop in range(4): + reduced_labels = direct_labels[:drop] + direct_labels[drop + 1:] + reduced_ns = direct_projectors[:drop] + direct_projectors[drop + 1:] + assert word_state(reduced_labels, reduced_ns) != TARGET + mutated_labels = list(direct_labels) + mutated_labels[1] = S + assert word_state(tuple(mutated_labels), direct_projectors) != TARGET + swapped_target = tuple((1 << 0) if g == R_INV else + (1 << 4) if g == R else + (1 << 8) if g == E else 0 + for g in range(NGROUP)) + assert TARGET != swapped_target + assert direct != swapped_target + swapped_direct = word_state((T, S, S, T), (1, 1, 16, 16)) + assert swapped_direct == swapped_target + print("DIRECT_CONTROL labels=stts calls=4 exact_endpoint=true") + print("NEGATIVE_CONTROLS deleted_calls=4 label_mutation=1 role_swap_distinct=true") + print("PASS_D10_INVERSE_ROTATION_MINIMUM min_calls=4 tested_words_le3=178809 projectors=28 group_order=10") + + +if __name__ == "__main__": + main() From 4f3bdf7c3bdd7033180c9d8c41245023cc402bc6 Mon Sep 17 00:00:00 2001 From: Cinna Davis <1337isnot1337@users.noreply.github.com> Date: Wed, 14 Oct 2026 09:59:23 -0500 Subject: [PATCH 2/3] Record finite-dihedral overlap distinction --- .../README.md | 4 +-- .../SOURCES.json | 14 +++++++++++ .../TASK.json | 25 ++++++++++++++++++- .../d10-reflection-sharing-seeda3def8/TASK.md | 2 +- 4 files changed, 41 insertions(+), 4 deletions(-) diff --git a/research/d10-reflection-sharing-seeda3def8/README.md b/research/d10-reflection-sharing-seeda3def8/README.md index b571db1985..b3cbd2e9eb 100644 --- a/research/d10-reflection-sharing-seeda3def8/README.md +++ b/research/d10-reflection-sharing-seeda3def8/README.md @@ -61,8 +61,8 @@ Expected markers include `PASS_D10_INVERSE_ROTATION_MINIMUM` and `PASS_D10_INDEP - Selected `kappa`: `836330098538459/500000000000000000`; the baseline checker prints `PASS_RESEARCH_BASELINE_BINDINGS_ONLY`, not a cold selected-construction replay. - The selected record points to review `docs/research/community-batch1099-review.md`, source manifest `research/community-frontier1094-audit/SELECTED-SOURCE.json`, certificate `research/community-frontier1094-audit/ASSEMBLY.json` (SHA-256 `1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045`), and reproduction target `make frontier1094-verify`; these are pinned in `SOURCES.json`. - Coordination claim: [Discussion #1167 comment 18926353](https://github.com/CrocSwap/integer-mult-bounds/discussions/1167#discussioncomment-18926353); handoff goes there. -- Nearby work: PR #1911 at head `712593f82739203639d0a169b88c6bcac6f0590c` proves reflection tariffs for `D_infinity`, but explicitly does not descend to finite quotients. PR #1821 at head `a986127fa82b680a5bbb29f49fec4c8c3a944bde` is a D16 central involution; PR #1573 at head `0b8c5a69297c794f2de22c04494c83e41300ae36` is a D8 central-target theorem. PR #1870 at head `538d194e69420a6a773612e0b5ad0c94575f8aaa` exhausts S3 target pairs. Their groups or endpoints differ from this D10 noncentral inverse-rotation pair. -- Overlap limits: the complete refreshed snapshot at 2026-10-14 14:40 UTC covered 597 open PRs and 568 Discussion records; no D10/order-five target claim appeared. The latest mechanism-thread comments were separately re-read at 14:38:49 UTC. Code diffs and closed PRs beyond the local ledger were not globally searched. +- Nearby work: PR #1911 at head `712593f82739203639d0a169b88c6bcac6f0590c` proves reflection tariffs for `D_infinity`, but explicitly does not descend to finite quotients. New open PR #1941 at head `5938ce3e91bbb8b5c2227af7976d444b2fbac7d4` proves tariffs for every **even** rotation order and explicitly leaves odd periods out. PR #1821 at head `a986127fa82b680a5bbb29f49fec4c8c3a944bde` is a D16 central involution; PR #1573 at head `0b8c5a69297c794f2de22c04494c83e41300ae36` is a D8 central-target theorem. PR #1870 at head `538d194e69420a6a773612e0b5ad0c94575f8aaa` exhausts S3 target pairs. Discussion #1929 comment 18925900 is the claim for PR #1941. The current result fixes odd rotation order `n=5` and the noncentral inverse pair, outside #1941's theorem. +- Overlap limits: the complete refreshed snapshot at 2026-10-14 14:56:57 UTC covered 601 open PRs and 575 Discussion records with no warnings; no D10/order-five target claim appeared. The latest mechanism-thread comments were separately re-read at 14:51:17 UTC, including the even-order claim and #1941's result. Code diffs and closed PRs beyond the local ledger were not globally searched. Prepared with substantial OpenAI Codex assistance in scope selection, exact enumeration, independent implementation and writing. No independent human review is claimed. diff --git a/research/d10-reflection-sharing-seeda3def8/SOURCES.json b/research/d10-reflection-sharing-seeda3def8/SOURCES.json index 0f4f10b66d..153a274dd5 100644 --- a/research/d10-reflection-sharing-seeda3def8/SOURCES.json +++ b/research/d10-reflection-sharing-seeda3def8/SOURCES.json @@ -81,6 +81,20 @@ "head": "538d194e69420a6a773612e0b5ad0c94575f8aaa", "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1870", "use": "Exact S3 target-pair census; group and target are different." + }, + { + "pr": 1941, + "head": "5938ce3e91bbb8b5c2227af7976d444b2fbac7d4", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1941", + "use": "Sharp finite-dihedral tariff for all even rotation orders; explicitly leaves odd periods out, so it does not cover D10 with rotation order five." + } + ], + "external_discussions": [ + { + "discussion": 1929, + "comment": 18925900, + "url": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1929#discussioncomment-18925900", + "use": "Original claim for PR #1941 covers finite dihedral groups with even rotation order; this package fixes odd rotation order five and the noncentral inverse-rotation endpoint." } ] } diff --git a/research/d10-reflection-sharing-seeda3def8/TASK.json b/research/d10-reflection-sharing-seeda3def8/TASK.json index 2559a1cd3f..6c1083e493 100644 --- a/research/d10-reflection-sharing-seeda3def8/TASK.json +++ b/research/d10-reflection-sharing-seeda3def8/TASK.json @@ -80,6 +80,12 @@ "head": "538d194e69420a6a773612e0b5ad0c94575f8aaa", "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1870", "use": "Exact S3 target-pair census; group and target are different." + }, + { + "pr": 1941, + "head": "5938ce3e91bbb8b5c2227af7976d444b2fbac7d4", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1941", + "use": "Sharp finite-dihedral tariff for all even rotation orders; explicitly leaves odd periods out, so it does not cover D10 with rotation order five." } ], "open_questions": [ @@ -110,5 +116,22 @@ "certificate_sha256": "1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045", "reproduce": "make frontier1094-verify" }, - "pull_request": null + "pull_request": null, + "external_discussions": [ + { + "discussion": 1929, + "comment": 18925900, + "url": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1929#discussioncomment-18925900", + "use": "Original claim for PR #1941 covers finite dihedral groups with even rotation order; this package fixes odd rotation order five and the noncentral inverse-rotation endpoint." + } + ], + "final_overlap_snapshot": { + "searched_at": "2026-10-14T14:56:57.247444Z", + "open_prs": 601, + "discussions": 575, + "complete_pagination": true, + "warnings": [], + "nearest_new_result": "https://github.com/CrocSwap/integer-mult-bounds/pull/1941", + "distinction": "PR #1941 proves all even rotation orders and explicitly excludes odd periods; this package treats the order-five rotation pair in D10." + } } diff --git a/research/d10-reflection-sharing-seeda3def8/TASK.md b/research/d10-reflection-sharing-seeda3def8/TASK.md index fef4caab7b..b156830265 100644 --- a/research/d10-reflection-sharing-seeda3def8/TASK.md +++ b/research/d10-reflection-sharing-seeda3def8/TASK.md @@ -4,7 +4,7 @@ - Accepted OS seed: `a3def8e7b944810f5d933bfa65cba990`; track `bit-mechanisms`; priority revision 3; catalogue SHA-256 `6686ad58f1fbdbc87134a78901b60fd53a20d3984355e91defbbebc9e9fa8075`; base `0b1cccf86e2f5132ed286a26ef0a681a495740ea`; selected-record SHA-256 `10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32`. - Scope status: refined, with one evidence-driven change from the first candidate. The first candidate was a W=4 rational two-relation target. PR #1733 and Discussion #1700 already cover a nearby two-relation W=4 family. This card instead tests finite torsion in a nonabelian group model, a stated open direction in PR #1911. - Concrete object and question: in the formal group algebra `F2[D10]`, with `D10=`, can three paid factors realize `diag([st],[ts],[e])` on three arbitrary dirty scalar registers? The complete paid alphabet for this experiment is `{s,t}`; each factor is `D_N(g)=I+([g]+[e])N` for a rank-one idempotent `N` in `M3(F2)`. The proposed shared schedule is label word `s,t,s`: the first two labels spell `st`, the last two spell `ts`. -- Nearest predecessor/overlap: PR #1911 proves an all-register sharp bill in `D_infinity` and expressly notes its Laurent proof does not descend to finite dihedral quotients; its open next question asks for a torsion-aware finite-quotient invariant. PR #1821 covers a D16 central involution; PR #1573 covers D8 central targets. Neither is the D10 noncentral inverse-rotation pair. The current overlap snapshot (complete pagination at 2026-10-14 14:40 UTC) has no D10/order-five target claim. The broad #1884 thread includes the D-infinity task; claim the finite D10 slice there with the distinction explicit. +- Nearest predecessor/overlap: PR #1911 proves an all-register sharp bill in `D_infinity` and expressly notes its Laurent proof does not descend to finite dihedral quotients; its open next question asks for a torsion-aware finite-quotient invariant. New PR #1941 (head `5938ce3e91bbb8b5c2227af7976d444b2fbac7d4`) resolves every even rotation order and explicitly leaves odd periods out. Discussion #1929 comment 18925900 is its original claim. PR #1821 covers a D16 central involution; PR #1573 covers D8 central targets. This task fixes odd rotation order `n=5` and the noncentral inverse pair. The complete final overlap snapshot at 2026-10-14 14:56:57 UTC covers 601 open PRs / 575 Discussions with no warnings and no D10 target claim. The broad #1884 thread includes the D-infinity task; this task was claimed in #1167 with the finite-quotient distinction explicit. - Baseline/full cost: two calls for `st` and two for `ts`, total 4; target helpers are identity and restoration is part of formal equality. Candidate target is 3 calls, so one paid-call saving in this abstract model. No supplier, compiler, hosting, precision or recursive interface mapping is assumed; no kappa claim is available from this experiment alone. - Method/domain: enumerate all 28 rank-one idempotents in `M3(F2)` for every position and every ordered label word of length at most 3 over `{s,t}`. Exact product in the 10-element formal group algebra, no finite representation substitution. Search candidate `s,t,s` first; then complete the full length-0..3 cover. - Optimistic cost and gate: direct 4 vs candidate 3, with each factor priced as one paid reflection. If the exact three-factor endpoint fails in the full cover, stop this construction and report the exact finite obstruction only for this group, target, register count and alphabet. From 0f26ac2016777224e3c66c8ead77defbf3e526d2 Mon Sep 17 00:00:00 2001 From: Cinna Davis <1337isnot1337@users.noreply.github.com> Date: Wed, 14 Oct 2026 10:00:13 -0500 Subject: [PATCH 3/3] Record D10 handoff and PR status --- .../d10-reflection-sharing-seeda3def8/README.md | 1 + .../d10-reflection-sharing-seeda3def8/TASK.json | 16 +++++++++++++++- .../d10-reflection-sharing-seeda3def8/TASK.md | 7 +++++++ 3 files changed, 23 insertions(+), 1 deletion(-) diff --git a/research/d10-reflection-sharing-seeda3def8/README.md b/research/d10-reflection-sharing-seeda3def8/README.md index b3cbd2e9eb..658429a788 100644 --- a/research/d10-reflection-sharing-seeda3def8/README.md +++ b/research/d10-reflection-sharing-seeda3def8/README.md @@ -57,6 +57,7 @@ Expected markers include `PASS_D10_INVERSE_ROTATION_MINIMUM` and `PASS_D10_INDEP - Accepted cycle seed: `a3def8e7b944810f5d933bfa65cba990`; track `bit-mechanisms`; task `bit-new-register-model`; priority revision 3. - Exact base commit: `0b1cccf86e2f5132ed286a26ef0a681a495740ea`. +- Focused contribution PR: [#1953](https://github.com/CrocSwap/integer-mult-bounds/pull/1953), open at handoff from head `4f3bdf7c` (the package and overlap record are the entire change). - Selected record SHA-256: `10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32`. - Selected `kappa`: `836330098538459/500000000000000000`; the baseline checker prints `PASS_RESEARCH_BASELINE_BINDINGS_ONLY`, not a cold selected-construction replay. - The selected record points to review `docs/research/community-batch1099-review.md`, source manifest `research/community-frontier1094-audit/SELECTED-SOURCE.json`, certificate `research/community-frontier1094-audit/ASSEMBLY.json` (SHA-256 `1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045`), and reproduction target `make frontier1094-verify`; these are pinned in `SOURCES.json`. diff --git a/research/d10-reflection-sharing-seeda3def8/TASK.json b/research/d10-reflection-sharing-seeda3def8/TASK.json index 6c1083e493..d6b2a8f0f9 100644 --- a/research/d10-reflection-sharing-seeda3def8/TASK.json +++ b/research/d10-reflection-sharing-seeda3def8/TASK.json @@ -116,7 +116,12 @@ "certificate_sha256": "1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045", "reproduce": "make frontier1094-verify" }, - "pull_request": null, + "pull_request": { + "number": 1953, + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1953", + "status": "open", + "head": "4f3bdf7c" + }, "external_discussions": [ { "discussion": 1929, @@ -133,5 +138,14 @@ "warnings": [], "nearest_new_result": "https://github.com/CrocSwap/integer-mult-bounds/pull/1941", "distinction": "PR #1941 proves all even rotation orders and explicitly excludes odd periods; this package treats the order-five rotation pair in D10." + }, + "handoff": { + "result": "Exact minimum four for the D10 order-five inverse-rotation pair with two paid reflections on three registers.", + "pr": "https://github.com/CrocSwap/integer-mult-bounds/pull/1953", + "remaining_obligations": [ + "Registered Python 3.12 replay and hosted CI", + "No native supplier/compiler or physical interface mapping", + "No conditional-moment or kappa consequence" + ] } } diff --git a/research/d10-reflection-sharing-seeda3def8/TASK.md b/research/d10-reflection-sharing-seeda3def8/TASK.md index b156830265..190727b5ad 100644 --- a/research/d10-reflection-sharing-seeda3def8/TASK.md +++ b/research/d10-reflection-sharing-seeda3def8/TASK.md @@ -11,3 +11,10 @@ - Success/falsification: full coefficient equality to `diag([st],[ts],[e])`; exact direct four-call positive control; one-call omission, label mutation and role-swap negative controls. Seed-specific domain is finite and fully enumerable. Stop after the complete <=3 search plus controls; no broader quotient claim. - Intended artifact: self-contained `research/d10-reflection-sharing-seeda3def8/` package with exact replay and scope. Reproduction command planned: `python3 -I -B research/d10-reflection-sharing-seeda3def8/verify.py`. - Predecessor attribution: PR #1911 (D-infinity reflection tariffs), PR #1821 (D16 central pair), PR #1573 (D8 central pair), and the base three-register rank-one-idempotent model in `research/bit-three-register-lower-bound/README.md`. Prepared with substantial OpenAI Codex assistance; no independent review claimed. + + +## Handoff + +- Result: exact minimum four; all 178,809 words through three calls excluded by both engines, with the direct four-call endpoint verified. +- PR: [#1953](https://github.com/CrocSwap/integer-mult-bounds/pull/1953), open at handoff from head `4f3bdf7c`. +- Remaining: registered Python 3.12 replay / hosted CI; no native supplier or compiler mapping; no conditional-moment or `kappa` consequence.