From 57b33fe2b64cde15c783f9d263c5729e935ae880 Mon Sep 17 00:00:00 2001 From: James Reed Date: Wed, 21 Oct 2026 18:44:47 -0700 Subject: [PATCH] Record the Neumann coefficient 9 Co-authored-by: Cursor --- research/gaussian-neumann-nine/README.md | 114 ++++++++++++++++++++ research/gaussian-neumann-nine/SOURCES.json | 24 +++++ research/gaussian-neumann-nine/TASK.json | 74 +++++++++++++ research/gaussian-neumann-nine/VERIFY.json | 21 ++++ research/gaussian-neumann-nine/verify.py | 78 ++++++++++++++ 5 files changed, 311 insertions(+) create mode 100644 research/gaussian-neumann-nine/README.md create mode 100644 research/gaussian-neumann-nine/SOURCES.json create mode 100644 research/gaussian-neumann-nine/TASK.json create mode 100644 research/gaussian-neumann-nine/VERIFY.json create mode 100644 research/gaussian-neumann-nine/verify.py diff --git a/research/gaussian-neumann-nine/README.md b/research/gaussian-neumann-nine/README.md new file mode 100644 index 0000000000..54a8ce117a --- /dev/null +++ b/research/gaussian-neumann-nine/README.md @@ -0,0 +1,114 @@ +# The smallest integer coefficient on the Neumann ceiling is 9 + +**Claim type:** one integer coefficient for the within-cell ceiling. +**No new κ.** The ideal-gap reading stays a hypothesis. The selected record +remains `23/10000`. + +## Question + +#4492 shows `U < 10 p^2` and leaves the smallest integer open. For + +```text +U = 8 p^2 (D - 4) / (D - 32 p^2), D = 2^{32760 p}, +``` + +what is the smallest integer `c` such that `U < c p^2` for every integer +`p ≥ 2`? + +## Lemma + +For every integer `p ≥ 2`, `D > 32 p^2` and + +```text +8 p^2 < U < 9 p^2. +``` + +The smallest such integer is therefore `9`. The same `9 p^2` is strictly +sharper than both upper bounds recorded with this formula: `9 p^2 < 16 p^2 - 1` +and `9 p^2 < p^6`. This comparison is a property of the formula. It becomes +an inverse bound only when the #4452 gauge holds, in which case the Neumann +1-norm and ∞-norm are already strictly below `U`, hence strictly below +`9 p^2`. + +## Proof + +The denominator `D - 32 p^2` is positive once `D > 32 p^2`, which follows +from the stronger estimate below. Cross-multiplying by that positive +denominator, `U < 9 p^2` is equivalent to + +```text +8(D - 4) < 9(D - 32 p^2). +``` + +The difference is + +```text +9(D - 32 p^2) - 8(D - 4) = D - 288 p^2 + 32. +``` + +It is enough to show `D > 288 p^2 - 32`. Since `288 < 512 = 2^9` and +`32 < 288`, the same estimate also gives `D > 32 p^2`. + +For every integer `p ≥ 2`, `2^{2p} ≥ p^2 + 1`, so `p^2 < 2^{2p}`. The base +is `2^4 = 16 ≥ 4 + 1`. If the inequality holds at `p`, then + +```text +2^{2p+2} = 4 · 2^{2p} ≥ 4(p^2 + 1), +``` + +and `4(p^2 + 1) - ((p + 1)^2 + 1) = 3p^2 - 2p + 2`. At `p = 2` this surplus +is 10, and the step to the next integer is `6p + 1 > 0`. Thus +`288 p^2 < 2^9 p^2 < 2^{2p+9}`. + +The remaining exponent gap is `32760 p - (2p + 9) = 32758 p - 9`. At +`p = 2` it equals 65507, and it increases by 32758 when `p` increases by 1. +Therefore `2^{2p+9} < 2^{32760 p} = D`, and `D > 288 p^2 > 288 p^2 - 32`. + +At `p = 2` the same polynomial is `288 · 4 - 32 = 1120 < 2^{13}`, while +`32760 · 2 > 13`. The coefficient 8 reverses the target inequality, because +`U > 8 p^2` exactly when `32 p^2 > 4`. No integer lies strictly between 8 +and 9, and every integer `c ≤ 8` fails because `U > 8 p^2 ≥ c p^2`. + +The two older ceilings lose to 9 by the same integer comparisons. From +`7 p^2 > 1` one has `9 p^2 < 16 p^2 - 1`. From `p^4 ≥ 16 > 9` one has +`9 p^2 < p^6`. + +## Not covered + +- A proof of the ideal gaps that make `U` an inverse bound. +- Replacing `10` by `9` in the tensor absorption or the Schur margin. +- Editing the #4100 notes. They still say `g p^{10 g} exp(-p^2)`. +- Any new κ. + +## Reproduce + +```sh +python3.12 -B scripts/research_package.py --package research/gaussian-neumann-nine --check-only +python3.12 -B scripts/research_package.py --package research/gaussian-neumann-nine +``` + +Base `2a13eb1827784206202db90e5dc8327cf8a250db`, priority revision 7, selection +refresh κ = `23/10000`. Upstream was fetched at 2026-10-22T01:42:53Z and was +still that commit. + +Overlap snapshot: open PRs fetched 2026-10-22T01:43:37Z (346 records) and +discussions fetched 2026-10-22T01:44:21Z (3370 records). A search for `U < 9`, +`9 p^2`, `288 p^2`, `smallest integer c` and `D - 288` returned this draft, +#4492, and its handoff, which leave the coefficient open, plus an unrelated +cyclic-Fourier log ceiling. A search miss is not a novelty certificate. +#4452 is the definition of `U`. HALO is the written error. + +## Open next questions + +1. **Does the #4484 gate absorb `g (9 p^2)^g exp(K p - p^2)`?** That gate + spends four bits because `10 < 16`. The first step is to put `9` in place + of `10` in the exponent `L + 4 g + 2 g L + 2 K p - p^2` and test whether + three bits fail because `9 > 8`. + +## Credit + +- The ceiling `U` and the bounds `8 p^2 < U < p^6` and `U < 16 p^2 - 1` are #4452's. +- The coefficient 10, and this question, are #4492's. +- The tensor use of `10 p^2` is #4484. The Schur margin `1/(10 p^2)` is #4481. + +Prepared by James Reed with substantial Cursor Grok 4.7 assistance. Apache-2.0. diff --git a/research/gaussian-neumann-nine/SOURCES.json b/research/gaussian-neumann-nine/SOURCES.json new file mode 100644 index 0000000000..b6dd82035c --- /dev/null +++ b/research/gaussian-neumann-nine/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" + } + ] +} diff --git a/research/gaussian-neumann-nine/TASK.json b/research/gaussian-neumann-nine/TASK.json new file mode 100644 index 0000000000..04fbc1f533 --- /dev/null +++ b/research/gaussian-neumann-nine/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": "Identify the smallest integer c such that the within-cell Neumann ceiling U = 8 p^2 (D - 4) / (D - 32 p^2), with D = 2^{32760 p}, satisfies U < c p^2 for every integer p >= 2.", + "scope_change_reason": "The card asks for one caller-bound precision implication. This package only identifies that integer coefficient. It does not prove the ideal gaps and does not claim a new kappa.", + "bottleneck_link": "The selected frontier is unchanged. This is the coefficient left open by the comparison with 10 p^2.", + "budget_minutes": 60, + "stop_rule": "Stop once the smallest integer coefficient is identified. Do not retune the tensor absorption, do not prove the ideal gaps, 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-neumann-nine", + "author": "James Reed", + "ai_assistance": "Substantial help from Cursor Grok 4.7 on the coefficient comparison and the package text.", + "open_questions": [ + { + "question": "Does the #4484 gate absorb g (9 p^2)^g exp(K p - p^2)?", + "why_it_matters": "The tensor error still spends four bits on the coefficient 10, while the within-cell formula is now strictly below 9 p^2.", + "first_step": "Put 9 in place of 10 in the exponent L + 4 g + 2 g L + 2 K p - p^2, and test whether three bits fail because 9 > 8.", + "blocked_by": "The reading of a 9 p^2 operator ceiling remains conditional on the ideal gaps. The absorption itself still treats that ceiling as a hypothesis." + } + ] +} diff --git a/research/gaussian-neumann-nine/VERIFY.json b/research/gaussian-neumann-nine/VERIFY.json new file mode 100644 index 0000000000..9239563f9b --- /dev/null +++ b/research/gaussian-neumann-nine/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": "U < 9 p^2 is equivalent to D > 288 p^2 - 32, which holds because 288 p^2 < 2^{2p+9} < 2^{32760 p}; the coefficient 8 fails because 32 p^2 > 4, so 9 is the smallest integer coefficient." + } + ] +} diff --git a/research/gaussian-neumann-nine/verify.py b/research/gaussian-neumann-nine/verify.py new file mode 100644 index 0000000000..ed1565a4a1 --- /dev/null +++ b/research/gaussian-neumann-nine/verify.py @@ -0,0 +1,78 @@ +#!/usr/bin/env python3 +"""The smallest integer coefficient on the Neumann ceiling is 9. + +Every comparison is an integer identity. The ideal-gap reading 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-neumann-nine" + + +def digest(path: Path) -> str: + return hashlib.sha256(path.read_bytes()).hexdigest() + + +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 "g p^(10g) exp(-p^2)," in halo + assert selected["kappa"] == "23/10000" + + +def cleared() -> None: + # 9(D - 32 s) - 8(D - 4) = D - 288 s + 32, with s = p^2. + degree = 7 + square = 3 + gap = 9 * (degree - 32 * square) - 8 * (degree - 4) + assert gap == degree - 288 * square + 32 + # 8 p^2 is not an upper bound, and the next integer is 9. + assert 32 * 4 > 4 + assert 8 + 1 == 9 + assert 32 < 288 + assert 288 < 2**9 + assert 2**9 == 512 + # 9 p^2 is sharper than both ceilings recorded with U. + assert 7 * 4 > 1 + assert 9 * 4 < 16 * 4 - 1 + assert 16 > 9 + assert 9 * 4 < 2**6 + + +def powers() -> None: + # 2^{2p} >= p^2 + 1, so p^2 < 2^{2p}. The step surplus is 3p^2 - 2p + 2. + assert 2**4 >= 2**2 + 1 + assert 4 * (2**2 + 1) - ((2 + 1) ** 2 + 1) == 3 * 2**2 - 2 * 2 + 2 + assert (3 * 3**2 - 2 * 3 + 2) - (3 * 2**2 - 2 * 2 + 2) == 6 * 2 + 1 + # 288 p^2 < 2^{2p+9} < 2^{32760 p}, since the exponent gap is 32758 p - 9. + assert 2**9 * 2 ** (2 * 2) == 2 ** (2 * 2 + 9) + assert 32760 * 2 > 2 * 2 + 9 + assert 32758 * 2 - 9 == 65507 + assert 65507 > 0 + assert (32758 * 3 - 9) - (32758 * 2 - 9) == 32758 + # At p = 2 the polynomial 288 p^2 - 32 is below 2^{13}. + assert 288 * 2**2 - 32 == 1120 + assert 2**13 > 1120 + assert 32760 * 2 > 13 + + +def main() -> None: + pins_and_phrases() + cleared() + powers() + print("PASS_GAUSSIAN_NEUMANN_NINE") + + +if __name__ == "__main__": + main()