Research: D10 inverse rotations retain four-call minimum

research/d10-reflection-sharing-seeda3def8/CERTIFICATE.json

@@ -0,0 +1,40 @@
+{
+  "schema_version": 1,
+  "model": {
+    "group": "D10 of order 10",
+    "presentation": "<s,t | s^2=t^2=e,(st)^5=e>",
+    "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."
+}

research/d10-reflection-sharing-seeda3def8/README.md

@@ -0,0 +1,74 @@
+# 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 = <s,t | s^2=t^2=e, (st)^5=e>`
+
+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`.
+- 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`.
+- 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. 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.
+
+## 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.

research/d10-reflection-sharing-seeda3def8/SOURCES.json

@@ -0,0 +1,100 @@
+{
+  "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."
+    },
+    {
+      "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."
+    }
+  ]
+}