Place a core row past the agreement radius p^26 (no new κ)

research/gaussian-core-row/README.md

@@ -0,0 +1,103 @@
+# A core row clears the within-cell agreement radius
+
+**Claim type:** a distance comparison for one core row.
+**No new κ.** The ideal-gap gauge stays a hypothesis. The selected record
+remains `23/10000`.
+
+## Question
+
+#4490 uses `||B - P|| < p^6 exp(-p^2)` on one core axis and asks whether a
+core row meets the within-cell gauge of #4452. That gauge gives the same
+error for a section whose ideal off-sums are at most `1 - 1/(8p^2)`, once
+the row lies past the agreement radius.
+
+## Lemma
+
+Let `p ≥ 2` and `W` be integers with `0 ≤ W ≤ p - 1`. Write
+
+```text
+R = (2 p^{24} - 1) W,    A = ceil(p^{48}).
+```
+
+Then `R < p^{26} < p^{48} = A`. An output kept at distance `A` from every
+face is strictly farther from the section boundary than this bandwidth.
+Its section-polynomial row is the global polynomial row. If the section
+meets the #4452 gauge, then
+
+```text
+||P - H_sec^{-1}||_2 < p^6 exp(-p^2),
+```
+
+and the core row is a row of that operator. The distance `p^{25}` does not
+clear the loose radius `(2 p^{24} + 1) W` at `p = 2`.
+
+## Proof
+
+The bandwidth identity is
+
+```text
+p^{26} - (2 p^{24} - 1)(p - 1)
+  = p^{24} ((p - 1)^2 + 1) + p - 1.
+```
+
+For every integer `p ≥ 2`, `(p - 1)^2 + 1 ≥ 1` and `p - 1 ≥ 1`, so the
+right-hand side is positive. Since `W ≤ p - 1`,
+
+```text
+R ≤ (2 p^{24} - 1)(p - 1) < p^{26}.
+```
+
+For an integer `p`, `p^{48}` is an integer, so `A = p^{48}`. Also
+`p^{48} = p^{26} p^{22}` and `p^{22} ≥ 2^{22} > 1`, hence `p^{48} > p^{26}`.
+The core distance exceeds the agreement radius of #4452. HALO's sentence
+that a row at distance `A` from a section boundary has its polynomial row
+equal to the global row therefore applies to this output. The operator
+bound itself is #4452's, under that package's ideal-gap hypotheses. This
+package does not re-prove it.
+
+At `p = 2` and `W = 1`, the loose radius is `2^{25} + 1`, which is larger
+than `p^{25}`. Exponent 25 is not a uniform agreement distance. Exponent
+26 is, and the core uses 48.
+
+## Not covered
+
+- A proof of the ideal off-sums `1 - 1/(8p^2)`.
+- The global-inverse summand `||P - H^{-1}||` on the same row.
+- The comparison of the Neumann ceiling `U` with `10 p^2`.
+- Editing the #4100 notes. They still use `A = ceil(p^{48})` and
+  `p^{10} exp(-p^2)`.
+- Any new κ.
+
+## Reproduce
+
+```sh
+python3.12 -B scripts/research_package.py --package research/gaussian-core-row --check-only
+python3.12 -B scripts/research_package.py --package research/gaussian-core-row
+```
+
+Base `2a13eb1827784206202db90e5dc8327cf8a250db`, priority revision 7, selection
+refresh κ = `23/10000`.
+
+Overlap on 2026-10-22 (open PRs fetched 2026-10-22T01:31:47Z, 344 records;
+discussions fetched 2026-10-22T01:32:37Z, 3368 records) names this draft, #4452
+and its check #4460, the gauge packages #4438 and #4469, #4482, and the
+locality audit. The audit and discussion comment 19078965 already say
+`A = ceil(p^{48})` clears the written radius with `J = ceil(p^{42})`. #4482
+uses agreement distance `p^{26}` as a core side, not as this row distance.
+No other package compares `ceil(p^{48})` with the lowered radius `p^{26}`.
+A search miss is not a novelty certificate. #4452 is the within-cell error.
+HALO is the core distance.
+
+## Open next questions
+
+1. **Is the within-cell Neumann ceiling `U` at most `10 p^2`?** #4452 proves
+   `8 p^2 < U < p^6` and `U < 16 p^2 - 1`. The tensor chain uses `10 p^2`.
+   The first step is to clear `8(D - 4) ≤ 10(D - 32 p^2)`.
+
+## Credit
+
+- The core distance `A = ceil(p^{48})` and the exact-row sentence are #4100's.
+- The radius `(2 p^{24} - 1) W < p^{26}` and the error `p^6 exp(-p^2)` are #4452's.
+- The polynomial split that consumes this error is #4490.
+
+Prepared by James Reed with substantial Cursor Grok 4.7 assistance. Apache-2.0.

