Research: general odd-kernel exclusion pattern for native DATA shear pairs (no new kappa)

research/odd-kernel-query-pair/NOTICE.md

@@ -0,0 +1,17 @@
+# Notice — research/odd-kernel-query-pair
+
+Prepared by Wentao Li (GitHub VictorLiwentao, X @Is__Victor) with substantial
+AI assistance. New material is Apache-2.0 under the repository LICENSE.
+
+Predecessor credit:
+
+- Wentao Li / PR840 (`research/dyadic-query-pair`) — three-query dyadic fusion,
+  sharp minimum, typed costs, and the explicit non-dyadic exclusion note.
+- Pending fork package `research/triadic-query-pair/` @ `77041f2d` — kernel-3
+  specialization and OQ2 answered here; not vendored (absent from this fork
+  base).
+- Karl Appel / applecrusher / PR521 — native unipotent ADDRESS query lowering.
+- commdata2338 / PR677 — completed DATA-shear boundaries without a private row.
+- Retained OpenAI tape / stream framework as cited by PR840.
+
+No independent human review is claimed. No selected frontier or kappa change.

research/odd-kernel-query-pair/PROOF.md

@@ -0,0 +1,69 @@
+# Excluded-prime pattern for general odd-kernel native DATA shears
+
+This is a local recursive-interface construction and a scoped admission lemma.
+Ordinary ADDRESS interchange and ordered affine tape streams remain premises.
+There is no new supplier, kappa, or formal multiplication proof.
+
+It answers open question 2 of the pending
+`research/triadic-query-pair/` package (fork tip `77041f2d`), which completes
+PR840's non-dyadic note for kernel **3** and asks for the excluded-prime pattern
+of a general odd kernel `q`.
+
+## Object
+
+Use the same six ADDRESS fields and unipotent push `h` as PR521/PR840:
+
+```text
+s=(1,0,1,-1,0,-1)^T, r=(1,0,-1,-1,0,1)^T,
+M(k)=I6+(k/4)s r^T,   h = array permutation of M(1).
+```
+
+For each positive odd integer `q` and each `j ≥ 0`, `σ ∈ {±1}`, set
+`a = σ·q·2^j`. The completed DATA endpoint is
+
+```text
+F_a(x,y,z)=(x+(h^a+h^-a)y, y, z).
+```
+
+## Lowering and exclusion pattern
+
+The seven-event word of PR840/triadic applies verbatim for any nonzero integer
+`k`, with diagonal units `1`, `c=k/4`, and `-1/c`. For `k = ±q·2^j` every
+numerator/denominator odd part divides a power of `q`. Therefore the lowering
+specializes to **every odd modulus coprime to `q`**. Equivalently: an odd
+modulus is admitted iff it shares no odd prime factor with `q`; every even
+modulus is excluded. When `q=1` this recovers PR840's all-odd-radix claim.
+When `q=3` this recovers the pending triadic exclusions.
+
+## Completed pair fusion and typed costs
+
+The fused program is identical in form to PR840:
+
+```text
+x <- h^-a x
+x ^= y
+x <- h^(2a) x
+x ^= y
+x <- h^-a x.
+```
+
+Relative to two separate completed shears, the fused word uses **three ordinary
+children, eighteen affine events and two XOR scans**. These counts are
+independent of `q`. No odd kernel improves the typed interface invoice over the
+dyadic case; larger radical(`q`) only shrinks the admitted modulus set.
+
+## Three-query necessity
+
+The PR840 determinant argument applies for any nonzero integer unit power `a`
+on an odd full-order orbit admitted by the lowering. This package treats that
+written argument as inherited; finite Laurent/two-query corroboration for
+kernel 3 remains in the triadic predecessor.
+
+## Evidence boundary
+
+The checker verifies, for kernels `{1,3,5,7,9,15}`, that the closed-form
+admission predicate matches denominator invertibility on a fixed probe modulus
+set, that rational and modular columns match `M(k)`, that
+`M(-a)M(2a)M(-a)=I`, and that fused/baseline invoices are `3/18/2` versus
+`4/24/4`. An independent module rebuilds the matrix identity without importing
+`verify.py`.

