diff --git a/research/gaussian-delta-exponents/README.md b/research/gaussian-delta-exponents/README.md new file mode 100644 index 0000000000..6e5f1cc5b7 --- /dev/null +++ b/research/gaussian-delta-exponents/README.md @@ -0,0 +1,161 @@ +# The published weight error lowers four halo exponents inside one cell + +**Claim type:** conditional exponent arithmetic for one within-cell block. +**No new κ.** The ideal gaps stay hypotheses. The selected record remains +`23/10000`. + +## Question + +#4451 showed that the published absolute weight error is a relative error +below `δ = 2^{2-32760p}`, which is stronger than `1/(16p^2)`. Do the +exponents 12, 26, 28, 28 and 6 still apply inside one cell, and is +`16p^2-1` still the inverse ceiling? + +## Lemma + +Let `p ≥ 2` be an integer and let `W` be an integer at most `p-1`. Assume +each ideal row off-sum and each ideal column off-sum is at most +`1 - 1/(8p^2)`. Inside the cell, assume `0 ≤ Ghat ≤ G` and +`a - 4η < ahat ≤ a` whenever `a > 2^{-8p}`, with `P = 32768p` and +`η = 2^{-P}`. + +Let `D = 2^{32760 p}` and + +```text +U = 8 p^2 (D - 4) / (D - 32 p^2). +``` + +Then both rounded off-sums are strictly below `(1 - 1/(8p^2)) / (1 - δ)`, +every absolute row sum and column sum is strictly below 2, and the Neumann +bounds on `||A^{-1}||_1` and `||A^{-1}||_∞` are strictly less than `U`. In +particular `8 p^2 < U < p^6` and `U < 16 p^2 - 1`. At `p = 2`, `U > 32 = p^5`. + +For this block the polynomial + +```text +P = p^{-11} sum_{j < p^{24}} Q^j A^*, Q = I - p^{-11} A^* A, +``` + +satisfies `||P - A^{-1}||_2 < p^6 exp(-p^2)`. Its bandwidth is at most +`(2 p^{24} - 1) W < p^{26}`, and the looser count `(2 p^{24} + 1) W` has +the same ceiling. A row at distance `p^{26}` from a section edge agrees +with the block row. + +So 12, 26, 28, 28 and 6 still apply. The normalizer 6 remains the smallest +uniform integer with that role. The other four are no longer smallest: +11, 24, 26 and 26 replace them. The value `16p^2-1` still upper-bounds the +inverse, and it is strictly larger than `U`. + +## Proof + +The denominator repair gives `a / ahat < 1/(1-δ)` with +`δ = 4/D = 2^{2-32760p}`, because `4η < 2^{-8p}` is the exponent identity +`32768 - 8 = 32760`. A downward kernel does not increase the entry. An +ideal off-sum at most `1 - 1/(8p^2)` therefore rounds to an off-sum +strictly below + +```text +(1 - 1/(8p^2)) / (1 - δ) = (D / (D - 4)) (1 - 1/(8p^2)). +``` + +The complementary gap is strictly larger than `(1/(8p^2) - δ) / (1 - δ)`, +so the Neumann bound is strictly less than `U`. Since `D > 32 p^2`, the +rounded off-sum is also strictly below 1, and both matrix norms that enter +the 2-norm comparison are strictly below 2. + +For every integer `p ≥ 2`, `2^{2p} ≥ p^2 + 1`. The base is `16 ≥ 5`. The +step is `4(p^2 + 1) - (p + 1)^2 = 3p^2 - 2p + 3`, and after `p = 2 + t` +every coefficient of that quadratic is positive. Also `2p + 6 ≤ 32760 p`: +at `p = 2` the numbers are `10 ≤ 65520`, and the slack increases by +`32758`. Therefore `D ≥ 2^{2p+6} = 64 · 2^{2p} ≥ 64(p^2 + 1)`. + +Clearing the positive denominator shows `U > 8 p^2` exactly when +`32 p^2 > 4`. At `p = 2` that lower bound is `32 = p^5`, so `U > p^5` and +`U^2 > (8p^2)^2 = p^{10}`. The same clearing gives `U < p^6` once +`32(p^6 - 1) < D(p^4 - 8)`. At `p = 2` this is `2016 < 8 D` with +`D ≥ 2^{16}`. For `p ≥ 3`, the comparison +`64(p^2 + 1)(p^4 - 8) - 32(p^6 - 1)` equals `32(p^6 + 2p^4 - 16p^2 - 15)`. +After `p = 3 + t` every coefficient is positive, and `p^4 ≥ 81 > 16`. + +The looser multiple `V = 8 p^2 D / (D - 32 p^2)` satisfies `U < V`. Then +`V^2 < p^{11}` once `64 D^2 < p^7 (D - 32 p^2)^2`. At `p = 2` this is +`D^2 < 2(D - 128)^2`, and `D^2 - 512 D + 32768` is positive for +`D ≥ 2^{16}` because `2^{32} > 2^{25}`. For `p ≥ 3`, `32 p^2/D < 1/2`, so +the squared factor exceeds `1/4` and `p^7/4 ≥ 2187/4 > 64`. Thus +`U^2 < p^{11}`. The eigenvalues of `A^* A` are strictly larger than +`p^{-11}` and strictly smaller than `4`. Since `4 < p^{11}`, they are +strictly smaller than `p^{11}`. The matrix `Q = I - p^{-11} A^* A` has +spectrum in `[0, 1 - p^{-22})`. The length `p^{24}` contributes `p^2`. +The length `p^{23}` contributes only `p`. The scalar step is strict +because `1/2! < 1`. + +The bandwidth identity is + +```text +p^{26} - (2 p^{24} - 1)(p - 1) = p^{24} ((p - 1)^2 + 1) + p - 1 > 0. +``` + +At `p = 2` the loose radius `(2 p^{24} + 1) W` equals `p^{25} + 1`. For +every integer `p ≥ 3`, +`(2 p^{24} - 1)(p - 1) - p^{25} = p^{24}(p - 2) - (p - 1)`, and +`p^2 - (p - 1) = p^2 - p + 1 > 0`, so the sharp radius exceeds `p^{25}`. +Exponent 25 is not a uniform ceiling. Exponent 26 is, for the bandwidth +and for the agreement distance. + +Finally `V < 16 p^2 - 1`. The cleared difference +`2(8p^2 - 1)(p^2 + 1) - p^2(16p^2 - 1)` equals `15p^2 - 2`, which is +positive for every integer `p ≥ 2`. Combined with `D ≥ 64(p^2 + 1)`, this +is `(8p^2 - 1) D > 32 p^2 (16p^2 - 1)`. At `p = 2` the same comparison is +`31 D > 8064`. The older ceiling remains legal and is strictly coarser +than `U`. + +| Role | Under `1/(16p^2)` | Under `δ` | Smallest | +| --- | ---: | ---: | --- | +| Spectral endpoint | 12 | 11 | 10 fails at `p=2` | +| Series length | 26 | 24 | 23 fails at `p=2` | +| Bandwidth | 28 | 26 | 25 fails | +| Agreement distance | 28 | 26 | 25 fails | +| Normalizer | 6 | 6 | 5 fails at `p=2` | + +## Not covered + +- Across-cell entries. #4449 gives `0 ≤ H ≤ n` for those entries. This + package does not move the global reference. +- A proof that the ideal gaps exceed `1/(8p^2)` for every prime. +- The core exponent 400. It still dominates an agreement distance of 26. +- Any new κ. The #4100 notes keep 20, 42, 45, 48 and 100. + +## Reproduce + +```sh +python3.12 -B scripts/research_package.py --package research/gaussian-delta-exponents --check-only +python3.12 -B scripts/research_package.py --package research/gaussian-delta-exponents +``` + +Base `2a13eb1827784206202db90e5dc8327cf8a250db`, priority revision 7, selection +refresh κ = `23/10000`. + +Overlap on 2026-10-21, using the snapshot fetched at 21:26 UTC and a +later look at the newest handoff comments and open pull requests, matched +this draft, PR #4451, and an unrelated digit string in +`research/capped-fusion-t74-k554`. It did not find another assignment of +11, 24, 26, 26 and 6. #4451 is the relative-error comparison. #4439 is the +coarser budget `1/(16p^2)`. A search miss is not a novelty certificate. + +## Open next questions + +1. **Do 11, 24, 26, 26 and 6 survive across a cell?** #4449 puts each + across-cell entry in `[0, n]`, with absolute error below `4η`. The + within-cell factor is now `1/(1-δ)`. The first step is the same column + split as #4442, with `δ` in place of `1/(16p^2)`. + +## Credit + +- HALO's locality witness and its written exponents are #4100's. +- The sharp radius `(2J-1)W` is Nick Petalas's halo audit, PR #4217. +- The in-cell ideal column gap is Ryanson Jonathan's #4402. +- The relative budget `1/(16p^2)` is #4438. The coarser exponents are #4439. +- The published error `δ = 2^{2-32760p}` is #4451. +- The across-cell repair `0 ≤ H ≤ n` is Mihir S's #4449. + +Prepared by James Reed with substantial Cursor Grok 4.7 assistance. Apache-2.0. diff --git a/research/gaussian-delta-exponents/SOURCES.json b/research/gaussian-delta-exponents/SOURCES.json new file mode 100644 index 0000000000..3c6d0c33f8 --- /dev/null +++ b/research/gaussian-delta-exponents/SOURCES.json @@ -0,0 +1,48 @@ +{ + "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": "references/semantic-bulk/rad20/reports/downstream-phase-cell-inverse.md", + "usage": "input", + "git_blob": "d72345a0aa748443c4efcddf87aa10d524664841", + "sha256": "3cdf492bcb719db4295658604dc202d6a2c5a008b87de43ec54f0107c64db730" + }, + { + "path": "research/capped-phase-fusion/LOG-A-PHASE-SCHUR-AUDIT.md", + "usage": "input", + "git_blob": "3bcf490a8c164d44aff5b7e2ec2e0f4bf07d7a73", + "sha256": "e05d6b8596c80b6e8676569a0ff464a29fa704c3304143f58914f47cdf38b272" + }, + { + "path": "research/gaussian-column-gap/README.md", + "usage": "input", + "git_blob": "7f8b5d9cbad96a1cd46432a6cf47422e2ced7fb4", + "sha256": "7e589bec5c03d788ac366c85080af9fe26dad254d289bec93553398380b46dab" + }, + { + "path": "research/unconditional-batched-crt/GAUSSIAN.md", + "usage": "input", + "git_blob": "adfb28c93e6b06178c901caaac39ede41a9e541b", + "sha256": "2f63c91c58f2d1cf31294812c75970ea390c61866a8da7ed700d4316a033a242" + }, + { + "path": "research/unconditional-batched-crt/HALO.md", + "usage": "input", + "git_blob": "5f601b3c8ac368aa79aa1007effe5933a360237b", + "sha256": "a2adcf18614983e9255def6d3f5e59be0018a392e418d65e94323722838289cc" + } + ] +} diff --git a/research/gaussian-delta-exponents/TASK.json b/research/gaussian-delta-exponents/TASK.json new file mode 100644 index 0000000000..04efecc2ab --- /dev/null +++ b/research/gaussian-delta-exponents/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": "Decide whether the within-cell halo exponents fall from 12, 26, 28, 28 and 6 to 11, 24, 26, 26 and 6 once the relative budget is the published \u03b4 = 2^{2-32760p}.", + "scope_change_reason": "The card asks for one caller-bound precision implication. This package only substitutes the published weight error into the within-cell ceiling. Across-cell transfer stays open, and this package does not claim a new kappa.", + "bottleneck_link": "The selected frontier is unchanged. A smaller within-cell inverse ceiling is the input to the halo polynomial, still under the eventual ideal-gap hypothesis.", + "budget_minutes": 60, + "stop_rule": "Stop once 11, 24, 26, 26 and 6 are compared with the \u03b4 ceiling. Do not transfer them across a cell, 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-delta-exponents", + "author": "James Reed", + "ai_assistance": "Substantial help from Cursor Grok 4.7 on the exponent comparison and the package text.", + "open_questions": [ + { + "question": "Do 11, 24, 26, 26 and 6 survive across a cell for every integer p \u2265 2, using the published absolute error below 4\u03b7 together with 0 \u2264 H \u2264 n?", + "why_it_matters": "The within-cell ceiling is now U, which is stricter than 16p^2-1. The across-cell block still uses the coarser budget.", + "first_step": "Repeat the column split from #4442 with \u03b4 in place of 1/(16p^2).", + "blocked_by": "The ideal gaps 1/(8p^2) remain eventual statements, so both ceilings still depend on them." + } + ] +} diff --git a/research/gaussian-delta-exponents/VERIFY.json b/research/gaussian-delta-exponents/VERIFY.json new file mode 100644 index 0000000000..940c4e5a94 --- /dev/null +++ b/research/gaussian-delta-exponents/VERIFY.json @@ -0,0 +1,25 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "certificates/selected-result.json", + "references/semantic-bulk/rad20/reports/downstream-phase-cell-inverse.md", + "research/capped-phase-fusion/LOG-A-PHASE-SCHUR-AUDIT.md", + "research/gaussian-column-gap/README.md", + "research/unconditional-batched-crt/GAUSSIAN.md", + "research/unconditional-batched-crt/HALO.md" + ], + "commands": [ + { + "argv": [ + "{python}", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 60, + "checks": "Under the ideal-gap hypothesis the Neumann ceiling is strictly below p^6 and its square is strictly below p^11, so 11, 24, 26, 26 and 6 apply; 10, 23, 25 and 5 fail." + } + ] +} diff --git a/research/gaussian-delta-exponents/verify.py b/research/gaussian-delta-exponents/verify.py new file mode 100644 index 0000000000..017ba68a08 --- /dev/null +++ b/research/gaussian-delta-exponents/verify.py @@ -0,0 +1,208 @@ +#!/usr/bin/env python3 +"""Halo exponents under the published weight error δ = 2^{2-32760 p}. + +Every comparison is an integer identity. The ideal gaps are hypotheses. +""" + +from __future__ import annotations + +import hashlib +import json +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[2] +PACKAGE = ROOT / "research" / "gaussian-delta-exponents" + + +def digest(path: Path) -> str: + return hashlib.sha256(path.read_bytes()).hexdigest() + + +def add(left, right): + out = dict(left) + for key, coeff in right.items(): + out[key] = out.get(key, 0) + coeff + if out[key] == 0: + del out[key] + return out + + +def scale(poly, factor): + return {key: factor * coeff for key, coeff in poly.items() if factor * coeff} + + +def mul(left, right): + out = {} + for degree, coeff in left.items(): + for other, factor in right.items(): + key = degree + other + out[key] = out.get(key, 0) + coeff * factor + return {key: coeff for key, coeff in out.items() if coeff} + + +def shift(poly, origin): + degree = max(poly) + choose = [[0] * (degree + 1) for _ in range(degree + 1)] + for row in range(degree + 1): + choose[row][0] = 1 + for col in range(1, row + 1): + choose[row][col] = choose[row - 1][col - 1] + choose[row - 1][col] + out = {} + for power, coeff in poly.items(): + for index in range(power + 1): + key = index + out[key] = out.get(key, 0) + coeff * choose[power][index] * origin ** (power - index) + return {key: coeff for key, coeff in out.items() if coeff} + + +def evaluate(poly, point): + total = 0 + for power in range(max(poly), -1, -1): + total = total * point + poly.get(power, 0) + return total + + +def positive_on_ray(poly, origin): + moved = shift(poly, origin) + assert set(moved) == set(range(max(poly) + 1)) + assert all(coeff > 0 for coeff in moved.values()) + for point in range(origin, origin + max(poly) + 1): + assert evaluate(poly, point) == evaluate(moved, point - origin) + assert evaluate(poly, point) > 0 + + +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" + ) + gaussian = ( + ROOT / "research/unconditional-batched-crt/GAUSSIAN.md" + ).read_text(encoding="utf-8") + column = (ROOT / "research/gaussian-column-gap/README.md").read_text( + encoding="utf-8" + ) + downstream = ( + ROOT / "references/semantic-bulk/rad20/reports/downstream-phase-cell-inverse.md" + ).read_text(encoding="utf-8") + log_a = ( + ROOT / "research/capped-phase-fusion/LOG-A-PHASE-SCHUR-AUDIT.md" + ).read_text(encoding="utf-8") + selected = json.loads( + (ROOT / "certificates/selected-result.json").read_text(encoding="utf-8") + ) + assert "2-norm at most p^10 and inverse\n2-norm at most p^10" in halo + assert "Q_i=I-p^-20 H_i^* H_i and J=ceil(p^42)" in halo + assert "bandwidth <=(2J+1)W None: + # 4η < 2^{-8p} is the exponent identity 32768 - 8 = 32760. + assert 32768 - 8 == 32760 + # Integer induction: 2^{2p} >= p^2 + 1. The step clears to 3p^2 - 2p + 3. + square = {2: 1} + successor = mul({1: 1, 0: 1}, {1: 1, 0: 1}) + gap = add(scale(add(square, {0: 1}), 4), scale(successor, -1)) + assert gap == {2: 3, 1: -2, 0: 3} + assert 2 ** (2 * 2) >= 2 ** 2 + 1 + positive_on_ray(gap, 2) + # 2p + 6 <= 32760 p, so D = 2^{32760 p} >= 2^{2p+6} = 64 * 2^{2p}. + assert 2 * 2 + 6 <= 32760 * 2 + assert 32760 - 2 > 0 + assert 2 ** (2 * 2 + 6) == 64 * (2 ** (2 * 2)) + # At p = 2 the same floor is visible directly: D >= 2^{16} > 64 p^2. + assert 2 ** 16 > 64 * 4 + assert 2 ** 16 > 252 + + +def ceiling() -> None: + # U > 8p^2 exactly when 32p^2 > 4. At p = 2 this floor is p^5, and its square is p^{10}. + assert 8 * 4 == 32 + assert 2 ** 5 == 32 + assert 32 * 4 > 4 + assert 64 * 16 == 1024 + assert 2 ** 10 == 1024 + assert 32 < 64 + assert 2 ** 6 == 64 + # U < p^6 at p = 2: 32(p^6 - 1) = 2016 < 8 D. + assert 32 * (64 - 1) == 2016 + assert 2016 < 8 * 2 ** 16 + # For p >= 3, 64(p^2+1)(p^4-8) - 32(p^6-1) has every coefficient positive after p = 3 + t. + sixth = {6: 1} + fourth = {4: 1} + room = add( + scale(mul(add({2: 1}, {0: 1}), add(fourth, {0: -8})), 64), + scale(add(sixth, {0: -1}), -32), + ) + reduced = scale({6: 1, 4: 2, 2: -16, 0: -15}, 32) + assert room == reduced + positive_on_ray({6: 1, 4: 2, 2: -16, 0: -15}, 3) + assert 3 ** 4 > 16 + # V^2 < p^{11}. At p = 2 the quadratic D^2 - 512 D + 32768 is positive for D >= 2^{16}. + assert 2 ** 32 > 512 * 2 ** 16 + assert 3 ** 7 > 256 + assert 3 ** 7 // 4 > 64 + # Eigenvalues of A*A stay below 4 < p^{11}. The scalar series step uses 1/2! < 1. + assert 4 < 2 ** 11 + assert 2 ** 11 == 2048 + assert 1 < 2 + # V < 16p^2 - 1 clears to 15p^2 - 2, positive for every integer p >= 2. + linear = {2: 8, 0: -1} + sixteen = {2: 16, 0: -1} + coarse = add( + scale(mul(linear, add({2: 1}, {0: 1})), 2), + scale(mul({2: 1}, sixteen), -1), + ) + assert coarse == {2: 15, 0: -2} + positive_on_ray(coarse, 2) + assert 16 * 4 - 1 == 63 + assert 63 > 32 + assert 128 * 63 == 8064 + assert 31 * 2 ** 16 > 8064 + + +def exponents() -> None: + quadratic = add(mul({1: 1, 0: -1}, {1: 1, 0: -1}), {0: 1}) + assert quadratic == {2: 1, 1: -2, 0: 2} + factored = add(mul({24: 1}, quadratic), {1: 1, 0: -1}) + sharp = mul({24: 2, 0: -1}, {1: 1, 0: -1}) + margin = add({26: 1}, scale(sharp, -1)) + assert factored == margin + assert margin == {26: 1, 25: -2, 24: 2, 1: 1, 0: -1} + assert 24 - 22 == 2 + assert 23 - 22 == 1 + assert 12 - 10 == 2 + # Exponent 25 fails. The p = 2 loose radius is p^{25} + 1. + assert 2 * (2 ** 24) + 1 == 2 ** 25 + 1 + assert 2 ** 25 + 1 > 2 ** 25 + assert (2 * (3 ** 24) - 1) * (3 - 1) > 3 ** 25 + # For p >= 3 the sharp radius exceeds p^{25} once p^2 > p - 1. + assert {2: 1, 1: -1, 0: 1} == add(add({2: 1}, {1: -1}), {0: 1}) + positive_on_ray({2: 1, 1: -1, 0: 1}, 3) + + +def main() -> None: + pins_and_phrases() + power_room() + ceiling() + exponents() + print("PASS_GAUSSIAN_DELTA_EXPONENTS") + + +if __name__ == "__main__": + main()