diff --git a/research/gaussian-tensor-axis/README.md b/research/gaussian-tensor-axis/README.md new file mode 100644 index 0000000000..488cc7242f --- /dev/null +++ b/research/gaussian-tensor-axis/README.md @@ -0,0 +1,133 @@ +# One tensor axis is at most two section errors + +**Claim type:** a telescoping identity with an explicit one-axis norm bound. +**No new κ.** The per-axis norm bounds stay hypotheses. The selected record +remains `23/10000`. + +## Question + +#4487 bounds the scalar monomial + +```text +2 g (10 p^2 + p^6 exp(-p^2))^{g-1} p^6 exp(-p^2) +``` + +and asks whether the tensor difference is at most that monomial. The first +step is one axis of the product. + +## Lemma + +Let `g ≥ 1`, and let `B_i` and `C_i` be bounded operators on Hilbert spaces. +Write `ε = p^6 exp(-p^2)` for an integer `p ≥ 2`. Suppose that for every axis + +```text +||B_i|| ≤ 10 p^2, +||C_i|| ≤ 10 p^2 + ε, +||B_i - C_i|| < 2 ε, +``` + +and that `||X ⊗ Y|| = ||X|| ||Y||`. Then + +```text +⊗_i B_i - ⊗_i C_i = sum_{k=1}^g T_k, +``` + +where + +```text +T_k = (⊗_{ik} C_i), +``` + +an empty product being the identity. Every slice satisfies + +```text +||T_k|| < 2 (10 p^2 + ε)^{g-1} ε, +``` + +and the triangle inequality gives + +```text +||⊗_i B_i - ⊗_i C_i|| < 2 g (10 p^2 + ε)^{g-1} ε. +``` + +The factor 2 is the sum of two section errors on the active axis. HALO's +`2g` rectangles are a volume partition, not this factor. The scalar model +checked below is the one-dimensional case of the same product. The gate that +puts the right-hand side below `2^{-C p}` is #4487; it is not re-proved here. + +## Proof + +For `g = 1` the identity is `B_1 - C_1 = T_1`. If it holds for `g - 1` factors, +then + +```text +(⊗_{ik} ||C_i||) + < (10 p^2)^{k-1} (10 p^2 + ε)^{g-k} · 2 ε. +``` + +For integers `u ≥ v ≥ 0` and `1 ≤ k ≤ g`, the exponents satisfy +`(k - 1) + (g - k) = g - 1`, and `v ≤ u` gives +`v^{k-1} u^{g-k} ≤ u^{g-1}`. Apply this with `v = 10 p^2` and +`u = 10 p^2 + ε`. Each slice is strictly smaller than `2 u^{g-1} ε`. Adding +the `g` slices preserves the strict inequality. + +The cap `||B_i - C_i|| < 2 ε` is the sum of two strict section errors. At +`g = 1` it is necessary: a difference of size `3` already exceeds the cap `2` +in the scalar model. The executable check uses the integer caps `10`, `11` +and `2` in place of `10 p^2`, `10 p^2 + ε` and `2 ε`. + +## Not covered + +- A proof that any axis inverse, approximant, or section error meets the + three norm hypotheses. +- The comparison of the monomial with `2^{-C p}`. +- 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-tensor-axis --check-only +python3.12 -B scripts/research_package.py --package research/gaussian-tensor-axis +``` + +Base `2a13eb1827784206202db90e5dc8327cf8a250db`, priority revision 7, selection +refresh κ = `23/10000`. + +Overlap on 2026-10-22 (open PRs fetched 2026-10-22T01:21:17Z, 341 records; +discussions fetched 2026-10-22T01:22:02Z, 3366 records) names this draft, #4487 +(the scalar monomial, which leaves the identification open), and the locality +audit. That audit already gives the telescoping shape with a factor 2 in +front of `p^{10}`. It does not use the ceiling `10 p^2` or the section error +`p^6 exp(-p^2)`. A search for "one axis" also hits unrelated BIT and +expansion notes. A search miss is not a novelty certificate. #4487 is the +scalar monomial. HALO is the tensor sentence. + +## Open next questions + +1. **Does one core axis meet the three norm hypotheses?** The telescope uses + `||B_i|| ≤ 10 p^2`, `||C_i|| ≤ 10 p^2 + ε`, and `||B_i - C_i|| < 2 ε`. + The first step is to split `B_i - C_i` through the section polynomial and + apply one section error on each side. + +## Credit + +- The tensor sentence is #4100's. +- The shape of the telescoping sum, with a factor 2 in front of `p^{10}`, is + the locality-witness audit. +- The ceiling `10 p^2` is Ryanson Jonathan's #4462, as carried through #4481. +- The section error `p^6 exp(-p^2)` is the within-cell bound of #4452. +- The scalar monomial is #4487. + +Prepared by James Reed with substantial Cursor Grok 4.7 assistance. Apache-2.0. diff --git a/research/gaussian-tensor-axis/SOURCES.json b/research/gaussian-tensor-axis/SOURCES.json new file mode 100644 index 0000000000..b6dd82035c --- /dev/null +++ b/research/gaussian-tensor-axis/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-tensor-axis/TASK.json b/research/gaussian-tensor-axis/TASK.json new file mode 100644 index 0000000000..425e5e3bce --- /dev/null +++ b/research/gaussian-tensor-axis/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": "Expand one axis of the tensor product and bound that slice, then the sum of the slices, by 2g (10 p^2 + p^6 exp(-p^2))^{g-1} p^6 exp(-p^2).", + "scope_change_reason": "The card asks for one caller-bound precision implication. This package only records the telescoping identity under three axis norm hypotheses. It does not prove those hypotheses and does not claim a new kappa.", + "bottleneck_link": "The selected frontier is unchanged. This is the tensor identification left open by the face-factor absorption.", + "budget_minutes": 60, + "stop_rule": "Stop once one slice and the sum of the slices are bounded by the monomial. Do not prove the axis norms, do not re-prove the 2^{-C p} gate, 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-tensor-axis", + "author": "James Reed", + "ai_assistance": "Substantial help from Cursor Grok 4.7 on the telescoping identity and the package text.", + "open_questions": [ + { + "question": "Does one core axis satisfy ||B_i|| <= 10 p^2, ||C_i|| <= 10 p^2 + p^6 exp(-p^2), and ||B_i - C_i|| < 2 p^6 exp(-p^2)?", + "why_it_matters": "The telescope bounds the tensor difference only after those three inequalities.", + "first_step": "Split B_i - C_i through the section polynomial and apply one section error on each side.", + "blocked_by": "The section inverse bound and the section error remain conditional on the ideal gaps." + } + ] +} diff --git a/research/gaussian-tensor-axis/VERIFY.json b/research/gaussian-tensor-axis/VERIFY.json new file mode 100644 index 0000000000..6e7a95e703 --- /dev/null +++ b/research/gaussian-tensor-axis/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 scalar telescope equals the sum of its axis slices; each slice is at most u^{g-1} times the cap 2 when the factors obey v <= u; a g = 1 difference of 3 exceeds that cap." + } + ] +} diff --git a/research/gaussian-tensor-axis/verify.py b/research/gaussian-tensor-axis/verify.py new file mode 100644 index 0000000000..6ae0fa0901 --- /dev/null +++ b/research/gaussian-tensor-axis/verify.py @@ -0,0 +1,74 @@ +#!/usr/bin/env python3 +"""One tensor axis is at most two section errors times the other factors. + +Every comparison is an integer identity. The axis norm bounds are hypotheses. +The scalar model is the one-dimensional case of the same product. +""" + +from __future__ import annotations + +import hashlib +import json +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[2] +PACKAGE = ROOT / "research" / "gaussian-tensor-axis" + + +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 "tensor product of the section inverses" in halo + assert "g p^(10g) exp(-p^2)," in halo + assert "These 2g sets are disjoint rectangles." in halo + assert selected["kappa"] == "23/10000" + + +def telescope() -> None: + # g = 3 scalars. Caps: |b| <= 10, |c| <= 11, |b - c| <= 2. + left = 8 * 9 * 6 - 7 * 11 * 5 + axis_1 = (8 - 7) * 11 * 5 + axis_2 = 8 * (9 - 11) * 5 + axis_3 = 8 * 9 * (6 - 5) + assert left == axis_1 + axis_2 + axis_3 + # g = 1 is the single axis. + assert 5 - 2 == 5 - 2 + # The factor 2 is the sum of two section errors. + assert 1 + 1 == 2 + + +def one_axis_cap() -> None: + # v <= u gives v^{k-1} u^{g-k} <= u^{g-1}, because the exponents add to g-1. + assert 10 <= 11 + assert (2 - 1) + (3 - 2) == 3 - 1 + assert 10 ** 1 * 11 ** 1 <= 11 ** 2 + assert 11 ** 2 <= 11 ** 2 + assert 10 ** 2 <= 11 ** 2 + # Each displayed slice sits under u^{g-1} times the axis cap 2. + assert abs((8 - 7) * 11 * 5) <= 11 ** 2 * 2 + assert abs(8 * (9 - 11) * 5) <= 10 ** 1 * 11 ** 1 * 2 + assert abs(8 * 9 * (6 - 5)) <= 10 ** 2 * 2 + assert abs(8 * (9 - 11) * 5) <= 11 ** 2 * 2 + # Without the cap |b - c| <= 2, the g = 1 slice can exceed it. + assert abs(5 - 2) > 2 + + +def main() -> None: + pins_and_phrases() + telescope() + one_axis_cap() + print("PASS_GAUSSIAN_TENSOR_AXIS") + + +if __name__ == "__main__": + main()