research/odd-kernel-query-pair/README.md

@@ -0,0 +1,83 @@
+# Excluded-prime pattern for general odd-kernel native DATA shears
+
+**Research construction / recursive interface; no new kappa.** Completes open
+question 2 of the pending
+[triadic-query-pair](https://github.com/VictorLiwentao/integer-mult-bounds/tree/cursor/triadic-query-pair-60b9)
+package (`77041f2d`), itself the kernel-3 specialization of
+[PR840](https://github.com/CrocSwap/integer-mult-bounds/pull/840)
+(`research/dyadic-query-pair`).
+
+For every positive odd kernel `q`, the same three-query fusion at `a=±q·2^j`
+attains the typed invoice below on every **odd modulus coprime to `q`**. Even
+moduli and odd moduli sharing a prime with `q` are excluded. Typed costs do
+**not** improve over the dyadic (`q=1`) case.
+
+```text
+x <- h^-a x
+x ^= y
+x <- h^(2a) x
+x ^= y
+x <- h^-a x
+```
+
+| Complete cost item | Separate pair | Fused odd-kernel pair |
+|---|---:|---:|
+| Ordinary recursive children | 4 | 3 |
+| Ordered affine events | 24 | 18 |
+| Aligned XOR scans | 4 | 2 |
+| Extra full private rows | 0 | 0 |
+
+Certificate kernels: `{1,3,5,7,9,15}` (dyadic recovery, triadic cross-check, and
+primary new kernels `{5,7,9,15}`). Pattern: admitted ⇔ odd and
+`gcd(modulus,q)=1`.
+
+## Reproduce
+
+Python 3.12, standard library only, from the repository root:
+
+```sh
+python3.12 -I -B research/odd-kernel-query-pair/verify.py
+python3.12 -I -O -B research/odd-kernel-query-pair/verify.py
+python3.12 -I -B research/odd-kernel-query-pair/independent.py
+python3.12 -I -B research/odd-kernel-query-pair/test_package.py
+python3.12 -B scripts/research_package.py --package research/odd-kernel-query-pair
+```
+
+Expected:
+
+```text
+PASS_ODD_KERNEL_QUERY_PAIR kernels=[1, 3, 5, 7, 9, 15] primary_new=[5, 7, 9, 15] children=4->3 affine=24->18 xor=4->2 no_typed_gain_over_dyadic ... no_new_kappa
+PASS_INDEPENDENT_ODD_KERNEL_QUERY_PAIR kernels=[1, 3, 5, 7, 9, 15] ... no_new_kappa
+PASS_ODD_KERNEL_QUERY_PAIR_PACKAGE_TESTS groups=6
+PASS_REGISTERED_RESEARCH_PACKAGE research/odd-kernel-query-pair outcome=completed
+```
+
+Default verify is read-only and compares a fresh rebuild to
+[CERTIFICATE.json](CERTIFICATE.json). Use `--write` only to regenerate that
+receipt. Admission uses `need()` (not `assert`); `-O` also passes.
+
+## Scope and overlap
+
+Base commit `0b1cccf86e2f5132ed286a26ef0a681a495740ea`. Direct predecessor:
+PR840 / `research/dyadic-query-pair`. Complementary pending: triadic kernel-3
+package (OQ2 answered here; kernel-3 rows are cross-checks, not a competing
+re-proof). Does not reopen leave-alone tooling through
+[#2487](https://github.com/CrocSwap/integer-mult-bounds/pull/2487), pending
+`mutable-source-789q-invoice`, or [#2643](https://github.com/CrocSwap/integer-mult-bounds/pull/2643)
+(`seven-query-xor-floor`).
+
+## Open next questions
+
+1. Can an admitted BIT supplier host some small odd-kernel shear on moduli
+   coprime to `q` with a favorable fully charged bill versus the dyadic path?
+   First write one exact source-return boundary and charge routing, precision
+   and dispatch.
+2. Do coefficient-table bit-sizes for larger `q` ever pay for themselves under
+   a concrete physical tariff despite identical typed child/XOR counts?
+
+## Credit
+
+Prepared by Wentao Li ([VictorLiwentao](https://github.com/VictorLiwentao),
+[@Is__Victor](https://x.com/Is__Victor)) with substantial AI assistance, under
+Apache-2.0. Credit PR840/PR521/PR677 and the pending triadic kernel-3 package.
+No independent human review is claimed. No new kappa.

research/odd-kernel-query-pair/SOURCES.json

@@ -0,0 +1,36 @@
+{
+  "schema_version": 1,
+  "base_commit": "0b1cccf86e2f5132ed286a26ef0a681a495740ea",
+  "files": [
+    {
+      "path": "research/dyadic-query-pair/PROOF.md",
+      "usage": "input",
+      "git_blob": "aaba3e501de1f761c783ec7f0dc9307ef45ab5d7",
+      "sha256": "9a5ce93b866371189c797fbe8837c6a0bd22c5cf71ed84d60b9ae1c22a5ec83a"
+    },
+    {
+      "path": "research/dyadic-query-pair/README.md",
+      "usage": "input",
+      "git_blob": "3988b2cb22f81be52ca00500e1576d9f52206dab",
+      "sha256": "9b37c24a1056fa495f12e322ba56f592494f6f34516b0112be0db3f5cd6883d4"
+    },
+    {
+      "path": "research/dyadic-query-pair/CERTIFICATE.json",
+      "usage": "input",
+      "git_blob": "d201254cdd56e90471869caadaba5bc5eda8436c",
+      "sha256": "8267e9a468eca814b3b8641aae07ff71acadb303fd434ce3ef1984a258c69307"
+    },
+    {
+      "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"
+    }
+  ]
+}

research/odd-kernel-query-pair/TASK.json

@@ -0,0 +1,84 @@
+{
+  "schema_version": 1,
+  "task_id": "connector-alphabet-change",
+  "priority_revision": 4,
+  "base_commit": "0b1cccf86e2f5132ed286a26ef0a681a495740ea",
+  "original_card": {
+    "id": "connector-alphabet-change",
+    "question": "Does one explicit extension of the connector alphabet offer a favorable completed budget?",
+    "starting_points": [
+      "research/universal-connector-boundary/README.md",
+      "certificates/selected-result.json"
+    ],
+    "methods": [
+      "Construct and charge a legal extra operation on a minimal instance.",
+      "Prove a target-specific bound after adding one specified operation family."
+    ],
+    "acceptance_gate": "State which fixed-alphabet premise changes and charge its implementation; do not declare it free.",
+    "first_step": {
+      "command": [
+        "python3",
+        "-B",
+        "research/universal-connector-boundary/verify.py"
+      ],
+      "expected": "PASS_UNIVERSAL_CONNECTOR_BOUNDARY",
+      "inspect": "Reproduce the 945-pairing control, then read Exact interface to list the allowed calls.",
+      "scope": "Positive control / source-bound orientation only; this is not a new construction or full cold replay."
+    },
+    "first_experiment": "Add exactly one legally priced operation and test a tiny dirty-input instance before enumerating larger cases.",
+    "bottleneck_link": "A new legal connector operation could change recursive interface cost; a larger census in the same alphabet is a separate side result.",
+    "allowed_variations": [
+      "Choose one additional operation and a small source count for its first counterexample."
+    ],
+    "scope_change_triggers": [
+      "Keeping the alphabet and only increasing the source count; record this as a changed assignment."
+    ],
+    "overlap_terms": [
+      "universal connector",
+      "source-toggle",
+      "connector alphabet"
+    ]
+  },
+  "scope_status": "changed",
+  "actual_scope": "Prove the excluded-prime admission pattern for general odd kernel q in the PR840 three-query fused native DATA shear (a=±q·2^j): odd moduli coprime to q; typed costs 4→3/24→18/4→2 with no improvement over dyadic; certificate for kernels {1,3,5,7,9,15}.",
+  "scope_change_reason": "The drawn connector-alphabet card is redirected to open question 2 of the pending triadic-query-pair package on the PR840 non-dyadic ADDRESS alphabet, which asks for the general-q exclusion pattern beyond kernel 3.",
+  "bottleneck_link": "A priced general odd-kernel native shear widens the paid query alphabet recursive BIT interfaces may use; exclusions are charged, and typed costs are shown not to improve with larger q.",
+  "budget_minutes": 60,
+  "stop_rule": "Stop after multi-kernel pattern census, invoice invariance, independent matrix identity, package tests; no supplier search.",
+  "outcome": "completed",
+  "evidence": "CERTIFICATE.json per-kernel admission/exclusion probes, invoices, rational/modular columns, M(-a)M(2a)M(-a)=I; independent closed-form replay.",
+  "author": "Wentao Li",
+  "ai_assistance": "Substantial AI assistance for derivation, implementation, checking and writing.",
+  "open_questions": [
+    {
+      "question": "Can an admitted BIT supplier host some small odd-kernel shear on moduli coprime to q with a favorable fully charged bill versus the dyadic path?",
+      "why_it_matters": "Local child/XOR counts alone do not admit a supplier or change kappa.",
+      "first_step": "Trace one exact source-return boundary and price routing, precision and dispatch against the dyadic PR840 path.",
+      "blocked_by": "No such hosted instance is constructed here."
+    },
+    {
+      "question": "Do coefficient-table bit-sizes for larger q ever pay for themselves under a concrete physical tariff despite identical typed child/XOR counts?",
+      "why_it_matters": "Larger kernels only shrink admitted moduli in this model; physical tables may still matter.",
+      "first_step": "Fix one j and compare compiled coefficient bit-lengths for q in {1,3,5,7} under a named tape cost.",
+      "blocked_by": "No physical tariff is attached here."
+    }
+  ],
+  "predecessors": [
+    {
+      "pr": 840,
+      "credit": "Wentao Li; dyadic three-query fusion and non-dyadic exclusion note"
+    },
+    {
+      "ref": "cursor/triadic-query-pair-60b9@77041f2d",
+      "credit": "Pending triadic kernel-3 package; OQ2 answered here"
+    },
+    {
+      "pr": 521,
+      "credit": "Karl Appel / applecrusher; native ADDRESS query lowering"
+    },
+    {
+      "pr": 677,
+      "credit": "commdata2338; completed DATA-shear boundaries"
+    }
+  ]
+}

research/odd-kernel-query-pair/VERIFY.json

@@ -0,0 +1,54 @@
+{
+  "schema_version": 1,
+  "status": "ready",
+  "python": "3.12",
+  "requirements": [],
+  "inputs": [
+    "research/dyadic-query-pair/PROOF.md",
+    "research/dyadic-query-pair/README.md",
+    "research/dyadic-query-pair/CERTIFICATE.json"
+  ],
+  "commands": [
+    {
+      "argv": [
+        "{python}",
+        "-I",
+        "-B",
+        "{package}/verify.py"
+      ],
+      "timeout_seconds": 180,
+      "checks": "Multi-kernel exclusion pattern, invoices, rational/modular columns, certificate match, source pins"
+    },
+    {
+      "argv": [
+        "{python}",
+        "-I",
+        "-O",
+        "-B",
+        "{package}/verify.py"
+      ],
+      "timeout_seconds": 180,
+      "checks": "Same admission under PYTHONOPTIMIZE via need()"
+    },
+    {
+      "argv": [
+        "{python}",
+        "-I",
+        "-B",
+        "{package}/independent.py"
+      ],
+      "timeout_seconds": 60,
+      "checks": "Separate closed-form columns, product identity, admission pattern"
+    },
+    {
+      "argv": [
+        "{python}",
+        "-I",
+        "-B",
+        "{package}/test_package.py"
+      ],
+      "timeout_seconds": 240,
+      "checks": "Corruption rejection and -O controls"
+    }
+  ]
+}