research/gaussian-core-row/SOURCES.json

@@ -0,0 +1,24 @@
+{
+  "schema_version": 1,
+  "base_commit": "2a13eb1827784206202db90e5dc8327cf8a250db",
+  "files": [
+    {
+      "path": "certificates/selected-result.json",
+      "usage": "provenance",
+      "git_blob": "ed33caef5c5827693e9572d252a66f99cbb73d40",
+      "sha256": "5732707cc1e460b090b53f2463162749ad860de878a18f7408938671d295a9d9"
+    },
+    {
+      "path": "docs/research/agent-task-catalog.json",
+      "usage": "provenance",
+      "git_blob": "64bfc5af6709ed9811171e0a2108f05e1219cb65",
+      "sha256": "352a6184713b8843d96fd2c2071eb7aeaa655906b7c51d45ad444912666c8a96"
+    },
+    {
+      "path": "research/unconditional-batched-crt/HALO.md",
+      "usage": "input",
+      "git_blob": "5f601b3c8ac368aa79aa1007effe5933a360237b",
+      "sha256": "a2adcf18614983e9255def6d3f5e59be0018a392e418d65e94323722838289cc"
+    }
+  ]
+}

research/gaussian-core-row/TASK.json

@@ -0,0 +1,74 @@
+{
+  "schema_version": 1,
+  "task_id": "uniform-transfer-audit",
+  "priority_revision": 7,
+  "base_commit": "2a13eb1827784206202db90e5dc8327cf8a250db",
+  "original_card": {
+    "id": "uniform-transfer-audit",
+    "question": "Does one quantified step of the proposed #4100 all-size construction hold at its actual caller?",
+    "starting_points": [
+      "docs/research/research-family-status.md",
+      "certificates/selected-result.json",
+      "research/unconditional-batched-crt/README.md"
+    ],
+    "methods": [
+      "Prove one missing implication with explicit quantified hypotheses.",
+      "Find an exact counterexample at the claimed interface boundary."
+    ],
+    "acceptance_gate": "Identify the proposition and what would change downstream; do not equate a finite replay with a universal proof.",
+    "first_step": {
+      "command": [
+        "python3",
+        "-B",
+        "scripts/research_baseline.py"
+      ],
+      "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY",
+      "inspect": "Read PROOF.md and AUDIT.md in #4100. Select one distinct obligation: CRT total repair, native/free-algebra lifting, precision/conditioning, or complete fixed-tape cost. This is an author-submitted proof, not an accepted unconditional theorem.",
+      "scope": "Source-binding orientation only; no scientific replay, theorem acceptance or supplier admission. Budget any heavy replay separately."
+    },
+    "first_experiment": "Check live handoffs; name one proposition, its caller, quantified domain and dependency closure. Independently prove the implication or exhibit a precise gap/counterexample. Prioritize CRT.md total repair or COMPLEX.md free-algebra lift only if unclaimed. Stop at the chosen obligation; do not substitute finite samples or root arithmetic for an all-size proof, or launch the complete package by default.",
+    "bottleneck_link": "Finite supplier improvements are useful only under the retained transfer obligations.",
+    "allowed_variations": [
+      "One CRT repair, native lift, precision/conditioning or tape-cost proposition, with its exact caller."
+    ],
+    "scope_change_triggers": [
+      "Replacing a quantified obligation with another finite smoke test.",
+      "Treating archive intake, an author PASS receipt or a finite composed fixture as discharge of the universal hypotheses."
+    ],
+    "overlap_terms": [
+      "uniform transfer",
+      "all-size",
+      "precision",
+      "4100",
+      "unconditional-batched-crt"
+    ],
+    "existing_checks": [
+      {
+        "scope": "PR #4100: proposed unconditional construction and finite checks, without independent acceptance.",
+        "evidence": "research/unconditional-batched-crt/README.md",
+        "remaining": "Independent proof audit of one caller-bound all-size implication; all other premises remain explicit.",
+        "status": "author-checked",
+        "source_commit": "337d04939571a637aeab54a0f58f54fde811663a",
+        "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129"
+      }
+    ]
+  },
+  "scope_status": "refined",
+  "actual_scope": "Show that a core row at distance ceil(p^48) lies past the within-cell agreement radius p^26, so the section error p^6 exp(-p^2) applies to that row when the ideal-gap gauge holds.",
+  "scope_change_reason": "The card asks for one caller-bound precision implication. This package only compares the core distance with the agreement radius. It does not prove the ideal gaps or the error bound, and it does not claim a new kappa.",
+  "bottleneck_link": "The selected frontier is unchanged. This is the core-row gauge match left open by the polynomial split.",
+  "budget_minutes": 60,
+  "stop_rule": "Stop once the core distance is compared with the agreement radius. Do not prove the ideal gaps, do not compare U with 10 p^2, do not edit the #4100 notes, and do not claim a new kappa.",
+  "outcome": "completed",
+  "evidence": "python3.12 -B scripts/research_package.py --package research/gaussian-core-row",
+  "author": "James Reed",
+  "ai_assistance": "Substantial help from Cursor Grok 4.7 on the distance comparison and the package text.",
+  "open_questions": [
+    {
+      "question": "Is the within-cell Neumann ceiling U at most 10 p^2?",
+      "why_it_matters": "The tensor hypotheses use 10 p^2, while #4452 only places U between 8 p^2 and p^6.",
+      "first_step": "Clear 8(D - 4) <= 10(D - 32 p^2).",
+      "blocked_by": "U remains conditional on the ideal gaps 1 - 1/(8p^2)."
+    }
+  ]
+}

research/gaussian-core-row/VERIFY.json

@@ -0,0 +1,21 @@
+{
+  "schema_version": 1,
+  "status": "ready",
+  "python": "3.12",
+  "requirements": [],
+  "inputs": [
+    "certificates/selected-result.json",
+    "research/unconditional-batched-crt/HALO.md"
+  ],
+  "commands": [
+    {
+      "argv": [
+        "{python}",
+        "-B",
+        "{package}/verify.py"
+      ],
+      "timeout_seconds": 60,
+      "checks": "The bandwidth gap p^26 - (2 p^24 - 1)(p - 1) equals the factored form and is positive; ceil(p^48) = p^48 exceeds p^26; distance p^25 fails the loose radius at p = 2."
+    }
+  ]
+}

research/gaussian-core-row/verify.py

@@ -0,0 +1,73 @@
+#!/usr/bin/env python3
+"""A core row sits past the within-cell agreement radius.
+
+Every comparison is an integer identity. The ideal-gap gauge stays a hypothesis.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[2]
+PACKAGE = ROOT / "research" / "gaussian-core-row"
+
+
+def digest(path: Path) -> str:
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+
+def radius_gap(prime: int) -> int:
+    return prime**26 - (2 * prime**24 - 1) * (prime - 1)
+
+
+def factored(prime: int) -> int:
+    return prime**24 * ((prime - 1) ** 2 + 1) + (prime - 1)
+
+
+def pins_and_phrases() -> None:
+    sources = json.loads((PACKAGE / "SOURCES.json").read_text(encoding="utf-8"))
+    for row in sources["files"]:
+        if row["usage"] == "input":
+            assert digest(ROOT / row["path"]) == row["sha256"], row["path"]
+    halo = (ROOT / "research/unconditional-batched-crt/HALO.md").read_text(encoding="utf-8")
+    selected = json.loads(
+        (ROOT / "certificates/selected-result.json").read_text(encoding="utf-8")
+    )
+    assert "A=ceil(p^48)" in halo
+    assert "EXACTLY the corresponding row of the global P_i" in halo
+    assert "Keep outputs at distance A" in halo
+    assert "g p^(10g) exp(-p^2)," in halo
+    assert selected["kappa"] == "23/10000"
+
+
+def agreement() -> None:
+    # p^{26} - (2 p^{24} - 1)(p - 1) = p^{24}((p - 1)^2 + 1) + p - 1.
+    assert radius_gap(2) == factored(2)
+    assert radius_gap(3) == factored(3)
+    assert (2 - 1) ** 2 + 1 >= 1
+    assert 2 - 1 >= 1
+    assert factored(2) > 0
+    # Worst bandwidth W = p - 1 still sits strictly below p^{26}.
+    assert (2 * 2**24 - 1) * (2 - 1) < 2**26
+    # Distance p^{25} does not clear the loose radius at p = 2.
+    assert 2 * 2**24 + 1 > 2**25
+
+
+def core_distance() -> None:
+    # For an integer p, ceil(p^{48}) = p^{48}, and p^{48} = p^{26} p^{22}.
+    assert 48 - 26 == 22
+    assert 2**22 > 1
+    assert 2**26 * (2**22 - 1) > 0
+
+
+def main() -> None:
+    pins_and_phrases()
+    agreement()
+    core_distance()
+    print("PASS_GAUSSIAN_CORE_ROW")
+
+
+if __name__ == "__main__":
+    main()