From ea3a415b56c321a8a18bea2e75d0ed1491f482b9 Mon Sep 17 00:00:00 2001 From: Claude Date: Thu, 1 Oct 2026 01:38:52 +0000 Subject: [PATCH 1/5] Add the C8 window coefficient in d = 4: reference value and torus transfer The birth window of [LP] (11.3) in d = 4 enters only through the total trace of the transverse Hessian: with f ~ N(0, 2/3) and A = Q - f I, the b-integral over B is exact and leaves W_B(T) = Phi(sqrt3 (b_+ - T/6)) - Phi(sqrt3 (b_- - T/6)). The sector integrand is odd in the innermost difference, so the q- and s-layers are elementary (F_3 in closed form), and I^ref_B = (1/(96 pi)) int_0^inf e^{-T^2/24} F_3(T) W_B(T) dT is certified by Taylor quadrature with Cauchy remainders. The full window reproduces Math-#201's D_3, and the same code at m = 2 reproduces 29/6 - sqrt6 and Math-#197's d = 3 window values. The torus transfer is Lemma S of Math-#205 with n = 7 and degree 6. The eigenvalue floor of C'_ref is (7 - sqrt37)/3 < 1/3, so the floor is certified as 3/10. The d = 4 image bound is E^(4)_L = 10240 (76 L^6 + 15) e^{-L^2/2}, giving eps(L >= 10) <= 8.27e-9. On the C8 band the reference value is c^(4) = 0.000241816107038247274210322215843921349422155120948..., and every L >= 10 and every frame lies in [0.00024181608774072626, 0.00024181612633576979]. Eighteen rules, eleven mutants, both interpreter modes byte-identical. Scientific effect NONE; C8 stays OPEN; no register surface is touched. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_017Mi3hxjaxV45x6zo6o1ee3 --- .../workflows/c8-window-coefficient-d4.yml | 79 + .../c8_window_coefficient_d4_20261001/NOTE.md | 319 ++++ .../RESULTS.json | 684 +++++++++ .../SOURCE_FILES.json | 85 ++ .../window_coefficient_d4.py | 1292 +++++++++++++++++ 5 files changed, 2459 insertions(+) create mode 100644 .github/workflows/c8-window-coefficient-d4.yml create mode 100644 frontiers/c8_window_coefficient_d4_20261001/NOTE.md create mode 100644 frontiers/c8_window_coefficient_d4_20261001/RESULTS.json create mode 100644 frontiers/c8_window_coefficient_d4_20261001/SOURCE_FILES.json create mode 100644 frontiers/c8_window_coefficient_d4_20261001/window_coefficient_d4.py diff --git a/.github/workflows/c8-window-coefficient-d4.yml b/.github/workflows/c8-window-coefficient-d4.yml new file mode 100644 index 000000000..4d18f5a53 --- /dev/null +++ b/.github/workflows/c8-window-coefficient-d4.yml @@ -0,0 +1,79 @@ +name: C8 window coefficient d4 + +'on': + pull_request: + paths: + - 'frontiers/c8_window_coefficient_d4_20261001/**' + - '.github/workflows/c8-window-coefficient-d4.yml' + - 'imports/lifetime_parent_20260925/UNIFORM_MATRIX_CAP_AND_LIFETIME.md' + - 'coefficients/side24_v1/PROOF.md' + workflow_dispatch: + +permissions: + contents: read + +jobs: + certify-and-reject-mutants: + runs-on: ubuntu-latest + timeout-minutes: 60 + steps: + - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 + with: + persist-credentials: false + - uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 + with: + python-version: '3.11.16' + - name: Verify sources and pins, replay both modes, reject mutants + env: + PYTHONDONTWRITEBYTECODE: '1' + run: | + set -euo pipefail + python -B -S - <<'PY' + import concurrent.futures, hashlib, json, pathlib, subprocess, sys + root = pathlib.Path('frontiers/c8_window_coefficient_d4_20261001').resolve() + manifest_doc = json.loads((root / 'SOURCE_FILES.json').read_text()) + manifest = manifest_doc['files'] + present = sorted(p.name for p in root.iterdir()) + expected_names = sorted([e['path'] for e in manifest] + ['SOURCE_FILES.json']) + if present != expected_names: + raise ValueError('packet tree differs from manifest: ' + repr(present)) + for entry in manifest: + path = root / entry['path'] + if pathlib.PurePosixPath(entry['path']).name != entry['path'] or path.is_symlink(): + raise ValueError('flat regular source required: ' + entry['path']) + data = path.read_bytes() + if len(data) != entry['bytes'] or hashlib.sha256(data).hexdigest() != entry['sha256']: + raise ValueError('source identity mismatch: ' + entry['path']) + # main-resident pins: the consumed sources must be the cited bytes + for pin in manifest_doc['pins_on_main']: + if not pin.get('workflow_checked'): + continue + p = pathlib.Path(pin['path']) + if p.is_symlink() or not p.is_file(): + raise ValueError('pinned source missing: ' + pin['path']) + data = p.read_bytes() + blob = hashlib.sha1(b'blob %d\0' % len(data) + data).hexdigest() + if blob != pin['git_blob']: + raise ValueError('pinned source drifted: ' + pin['path'] + ' ' + blob) + script = str(root / 'window_coefficient_d4.py') + expected = (root / 'RESULTS.json').read_bytes() + mutants = ['image-shells', 'd3-floor', 'sandwich-swap', 'window-scale', 'trace-slope', 'moment-recurrence', 'remainder-dropped', 'schur-sign', 'tau-cross', 'sphere', 'tilt-gamma'] + def mutant_rc(args): + flags, m = args + return m, flags, subprocess.run([sys.executable, *flags, script, '--mutant', m], + capture_output=True, timeout=1500).returncode + for flags in (['-B', '-S'], ['-B', '-O', '-S']): + out = subprocess.run([sys.executable, *flags, script], + check=True, capture_output=True, timeout=1500).stdout + if out != expected: + raise RuntimeError('output differs from RESULTS.json under ' + ' '.join(flags)) + doc = json.loads(out) + if not (doc['passed'] and len(doc['checks']) == 18 and all(doc['checks'].values())): + raise RuntimeError('certification did not pass under ' + ' '.join(flags)) + with concurrent.futures.ThreadPoolExecutor(max_workers=4) as pool: + for m, fl, rc in pool.map(mutant_rc, [(flags, m) for m in mutants]): + if rc != 1: + raise RuntimeError('mutant ' + m + ' not rejected under ' + ' '.join(fl)) + print(json.dumps({'scientific_effect': 'NONE', 'mathematical_acceptance': False, 'certified_enclosures': True, 'C8': 'OPEN'})) + PY + git diff --exit-code diff --git a/frontiers/c8_window_coefficient_d4_20261001/NOTE.md b/frontiers/c8_window_coefficient_d4_20261001/NOTE.md new file mode 100644 index 000000000..d67d4fe4c --- /dev/null +++ b/frontiers/c8_window_coefficient_d4_20261001/NOTE.md @@ -0,0 +1,319 @@ +# The compact-window coefficient `c_{B,K}` in `d = 4`: reference value and transfer to the torus for every `L ≥ 10` and every frame + +**Object** `CL-C8-WINDOW-COEFFICIENT-D4-20261001-v1` · **scientific effect NONE** · declarative record, `executed: false` · +base `main 3e0a91b` · claim: Math-#205 comment 5922418823 · companions (not on `main`): Math-#205 (Lemma S and the `d = 3` transfer, +whose §7 leaves `d ≥ 4` open), Math-#197 (the interval toolkit and the `d = 3` reference closed form), Math-#199 (the `D_3` +reduction, the Taylor quadrature, `c_{4,ref}`), Math-#201 (the closed form of `D_3`). Catalog entry C8 stays OPEN; no register, +GRAPH, STATUS or catalog surface is touched. Same GitHub account as every lane: zero organizational-independence credit. Claude +reads of this record count for nothing. The author will not merge. + +## 0. Statement + +Let `f` be the unit-variance stationary Gaussian field on `R⁴/(LZ⁴)` with the parent kernel `K_L` of [LP] §1, `B = [b_−, b_+]` a +birth window and `K = [k_−, k_+]` a gap window (`k_− ≥ 0`), and `c^(4)_{B,K}` the leading coefficient of [LP] Theorem B for the +pairs with birth in `B` and scaled gap in `K` ([LP] (11.3), §15; both stated for every `d`). + +**Proposition (d = 4 window coefficient).** For the reference kernel `e^{−|z|²/2}`, `c^(4)_{B,K} = c_{4,ref} F^(4)_B G_K` with the +birth factor `F^(4)_B` the one-dimensional integral (2.4) below. For the torus, for every `L ≥ 10` and every frame, +`c^(4)_{B,K}` lies in the interval computed by `window_coefficient_d4.py` from the entry box of radius `E^(4)_10 ≈ 1.501·10⁻¹⁰`. +On the C8 band `B = [0, 1]`, `K = [1/2, 2]`, + +``` +c^(4)_{B,K}(reference) = 0.000241816107038247274210322215843921349422155120948…, +c^(4)_{B,K}(torus, every L ≥ 10, every frame) ∈ [0.00024181608774072626, 0.00024181612633576979] (relative half-width 8.0e-8), +c^(4)_{B,K}(torus, L = 24) = the reference digits to about 48 places (quadrature-limited). +``` + +The same holds on every window of §5, with relative half-width at most `9.0·10⁻⁸` at `L ≥ 10`. The full window returns `c_{4,ref}` +(Math-#199, from Math-#201's closed form of `D_3`). + +## 1. The object and the reference law + +As in Math-#205 §1, with `|S³| = 2π²`, frame `(u, w_1, w_2, w_3)`, `G = ∇f ∈ R⁴`, `V = (f_uu, f_uw1, f_uw2, f_uw3)`, +`A = (f_{w_i w_j})` the `3×3` transverse Hessian, `t = f_uuu`, `τ² = Var(t | G = 0)`: + +``` +c^(4)_{B,K} = 144 ∫_{S³} p_G(0) p_V(0) I_B(u) J_K(u) dσ(u), I_B(u) = E[1{f ∈ B} det(A)² 1{A ≺ 0} | V = 0], +J_K(u) = ∫_K k^{4/3} φ_τ(12k) dk. (1.1) +``` + +Odd and even derivatives are independent for an even kernel, so `(G, t)` is independent of `(f, V, A)`. For the reference kernel, +`Cov(∂^a f, ∂^b f) = (−1)^{|a|} ∂^{a+b} e^{−|z|²/2}|_0` in exact rationals gives `Cov V = diag(3, 1, 1, 1)`, `Cov G = I`, +`τ² = 15 − 9 = 6`, and for `(f, A_11, A_12, A_13, A_22, A_23, A_33) | V = 0` + +``` +C'_ref: Var f = 2/3, Cov(f, A_ii) = −2/3, Var A_ii = 8/3, Cov(A_ii, A_jj) = 2/3, Var A_ij = 1 (i ≠ j), all else 0; +A | f = b, V = 0 ~ −b I + Q, Q the 3×3 GOE (diagonal variance 2, off-diagonal 1), (1.2) +``` + +that is, `f ~ N(0, 2/3)` and `A = Q − f I` with `Q` independent of `f` (rule `REFERENCE_EXACT`). This is SIDE24's reference law +`A = Q + √(2/3) Z I` (Math-#199 §0) with the scalar part identified as `−f`. The full-window value is +`I_R = D_3 = (50π + 200 arctan 2 − 228)/(9π) = 5.32318026888989689492…` (Math-#201), and +`c_{4,ref} = Γ(7/6)(3/2)^{1/3} D_3 / (8√3 π^{5/2}) = 0.0233216660029528350945…` (Math-#199). Hence +`c^(4,ref)_{B,K} = c_{4,ref} F^(4)_B G_K` with `F^(4)_B = I^ref_B / D_3` and Math-#197's gap factor +`G_K = P(7/6, 12k_+²) − P(7/6, 12k_−²)` (dimension-free). + +## 2. The reference birth integral as a one-dimensional integral + +Let `λ_1, λ_2, λ_3` be the eigenvalues of `Q`, with Mehta's density `|Δ(λ)| e^{−|λ|²/4} / Z_3`, `Z_3 = 48√2 π` (Math-#199 §1). By +(1.2), `I^ref_B = ∫_B φ_{2/3}(b) E[Π_i (b − λ_i)² 1{λ_max < b}] db`. Put `μ_i = λ_i − b < 0` and `T = −Σ μ_i > 0`. Then +`|λ|² = |μ|² − 2bT + 3b²`, and the `b`-dependence is the Gaussian factor `exp(−3b²/4 − 3b²/4 + bT/2)`. Its integral over `B` is exact: + +``` +∫_B √(3/4π) e^{−3b²/4} e^{bT/2 − 3b²/4} db = √(1/2) e^{T²/24} W_B(T), +W_B(T) = Φ(√3 (b_+ − T/6)) − Φ(√3 (b_− − T/6)). (2.1) +``` + +(In general `m`: `√(3/(m+3)) e^{T²/(4(m+3))} [Φ(√((m+3)/2)(b_± − T/(m+3)))]`.) **The window enters only through the total trace.** For +`B = R` this is Math-#199 (1.1). On the ordered sector `μ_3 = −a`, `μ_2 = −a − p`, `μ_1 = −a − p − q`, take `T = 3a + 2p + q`, +`s = 2p + q` and `q` as coordinates. The Jacobian is `1/6`, the region `T > s > q > 0`, and the `3!` sectors cancel it. The traceless +part gives `|μ|²/4 − T²/24 = T²/24 + s²/24 + q²/8`, so + +``` +I^ref_B = (1/(96π)) ∫_{T>s>q>0} P(T, s, q) e^{−T²/24 − s²/24 − q²/8} W_B(T) dq ds dT, +P = a²(a+p)²(a+p+q)² · pq(p+q) = ((T−s)/3)² · ((2T+s)² − 9q²)²/1296 · q(s² − q²)/4. (2.2) +``` + +**`P` is odd in `q`.** So the `q`-integral involves only the odd `J_k(s) = ∫_0^s q^k e^{−q²/8} dq`, which are elementary: +`J_1 = 4 − 4e^{−s²/8}` and `J_{k+2} = −4s^{k+1}e^{−s²/8} + 4(k+1)J_k`, with no `erf`. The `s`-integral then consists of incomplete Gaussian +moments `∫_0^T s^j e^{−γ s²} ds` with `γ ∈ {1/24, 1/6}`. Both layers are exact (rational polynomial algebra), and + +``` +F_3(T) = (4√(6π)/729) (T⁶ − 90T⁴ + 2835T² + 11340) [erf(T/(2√6)) + erf(T/√6)] + − (8T/243)(8802 + 933T² − 2T⁴) e^{−T²/24} + (8T/243)(T⁴ − 93T² + 3132) e^{−T²/6}, (2.3) + +I^ref_B = (1/(96π)) ∫_0^∞ e^{−T²/24} F_3(T) W_B(T) dT. (2.4) +``` + +The script derives (2.3) and requires it to equal the displayed form coefficient by coefficient. It also checks (2.3) against a +direct float double integral of (2.2) at `T = 2, 4, 6`, to `10⁻⁶` (rule `INNER_LAYERS`). + +Three controls test (2.1)–(2.4): + +- **Full window (rule `D3_EXACT`).** For `B = R`, (2.4) encloses Math-#201's closed form of `D_3` to `10⁻⁴⁵`. Every factor of + (2.3) is tested this way. +- **Same code at `m = 2` (rule `M2_CROSSCHECK`).** Here `T = 2a + p`, the exponent is `3T²/40 + p²/8`, the prefactor + `√(3/5)/(8√(2π))`, `P = (T² − p²)² p/16`, and `W` has slope `√(5/2)(b − T/5)`. The code returns `29/6 − √6`, and on `[0,1]`, + `[−1,1]`, `[3, 7/2]`, `[0, ∞)` and `(−∞, 0]` it returns Math-#197's `d = 3` closed form (through Owen's `T`) to `10⁻⁴⁵`. This + tests the window factor (2.1) and its slope. +- **Independent float quadrature (rule `FLOAT_CONTROL`).** `M_3(b) = E[det(bI − Q)² 1{Q ≺ bI}]` is evaluated by Gauss–Legendre + quadrature over the ordered eigenvalues, with Mehta's density at the shift `b`, then integrated in `b`. It agrees with (2.4) on + `[0, 1]` and `[1, 2]` to `7·10⁻¹¹` relative. The control does not use the coordinates `(T, s, q)`, (2.3) or the window factor. + +## 3. Certified quadrature + +(2.4) is `Λ(b_+) − Λ(b_−)` over `96π` with `Λ(b) = ∫_0^∞ g(T) Φ(√3 b − T/(2√3)) dT`, `g = e^{−T²/24} F_3 ≥ 0`, `Λ(−∞) = 0`, and +`Λ(+∞) = 96π D_3`. The method is Math-#199 §3: + +- **Cells.** On each cell of width `1/2` in `(0, 60)`, the point Taylor coefficients of `g` to order `40` at the centre are formed + once from those of its factors (polynomials, `e^{−γT²}`, `erf(κT)`) and contracted with the cell moments. +- **The window factor.** For given `b` (or a whole interval of `b`), one evaluation multiplies these coefficients by those of + `Φ(α − βT)`: `Φ(w_0)`, then `−(β/√(2π)) y_n/(n+1)` with `(n+1) y_{n+1} = β w_0 y_n − β² y_{n−1}`. +- **Remainder.** The order-40 remainder of the product is bounded by Cauchy's estimate at the centre on the disc of radius `6`. On + that disc, `|Φ(α − βz)| ≤ 1 + βρ e^{β²ρ²/2}/√(2π)`, because the segment from the real point `w_0` stays within `|Im| ≤ βρ`. The + other factor bounds are Math-#199's. +- **Tail.** Beyond `T = 60`, `0 ≤ Φ ≤ 1` and incomplete-gamma bounds apply. + +Rule `QUAD_COARSE` runs the same quadrature at order `8` with cells of width `2`, where the truncation error is visible. It requires +the enclosure, remainder included, to contain `D_3`. + +Each evaluation of `Λ` at an interval argument encloses `Λ` over that interval. The rescaled endpoints `b/√(1 ± ε)` of §4 are +therefore evaluated directly, with no Lipschitz bound. + +## 4. The torus: Lemma S in `d = 4`, the eigenvalue floor, the image bound + +**Lemma S** (Math-#205 §2) is stated there for the 4-vector `(f, A)` of `d = 3`. Its proof uses only the density comparison and +homogeneity, so it applies verbatim to the 7-vector `(f, A)` of `d = 4`, whose `det(A)²` has degree `6`. If +`(1 − ε)C'_ref ≤ C' ≤ (1 + ε)C'_ref`, then: + +- The density comparison gives `p_{C'}(x) ≤ ((1+ε)/(1−ε))^{7/2} p_{(1+ε)C'_ref}(x)`. +- Homogeneity gives `E_{sC}[g] = s³ I^C_{B/√s}`. + +Together: + +``` +(1 − ε)^{13/2}/(1 + ε)^{7/2} · I^ref_{B/√(1−ε)} ≤ I'_B ≤ (1 + ε)^{13/2}/(1 − ε)^{7/2} · I^ref_{B/√(1+ε)}. (4.1) +``` + +**Eigenvalue floor.** The eigenvalues of `C'_ref` are: + +- `1` on the three `A_ij` with `i ≠ j`; +- `2` on the traceless diagonal, twice; +- `(7 ± √37)/3` on `(f, tr A/√3)`, whose `2×2` block is `[[2/3, −2/√3], [−2/√3, 4]]`. + +So `λ_min = (7 − √37)/3 = 0.3057`. This is **below `1/3`**, so SIDE24's floor and Math-#205's `ε = 3‖·‖_F` do not carry over to +`d = 4`. The script checks, by Sylvester's criterion in exact rationals, that `C'_ref − (3/10)I` and `C'_ref − 0.305 I` are positive +definite while `C'_ref − 0.306 I` and `C'_ref − I/3` are not (rule `LAMBDA_FLOOR`). Hence `ε := (10/3)‖C' − C'_ref‖_F` satisfies the +hypothesis of (4.1). + +**Image bound in `d = 4`.** This is Math-#197 §3 and Math-#205 §4 with the `d = 4` shell count. The contraction bound +`|D^q φ(x)| ≤ 76|x|⁶φ(x)` (`q ≤ 6`, `|x| ≥ 1`), `|D^q φ(0)| ≤ 15` and the normalization `S ≥ 1` are dimension-free. The shell +`|n|_∞ = j` holds `(2j+1)⁴ − (2j−1)⁴ = 64j³ + 16j ≤ 80j³` points with `|n|² ≤ 4j²`, so +`Σ_{n≠0} |n|⁶ e^{−L²|n|²/2} ≤ 5120 Σ_j j⁹ e^{−L²j²/2} ≤ 10240 e^{−L²/2}`. The ratio of successive terms is at most +`2⁹ e^{−3L²/2} < 1/2` for `L ≥ 10`. Every covariance entry of the 4-jet of `K_L` (derivatives of order `≤ 6`), in every frame, is +within + +``` +E^(4)_L = 10240 (76 L⁶ + 15) e^{−L²/2}: E^(4)_10 ≈ 1.5010e-10, E^(4)_12 ≈ 1.2503e-19, E^(4)_24 ≈ 1.2461e-111 (rule IMAGE_BOUND) +``` + +of its reference value; `E^(4)_L` decreases in `L`. + +**Interval evaluation.** The class `Space4(E)` widens the 66 entries of the even block +`(f, f_uu, f_uw1, f_uw2, f_uw3, A_11, …, A_33)` (all but `Var f = 1`) and the 15 entries of the odd block `(f_u, f_w1, f_w2, f_w3, t)` +by `±E`. Over that box it evaluates `p_G(0) = (2π)^{−2} det(Cov G)^{−1/2}`, `p_V(0)`, `τ²` and the `7×7` Schur complement `C'` by +interval linear algebra (adjugate inverses, Laplace determinants), and `ε` with each entry's deviation the supremum over its +interval. One box bounds the integrand of (1.1) for every `u` (rule `EPSILON`): + +``` +ε(L ≥ 10) ≤ 8.274e-9, ε(L ≥ 12) ≤ 6.892e-18, ε(L = 24) ≤ 8.6e-58 (arithmetic-limited), ε(E = 0) ≤ 5.9e-59; +τ²(L ≥ 10) ∈ [5.9999999894, 6.0000000106], p_G p_V (L ≥ 10) ∈ [0.0003704417259359, 0.0003704417263438] (reference (2π)^{−4}/√3). +``` + +Then `c^(4)_{B,K} ∈ 144 · 2π² · [p_G p_V] · (4.1)(I^ref, ε) · J_K(τ²)`, with `J_K` by Math-#197 (2.2) at the interval `τ²`. + +**Two exact tests of (4.1) as implemented.** + +1. *Scalar perturbation (rule `SANDWICH_EXACT_SCALING`).* For `C' = (1 + η)C'_ref`, the exact value + `(1 + η)³ I^ref_{B/√(1+η)}` lies inside the bracket for `ε = |η|`. This is checked for `η = ±1/50` on `[0, 1]`, `[3, 7/2]` and + `[−7/2, −3]`; on the last two the rescaling dominates. +2. *Non-scalar, tilted perturbation (rule `TILTED_EXACT`).* + - **Model.** Take `A = Q − gI` with `g = μf + σZ`, where `f ~ N(0, v)` and `Z` is an independent standard normal. Choose + `(v, μ, σ²) = (17/25, 33/34, 133/5100)`, so that `μ²v + σ² = 2/3`. This moves `Var f` and `Cov(f, A_ii)` but not the law of `A`, + so `C'` is not a multiple of `C'_ref`, and `ε = (10/3)·√10/150 = 0.0703`. + - **Exact value.** `I'_B` follows from the same reduction. Conditioning on `f = b` and integrating `g` exactly changes only the + prefactor `(2vAD)^{−1/2}`, the slope `√(2A)` and the centre `c'T` of the window factor. Here `D = 1 + 3σ²/2`, + `A = 1/(2v) + 3μ²/(4D)` and `c' = μ/(4AD) = 33/200`. The outer Gaussian `e^{−T²/24}` is unchanged. + - **Checks.** On `B = R` the tilted value equals `D_3`, as it must, since the law of `g` is that of the reference shift. On `[0, 1]` + and `[1, 2]` it differs from the reference by `5.9 %` and `1.0 %` and lies inside its bracket (4.1). + +## 5. Values (`RESULTS.json`) + +`F^(4)_B = I^ref_B/D_3`, `G_K` is Math-#197's, and `c^(4,ref) = c_{4,ref} F^(4)_B G_K`. Displayed intervals are rounded outward (lower +endpoints down, upper endpoints up) and contain the certified intervals of `RESULTS.json`; every `…`-terminated digit string is a common +prefix of a certified interval's endpoints (both checked mechanically before publication). + +| `B` | `K` | `F^(4)_B` | `c^(4)` reference | torus, every `L ≥ 10`, every frame | +|---|---|---|---|---| +| `[0,1]` | `[1/2,2]` | `0.15390330006768…` | `0.0002418161070382472742…` | `[0.00024181608774072626, 0.00024181612633576979]` | +| `[0,1]` | `(0,∞)` | `0.15390330006768…` | `0.0035892813609306973172…` | `[0.00358928109253599678, 0.00358928162932541748]` | +| `[−1,1]` | `[1/2,2]` | `0.16030200166098…` | `0.0002518698817702562001…` | `[0.00025186986157436282, 0.00025186990196615116]` | +| `[−2,2]` | `[1/2,2]` | `0.68011507457563…` | `0.0010686111317923825650…` | `[0.00106861104288191615, 0.00106861122070285613]` | +| `[0,∞)` | `[1/2,2]` | `0.99357136828676…` | `0.0015611202634258783862…` | `[0.00156112012373210018, 0.00156112040311966873]` | +| `(−∞,0]` | `[1/2,2]` | `0.00642863171323…` | `0.0000101008015669100341…` | `[0.00001010080066305966, 0.00001010080247076049]` | +| `R` | `[1/2,2]` | `1` | `0.0015712210649927884204…` | `[0.00157122092439515984, 0.00157122120559042922]` | +| `R` | `(0,∞)` | `1` | `0.0233216660029528350945…` (= `c_{4,ref}`) | `[0.02332166403326801449, 0.02332166797263781719]` | + +`RESULTS.json` lists all twelve window pairs; each `L ≥ 10` enclosure contains its reference value. At `L = 24` every enclosure +agrees with the reference to about 48 digits, and the full window contains Math-#199's `c_{4,ref}`, whose `c_{4,24}` equals it to +`1.6e-108` (rule `C4_CONSISTENT`). + +**How the birth mass moves with dimension.** The C8 band `B = [0, 1]` carries: + +| `d` | share of the birth mass | +|---|---| +| 2 | `48.3 %` | +| 3 | `34.6 %` | +| 4 | **`15.4 %`** | + +The negative half-line carries `0.64 %` in `d = 4`, against `4.6 %` in `d = 3`. The reason is that `f` must exceed the largest +eigenvalue of a larger GOE matrix. The gap factor is dimension-free (`6.74 %`). On the band, `c^(4)_{B,K}/c_{4,ref} = 1.04 %`. + +## 6. Rules, mutants, verification + +`python3 -B -S window_coefficient_d4.py` (also `-B -O -S`; about a minute) prints `RESULTS.json`. It exits `0` only if all eighteen +rules hold: + +| rule | what it requires | +|---|---| +| `REFERENCE_EXACT` | the reference law (1.2), and that the tilted covariance at `(2/3, 1, 0)` is `C'_ref` | +| `LAMBDA_FLOOR` | the eigenvalue floor of §4 | +| `INNER_LAYERS` | (2.3) exact and against the float double integral | +| `D3_EXACT` | the full window encloses Math-#201's `D_3` | +| `QUAD_COARSE` | the coarse quadrature with its remainder contains `D_3` | +| `M2_CROSSCHECK` | the `m = 2` run reproduces `29/6 − √6` and Math-#197's windows | +| `FLOAT_CONTROL` | the eigenvalue float quadrature agrees with (2.4) | +| `IMAGE_BOUND` | the values of `E^(4)_L` | +| `EPSILON` | the values of `ε` | +| `SANDWICH_EXACT_SCALING` | exact scalar perturbations lie inside (4.1) | +| `TILTED_EXACT` | the tilted perturbation lies inside (4.1) | +| `FACTORIZATION` | the pipeline at `E = 0` reproduces `c_{4,ref} F^(4)_B G_K` on the band and on the full window | +| `C4_CONSISTENT` | agreement with Math-#199's `c_{4,ref}` | +| `NESTING` | every `L ≥ 10` enclosure contains the reference, and the band's meets the `10³⁰`-times narrower `L = 24` one | +| `WIDTHS` | relative half-width below `10⁻⁷` at `L ≥ 10` | +| `SANDWICH_ORDERED` | every bracket comes out in order | +| `LIBRARY_EXACT` | exp, sqrt and negation against exact rational brackets | +| `PINNED` | the quoted digits | + +Eleven mutants exit `1` in both interpreter modes: + +| mutant | change | +|---|---| +| `image-shells` | `64j³` shells | +| `d3-floor` | the `d = 3` floor `1/3` | +| `sandwich-swap` | the two rescalings exchanged | +| `window-scale` | `B·s` for `B/s` | +| `trace-slope` | the window factor's centre `T/5` for `T/6` | +| `moment-recurrence` | `j` for `j + 1` in the moment recurrence | +| `remainder-dropped` | the Cauchy remainder omitted | +| `schur-sign` | the sign of the Schur complement flipped | +| `tau-cross` | `Cov(t, f_u)` dropped | +| `sphere` | `4π` for `2π²` | +| `tilt-gamma` | the `σ²` term dropped from the tilted exponent | + +The hosted workflow replays the manifest, the pins, both modes byte for byte, and the mutants. + +## 7. What this does not do + +- It encloses `c^(4)_{B,K}` for the reference kernel and the torus. It does not revalidate [LP] Theorem B and §15, which it + consumes at their scope, and it does not review Math-#197, #199, #201 or #205. +- It does not cover `d ≥ 5`. Lemma S holds in every `d` (`n = 1 + m(m+1)/2` coordinates, degree `2m`), and (2.1) puts the window on + the total trace in every `d`. In `d = 5`, however, the inner integrals over the differences have one more layer, and Math-#202's + closed form of `D_4` integrates in a different order, so that layer is not supplied here. The floor must also be re-derived: + `λ_min = ((2m+8)/3 − √(((2m+8)/3)² − 16/3))/2`, which is `0.2630` at `m = 4`. +- **Unbounded windows** (`B = [0,∞)`, `(−∞,0]`, `R`; `K = (0,∞)`): the tabulated values are the coefficient integrals (1.1) on those + sets. [LP] Theorem B's asymptotic statement is for compact windows and is not extended here; the full window is [LP] (15.2)'s + `c_{4,L}`. +- It does not address `C`, `r_*` or `z_*`. C8 stays OPEN; no register surface is touched; `executed: false`. The replay workflow + follows the repository's per-packet convention; the owner's open decision on such workflows (Math-#202/#204) applies here too. + +## 8. Provenance + +**Pins on `main 3e0a91b` (workflow-checked):** + +- [LP] `imports/lifetime_parent_20260925/UNIFORM_MATRIX_CAP_AND_LIFETIME.md`, blob `dfed3b8d`: (11.3) and §15. +- SIDE24 `coefficients/side24_v1/PROOF.md`, blob `44b66f04`: §§2–4, the image-bound pattern and the scaling argument. + +**Companions, not on `main`:** + +- **Math-#197** at `63e123f`, `window_coefficient.py` blob `43b4f51b`. The interval class, special functions, Owen primitives, + incomplete gamma and `library_exact` are reused verbatim, through Math-#205's copy. +- **Math-#205** at `b875a46`, `window_coefficient_d3.py` blob `ba24b380`. The toolkit section and `I3_ref` (the `d = 3` reference + window integral, for `M2_CROSSCHECK`) are reused verbatim; Lemma S is its §2. +- **Math-#199** at `617236d`: + - `cone_moment_d4.py`, blob `4787d6bf`: the exact polynomial algebra, reused verbatim; the quadrature method of its §3, adapted; + `Z_3`. + - `RESULTS.json`, blob `187552f5`: `c_{4,ref}`. +- **Math-#201** at `3abcc10`, `closed_form_d3.py` blob `a0c91692` and `NOTE.md` blob `cbf35dea`: the closed form of `D_3`. + +No external numerical library is used. + +## 9. Current disposition + +- **Head / owner:** see the PR's disposition block. Branch `claude/c8-window-d4-20261001` (base `main 3e0a91b`); author lane + Anthropic / Claude (`session_017Mi3hxjaxV45x6zo6o1ee3`). +- **Claim:** the reduction (2.1)–(2.4) and its closed inner layers (2.3); the certified reference values of `c^(4)_{B,K}`; Lemma S + in `d = 4` with the floor `3/10`; the `d = 4` image bound; the certified `ε`; the torus enclosures for every `L ≥ 10` and every + frame, and for `L = 24`, on the windows of §5. No theorem of [LP] or SIDE24 is proved or reviewed. +- **Completed review scopes:** none yet. Requested nonauthor reads: + + | slice | scope | + |---|---| + | A | §§1–3: the reference law, (2.1)–(2.4), the quadrature | + | B | §4: Lemma S in `d = 4`, the floor, the image bound, the entry box and `ε`, the exact tests | + | C | §§5–7: values, rules, mutants, non-claims | + +- **Unresolved finding IDs:** none. +- **Validation:** 18/18 rules in both modes, byte-identical output; 11/11 mutants rejected in both modes; workflow replayed + locally; hosted run pending at opening. +- **Next action:** nonauthor reads; amendments on this branch, recorded in `SOURCE_FILES.json`. Author will not merge. diff --git a/frontiers/c8_window_coefficient_d4_20261001/RESULTS.json b/frontiers/c8_window_coefficient_d4_20261001/RESULTS.json new file mode 100644 index 000000000..eb1b28c27 --- /dev/null +++ b/frontiers/c8_window_coefficient_d4_20261001/RESULTS.json @@ -0,0 +1,684 @@ +{ + "object": "CL-C8-WINDOW-COEFFICIENT-D4-20261001-v1", + "scientific_effect": "NONE", + "certified": true, + "mutant": null, + "passed": true, + "checks": { + "REFERENCE_EXACT": true, + "LAMBDA_FLOOR": true, + "INNER_LAYERS": true, + "D3_EXACT": true, + "QUAD_COARSE": true, + "M2_CROSSCHECK": true, + "FLOAT_CONTROL": true, + "IMAGE_BOUND": true, + "EPSILON": true, + "SANDWICH_EXACT_SCALING": true, + "TILTED_EXACT": true, + "FACTORIZATION": true, + "C4_CONSISTENT": true, + "NESTING": true, + "WIDTHS": true, + "SANDWICH_ORDERED": true, + "LIBRARY_EXACT": true, + "PINNED": true + }, + "c8_band": { + "B": "[0,1]", + "K": "[1/2,2]", + "c4_reference": [ + "0.000241816107038247274210322215843921349422155120948079032849318", + "0.000241816107038247274210322215843921349422155120948110908719951" + ], + "c4_reference_digits": "0.000241816107038247274210322215843921349422155120948", + "F4_B": [ + "0.153903300067681539201309170781277197985100298089689776781784", + "0.153903300067681539201309170781277197985100298089710062927363" + ], + "c4_torus_every_L_ge_10_every_frame": [ + "0.000241816087740726263040393844830860066879773490482745244022762", + "0.000241816126335769789563608070288481985320113442074139170361672" + ], + "c4_torus_L_24": [ + "0.000241816107038247274210322215843921349422155120948079033770994", + "0.000241816107038247274210322215843921349422155120948110907798312" + ], + "relative_half_width_L_ge_10": "7.98024727947476036120488700334975733000597171448733584010622E-8" + }, + "full_window": { + "c_4_ref": [ + "0.0233216660029528350945211949528568851531013723632403344029635", + "0.0233216660029528350945211949528568851531013723632403344090079" + ], + "c4_torus_every_L_ge_10": [ + "0.0233216640332680144945564044762068055869248182028034808996727", + "0.0233216679726378171819692637137012362629915001620433627687975" + ], + "c4_torus_L_24": [ + "0.0233216660029528350945211949528568851531013723632403055321900", + "0.0233216660029528350945211949528568851531013723632403632797841" + ], + "Math199_c_4_ref_digits": "0.023321666002952835094521194952856885153101372363" + }, + "windows": { + "B=[0,1] K=[1/2,2]": { + "F4_B": [ + "0.153903300067681539201309170781277197985100298089689776781784", + "0.153903300067681539201309170781277197985100298089710062927363" + ], + "G_K": [ + "0.067371733425641667348844418474402773431540422159891980011888", + "0.067371733425641667348844418474402773431540422159891980510232" + ], + "c4_ref": [ + "0.000241816107038247274210322215843921349422155120948079032849318", + "0.000241816107038247274210322215843921349422155120948110908719951" + ], + "c4_torus_L_ge_10": [ + "0.000241816087740726263040393844830860066879773490482745244022762", + "0.000241816126335769789563608070288481985320113442074139170361672" + ], + "c4_torus_L_24": [ + "0.000241816107038247274210322215843921349422155120948079033770994", + "0.000241816107038247274210322215843921349422155120948110907798312" + ] + }, + "B=[0,1] K=[0,inf]": { + "F4_B": [ + "0.153903300067681539201309170781277197985100298089689776781784", + "0.153903300067681539201309170781277197985100298089710062927363" + ], + "G_K": [ + "0.999999999999999999999999999999999999999999999999999999742690", + "1.00000000000000000000000000000000000000000000000000000025731" + ], + "c4_ref": [ + "0.00358928136093069731722131549109076264446799103581521733970880", + "0.00358928136093069731722131549109076264446799103581569044919787" + ], + "c4_torus_L_ge_10": [ + "0.00358928109253599678508907362356275018312084167894405361013482", + "0.00358928162932541747262187263816795768683187843481806623920013" + ], + "c4_torus_L_24": [ + "0.00358928136093069731722131549109076264446799103581521734060677", + "0.00358928136093069731722131549109076264446799103581569044830007" + ] + }, + "B=[-1,1] K=[1/2,2]": { + "F4_B": [ + "0.160302001660989843440686508807421440152902342543871892861292", + "0.160302001660989843440686508807421440152902342543892179006559" + ], + "G_K": [ + "0.067371733425641667348844418474402773431540422159891980011888", + "0.067371733425641667348844418474402773431540422159891980510232" + ], + "c4_ref": [ + "0.000251869881770256200124981086964223219423385569084794242725745", + "0.000251869881770256200124981086964223219423385569084826118672861" + ], + "c4_torus_L_ge_10": [ + "0.000251869861574362822716289088672433073381167624855998537562504", + "0.000251869901966151159639565631483442464859118633189261226113841" + ], + "c4_torus_L_24": [ + "0.000251869881770256200124981086964223219423385569084794243685730", + "0.000251869881770256200124981086964223219423385569084826117712913" + ] + }, + "B=[-1,1] K=[0,inf]": { + "F4_B": [ + "0.160302001660989843440686508807421440152902342543871892861292", + "0.160302001660989843440686508807421440152902342543892179006559" + ], + "G_K": [ + "0.999999999999999999999999999999999999999999999999999999742690", + "1.00000000000000000000000000000000000000000000000000000025731" + ], + "c4_ref": [ + "0.00373850974234239573434254726380052990610416132823086224563560", + "0.00373850974234239573434254726380052990610416132823133535523287" + ], + "c4_torus_L_ge_10": [ + "0.00373850946136311900924670151572435453936614267285845112676776", + "0.00373851002332169311258637286844760853518635211609067049529919" + ], + "c4_torus_L_24": [ + "0.00373850974234239573434254726380052990610416132823086224657075", + "0.00373850974234239573434254726380052990610416132823133535429789" + ] + }, + "B=[-2,2] K=[1/2,2]": { + "F4_B": [ + "0.680115074575637304761039823451489822273186160635557028171485", + "0.680115074575637304761039823451489822273186160635577314340664" + ], + "G_K": [ + "0.067371733425641667348844418474402773431540422159891980011888", + "0.067371733425641667348844418474402773431540422159891980510232" + ], + "c4_ref": [ + "0.00106861113179238256506386709903795828591463642908624538680762", + "0.00106861113179238256506386709903795828591463642908627726904538" + ], + "c4_torus_L_ge_10": [ + "0.00106861104288191615721546692443125663149439077433510628033582", + "0.00106861122070285612440043427556794014748024358498836055392140" + ], + "c4_torus_L_24": [ + "0.00106861113179238256506386709903795828591463642908624539088023", + "0.00106861113179238256506386709903795828591463642908627726497291" + ] + }, + "B=[-2,2] K=[0,inf]": { + "F4_B": [ + "0.680115074575637304761039823451489822273186160635557028171485", + "0.680115074575637304761039823451489822273186160635577314340664" + ], + "G_K": [ + "0.999999999999999999999999999999999999999999999999999999742690", + "1.00000000000000000000000000000000000000000000000000000025731" + ], + "c4_ref": [ + "0.0158614166128263726192970221103792907273023675245585632572210", + "0.0158614166128263726192970221103792907273023675245590363767568" + ], + "c4_torus_L_ge_10": [ + "0.0158614153728418738314194440258848407956867310866901973241127", + "0.0158614178528109650684682669223903571442243259998662165800428" + ], + "c4_torus_L_24": [ + "0.0158614166128263726192970221103792907273023675245585632611837", + "0.0158614166128263726192970221103792907273023675245590363727946" + ] + }, + "B=[0,inf] K=[1/2,2]": { + "F4_B": [ + "0.993571368286768485535965840965759817167557417080955374034170", + "0.993571368286768485535965840965759817167557417080967992964881" + ], + "G_K": [ + "0.067371733425641667348844418474402773431540422159891980011888", + "0.067371733425641667348844418474402773431540422159891980510232" + ], + "c4_ref": [ + "0.00156112026342587838627219466662169730647347804198066288971752", + "0.00156112026342587838627219466662169730647347804198068272879939" + ], + "c4_torus_L_ge_10": [ + "0.00156112012373210018538818427751937983998319335149310026676806", + "0.00156112040311966872460587968311673504825035095836403911998466" + ], + "c4_torus_L_24": [ + "0.00156112026342587838627219466662169730647347804198066289566615", + "0.00156112026342587838627219466662169730647347804198068272285089" + ] + }, + "B=[0,inf] K=[0,inf]": { + "F4_B": [ + "0.993571368286768485535965840965759817167557417080955374034170", + "0.993571368286768485535965840965759817167557417080967992964881" + ], + "G_K": [ + "0.999999999999999999999999999999999999999999999999999999742690", + "1.00000000000000000000000000000000000000000000000000000025731" + ], + "c4_ref": [ + "0.0231717396012808592441842393528105724036773366075031389703866", + "0.0231717396012808592441842393528105724036773366075034332828044" + ], + "c4_torus_L_ge_10": [ + "0.0231717376442584169469991087404595054631191948498930364281227", + "0.0231717415583034619907090919566342472278530169110873734042378" + ], + "c4_torus_L_24": [ + "0.0231717396012808592441842393528105724036773366075031389761609", + "0.0231717396012808592441842393528105724036773366075034332770297" + ] + }, + "B=[-inf,0] K=[1/2,2]": { + "F4_B": [ + "0.00642863171323151446403415903424018283244258291903324496500009", + "0.00642863171323151446403415903424018283244258291904338803608509" + ], + "G_K": [ + "0.067371733425641667348844418474402773431540422159891980011888", + "0.067371733425641667348844418474402773431540422159891980510232" + ], + "c4_ref": [ + "0.0000101008015669100341586217092455594066820367392354809937282950", + "0.0000101008015669100341586217092455594066820367392354969308125804" + ], + "c4_torus_L_ge_10": [ + "0.0000101008006630596602978721700660796431684200505272932722297642", + "0.0000101008024707604865514187555958246376771364147755078503126433" + ], + "c4_torus_L_24": [ + "0.0000101008015669100341586217092455594066820367392354809937667840", + "0.0000101008015669100341586217092455594066820367392354969307740923" + ] + }, + "B=[-inf,0] K=[0,inf]": { + "F4_B": [ + "0.00642863171323151446403415903424018283244258291903324496500009", + "0.00642863171323151446403415903424018283244258291904338803608509" + ], + "G_K": [ + "0.999999999999999999999999999999999999999999999999999999742690", + "1.00000000000000000000000000000000000000000000000000000025731" + ], + "c4_ref": [ + "0.000149926401671975850336955600046312749424035755736930002675729", + "0.000149926401671975850336955600046312749424035755737166556107831" + ], + "c4_torus_L_ge_10": [ + "0.000149926389009597547557295735747300123805623352910207918254056", + "0.000149926414334355191260171757066989035138483250956225917895644" + ], + "c4_torus_L_24": [ + "0.000149926401671975850336955600046312749424035755736930002713090", + "0.000149926401671975850336955600046312749424035755737166556070468" + ] + }, + "B=[-inf,inf] K=[1/2,2]": { + "F4_B": [ + "0.999999999999999999999999999999999999999999999999998762070248", + "1.00000000000000000000000000000000000000000000000000123792989" + ], + "G_K": [ + "0.067371733425641667348844418474402773431540422159891980011888", + "0.067371733425641667348844418474402773431540422159891980510232" + ], + "c4_ref": [ + "0.00157122106499278842043081637586725671315551478121615982045275", + "0.00157122106499278842043081637586725671315551478121616372260503" + ], + "c4_torus_L_ge_10": [ + "0.00157122092439515984568605644758545948315161340202040947600333", + "0.00157122120559042921115729843871255968592748737313953103328893" + ], + "c4_torus_L_24": [ + "0.00157122106499278842043081637586725671315551478121615982643987", + "0.00157122106499278842043081637586725671315551478121616371661804" + ] + }, + "B=[-inf,inf] K=[0,inf]": { + "F4_B": [ + "0.999999999999999999999999999999999999999999999999998762070248", + "1.00000000000000000000000000000000000000000000000000123792989" + ], + "G_K": [ + "0.999999999999999999999999999999999999999999999999999999742690", + "1.00000000000000000000000000000000000000000000000000000025731" + ], + "c4_ref": [ + "0.0233216660029528350945211949528568851531013723632403055263783", + "0.0233216660029528350945211949528568851531013723632403632855963" + ], + "c4_torus_L_ge_10": [ + "0.0233216640332680144945564044762068055869248182028034808996727", + "0.0233216679726378171819692637137012362629915001620433627687975" + ], + "c4_torus_L_24": [ + "0.0233216660029528350945211949528568851531013723632403055321900", + "0.0233216660029528350945211949528568851531013723632403632797841" + ] + } + }, + "worst_relative_half_width_L_ge_10": "8.94830462729858059341960688502522806885847787025234953118473E-8", + "transfer": { + "E4_10": [ + "1.50103057793541602271318834499783888472477596452853503674547E-10", + "1.50103057793541602271318834499783888472477596452853503674552E-10" + ], + "E4_12": [ + "1.25025429996234637485159337038323602638838338997619710949555E-19", + "1.25025429996234637485159337038323602638838338997619710949557E-19" + ], + "E4_24": [ + "1.24614968346183326033273338980201191527161500226085180392811E-111", + "1.24614968346183326033273338980201191527161500226085180392812E-111" + ], + "eps_L_ge_10": "8.27394521457206030025583738364704992180450046300834708060057E-9", + "eps_L_ge_12": "6.8916221472202761368053356027654086314901315862093096836672E-18", + "eps_L_24": "8.5164546614186821490098404962377161722775145952785685489134E-58", + "eps_E0": "5.89726867098471084893001172369660015903009674959693955781524E-59", + "lambda_floor": "3/10", + "lambda_min_exact": "(7 - sqrt37)/3", + "tau2_L_ge_10": [ + "5.99999998949278594611564449006695441435004947868381444519534", + "6.00000001050721404180777811899353455412921320777219075373722" + ], + "pG_pV_L_ge_10": [ + "0.000370441725935987203974288177233040332040565607489449175830924", + "0.000370441726343753066795775212970291311814181653038585074868670" + ] + }, + "reference": { + "C_prime": [ + [ + "2/3", + "-2/3", + "0", + "0", + "-2/3", + "0", + "-2/3" + ], + [ + "-2/3", + "8/3", + "0", + "0", + "2/3", + "0", + "2/3" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "-2/3", + "2/3", + "0", + "0", + "8/3", + "0", + "2/3" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "-2/3", + "2/3", + "0", + "0", + "2/3", + "0", + "8/3" + ] + ], + "A_given_f_mean": [ + "-1", + "0", + "0", + "-1", + "0", + "-1" + ], + "A_given_f_cov": [ + [ + "2", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "2", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "2" + ] + ], + "tau2": "6", + "det_Cov_V": "3", + "D_3_quadrature": [ + "5.32318026888989689492319873968726063578438852944091346039984", + "5.32318026888989689492319873968726063578438852944092663984054" + ], + "D_3_closed_form_Math201": [ + "5.32318026888989689492319873968726063578438852944092005011660", + "5.32318026888989689492319873968726063578438852944092005012307" + ], + "coarse_quadrature": [ + "4.09796416764767699852795510007044899858896869159062212498378", + "6.54839635865609652368011020527472479021427643409370242252411" + ], + "F_3_pieces": { + "('1',)": [], + "('E', Fraction(1, 24))": [ + "560/9", + "0", + "140/9", + "0", + "-40/81", + "0", + "4/729" + ], + "('E', Fraction(1, 6))": [ + "1120/9", + "0", + "280/9", + "0", + "-80/81", + "0", + "8/729" + ], + "('e', Fraction(1, 24))": [ + "0", + "-2608/9", + "0", + "-2488/81", + "0", + "16/243" + ], + "('e', Fraction(1, 6))": [ + "0", + "928/9", + "0", + "-248/81", + "0", + "8/243" + ] + } + }, + "layers_float_control": { + "2": [ + "0.00305383585004", + "0.00305383587956" + ], + "4": [ + "4.40321034658", + "4.40321036724" + ], + "6": [ + "228.29501064", + "228.295010934" + ] + }, + "m2_crosscheck": { + "[0,1]": { + "T_quadrature": [ + "0.825283771446628026153734795989501098973937785745525306093630", + "0.825283771446628026153734795989501098973937785745525366982627" + ], + "Math197_closed_form": [ + "0.82528377144662802615373479598950109897393778574552533653260", + "0.82528377144662802615373479598950109897393778574552533653677" + ] + }, + "[-1,1]": { + "T_quadrature": [ + "0.933236521461220239242324798257821005678820423349677722291806", + "0.933236521461220239242324798257821005678820423349677783179242" + ], + "Math197_closed_form": [ + "0.93323652146122023924232479825782100567882042334967775272866", + "0.93323652146122023924232479825782100567882042334967775273472" + ] + }, + "[3,7/2]": { + "T_quadrature": [ + "0.0139921205104396079790627336205182811993011850118844903777648", + "0.0139921205104396079790627336205182811993011850118845512837531" + ], + "Math197_closed_form": [ + "0.0139921205104396079790627336205182811993011850118845208278966", + "0.0139921205104396079790627336205182811993011850118845208341167" + ] + }, + "[0,inf]": { + "T_quadrature": [ + "2.27370461420265554951426922659790932865680254094792442057168", + "2.27370461420265554951426922659790932865680254094792445646427" + ], + "Math197_closed_form": [ + "2.27370461420265554951426922659790932865680254094792443851779", + "2.27370461420265554951426922659790932865680254094792443851892" + ] + }, + "[-inf,0]": { + "T_quadrature": [ + "0.110138976347499685621780032029532612710583311728738751164415", + "0.110138976347499685621780032029532612710583311728738781601011" + ], + "Math197_closed_form": [ + "0.110138976347499685621780032029532612710583311728738766381762", + "0.110138976347499685621780032029532612710583311728738766382795" + ] + } + }, + "float_control": { + "[0,1]": { + "float_eigenvalue_quadrature": "0.819255010256", + "certified": [ + "0.819255010237323502832940581842915087462647431071791788840888", + "0.819255010237323502832940581842915087462647431071899775649769" + ] + }, + "[1,2]": { + "float_eigenvalue_quadrature": "2.76689943914", + "certified": [ + "2.76689943894513514126193029896578891134218830034373217858307", + "2.76689943894513514126193029896578891134218830034384016553201" + ] + } + }, + "tilted": { + "v_mu_sigma2": [ + "17/25", + "33/34", + "133/5100" + ], + "eps": "0.0702728368926306518221976343207270785271012253183381517079497", + "full_window": [ + "5.32318026888989689492319873968726063578438852944091346039984", + "5.32318026888989689492319873968726063578438852944092663984054" + ], + "windows": { + "[0,1]": { + "tilted_exact": [ + "0.867489607640667436914003787316442946326790842422808023483543", + "0.867489607640667436914003787316442946326790842422904494692321" + ], + "sandwich": [ + "0.438112756536888108361422226052195884818189674352598133323882", + "1.51861760205619980318453475744302294263009496548839143250051" + ], + "reference": [ + "0.819255010237323502832940581842915087462647431071791788840888", + "0.819255010237323502832940581842915087462647431071899775649769" + ] + }, + "[1,2]": { + "tilted_exact": [ + "2.73987109907430532176210526998041831359049456420997171623434", + "2.73987109907430532176210526998041831359049456421006818758323" + ], + "sandwich": [ + "1.42008649394506780336461126812734940361310778084339585867444", + "5.30110216250401605102461153098943495911589556202986837814946" + ], + "reference": [ + "2.76689943894513514126193029896578891134218830034373217858307", + "2.76689943894513514126193029896578891134218830034384016553201" + ] + } + } + }, + "constants": { + "pi": [ + "3.14159265358979323846264338327950288419716939937510582097457", + "3.14159265358979323846264338327950288419716939937510582097528" + ], + "Gamma(7/6)": [ + "0.927719333630039200708349482534621018566466519145475576700351", + "0.927719333630039200708349482534621018566466519145475576939062" + ], + "(3/2)^(1/3)": [ + "1.14471424255333186780804221193967700891590692078793107209905", + "1.14471424255333186780804221193967700891590692078793107209906" + ], + "arctan 2": [ + "1.10714871779409050301706546017853704007004764540143264667625", + "1.10714871779409050301706546017853704007004764540143264667681" + ] + }, + "exact_relations": { + "window coefficient": "c^(4)_{B,K} = 144 int_{S^3} p_G(0) p_V(0) I_B(u) J_K(u) dsigma(u), I_B = E[1{f in B} det(A)^2 1{A<0} | V=0] ([LP] (11.3), section 15)", + "reference": "(f, A) | V=0: f ~ N(0, 2/3), A = Q - f I, Q the 3x3 GOE; I^ref_B = (1/(96 pi)) int_0^inf e^{-T^2/24} F_3(T) [Phi(sqrt3(b_+ - T/6)) - Phi(sqrt3(b_- - T/6))] dT", + "sandwich": "(1-eps) C'_ref <= C' <= (1+eps) C'_ref => (1-eps)^(13/2)/(1+eps)^(7/2) I^ref_{B/sqrt(1-eps)} <= I'_B <= (1+eps)^(13/2)/(1-eps)^(7/2) I^ref_{B/sqrt(1+eps)}", + "epsilon": "eps = ||C' - C'_ref||_F / lambda0, lambda0 = 3/10 <= lambda_min(C'_ref) = (7 - sqrt37)/3", + "image bound": "E^(4)_L = 10240 (76 L^6 + 15) exp(-L^2/2)" + } +} diff --git a/frontiers/c8_window_coefficient_d4_20261001/SOURCE_FILES.json b/frontiers/c8_window_coefficient_d4_20261001/SOURCE_FILES.json new file mode 100644 index 000000000..9cbb1d16d --- /dev/null +++ b/frontiers/c8_window_coefficient_d4_20261001/SOURCE_FILES.json @@ -0,0 +1,85 @@ +{ + "schema": 1, + "object": "CL-C8-WINDOW-COEFFICIENT-D4-20261001-v1", + "scientific_effect": "NONE", + "certified": true, + "review_status": "AUTHOR_SIDE_CERTIFIED_ENCLOSURE_NONAUTHOR_READS_OPEN", + "disposition": "CERTIFIED_REFERENCE_AND_TORUS_ENCLOSURES_OF_THE_D4_WINDOW_COEFFICIENT_NO_REGISTER_CHANGE_C8_OPEN", + "declarative": true, + "executed": false, + "base": "3e0a91b69892b9717564c592e7a966492a81566a", + "claim": "https://github.com/d6g8k5htny-coder/Math-/pull/205#issuecomment-5922418823", + "pins_on_main": [ + { + "label": "LP", + "path": "imports/lifetime_parent_20260925/UNIFORM_MATRIX_CAP_AND_LIFETIME.md", + "git_blob": "dfed3b8d318a3ab1950957f393307733a4bef3f2", + "role": "(11.3) the window coefficient in every d; section 15 factorization p_(f,V)(b,0) p_G(0) phi_tau(12k), z_0 = 36 k^2 E[det(A)^2 1{A<0} | f=b, V=0]", + "workflow_checked": true + }, + { + "label": "S24", + "path": "coefficients/side24_v1/PROOF.md", + "git_blob": "44b66f04f89fcd87383b3603fa69f1feb64cdddd", + "role": "sections 1-4: the reference law A = Q + sqrt(2/3) Z I, the image-bound pattern (76|x|^6 contraction bound, normalization), the covariance-sandwich scaling argument", + "workflow_checked": true + } + ], + "companion_not_on_main": [ + { + "pr": "https://github.com/d6g8k5htny-coder/Math-/pull/197", + "commit": "63e123f", + "path": "frontiers/c8_window_coefficient_planar_20260930/window_coefficient.py", + "git_blob": "43b4f51ba0e29c38468c40b4648f683848a3b218", + "role": "interval class, erf, arctan, Owen's T, Owen primitives G_0..G_4, incomplete gamma, gap factor G_K, library_exact (reused verbatim through Math-#205's copy)" + }, + { + "pr": "https://github.com/d6g8k5htny-coder/Math-/pull/205", + "commit": "b875a46", + "path": "frontiers/c8_window_coefficient_d3_torus_20260930/window_coefficient_d3.py", + "git_blob": "ba24b3802eb0baf5ade65d49fd47ca862972f8bd", + "role": "the toolkit section and I3_ref (the d = 3 reference window integral, rule M2_CROSSCHECK) reused verbatim; Lemma S (its NOTE section 2) applied with n = 7, degree 6" + }, + { + "pr": "https://github.com/d6g8k5htny-coder/Math-/pull/199", + "commit": "617236d", + "path": "coefficients/side24_d4_20260930/cone_moment_d4.py", + "git_blob": "4787d6bf5a3bc469ae62075dde24e913b786e44a", + "role": "exact polynomial algebra (padd, pmul, pscale, pconst, pvar) reused verbatim; the Taylor quadrature with Cauchy remainders (section 3) adapted; Mehta's Z_3 = 48 sqrt2 pi" + }, + { + "pr": "https://github.com/d6g8k5htny-coder/Math-/pull/199", + "commit": "617236d", + "path": "coefficients/side24_d4_20260930/RESULTS.json", + "git_blob": "187552f596576c9dcdecd1deabc0304412d8a1f7", + "role": "c_{4,ref} digits quoted in the script (rule C4_CONSISTENT)" + }, + { + "pr": "https://github.com/d6g8k5htny-coder/Math-/pull/201", + "commit": "3abcc10", + "path": "coefficients/side24_d4_closed_form_20260930/NOTE.md", + "git_blob": "cbf35dead9f20cb8e68c357c62aca6413fb870af", + "role": "D_3 = (50 pi + 200 arctan 2 - 228)/(9 pi) (rule D3_EXACT)" + } + ], + "files": [ + { + "path": "NOTE.md", + "bytes": 21618, + "sha256": "cba042c28d9f09999d653f7bceafe52eda2fd4794104b8d9d81ab53dcac1acc5", + "git_blob": "d67d4fe4cddcaa877452d75b12c4e7b7016f25bb" + }, + { + "path": "RESULTS.json", + "bytes": 21015, + "sha256": "9d97628a73ca25ece9732c7c00a03acc74456ea21c32b8dc18f370db934908b2", + "git_blob": "eb1b28c274494eec3dbe3d1454b83d55c6367baa" + }, + { + "path": "window_coefficient_d4.py", + "bytes": 54785, + "sha256": "96cb6963993102a48436163acc40132e7b99fade96361d43b1c9c491688e0d5c", + "git_blob": "f77f7d2d158f9513f23f1b55fe0f839eb112d387" + } + ] +} diff --git a/frontiers/c8_window_coefficient_d4_20261001/window_coefficient_d4.py b/frontiers/c8_window_coefficient_d4_20261001/window_coefficient_d4.py new file mode 100644 index 000000000..f77f7d2d1 --- /dev/null +++ b/frontiers/c8_window_coefficient_d4_20261001/window_coefficient_d4.py @@ -0,0 +1,1292 @@ +"""The compact-window coefficient c_{B,K} of [LP] Theorem B in d = 4: reference value and transfer to the torus for every +L >= 10 and every frame. + +Standard library only. Run from anywhere: python -B -S window_coefficient_d4.py [--mutant NAME] (about seventy seconds) +Every printed interval [lo, hi] is a rigorous enclosure: interval arithmetic over `decimal` (60 digits, directed rounding; exp +and sqrt widened by two units in the last place and checked against exact rational brackets by rule LIBRARY_EXACT), pi by +Machin, fractional powers by exact integer roots, erf and the lower incomplete gamma function by positive series with geometric +tails, arctan and Owen's T by alternating series bracketed by consecutive partial sums (the Math-#197 toolkit, unchanged), and one +one-dimensional integral by an order-40 Taylor expansion at each cell centre with a Cauchy remainder (Math-#199 section 3). + +Object ([LP] = imports/lifetime_parent_20260925/UNIFORM_MATRIX_CAP_AND_LIFETIME.md, (11.3) with the section 15 factorization, +both stated for every d; frame (u, w1, w2, w3), G = grad f, V = (f_uu, f_uw1, f_uw2, f_uw3), A the 3 x 3 transverse Hessian, +t = f_uuu): + + c^(4)_{B,K} = 144 int_{S^3} p_G(0) p_V(0) I_B(u) J_K(u) dsigma(u), I_B(u) = E[1{f in B} det(A)^2 1{A < 0} | V = 0], + J_K(u) = int_K k^(4/3) phi_tau(12 k) dk, tau^2 = Var(t | G = 0). + +Reference kernel. (f, A) | V = 0 is f ~ N(0, 2/3) and A = Q - f I with Q the 3 x 3 GOE (density ~ exp(-tr Q^2/4)) independent +of f. On the ordered eigenvalue sector of A, with total trace -T and differences (s, q), the birth window enters only through +W_B(T) = Phi(sqrt3 (b_+ - T/6)) - Phi(sqrt3 (b_- - T/6)), and only odd powers of q occur, so the q- and s-integrals are exact: + + I^ref_B = (1/(96 pi)) int_0^inf exp(-T^2/24) F_3(T) W_B(T) dT, F_3 elementary (polynomials, exp(-T^2/24), exp(-T^2/6), + erf(T/sqrt24), erf(T/sqrt6)), + +and B = R returns Math-#201's D_3 = (50 pi + 200 arctan 2 - 228)/(9 pi). The same code at m = 2 returns 29/6 - sqrt6 and +Math-#197's d = 3 window values (closed form through Owen's T). + +Torus. If (1-eps) C'_ref <= C' <= (1+eps) C'_ref for the covariance of the 7-vector (f, A) | V = 0, the density comparison and +the degree-6 homogeneity of det(A)^2 give (Lemma S of Math-#205 with n = 7, degree 6) + + (1-eps)^(13/2)/(1+eps)^(7/2) I^ref_{B/sqrt(1-eps)} <= I'_B <= (1+eps)^(13/2)/(1-eps)^(7/2) I^ref_{B/sqrt(1+eps)}. + +lambda_min(C'_ref) = (7 - sqrt37)/3 = 0.3057 (below SIDE24's 1/3): eps = ||C' - C'_ref||_F / (3/10) over the entry box of the +d = 4 image bound E^(4)_L = 10240 (76 L^6 + 15) exp(-L^2/2); p_G(0), p_V(0) and tau^2 over the same box. One enclosure covers +every frame and every L >= 10. Scientific effect NONE. +""" +import argparse +import json +import math +import sys +import time +from decimal import Decimal, Context, ROUND_FLOOR, ROUND_CEILING, ROUND_HALF_EVEN, setcontext +from fractions import Fraction as Fr + +MUTANTS = ("image-shells", "d3-floor", "sandwich-swap", "window-scale", "trace-slope", "moment-recurrence", "remainder-dropped", + "schur-sign", "tau-cross", "sphere", "tilt-gamma") +MUT = None + +PREC = 60 +CF = Context(prec=PREC, rounding=ROUND_FLOOR, Emin=-9999999, Emax=9999999) +CC = Context(prec=PREC, rounding=ROUND_CEILING, Emin=-9999999, Emax=9999999) +CE = Context(prec=PREC, rounding=ROUND_HALF_EVEN, Emin=-9999999, Emax=9999999) +# Every arithmetic step below names one of the three contexts; operator syntax on Decimals would round to the thread's +# current context, which is widened as a safety net (rule LIBRARY_EXACT checks exp, sqrt and the negation). +setcontext(Context(prec=2 * PREC + 20, rounding=ROUND_HALF_EVEN, Emin=-9999999, Emax=9999999)) +ZERO, ONE, HALF = Decimal(0), Decimal(1), Decimal("0.5") +INF = math.inf +ROOT_DIGITS = 70 +K_ORDER, RHO, CELL, T_CUT = 40, Fr(6), Fr(1, 2), Fr(60) # Taylor order, Cauchy radius, cell width, cut (Math-#199 section 3) +C4_REF_199 = "0.023321666002952835094521194952856885153101372363" # Math-#199 RESULTS.json (c_{4,ref}, pinned there) +PINNED = {"c_4_ref": "0.023321666002952835094521194952856885153101372363", "D_3": "5.32318026888989689492319873968726063578438852944", "F4|[0,1]": "0.1539033000676815392013091707812771979851002980", "c4|[0,1]x[1/2,2] ref": "0.000241816107038247274210322215843921349422155120", "pi": "3.14159265358979323846264338327950288419716939937510"} + + +# ---------------- interval arithmetic and special functions (Math-#197 toolkit, unchanged) +def ulp(x): + if x == 0: + return Decimal(1).scaleb(-PREC - 30) + return Decimal(1).scaleb(x.adjusted() - PREC + 1) + + +class Iv: + """Closed interval [lo, hi] of Decimals; every operation encloses the exact result.""" + __slots__ = ("lo", "hi") + + def __init__(self, lo, hi=None): + if hi is None: + hi = lo + if lo > hi: + raise ValueError("empty interval") + self.lo, self.hi = lo, hi + + @staticmethod + def frac(q): + q = Fr(q) + n, d = Decimal(q.numerator), Decimal(q.denominator) + return Iv(CF.divide(n, d), CC.divide(n, d)) + + @staticmethod + def of(x): + return x if isinstance(x, Iv) else Iv.frac(x) + + def __add__(a, b): + b = Iv.of(b) + return Iv(CF.add(a.lo, b.lo), CC.add(a.hi, b.hi)) + __radd__ = __add__ + + def __neg__(a): + return Iv(a.hi.copy_negate(), a.lo.copy_negate()) # exact: unary minus would round to the default context + + def __sub__(a, b): + b = Iv.of(b) + return Iv(CF.subtract(a.lo, b.hi), CC.subtract(a.hi, b.lo)) + + def __rsub__(a, b): + return Iv.of(b) - a + + def __mul__(a, b): + b = Iv.of(b) + c = [(x, y) for x in (a.lo, a.hi) for y in (b.lo, b.hi)] + return Iv(min(CF.multiply(x, y) for x, y in c), max(CC.multiply(x, y) for x, y in c)) + __rmul__ = __mul__ + + def __truediv__(a, b): + b = Iv.of(b) + if b.lo <= 0 <= b.hi: + raise ZeroDivisionError("interval division by an interval containing 0") + c = [(x, y) for x in (a.lo, a.hi) for y in (b.lo, b.hi)] + return Iv(min(CF.divide(x, y) for x, y in c), max(CC.divide(x, y) for x, y in c)) + + def __rtruediv__(a, b): + return Iv.of(b) / a + + def sq(a): + if a.lo <= 0 <= a.hi: + return Iv(ZERO, max(CC.multiply(a.lo, a.lo), CC.multiply(a.hi, a.hi))) + return a * a + + def exp(a): + lo, hi = CE.exp(a.lo), CE.exp(a.hi) + return Iv(max(ZERO, CF.subtract(lo, CC.multiply(Decimal(2), ulp(lo)))), CC.add(hi, CC.multiply(Decimal(2), ulp(hi)))) + + def sqrt(a): + if a.lo < 0: + raise ValueError("sqrt of an interval with negative part") + lo, hi = CE.sqrt(a.lo), CE.sqrt(a.hi) + return Iv(max(ZERO, CF.subtract(lo, CC.multiply(Decimal(2), ulp(lo)))), CC.add(hi, CC.multiply(Decimal(2), ulp(hi)))) + + def width(a): + return CC.subtract(a.hi, a.lo) + + def contains(a, x): + x = Iv.of(x) + return a.lo <= x.lo and x.hi <= a.hi + + def intersects(a, b): + return a.lo <= b.hi and b.lo <= a.hi + + def mag(a): + return max(abs(a.lo), abs(a.hi)) + + def mid_float(a): + return float((a.lo + a.hi) / 2) + + def pair(a): + return [str(a.lo), str(a.hi)] + + +def hull(a, b): + return Iv(min(a.lo, b.lo), max(a.hi, b.hi)) + + +def inroot(N, n): + """floor(N ** (1/n)) for integers N >= 0, n >= 1: integer Newton iteration started above the root.""" + if N < 2: + return N + x = 1 << ((N.bit_length() + n - 1) // n) + while True: + y = ((n - 1) * x + N // pow(x, n - 1)) // n + if y >= x: + break + x = y + if not (pow(x, n) <= N < pow(x + 1, n)): + raise ValueError("integer root failed") + return x + + +def root_frac(q, n): + """Rigorous bracket of q ** (1/n) for a positive rational q, width 10^-ROOT_DIGITS.""" + q = Fr(q) + if q <= 0: + raise ValueError("root of a nonpositive number") + p, d = q.numerator, q.denominator + scale = 10 ** ROOT_DIGITS + r = inroot(p * d ** (n - 1) * scale ** n, n) + den = d * scale + return Iv(Iv.frac(Fr(r, den)).lo, Iv.frac(Fr(r + 1, den)).hi) + + +def root_iv(x, n): + """x ** (1/n) for an interval x > 0 (monotone: endpoint brackets).""" + return Iv(root_frac(Fr(x.lo), n).lo, root_frac(Fr(x.hi), n).hi) + + +def pi_interval(): + def atan_inv(n, terms): + x = Fr(1, n) + partial, sums = Iv(ZERO), [] + for m in range(terms + 2): + t = Iv.frac(x ** (2 * m + 1) / (2 * m + 1)) + partial = partial + t if m % 2 == 0 else partial - t + sums.append(partial) + return hull(sums[-1], sums[-2]) # alternating series with decreasing terms + return atan_inv(5, 44) * 16 - atan_inv(239, 22) * 4 + + +PI = pi_interval() +SQRT2 = Iv.frac(2).sqrt() +SQRT3 = Iv.frac(3).sqrt() +SQRT2PI = (2 * PI).sqrt() +SQRTPI = PI.sqrt() +TINY = Decimal(10) ** (-PREC - 8) + + +def erf_point(x, coarse=False): + """erf(x) at a Decimal point: (2/sqrt pi) exp(-x^2) sum_n 2^n x^(2n+1)/(2n+1)!!, positive terms; once the term ratio + 2x^2/(2n+3) is at most 1/2 the omitted tail is at most twice the first omitted term. coarse=True stops at that point + (a valid, wider enclosure used by TRUNCATION_NESTING); the production run continues until the tail is negligible.""" + tail = MUT != "tail-dropped" + coarse = coarse or not tail + if x < 0: + return -erf_point(-x, coarse) + if x == 0: + return Iv(ZERO) + X = Iv(x) + x2 = X * X + t, S, n = X, Iv(ZERO), 0 + while True: + S = S + t + ratio = x2 * 2 / (2 * n + 3) + t = t * ratio + n += 1 + if ratio.hi <= HALF and (coarse or t.hi < S.lo * TINY): + break + if n > 200000: + raise RuntimeError("erf series did not converge") + rest = Iv(ZERO, CC.multiply(Decimal(2), t.hi)) if tail else Iv(ZERO) + return (S + rest) * (-x2).exp() * 2 / SQRTPI + + +def erf_iv(x, coarse=False): + return Iv(erf_point(x.lo, coarse).lo, erf_point(x.hi, coarse).hi) + + +def Phi(x): + return (1 + erf_iv(x / SQRT2)) / 2 + + +def phi(x): + return (-(x.sq()) / 2).exp() / SQRT2PI + + +def atan_iv(a, N=90): + """arctan(a) for an interval 0 <= a <= 1: halve the argument, then the alternating series bracketed by consecutive + partial sums (for each fixed argument the terms decrease, so the value lies between them).""" + a1 = a / (1 + (1 + a.sq()).sqrt()) + a1sq, p, S, prev = a1.sq(), a1, Iv(ZERO), None + for n in range(N + 1): + t = p / (2 * n + 1) + prev = S + S = S + t if n % 2 == 0 else S - t + p = p * a1sq + return 2 * hull(prev, S) + + +def owen_T(h, a, N=160, bracket=True): + """Owen's T(h, a) = (1/2 pi) int_0^a exp(-h^2 (1+x^2)/2)/(1+x^2) dx for 0 <= a <= 1, by Owen's series + T = (1/2 pi)[arctan a - sum_j c_j a^(2j+1)], c_j = (-1)^j/(2j+1) [1 - exp(-h^2/2) sum_{i<=j} (h^2/2)^i/i!]. + The bracket is P(Poisson(h^2/2) > j), decreasing in j, so for fixed (h, a) the terms alternate with decreasing size and + the sum lies between consecutive partial sums; interval evaluation of both encloses it for every point of the intervals.""" + if MUT == "no-owen": + return Iv(ZERO) + h2 = h.sq() / 2 + e = (-h2).exp() + pois, term, apow, a2 = Iv(ONE), Iv(ONE), a, a.sq() + S, prev = Iv(ZERO), None + for j in range(N + 1): + if j > 0: + term = term * h2 / j + pois = pois + term + cj = apow / (2 * j + 1) * (1 - e * pois) + prev = S + S = S + cj if j % 2 == 0 else S - cj + apow = apow * a2 + val = hull(prev, S) if bracket else S + return (atan_iv(a) - val) / (2 * PI) + + +def owen_T_eval(h, a): + if MUT == "tail-dropped": + return owen_T(h, a, N=6, bracket=False) + return owen_T(h, a) + + +def SHAPE(): + """Shape parameter of the gap-window incomplete gamma factor (mutant gamma-shape perturbs it).""" + return Fr(4, 3) if MUT == "gamma-shape" else Fr(7, 6) + + +def gamma_lower_point(x, a, coarse=False): + """gamma(a, x) = int_0^x s^(a-1) e^-s ds = x^a e^-x sum_n x^n/(a (a+1) ... (a+n)), positive terms; once the term ratio + x/(a+n) is at most 1/2 the omitted tail is at most twice the first omitted term. x a Decimal point >= 0, a = 7/6 or 4/3.""" + tail = MUT != "tail-dropped" + coarse = coarse or not tail + if x == 0: + return Iv(ZERO) + X = Iv(x) + t, S, n = Iv.frac(1 / a), Iv(ZERO), 0 + while True: + S = S + t + n += 1 + ratio = X / Iv.frac(a + n) + t = t * ratio + if ratio.hi <= HALF and (coarse or t.hi < S.lo * TINY): + break + if n > 200000: + raise RuntimeError("incomplete gamma series did not converge") + rest = Iv(ZERO, CC.multiply(Decimal(2), t.hi)) if tail else Iv(ZERO) + xa = X * root_frac(Fr(x), 6) if a == Fr(7, 6) else X * root_frac(Fr(x), 3) # x^a + return xa * (-X).exp() * (S + rest) + + +def gamma_lower(x, a, coarse=False): + """gamma(a, x) for an interval x >= 0 or x = INF (monotone in x).""" + if isinstance(x, float): + return GAMMA[a] + return Iv(gamma_lower_point(x.lo, a, coarse).lo, gamma_lower_point(x.hi, a, coarse).hi) + + +def gamma_complete(a, X=Decimal(120)): + """Gamma(a) = gamma(a, X) + Gamma(a, X), 1 < a < 2, with X^(a-1) e^-X <= Gamma(a, X) <= X^(a-1) e^-X / (1 - (a-1)/X).""" + low = gamma_lower_point(X, a) + xa1 = root_frac(Fr(X), 6) if a == Fr(7, 6) else root_frac(Fr(X), 3) + up = xa1 * (-Iv(X)).exp() + return low + Iv(up.lo, (up / (1 - Iv.frac(a - 1) / Iv(X))).hi) + + +GAMMA = {Fr(7, 6): gamma_complete(Fr(7, 6)), Fr(4, 3): gamma_complete(Fr(4, 3))} +GAMMA76 = GAMMA[Fr(7, 6)] +CBRT32 = root_frac(Fr(12), 3) / 2 # (3/2)^(1/3) = 12^(1/3)/2 +C72 = 1 / (72 * root_frac(Fr(72), 6)) # 72^(-7/6) +SIGMA_REF = Iv.frac(Fr(2, 3)).sqrt() # sd of f | V=0 for the reference kernel +D2_EXACT = Iv.frac(Fr(29, 6)) - Iv.frac(6).sqrt() # SIDE24 cone moment m = 2 +C3_REF = GAMMA76 * CBRT32 * D2_EXACT / (2 * SQRT3 * PI * PI * SQRTPI) # SIDE24 (1), d = 3 + + +# ---------------- the Gaussian integrals int_{-inf}^x t^n phi(t) Phi(a t) dt, n <= 4 (Math-#197 section 2, unchanged) +def G_finite(x, a): + rho2 = 1 + a.sq() + rho = rho2.sqrt() + Phx, phx, Phax = Phi(x), phi(x), Phi(a * x) + T = owen_T_eval(x, a) + Erho = (-(rho2 * x.sq()) / 2).exp() + Phrx = Phi(rho * x) + x2 = x.sq() + G0 = Phx / 2 - T + G1 = -phx * Phax + a / (rho * SQRT2PI) * Phrx + G2 = G0 - x * phx * Phax - a / (2 * PI * rho2) * Erho + G3 = -x2 * phx * Phax + a / (2 * PI) * (-(x / rho2) * Erho + SQRT2PI / (rho2 * rho) * Phrx) + 2 * G1 + G4 = -x * x2 * phx * Phax - a / (2 * PI) * (x2 / rho2 + 2 / rho2.sq()) * Erho + 3 * G2 + return [G0, G1, G2, G3, G4] + + +def G_limit(a, sign): + if sign < 0: + return [Iv(ZERO)] * 5 + rho2 = 1 + a.sq() + rho = rho2.sqrt() + g1 = a / (rho * SQRT2PI) + return [Iv.frac(Fr(1, 2)), g1, Iv.frac(Fr(1, 2)), a / (rho2 * rho * SQRT2PI) + 2 * g1, Iv.frac(Fr(3, 2))] + + +def G_at(x, a): + """x an interval or +-INF.""" + if isinstance(x, float): + return G_limit(a, 1 if x > 0 else -1) + return G_finite(x, a) + + +def P_reg(s): + """Regularized lower incomplete gamma P(7/6, s) (s an interval >= 0 or INF).""" + a = SHAPE() + return gamma_lower(s, a) / GAMMA76 + + +def G_ref(K): + lo, hi = K + def s(k): + return k if isinstance(k, float) else 12 * Iv.frac(k * k) + return P_reg(s(hi)) - P_reg(s(lo)) + + +def library_exact(): + """exp and sqrt of the decimal module, and the interval negation, against exact rational brackets: e^-q by the + rational series of e^(-q/64) raised to the 64th power (alternating tail below the last term), sqrt by an integer root.""" + ok = True + args = [Fr(48) - Fr(51035039649098175696, 10 ** 29), Fr(3), Fr(120), Fr(1, 2), Fr(288), Fr(5, 7)] + for q in args: + g = -q / 64 + parts = [] + term, ssum = Fr(1), Fr(0) + for k in range(0, 60): + ssum += term + parts.append(ssum) + term = term * g / (k + 1) + lo, hi = min(parts[-1], parts[-2]), max(parts[-1], parts[-2]) # alternating series with decreasing terms + exact = Iv(Iv.frac(lo ** 64).lo, Iv.frac(hi ** 64).hi) # e^-q = (e^(-q/64))^64, both endpoints positive + X = Iv.frac(q) + got = (-X).exp() + ok &= got.intersects(exact) and CC.divide(got.width(), got.lo) < Decimal(10) ** (-PREC + 3) + r = root_frac(q, 2) + ok &= X.sqrt().intersects(r) and CC.divide(X.sqrt().width(), r.lo) < Decimal(10) ** (-PREC + 3) + ok &= (-X).lo == X.hi.copy_negate() and (-X).hi == X.lo.copy_negate() + return ok + + +# ---------------- the d = 3 reference birth integral with interval endpoints (Math-#197 (4.1) and its three primitives) +def endpoint(b): + return b if isinstance(b, (float, Iv)) else Iv.frac(b) + + +def I3_ref(lo, hi): + """int_lo^hi phi_{2/3}(b) m_{3,b} db, m_{3,b} = (b^3 + b) phi(b) + (b^4 + 2 b^2 + 7) Phi(b) - 4 sqrt2 exp(-b^2/4) Phi(b/sqrt2); + lo, hi are rationals, intervals or +-INF.""" + sig = SIGMA_REF + def term_i(b): + if isinstance(b, float): + return Iv(ZERO) + return -(b.sq() * 2 / 5 + Iv.frac(Fr(18, 25))) * (-(b.sq()) * 5 / 4).exp() / (2 * PI * sig) + def term_ii(b): + G = G_at(b if isinstance(b, float) else b / sig, sig) + return sig.sq().sq() * G[4] + 2 * sig.sq() * G[2] + 7 * G[0] + def term_iii(b): + G = G_at(b if isinstance(b, float) else b * SQRT2, Iv.frac(Fr(1, 2))) + return 4 / sig * G[0] + lo, hi = endpoint(lo), endpoint(hi) + cross = Iv.frac(Fr(1, 2)) if MUT == "d3-cross" else Iv(ONE) + return (term_i(hi) - term_i(lo)) + (term_ii(hi) - term_ii(lo)) - cross * (term_iii(hi) - term_iii(lo)) + + +# ---------------- exact polynomial algebra (Math-#199 cone_moment_d4.py, unchanged) +def padd(u, v): + w = dict(u) + for k, c in v.items(): + w[k] = w.get(k, Fr(0)) + c + return {k: c for k, c in w.items() if c != 0} + + +def pmul(u, v): + w = {} + for k1, c1 in u.items(): + for k2, c2 in v.items(): + k = tuple(a + b for a, b in zip(k1, k2)) + w[k] = w.get(k, Fr(0)) + c1 * c2 + return {k: c for k, c in w.items() if c != 0} + + +def pscale(u, c): + return {k: v * c for k, v in u.items() if v * c != 0} + + +def pconst(c, nvars): + return {(0,) * nvars: Fr(c)} if c != 0 else {} + + +def pvar(i, nvars): + e = [0] * nvars + e[i] = 1 + return {tuple(e): Fr(1)} + + +def plin(coeffs): + """sum_i coeffs[i] * variable_i.""" + out = {} + for i, c in enumerate(coeffs): + if c: + out = padd(out, pscale(pvar(i, len(coeffs)), Fr(c))) + return out + + +def lpadd(u, v): + n = max(len(u), len(v)) + return [(u[i] if i < len(u) else Fr(0)) + (v[i] if i < len(v) else Fr(0)) for i in range(n)] + + +def lpmul(u, v): + if not u or not v: + return [] + w = [Fr(0)] * (len(u) + len(v) - 1) + for i, a in enumerate(u): + for j, b in enumerate(v): + w[i + j] += a * b + return w + + +# ---------------- the reference birth integral as a one-dimensional integral in the total trace (NOTE section 2) +def Jk_closed(k): + """J_k(s) = int_0^s q^k e^{-q^2/8} dq for odd k: J_k = B_k + C_k(s) e^{-s^2/8} with B_k rational and C_k a rational polynomial + (list by power): J_1 = 4 - 4 e^{-s^2/8}, J_{k+2} = -4 s^{k+1} e^{-s^2/8} + 4 (k+1) J_k.""" + if k % 2 != 1: + raise ValueError("even power of q") + B, C, j = Fr(4), [Fr(-4)], 1 + while j < k: + C2 = [4 * (j + 1) * c for c in C] + [Fr(0)] * (j + 2 - len(C)) + C2[j + 1] += -4 + B, C, j = 4 * (j + 1) * B, C2, j + 2 + return B, C + + +def moments(gamma, nmax): + """M_j(T) = int_0^T s^j e^{-gamma s^2} ds = alpha_j + rho_j(T) e^{-gamma T^2} + beta_j E_gamma(T), E_gamma = (1/2) sqrt(pi/gamma) + erf(sqrt(gamma) T): M_0 = E_gamma, M_1 = (1 - e^{-gamma T^2})/(2 gamma), M_{j+2} = ((j+1) M_j - T^{j+1} e^{-gamma T^2})/(2 gamma).""" + g = Fr(gamma) + M = [(Fr(0), [], Fr(1)), (1 / (2 * g), [-1 / (2 * g)], Fr(0))] + for j in range(nmax - 1): + a, r, b = M[j] + f = Fr(j if MUT == "moment-recurrence" else j + 1) + r2 = [x * f / (2 * g) for x in r] + [Fr(0)] * (j + 2 - len(r)) + r2[j + 1] += -1 / (2 * g) + M.append((f * a / (2 * g), r2, f * b / (2 * g))) + return M + + +def F_pieces(m): + """The inner integrals in closed form. m = 3: on the ordered sector mu_3 = -a, mu_2 = -a-p, mu_1 = -a-p-q put T = 3a + 2p + q + (minus the trace), s = 2p + q, q (Jacobian 1/6, region T > s > q > 0); the integrand is P(T, s, q) e^{-T^2/24 - s^2/24 - q^2/8} + with P = a^2 (a+p)^2 (a+p+q)^2 pq(p+q), a = (T-s)/3, p = (s-q)/2. m = 2: mu_2 = -a, mu_1 = -a-p, T = 2a + p, p (Jacobian 1/2), + P = (T^2 - p^2)^2 p/16, exponent 3T^2/40 + p^2/8. Returns ({kind: polynomial in T}, outer gamma) with F_m(T) = sum of + poly * [1 | e^{-g T^2} | E_g(T)] by kind ('1',), ('e', g), ('E', g).""" + out = {} + + def acc(key, poly): + out[key] = lpadd(out.get(key, []), poly) + if m == 3: + T, s, q = pvar(0, 3), pvar(1, 3), pvar(2, 3) + a, p = plin([Fr(1, 3), Fr(-1, 3), 0]), plin([0, Fr(1, 2), Fr(-1, 2)]) + ap = padd(a, p) + apq = padd(ap, q) + P = pmul(pmul(pmul(a, a), pmul(ap, ap)), pmul(apq, apq)) + P = pmul(P, pmul(pmul(p, q), padd(p, q))) + U, V = {}, {} + for (i, j, k), c in P.items(): + Bk, Ck = Jk_closed(k) # raises on an even power of q + U = padd(U, {(i, j): c * Bk}) + V = padd(V, pmul({(i, j): c}, {(0, n): x for n, x in enumerate(Ck) if x})) + for W_, gam in ((U, Fr(1, 24)), (V, Fr(1, 24) + Fr(1, 8))): + Ms = moments(gam, max(j for (_, j) in W_)) + for (i, j), c in W_.items(): + a_, r_, b_ = Ms[j] + Ti = [Fr(0)] * i + [c] + acc(("1",), lpmul(Ti, [a_])) + acc(("e", gam), lpmul(Ti, r_)) + acc(("E", gam), lpmul(Ti, [b_])) + return out, Fr(1, 24) + if m == 2: + T, p = pvar(0, 2), pvar(1, 2) + d = padd(pmul(T, T), pscale(pmul(p, p), Fr(-1))) + P = pscale(pmul(pmul(d, d), p), Fr(1, 16)) + for (i, k), c in P.items(): + Bk, Ck = Jk_closed(k) + acc(("1",), lpmul([Fr(0)] * i + [c], [Bk])) + acc(("e", Fr(1, 8)), lpmul([Fr(0)] * i + [c], Ck)) + return out, Fr(3, 40) + raise ValueError("m must be 2 or 3") + + +def trim(poly): + poly = list(poly) + while poly and poly[-1] == 0: + poly.pop() + return poly + + +def g_terms(m, gamma_out=None): + """g_m(T) = e^{-gamma_out T^2} F_m(T) as terms (const, polynomial, gamma, kappa): const * poly(T) e^{-gamma T^2} [erf(kappa T)].""" + pieces, g_ref = F_pieces(m) + gout = g_ref if gamma_out is None else gamma_out + terms = [] + for key, poly in sorted(pieces.items(), key=lambda kv: str(kv[0])): + poly = trim(poly) + if not poly: + continue + if key[0] == "1": + terms.append((Iv(ONE), poly, Iv.frac(gout), None)) + elif key[0] == "e": + terms.append((Iv(ONE), poly, Iv.frac(gout + key[1]), None)) + else: + terms.append(((PI / Iv.frac(key[1])).sqrt() / 2, poly, Iv.frac(gout), Iv.frac(key[1]).sqrt())) + return terms + + +def F_float(pieces, T): + tot = 0.0 + for key, poly in pieces.items(): + pv = sum(float(c) * T ** i for i, c in enumerate(poly)) + if key[0] == "1": + tot += pv + elif key[0] == "e": + tot += pv * math.exp(-float(key[1]) * T * T) + else: + g = float(key[1]) + tot += pv * 0.5 * math.sqrt(math.pi / g) * math.erf(math.sqrt(g) * T) + return tot + + +def F3_direct_float(T, n=200): + """int_0^T int_0^s P(T, s, q) e^{-s^2/24 - q^2/8} dq ds by composite Simpson in (s, q): an independent float control of the + exact layers.""" + hs = T / n + tot = 0.0 + for i in range(n + 1): + sv = i * hs + ws = 1 if i in (0, n) else (4 if i % 2 else 2) + hq = sv / n + inner = 0.0 + for j in range(n + 1): + qv = j * hq + wq = 1 if j in (0, n) else (4 if j % 2 else 2) + a, p = (T - sv) / 3, (sv - qv) / 2 + inner += wq * a * a * (a + p) ** 2 * (a + p + qv) ** 2 * p * qv * (p + qv) * math.exp(-sv * sv / 24 - qv * qv / 8) + tot += ws * inner * hq / 3 + return tot * hs / 3 + + +# ---------------- Taylor quadrature with Cauchy remainders (Math-#199 section 3; factors as functions, plus Phi(alpha - beta T)) +def ipow(x, n): + r = Iv(ONE) + for _ in range(n): + r = r * x + return r + + +def gauss_coeffs(g, s0, K): + """Taylor coefficients of exp(-g s^2) at s0: (n+1) y_{n+1} = -2 g (s0 y_n + y_{n-1}).""" + S0 = Iv.frac(s0) + y = [(-(g * S0.sq())).exp()] + prev = Iv(ZERO) + for n in range(K): + nxt = -(2 * g) * (S0 * y[n] + prev) / (n + 1) + prev = y[n] + y.append(nxt) + return y + + +def gauss_bound(g, s0, rho): + inner = max(Fr(0), abs(Fr(s0)) - Fr(rho)) + return (g * Iv.frac(rho * rho) - g * Iv.frac(inner * inner)).exp() # |e^{-g z^2}| = e^{-g(x^2 - y^2)}, |y| <= rho + + +def erf_coeffs(kappa, s0, K): + """erf(kappa s): value at s0, then (2 kappa/sqrt pi) times the Gaussian's coefficients divided by n + 1.""" + y = gauss_coeffs(kappa.sq(), s0, K) + pref = 2 * kappa / SQRTPI + return [erf_iv(kappa * Iv.frac(s0))] + [pref * y[n] / (n + 1) for n in range(K)] + + +def erf_bound(kappa, s0, rho): + return 2 * kappa / SQRTPI * Iv.frac(abs(Fr(s0)) + Fr(rho)) * (kappa.sq() * Iv.frac(Fr(rho) ** 2)).exp() + + +def poly_coeffs(c, s0, K): + out = [] + for n in range(K + 1): + v = Fr(0) + for j, cj in enumerate(c): + if j >= n: + v += cj * math.comb(j, n) * Fr(s0) ** (j - n) + out.append(Iv.frac(v)) + return out + + +def poly_bound(c, s0, rho): + r = abs(Fr(s0)) + Fr(rho) + return Iv.frac(sum(abs(cj) * r ** j for j, cj in enumerate(c))) + + +def t_mul(u, v): + K = len(u) - 1 + out = [] + for n in range(K + 1): + acc = Iv(ZERO) + for i in range(n + 1): + acc = acc + u[i] * v[n - i] + out.append(acc) + return out + + +def phi_aff_coeffs(alpha, beta, s0, K): + """Phi(alpha - beta T) at T = s0 + x (alpha, beta real intervals, beta > 0): c_0 = Phi(w0), w0 = alpha - beta s0, and + c_{n+1} = -(beta/sqrt(2 pi)) y_n/(n+1) with y the coefficients of exp(-(w0 - beta x)^2/2), (n+1) y_{n+1} = beta w0 y_n - beta^2 y_{n-1}.""" + w0 = alpha - beta * Iv.frac(s0) + y = [(-(w0.sq()) / 2).exp()] + prev = Iv(ZERO) + b2 = beta.sq() + for n in range(K): + nxt = (beta * w0 * y[n] - b2 * prev) / (n + 1) + prev = y[n] + y.append(nxt) + pref = beta / SQRT2PI + return [Phi(w0)] + [-(pref * y[n] / (n + 1)) for n in range(K)] + + +def phi_aff_bound(beta, rho): + """|Phi(alpha - beta z)| <= Phi(w0) + |int_{w0}^{w} phi| <= 1 + beta rho e^{beta^2 rho^2/2}/sqrt(2 pi) on |z - s0| <= rho + (the segment from the real point w0 has |Im t| <= beta rho, and |phi(t)| <= e^{(Im t)^2/2}/sqrt(2 pi)).""" + br = beta * Iv.frac(rho) + return 1 + br * (br.sq() / 2).exp() / SQRT2PI + + +class Model: + """int_0^inf g(T) Phi(alpha - beta T) dT for g = sum const * poly(T) e^{-gamma T^2} [erf(kappa T)] (entire). On each cell of + width CELL the point Taylor coefficients of g at the centre are computed once and contracted with the cell moments, so that an + evaluation for given (alpha, beta) costs one product of coefficient vectors per cell. The remainder of the order-K Taylor + polynomial of the product is bounded by Cauchy's estimate at the centre, |c_n| <= M_g M_Phi / rho^n, summed geometrically; + beyond T_CUT the integrand is bounded by |g| (0 <= Phi <= 1) and incomplete gamma bounds.""" + + def __init__(self, terms, K=K_ORDER, cell=CELL, T=T_CUT, rho=RHO): + self.K, self.rho = K, rho + half = cell / 2 + ncell = int(T / cell) + if ncell * cell != T or Fr(half) >= Fr(rho): + raise ValueError("bad quadrature parameters") + mom = [Iv.frac(2 * half ** (n + 1) / (n + 1)) if n % 2 == 0 else Iv(ZERO) for n in range(K + 1)] + rem_moment = Iv.frac(2 * half ** (K + 2) / (K + 2) / (1 - Fr(half) / Fr(rho))) + rho_pow = Iv.frac(Fr(rho) ** (K + 1)) + self.cells, Rsum = [], Iv(ZERO) + for c in range(ncell): + s0 = (2 * c + 1) * half + G, M = [Iv(ZERO)] * (K + 1), Iv(ZERO) + for const, poly, gam, kap in terms: + pc = t_mul(poly_coeffs(poly, s0, K), gauss_coeffs(gam, s0, K)) + Mb = poly_bound(poly, s0, rho) * gauss_bound(gam, s0, rho) + if kap is not None: + pc = t_mul(pc, erf_coeffs(kap, s0, K)) + Mb = Mb * erf_bound(kap, s0, rho) + G = [x + const * y for x, y in zip(G, pc)] + M = M + Iv(const.mag()) * Mb + Gm = [] + for j in range(K + 1): + acc = Iv(ZERO) + for i in range(j % 2, K + 1 - j, 2): + acc = acc + G[i] * mom[i + j] + Gm.append(acc) + self.cells.append((s0, Gm)) + Rsum = Rsum + M / rho_pow * rem_moment + self.Rsum = Rsum.hi + tail = Iv(ZERO) + for const, poly, gam, kap in terms: # int_T^inf t^j e^{-g t^2} dt = (1/2) g^{-(j+1)/2} Gamma((j+1)/2, g T^2) + x = gam * Iv.frac(T * T) + for j, cj in enumerate(poly): + if cj == 0: + continue + a = Fr(j + 1, 2) + if a.denominator == 2: + xa1, gpow = ipow(x, int(a - Fr(1, 2))) * x.sqrt() / x, ipow(gam, int(a)) * gam.sqrt() + else: + xa1, gpow = ipow(x, int(a) - 1), ipow(gam, int(a)) + up = xa1 * (-x).exp() # Gamma(a, x) <= x^(a-1) e^-x (a <= 1), / (1 - (a-1)/x) (a > 1) + if a > 1: + up = up / (1 - Iv.frac(a - 1) / x) + tail = tail + Iv(const.mag()) * Iv.frac(abs(cj)) * up / gpow / 2 + self.tail = tail.hi + + def integral(self, alpha=None, beta=None): + tot = Iv(ZERO) + if alpha is None: + for _, Gm in self.cells: + tot = tot + Gm[0] + R = self.Rsum + else: + for s0, Gm in self.cells: + Wc = phi_aff_coeffs(alpha, beta, s0, self.K) + for j in range(self.K + 1): + tot = tot + Wc[j] * Gm[j] + R = (Iv(self.Rsum) * phi_aff_bound(beta, self.rho)).hi + if MUT == "remainder-dropped": + R = ZERO + R = CC.add(R, self.tail) + return tot + Iv(R.copy_negate(), R) + + +MODELS = {} + + +def model(m, gamma_out=None): + key = (m, gamma_out) + if key not in MODELS: + MODELS[key] = Model(g_terms(m, gamma_out)) + return MODELS[key] + + +Z_MEHTA = {2: 8 * SQRT2PI, 3: 48 * SQRT2 * PI} # Math-#199 section 1 (Mehta's integral; Z_3 also in closed form there) + + +class Birth: + """I_B = kappa0/Z_m int_0^inf e^{-gamma_out T^2} F_m(T) [Phi(sl (b_+ - c T)) - Phi(sl (b_- - c T))] dT for the Gaussian pair + f ~ N(0, v), g = mu f + sigma Z (A = Q - g I): conditioning on f = b and integrating the GOE shift exactly (NOTE section 2). + Reference: v = 2/3, mu = 1, sigma = 0, i.e. kappa0 = sqrt(3/(m+3)), gamma_out = 3/(4m(m+3)), sl = sqrt((m+3)/2), c = 1/(m+3).""" + + def __init__(self, m, v=Fr(2, 3), mu=Fr(1), sig2=Fr(0)): + D = 1 + m * sig2 / 2 + A = 1 / (2 * v) + m * mu * mu / (4 * D) + Bc = mu / (2 * D) + g0 = Bc * Bc / (4 * A) + (Fr(0) if MUT == "tilt-gamma" else sig2 / (8 * D)) + self.m = m + self.gamma_out = Fr(1, 4 * m) - g0 + c = Bc / (2 * A) + if MUT == "trace-slope" and sig2 == 0: + c = Fr(1, m + 2) + self.sl = Iv.frac(2 * A).sqrt() + self.beta = self.sl * Iv.frac(c) + self.pref = 1 / Iv.frac(2 * v * A * D).sqrt() / Z_MEHTA[m] + self.M = model(m, None if self.gamma_out == F_pieces(m)[1] else self.gamma_out) + self.cache = {} + + def lam(self, b): + if isinstance(b, float): + return self.M.integral() if b > 0 else Iv(ZERO) + key = (b.lo, b.hi) + if key not in self.cache: + self.cache[key] = self.M.integral(self.sl * b, self.beta) + return self.cache[key] + + def I(self, B): + lo, hi = (x if isinstance(x, (float, Iv)) else Iv.frac(x) for x in B) + return self.pref * (self.lam(hi) - self.lam(lo)) + + +def gl_nodes(n): + xs, ws = [], [] + for i in range(1, n + 1): + x = math.cos(math.pi * (i - 0.25) / (n + 0.5)) + for _ in range(100): + p0, p1 = 1.0, x + for k in range(2, n + 1): + p0, p1 = p1, ((2 * k - 1) * x * p1 - (k - 1) * p0) / k + dp = n * (x * p1 - p0) / (x * x - 1) + dx = p1 / dp + x -= dx + if abs(dx) < 1e-15: + break + xs.append(x) + ws.append(2 / ((1 - x * x) * dp * dp)) + return xs, ws + + +def M3_float(b, nodes, R=16.0): + """E[det(bI - Q)^2 1{Q < bI}] for the 3 x 3 GOE, by Gauss-Legendre over the ordered eigenvalues lambda_3 = b - a, + lambda_2 = b - a - p, lambda_1 = b - a - p - q with Mehta's density 6/Z_3 |Delta| e^{-|lambda|^2/4} (float control).""" + xs, ws = nodes + pts = [(R * (x + 1) / 2, w * R / 2) for x, w in zip(xs, ws)] + tot = 0.0 + for a, wa in pts: + ea = (b - a) ** 2 + for p, wp in pts: + ep = ea + (b - a - p) ** 2 + for q, wq in pts: + e = ep + (b - a - p - q) ** 2 + tot += wa * wp * wq * a * a * (a + p) ** 2 * (a + p + q) ** 2 * p * q * (p + q) * math.exp(-e / 4) + return 6 / (48 * math.sqrt(2) * math.pi) * tot + + +def I3_float(B, nb=20, n=28): + xs, ws = gl_nodes(nb) + nodes = gl_nodes(n) + lo, hi = float(B[0]), float(B[1]) + tot = 0.0 + for x, w in zip(xs, ws): + b = lo + (hi - lo) * (x + 1) / 2 + tot += w * math.sqrt(3 / (4 * math.pi)) * math.exp(-3 * b * b / 4) * M3_float(b, nodes) + return tot * (hi - lo) / 2 + + +# ---------------- the d = 4 jet of the reference kernel exp(-|z|^2/2), frame (u, w1, w2, w3) +EVEN = [(0, 0, 0, 0), (2, 0, 0, 0), (1, 1, 0, 0), (1, 0, 1, 0), (1, 0, 0, 1), + (0, 2, 0, 0), (0, 1, 1, 0), (0, 1, 0, 1), (0, 0, 2, 0), (0, 0, 1, 1), (0, 0, 0, 2)] # f, f_uu, f_uw*, A11 A12 A13 A22 A23 A33 +ODD = [(1, 0, 0, 0), (0, 1, 0, 0), (0, 0, 1, 0), (0, 0, 0, 1), (3, 0, 0, 0)] # f_u, f_w1, f_w2, f_w3, t = f_uuu +IDX_X, IDX_V = [0, 5, 6, 7, 8, 9, 10], [1, 2, 3, 4] +DIAG_A = [1, 4, 6] # positions of A11, A22, A33 in IDX_X +N_VEC, DEGREE = 7, 6 # Lemma S: dimension of (f, A), degree of det(A)^2 + + +def dfact2(n): + r = 1 + while n > 1: + r *= n + n -= 2 + return r + + +def ref_cov(a, b): + """Cov(d^a f, d^b f) = (-1)^|a| d^(a+b) exp(-|z|^2/2) at 0 = (-1)^|a| prod_i (-1)^(al_i/2) (al_i - 1)!! (all al_i even).""" + al = [x + y for x, y in zip(a, b)] + if any(x % 2 for x in al): + return Fr(0) + v = Fr((-1) ** sum(a)) + for x in al: + v *= (-1) ** (x // 2) * dfact2(x - 1) + if MUT == "tau-cross" and sorted([a, b]) == sorted([(3, 0, 0, 0), (1, 0, 0, 0)]): + return Fr(0) + return v + + +def ref_matrix(idx): + return [[ref_cov(a, b) for b in idx] for a in idx] + + +def det_n(M): + """Determinant by Laplace expansion along the first row (n <= 4); Fractions or intervals.""" + n = len(M) + if n == 1: + return M[0][0] + if n == 2: + return M[0][0] * M[1][1] - M[0][1] * M[1][0] + tot = None + for j in range(n): + minor = [[M[i][k] for k in range(n) if k != j] for i in range(1, n)] + t = M[0][j] * det_n(minor) + tot = t if tot is None else (tot + t if j % 2 == 0 else tot - t) + return tot + + +def inv_n(M): + """Inverse by the adjugate (n <= 4); works for Fractions and for intervals.""" + n = len(M) + d = det_n(M) + cof = [[None] * n for _ in range(n)] + for i in range(n): + for j in range(n): + minor = [[M[r][c] for c in range(n) if c != j] for r in range(n) if r != i] + v = det_n(minor) + cof[i][j] = v if (i + j) % 2 == 0 else -v + return [[cof[j][i] / d for j in range(n)] for i in range(n)], d + + +def schur(C, X, V): + """Cov(X | V) = C_XX - C_XV C_VV^-1 C_VX for index lists into C (Fractions or intervals).""" + Vinv, detV = inv_n([[C[i][j] for j in V] for i in V]) + out = [] + for i in X: + row = [] + for j in X: + s = None + for p in range(len(V)): + for q in range(len(V)): + t = C[i][V[p]] * Vinv[p][q] * C[V[q]][j] + s = t if s is None else s + t + row.append(C[i][j] + s if MUT == "schur-sign" else C[i][j] - s) + out.append(row) + return out, detV + + +def sylvester_pd(M): + """Exact positive definiteness of a symmetric rational matrix (Gaussian elimination; all pivots positive).""" + n = len(M) + A = [list(map(Fr, r)) for r in M] + for k in range(n): + if A[k][k] <= 0: + return False + for i in range(k + 1, n): + f = A[i][k] / A[k][k] + for j in range(k, n): + A[i][j] -= f * A[k][j] + return True + + +C_EVEN_REF = ref_matrix(EVEN) +C_ODD_REF = ref_matrix(ODD) +CPRIME_REF, DETV_REF = schur(C_EVEN_REF, IDX_X, IDX_V) +LAMBDA0 = Fr(3, 10) + + +def shifted(M, lam): + return [[M[i][j] - (lam if i == j else 0) for j in range(len(M))] for i in range(len(M))] + + +# ---------------- image bound for the torus kernel in d = 4 +def image_bound4(L): + """E^(4)_L = 10240 (76 L^6 + 15) exp(-L^2/2): the shell |n|_inf = j carries (2j+1)^4 - (2j-1)^4 = 64 j^3 + 16 j <= 80 j^3 points + with |n|^2 <= 4 j^2, so sum_{n != 0} |n|^6 exp(-L^2 |n|^2/2) <= 5120 sum_j j^9 exp(-L^2 j^2/2) <= 10240 exp(-L^2/2) (successive + terms ratio at most 2^9 exp(-3L^2/2) < 1/2 for L >= 10); the contraction bound 76|x|^6 phi(x) (q <= 6, |x| >= 1), |D^q phi(0)| <= 15 + and the normalization S >= 1 are those of Math-#197 section 3 (dimension-free).""" + shells = 64 if MUT == "image-shells" else 80 + L = Fr(L) + return Iv.frac(2 * shells * 64 * (76 * L ** 6 + 15)) * (-Iv.frac(L * L / 2)).exp() + + +def half_power(x, twice): + r = ipow(x, twice // 2) + return r * x.sqrt() if twice % 2 else r + + +SANDWICH_VIOLATIONS = [] + + +def scaled(b, s): + if isinstance(b, float): + return b + b = b if isinstance(b, Iv) else Iv.frac(b) + return b * s if MUT == "window-scale" else b / s + + +def sandwich(birth, B, eps): + """Lemma S with n = 7, degree 6: (1-eps)^(13/2)/(1+eps)^(7/2) I^ref_{B/sqrt(1-eps)} <= I'_B <= (1+eps)^(13/2)/(1-eps)^(7/2) + I^ref_{B/sqrt(1+eps)}.""" + e = Iv(eps) if isinstance(eps, Decimal) else Iv.of(eps) + if e.hi >= 1: + raise ValueError("eps must be below 1") + up, dn = 1 + e, 1 - e + s_up, s_dn = up.sqrt(), dn.sqrt() + su, sd = (s_dn, s_up) if MUT == "sandwich-swap" else (s_up, s_dn) + lo, hi = B + upper = half_power(up, N_VEC + DEGREE) / half_power(dn, N_VEC) * birth.I((scaled(lo, su), scaled(hi, su))) + lower = half_power(dn, N_VEC + DEGREE) / half_power(up, N_VEC) * birth.I((scaled(lo, sd), scaled(hi, sd))) + if lower.lo > upper.hi: # impossible for a correct bracket; recorded and reported by rule SANDWICH_ORDERED + SANDWICH_VIOLATIONS.append(str(B)) + return Iv(upper.lo, lower.hi) + return Iv(lower.lo, upper.hi) + + +def scaled_exact(birth, B, eta): + """Exact I'_B for C' = (1 + eta) C'_ref: (1 + eta)^3 I^ref_{B/sqrt(1+eta)} (degree-6 homogeneity of det(A)^2).""" + s = (1 + Iv.frac(eta)).sqrt() + lo, hi = B + return ipow(1 + Iv.frac(eta), DEGREE // 2) * birth.I((scaled(lo, s), scaled(hi, s))) + + +def frob_eps(Cp, Cref): + """eps = ||C' - C'_ref||_F / lambda0, entrywise supremum of the deviation over each interval entry.""" + dev2 = Iv(ZERO) + n = len(Cref) + for i in range(n): + for j in range(n): + r = Iv.frac(Cref[i][j]) + c = Cp[i][j] if isinstance(Cp[i][j], Iv) else Iv.frac(Cp[i][j]) + d = max(abs(CC.subtract(c.hi, r.lo)), abs(CF.subtract(c.lo, r.hi))) + dev2 = dev2 + Iv(d).sq() + return (dev2.sqrt() / Iv.frac(LAMBDA0)).hi + + +class Space4: + """Every covariance entry of the 4-jet (other than Var f = 1, exact by the normalization) in [ref - E, ref + E]; the odd block + (G, t) is independent of the even block (f, V, A) for any even kernel ([LP] section 15).""" + + def __init__(self, E, birth): + E = Iv.of(E) + self.birth = birth + + def box(M): + n = len(M) + Bx = [[None] * n for _ in range(n)] + for i in range(n): + for j in range(i, n): + Bx[i][j] = Bx[j][i] = Iv.frac(M[i][j]) + Iv(E.hi.copy_negate(), E.hi) + return Bx + CE_ = box(C_EVEN_REF) + CE_[0][0] = Iv(ONE) + CO = box(C_ODD_REF) + G = [[CO[i][j] for j in range(4)] for i in range(4)] + Ginv, detG = inv_n(G) + c = [CO[4][j] for j in range(4)] + self.tau2 = CO[4][4] - sum((c[i] * Ginv[i][j] * c[j] for i in range(4) for j in range(4)), Iv(ZERO)) + self.pG = 1 / (4 * PI.sq() * detG.sqrt()) # (2 pi)^(-2) det(Cov G)^(-1/2) + self.Cp, detV = schur(CE_, IDX_X, IDX_V) + self.pV = 1 / (4 * PI.sq() * detV.sqrt()) + self.tau43 = root_iv(self.tau2.sq(), 3) + self.eps = frob_eps(self.Cp, CPRIME_REF) + + def k_integral(self, K): + lo, hi = K + + def s(k): + return k if isinstance(k, float) else 72 * Iv.frac(k * k) / self.tau2 + a = SHAPE() + return self.tau43 * C72 * (gamma_lower(s(hi), a) - gamma_lower(s(lo), a)) / (2 * SQRT2PI) + + def coefficient(self, B, K): + sphere = 4 * PI if MUT == "sphere" else 2 * PI.sq() # |S^3| = 2 pi^2 + return 144 * sphere * self.pG * self.pV * sandwich(self.birth, B, self.eps) * self.k_integral(K) + + +# ---------------- a non-scalar exact test of Lemma S: the tilted pair (f, g) +TILT = (Fr(17, 25), Fr(33, 34), Fr(2261, 86700)) # v = Var f, mu, sigma^2 with mu^2 v + sigma^2 = 2/3 + + +def tilted_cprime(v, mu, sig2): + """Covariance of (f, A11, A12, A13, A22, A23, A33) for A = Q - (mu f + sigma Z) I.""" + s = mu * mu * v + sig2 + C = [[Fr(0)] * 7 for _ in range(7)] + C[0][0] = v + for i in DIAG_A: + C[0][i] = C[i][0] = -mu * v + for j in DIAG_A: + C[i][j] = s + (2 if i == j else 0) + for i in (2, 3, 5): + C[i][i] = Fr(1) + return C + + +# ---------------- main +ATAN2 = PI / 2 - atan_iv(Iv.frac(Fr(1, 2))) +D3_CF = (50 * PI + 200 * ATAN2 - 228) / (9 * PI) # Math-#201: D_3 = (50 pi + 200 arctan 2 - 228)/(9 pi) +C4_REF = GAMMA76 * CBRT32 * D3_CF / (8 * SQRT3 * PI.sq() * SQRTPI) # Math-#199: c_{4,ref} = Gamma(7/6) (3/2)^(1/3) D_3/(8 sqrt3 pi^(5/2)) + + +def label(W): + def f(x): + return ("inf" if x > 0 else "-inf") if isinstance(x, float) else str(x) + return "[%s,%s]" % (f(W[0]), f(W[1])) + + +def within(iv, fv, tol): + f, t = Decimal(repr(fv)), Decimal(repr(tol)) + return CE.subtract(iv.lo, f) <= t and CE.subtract(f, iv.hi) <= t + + +def common_prefix(iv): + lo, hi = str(iv.lo), str(iv.hi) + i = 0 + while i < min(len(lo), len(hi)) and lo[i] == hi[i]: + i += 1 + return lo[:i] + + +def rel_width(iv): + return CC.divide(iv.width(), CC.multiply(Decimal(2), iv.lo)) + + +def main(): + global MUT, C_EVEN_REF, C_ODD_REF, CPRIME_REF, DETV_REF, LAMBDA0 + ap = argparse.ArgumentParser() + ap.add_argument("--mutant", choices=MUTANTS) + MUT = ap.parse_args().mutant + C_EVEN_REF, C_ODD_REF = ref_matrix(EVEN), ref_matrix(ODD) # rebuilt: they depend on the mutant + CPRIME_REF, DETV_REF = schur(C_EVEN_REF, IDX_X, IDX_V) + LAMBDA0 = Fr(1, 3) if MUT == "d3-floor" else Fr(3, 10) + t0 = time.time() + checks = {} + full, fullK = (-INF, INF), (Fr(0), INF) + band, bandK = (Fr(0), Fr(1)), (Fr(1, 2), Fr(2)) + + # the reference law, exactly + a, c, t, o = Fr(2, 3), Fr(-2, 3), Fr(8, 3), Fr(0) + stated = [[a, c, o, o, c, o, c], [c, t, o, o, a, o, a], [o, o, 1, o, o, o, o], [o, o, o, 1, o, o, o], + [c, a, o, o, t, o, a], [o, o, o, o, o, 1, o], [c, a, o, o, a, o, t]] + s2 = CPRIME_REF[0][0] + mean = [CPRIME_REF[i][0] / s2 for i in range(1, 7)] + condA = [[CPRIME_REF[i][j] - CPRIME_REF[i][0] * CPRIME_REF[0][j] / s2 for j in range(1, 7)] for i in range(1, 7)] + goe = [[Fr(2) if (i == j and i in (0, 3, 5)) else (Fr(1) if i == j else Fr(0)) for j in range(6)] for i in range(6)] + Ginv, detG = inv_n([[C_ODD_REF[i][j] for j in range(4)] for i in range(4)]) + tau2_ref = C_ODD_REF[4][4] - sum(C_ODD_REF[4][i] * Ginv[i][j] * C_ODD_REF[4][j] for i in range(4) for j in range(4)) + checks["REFERENCE_EXACT"] = bool(CPRIME_REF == stated and mean == [-1, 0, 0, -1, 0, -1] and condA == goe and DETV_REF == 3 + and detG == 1 and tau2_ref == 6 and tilted_cprime(Fr(2, 3), Fr(1), Fr(0)) == CPRIME_REF) + checks["LAMBDA_FLOOR"] = bool(LAMBDA0 == Fr(3, 10) and sylvester_pd(shifted(CPRIME_REF, LAMBDA0)) + and sylvester_pd(shifted(CPRIME_REF, Fr(305, 1000))) + and not sylvester_pd(shifted(CPRIME_REF, Fr(306, 1000))) + and not sylvester_pd(shifted(CPRIME_REF, Fr(1, 3)))) + + # the exact inner layers against a direct float double integral + pieces3 = F_pieces(3)[0] + R6 = [Fr(4, 729) * x for x in (11340, 0, 2835, 0, -90, 0, 1)] # (4/729)(T^6 - 90T^4 + 2835T^2 + 11340) + stated_F3 = {("E", Fr(1, 24)): R6, ("E", Fr(1, 6)): [2 * x for x in R6], # E_{1/24} = sqrt(6pi) erf, E_{1/6} = sqrt(6pi)/2 erf + ("e", Fr(1, 24)): [Fr(8, 243) * x for x in (0, -8802, 0, -933, 0, 2)], + ("e", Fr(1, 6)): [Fr(8, 243) * x for x in (0, 3132, 0, -93, 0, 1)]} + layer_ctrl = {str(T): ["%.12g" % F_float(pieces3, T), "%.12g" % F3_direct_float(float(T))] for T in (2, 4, 6)} + checks["INNER_LAYERS"] = bool(all(abs(float(x) - float(y)) <= 1e-6 * abs(float(y)) for x, y in layer_ctrl.values()) + and {k: trim(v) for k, v in pieces3.items() if trim(v)} == stated_F3) + + # the reference birth integral: full window, coarse quadrature, m = 2, float control + ref3 = Birth(3) + I_full = ref3.I(full) + checks["D3_EXACT"] = bool(I_full.intersects(D3_CF) and I_full.width() < Decimal("1e-45") and D3_CF.width() < Decimal("1e-50")) + coarse = Model(g_terms(3), K=8, cell=Fr(2), T=Fr(60), rho=Fr(6)).integral() / (96 * PI) + checks["QUAD_COARSE"] = bool(coarse.contains(D3_CF)) + ref2 = Birth(2) + m2 = {} + ok = ref2.I(full).intersects(D2_EXACT) and ref2.I(full).width() < Decimal("1e-45") + for B in ((Fr(0), Fr(1)), (Fr(-1), Fr(1)), (Fr(3), Fr(7, 2)), (Fr(0), INF), (-INF, Fr(0))): + x, y = ref2.I(B), I3_ref(*B) + ok &= x.intersects(y) and x.width() < Decimal("1e-45") + m2[label(B)] = {"T_quadrature": x.pair(), "Math197_closed_form": y.pair()} + checks["M2_CROSSCHECK"] = bool(ok) + fctrl = {} + ok = True + for B in ((Fr(0), Fr(1)), (Fr(1), Fr(2))): + fv, cv = I3_float(B), ref3.I(B) + ok &= within(cv, fv, 1e-8 * fv) + fctrl[label(B)] = {"float_eigenvalue_quadrature": "%.12g" % fv, "certified": cv.pair()} + checks["FLOAT_CONTROL"] = bool(ok) + + # image bound and epsilon + E10, E12, E24 = image_bound4(10), image_bound4(12), image_bound4(24) + checks["IMAGE_BOUND"] = bool(Decimal("1.50e-10") < E10.lo and E10.hi < Decimal("1.51e-10") + and Decimal("1.24e-111") < E24.lo and E24.hi < Decimal("1.25e-111") + and (Iv.frac(512) * (-Iv.frac(150)).exp()).hi < HALF) + S0, S10, S12, S24 = Space4(0, ref3), Space4(E10, ref3), Space4(E12, ref3), Space4(E24, ref3) + checks["EPSILON"] = bool(S0.eps < Decimal("1e-55") and S10.eps < Decimal("1e-8") and S12.eps < Decimal("1e-17") + and S24.eps < Decimal("1e-55")) + + # Lemma S against exact scalar perturbations and an exact non-scalar (tilted) covariance + ok = True + for eta in (Fr(1, 50), Fr(-1, 50)): + for B in ((Fr(0), Fr(1)), (Fr(3), Fr(7, 2)), (Fr(-7, 2), Fr(-3))): + ok &= sandwich(ref3, B, Iv.frac(abs(eta))).contains(scaled_exact(ref3, B, eta)) + checks["SANDWICH_EXACT_SCALING"] = bool(ok) + tb = Birth(3, *TILT) + eps_t = frob_eps(tilted_cprime(*TILT), CPRIME_REF) + full_t = tb.I(full) + tilt = {"v_mu_sigma2": [str(x) for x in TILT], "eps": str(eps_t), "full_window": full_t.pair(), "windows": {}} + ok = full_t.intersects(D3_CF) and Decimal("0.07") < eps_t < Decimal("0.071") + for B in ((Fr(0), Fr(1)), (Fr(1), Fr(2))): + if not ok: # eps outside its certified range: no bracket is formed + break + ex, sw, rf = tb.I(B), sandwich(ref3, B, eps_t), ref3.I(B) + ok &= sw.contains(ex) and not ex.intersects(rf) + tilt["windows"][label(B)] = {"tilted_exact": ex.pair(), "sandwich": sw.pair(), "reference": rf.pair()} + checks["TILTED_EXACT"] = bool(ok) + + # the coefficient: reference, every L >= 10, L = 24 + b_windows = [(Fr(0), Fr(1)), (Fr(-1), Fr(1)), (Fr(-2), Fr(2)), (Fr(0), INF), (-INF, Fr(0)), full] + table = {} + for B in b_windows: + F4 = ref3.I(B) / D3_CF + for K in (bandK, fullK): + GK = G_ref(K) + table["B=%s K=%s" % (label(B), label(K))] = { + "F4_B": F4.pair(), "G_K": GK.pair(), "c4_ref": (C4_REF * F4 * GK).pair(), + "c4_torus_L_ge_10": S10.coefficient(B, K).pair(), "c4_torus_L_24": S24.coefficient(B, K).pair()} + F4_band = ref3.I(band) / D3_CF + c_band_ref = C4_REF * F4_band * G_ref(bandK) + c_band_0, c_band_10, c_band_24 = S0.coefficient(band, bandK), S10.coefficient(band, bandK), S24.coefficient(band, bandK) + c_full_0, c_full_10, c_full_24 = S0.coefficient(full, fullK), S10.coefficient(full, fullK), S24.coefficient(full, fullK) + checks["FACTORIZATION"] = bool(c_band_0.intersects(c_band_ref) and c_full_0.intersects(C4_REF)) + checks["C4_CONSISTENT"] = bool(str(C4_REF.lo).startswith(C4_REF_199) and str(C4_REF.hi).startswith(C4_REF_199) + and c_full_24.intersects(C4_REF) and c_full_10.contains(C4_REF)) + checks["NESTING"] = bool(c_band_10.contains(c_band_ref) and c_band_10.intersects(c_band_24) + and c_band_10.width() > c_band_24.width() * Decimal(10) ** 30 + and all(Iv(Decimal(v["c4_torus_L_ge_10"][0]), Decimal(v["c4_torus_L_ge_10"][1])).contains( + Iv(Decimal(v["c4_ref"][0]), Decimal(v["c4_ref"][1]))) for v in table.values())) + rel10 = rel_width(c_band_10) + worst = max(rel_width(Iv(Decimal(v["c4_torus_L_ge_10"][0]), Decimal(v["c4_torus_L_ge_10"][1]))) for v in table.values()) + checks["WIDTHS"] = bool(worst < Decimal("1e-7") and c_band_24.width() < c_band_24.lo * Decimal("1e-40")) + checks["SANDWICH_ORDERED"] = bool(not SANDWICH_VIOLATIONS) + checks["LIBRARY_EXACT"] = bool(library_exact()) + pinned = {"c_4_ref": C4_REF, "D_3": I_full, "F4|[0,1]": F4_band, "c4|[0,1]x[1/2,2] ref": c_band_ref, "pi": PI} + checks["PINNED"] = bool(all(str(pinned[k].lo).startswith(p) and str(pinned[k].hi).startswith(p) for k, p in PINNED.items())) + if len(checks) != 18: + raise ValueError("rule count changed") + passed = all(checks.values()) + + out = { + "object": "CL-C8-WINDOW-COEFFICIENT-D4-20261001-v1", + "scientific_effect": "NONE", + "certified": True, + "mutant": MUT, + "passed": passed, + "checks": checks, + "c8_band": {"B": "[0,1]", "K": "[1/2,2]", + "c4_reference": c_band_ref.pair(), "c4_reference_digits": common_prefix(c_band_ref), + "F4_B": F4_band.pair(), "c4_torus_every_L_ge_10_every_frame": c_band_10.pair(), + "c4_torus_L_24": c_band_24.pair(), "relative_half_width_L_ge_10": str(rel10)}, + "full_window": {"c_4_ref": C4_REF.pair(), "c4_torus_every_L_ge_10": c_full_10.pair(), "c4_torus_L_24": c_full_24.pair(), + "Math199_c_4_ref_digits": C4_REF_199}, + "windows": table, + "worst_relative_half_width_L_ge_10": str(worst), + "transfer": {"E4_10": E10.pair(), "E4_12": E12.pair(), "E4_24": E24.pair(), + "eps_L_ge_10": str(S10.eps), "eps_L_ge_12": str(S12.eps), "eps_L_24": str(S24.eps), "eps_E0": str(S0.eps), + "lambda_floor": str(LAMBDA0), "lambda_min_exact": "(7 - sqrt37)/3", + "tau2_L_ge_10": S10.tau2.pair(), "pG_pV_L_ge_10": (S10.pG * S10.pV).pair()}, + "reference": {"C_prime": [[str(x) for x in r] for r in CPRIME_REF], "A_given_f_mean": [str(x) for x in mean], + "A_given_f_cov": [[str(x) for x in r] for r in condA], "tau2": str(tau2_ref), "det_Cov_V": str(DETV_REF), + "D_3_quadrature": I_full.pair(), "D_3_closed_form_Math201": D3_CF.pair(), "coarse_quadrature": coarse.pair(), + "F_3_pieces": {"%s" % (k,): [str(x) for x in trim(v)] for k, v in sorted(pieces3.items(), key=lambda kv: str(kv[0]))}}, + "layers_float_control": layer_ctrl, + "m2_crosscheck": m2, + "float_control": fctrl, + "tilted": tilt, + "constants": {"pi": PI.pair(), "Gamma(7/6)": GAMMA76.pair(), "(3/2)^(1/3)": CBRT32.pair(), "arctan 2": ATAN2.pair()}, + "exact_relations": { + "window coefficient": "c^(4)_{B,K} = 144 int_{S^3} p_G(0) p_V(0) I_B(u) J_K(u) dsigma(u), I_B = E[1{f in B} det(A)^2 1{A<0} | V=0] ([LP] (11.3), section 15)", + "reference": "(f, A) | V=0: f ~ N(0, 2/3), A = Q - f I, Q the 3x3 GOE; I^ref_B = (1/(96 pi)) int_0^inf e^{-T^2/24} F_3(T) [Phi(sqrt3(b_+ - T/6)) - Phi(sqrt3(b_- - T/6))] dT", + "sandwich": "(1-eps) C'_ref <= C' <= (1+eps) C'_ref => (1-eps)^(13/2)/(1+eps)^(7/2) I^ref_{B/sqrt(1-eps)} <= I'_B <= (1+eps)^(13/2)/(1-eps)^(7/2) I^ref_{B/sqrt(1+eps)}", + "epsilon": "eps = ||C' - C'_ref||_F / lambda0, lambda0 = 3/10 <= lambda_min(C'_ref) = (7 - sqrt37)/3", + "image bound": "E^(4)_L = 10240 (76 L^6 + 15) exp(-L^2/2)", + }, + } + sys.stdout.write(json.dumps(out, indent=1) + "\n") + sys.stderr.write("seconds %.1f\n" % (time.time() - t0)) + sys.exit(0 if passed else 1) + + +if __name__ == "__main__": + main() From e98673f2a8a7fbb56a602fbed1518e75d80c4ae2 Mon Sep 17 00:00:00 2001 From: Claude Date: Thu, 1 Oct 2026 04:22:46 +0000 Subject: [PATCH 2/5] State [LP] Theorem B's gap-window hypothesis in the d = 4 NOTE (v1.1) NOTE section 0 said k_- >= 0. [LP] Theorem B assumes 0 < k_- <= k_+ < infinity, and section 0 now says so. Section 7 classes windows touching k = 0 or infinity (the tabulated K = (0, infinity)) and unbounded B as coefficient integrals only. This is the defect Codex found on Math-#213 (thread 4151593177). The script, RESULTS.json, the rules and the mutants are byte-unchanged; SOURCE_FILES.json records the revision. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_017Mi3hxjaxV45x6zo6o1ee3 --- .../c8_window_coefficient_d4_20261001/NOTE.md | 24 +++++++++++++------ .../SOURCE_FILES.json | 18 +++++++++++--- 2 files changed, 32 insertions(+), 10 deletions(-) diff --git a/frontiers/c8_window_coefficient_d4_20261001/NOTE.md b/frontiers/c8_window_coefficient_d4_20261001/NOTE.md index d67d4fe4c..0c633a9e3 100644 --- a/frontiers/c8_window_coefficient_d4_20261001/NOTE.md +++ b/frontiers/c8_window_coefficient_d4_20261001/NOTE.md @@ -10,8 +10,9 @@ reads of this record count for nothing. The author will not merge. ## 0. Statement Let `f` be the unit-variance stationary Gaussian field on `R⁴/(LZ⁴)` with the parent kernel `K_L` of [LP] §1, `B = [b_−, b_+]` a -birth window and `K = [k_−, k_+]` a gap window (`k_− ≥ 0`), and `c^(4)_{B,K}` the leading coefficient of [LP] Theorem B for the -pairs with birth in `B` and scaled gap in `K` ([LP] (11.3), §15; both stated for every `d`). +birth window and `K = [k_−, k_+]` a gap window with `0 < k_− ≤ k_+ < ∞` ([LP] Theorem B's hypothesis), and `c^(4)_{B,K}` the +leading coefficient of [LP] Theorem B for the pairs with birth in `B` and scaled gap in `K` ([LP] (11.3), §15; both stated for every +`d`). Windows outside that hypothesis are treated in §7. **Proposition (d = 4 window coefficient).** For the reference kernel `e^{−|z|²/2}`, `c^(4)_{B,K} = c_{4,ref} F^(4)_B G_K` with the birth factor `F^(4)_B` the one-dimensional integral (2.4) below. For the torus, for every `L ≥ 10` and every frame, @@ -271,9 +272,10 @@ The hosted workflow replays the manifest, the pins, both modes byte for byte, an the total trace in every `d`. In `d = 5`, however, the inner integrals over the differences have one more layer, and Math-#202's closed form of `D_4` integrates in a different order, so that layer is not supplied here. The floor must also be re-derived: `λ_min = ((2m+8)/3 − √(((2m+8)/3)² − 16/3))/2`, which is `0.2630` at `m = 4`. -- **Unbounded windows** (`B = [0,∞)`, `(−∞,0]`, `R`; `K = (0,∞)`): the tabulated values are the coefficient integrals (1.1) on those - sets. [LP] Theorem B's asymptotic statement is for compact windows and is not extended here; the full window is [LP] (15.2)'s - `c_{4,L}`. +- **Windows outside [LP] Theorem B's hypothesis.** Theorem B assumes a compact `B` and `0 < k_− ≤ k_+ < ∞`. For a gap window that + touches `k = 0` or `∞` (the tabulated `K = (0,∞)`), and for an unbounded `B` (`[0,∞)`, `(−∞,0]`, `R`), the tabulated values are + the coefficient integrals (1.1) on those sets only. Theorem B's asymptotic statement is not extended to them; the full window is + [LP] (15.2)'s `c_{4,L}`. - It does not address `C`, `r_*` or `z_*`. C8 stays OPEN; no register surface is touched; `executed: false`. The replay workflow follows the repository's per-packet convention; the owner's open decision on such workflows (Math-#202/#204) applies here too. @@ -305,7 +307,7 @@ No external numerical library is used. - **Claim:** the reduction (2.1)–(2.4) and its closed inner layers (2.3); the certified reference values of `c^(4)_{B,K}`; Lemma S in `d = 4` with the floor `3/10`; the `d = 4` image bound; the certified `ε`; the torus enclosures for every `L ≥ 10` and every frame, and for `L = 24`, on the windows of §5. No theorem of [LP] or SIDE24 is proved or reviewed. -- **Completed review scopes:** none yet. Requested nonauthor reads: +- **Completed review scopes:** Codex code review at `ea3a415`, no findings. Requested nonauthor reads: | slice | scope | |---|---| @@ -315,5 +317,13 @@ No external numerical library is used. - **Unresolved finding IDs:** none. - **Validation:** 18/18 rules in both modes, byte-identical output; 11/11 mutants rejected in both modes; workflow replayed - locally; hosted run pending at opening. + locally; hosted run 4/4 green at `ea3a415`. - **Next action:** nonauthor reads; amendments on this branch, recorded in `SOURCE_FILES.json`. Author will not merge. + +## 10. Revisions + +- **v1.1 (gap-window hypothesis; NOTE only).** §0 said `k_− ≥ 0`, which admits a gap window touching `k = 0`. [LP] Theorem B + assumes `0 < k_− ≤ k_+ < ∞`, and §0 now states that hypothesis. §7 says that windows outside it, including the tabulated + `K = (0,∞)` and the unbounded `B`, are coefficient integrals only. Codex found the same defect on Math-#213 (thread 4151593177), + and it is repaired in every packet of the series. §9 records the Codex review. The script, `RESULTS.json`, the rules and the + mutants are byte-unchanged. diff --git a/frontiers/c8_window_coefficient_d4_20261001/SOURCE_FILES.json b/frontiers/c8_window_coefficient_d4_20261001/SOURCE_FILES.json index 9cbb1d16d..007fa058a 100644 --- a/frontiers/c8_window_coefficient_d4_20261001/SOURCE_FILES.json +++ b/frontiers/c8_window_coefficient_d4_20261001/SOURCE_FILES.json @@ -65,9 +65,9 @@ "files": [ { "path": "NOTE.md", - "bytes": 21618, - "sha256": "cba042c28d9f09999d653f7bceafe52eda2fd4794104b8d9d81ab53dcac1acc5", - "git_blob": "d67d4fe4cddcaa877452d75b12c4e7b7016f25bb" + "bytes": 22477, + "sha256": "33ef38c1671b52da7b537fd4620abf8cc2856fb230b87445276fa18892a3dd8e", + "git_blob": "0c633a9e3470ee8b81e1d715da4ae9c7c88ef8e8" }, { "path": "RESULTS.json", @@ -81,5 +81,17 @@ "sha256": "96cb6963993102a48436163acc40132e7b99fade96361d43b1c9c491688e0d5c", "git_blob": "f77f7d2d158f9513f23f1b55fe0f839eb112d387" } + ], + "revisions": [ + { + "version": "v1.1", + "finding": "gap-window hypothesis wording (same defect as Codex thread 4151593177 on Math-#213)", + "review": "https://github.com/d6g8k5htny-coder/Math-/pull/213#discussion_r4151593177", + "change": "NOTE.md only: section 0 states [LP] Theorem B hypothesis 0 < k_- <= k_+ < infinity instead of k_- >= 0; section 7 says windows touching k = 0 or infinity (including the tabulated K = (0,infinity)) and unbounded B are coefficient integrals only", + "unchanged": [ + "window_coefficient_d4.py", + "RESULTS.json" + ] + } ] } From 84a494aca09622df172feb9c8132d47e9abea803 Mon Sep 17 00:00:00 2001 From: Claude Date: Thu, 1 Oct 2026 10:51:40 +0000 Subject: [PATCH 3/5] State positive-length windows in the d = 4 NOTE (v1.2) [LP] Theorem B also requires B and K of positive length (pinned [LP] line 37; C43-205-H-01 on Math-#205, review 5377957341). Section 0 now states -inf < b_- < b_+ < inf and 0 < k_- < k_+ < inf, and section 7 classes singleton windows, where (1.1) is zero, outside the hypothesis with zero-touching or infinite gap windows and unbounded B. No tabulated window is a singleton. The script, RESULTS.json, the rules and the mutants are byte-unchanged; section 10 and SOURCE_FILES.json record v1.2. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_017Mi3hxjaxV45x6zo6o1ee3 --- .../c8_window_coefficient_d4_20261001/NOTE.md | 25 +++++++++++++------ .../SOURCE_FILES.json | 16 +++++++++--- 2 files changed, 31 insertions(+), 10 deletions(-) diff --git a/frontiers/c8_window_coefficient_d4_20261001/NOTE.md b/frontiers/c8_window_coefficient_d4_20261001/NOTE.md index 0c633a9e3..3bae7f1df 100644 --- a/frontiers/c8_window_coefficient_d4_20261001/NOTE.md +++ b/frontiers/c8_window_coefficient_d4_20261001/NOTE.md @@ -10,9 +10,10 @@ reads of this record count for nothing. The author will not merge. ## 0. Statement Let `f` be the unit-variance stationary Gaussian field on `R⁴/(LZ⁴)` with the parent kernel `K_L` of [LP] §1, `B = [b_−, b_+]` a -birth window and `K = [k_−, k_+]` a gap window with `0 < k_− ≤ k_+ < ∞` ([LP] Theorem B's hypothesis), and `c^(4)_{B,K}` the -leading coefficient of [LP] Theorem B for the pairs with birth in `B` and scaled gap in `K` ([LP] (11.3), §15; both stated for every -`d`). Windows outside that hypothesis are treated in §7. +birth window and `K = [k_−, k_+]` a gap window, compact and of positive length with a positive gap floor: `−∞ < b_− < b_+ < ∞` and +`0 < k_− < k_+ < ∞`. This is [LP] Theorem B's hypothesis (lines 16 and 37 of the pinned [LP]). Let `c^(4)_{B,K}` be the leading +coefficient of [LP] Theorem B for the pairs with birth in `B` and scaled gap in `K` ([LP] (11.3), §15; both stated for every `d`). +Windows outside that hypothesis are treated in §7. **Proposition (d = 4 window coefficient).** For the reference kernel `e^{−|z|²/2}`, `c^(4)_{B,K} = c_{4,ref} F^(4)_B G_K` with the birth factor `F^(4)_B` the one-dimensional integral (2.4) below. For the torus, for every `L ≥ 10` and every frame, @@ -272,10 +273,15 @@ The hosted workflow replays the manifest, the pins, both modes byte for byte, an the total trace in every `d`. In `d = 5`, however, the inner integrals over the differences have one more layer, and Math-#202's closed form of `D_4` integrates in a different order, so that layer is not supplied here. The floor must also be re-derived: `λ_min = ((2m+8)/3 − √(((2m+8)/3)² − 16/3))/2`, which is `0.2630` at `m = 4`. -- **Windows outside [LP] Theorem B's hypothesis.** Theorem B assumes a compact `B` and `0 < k_− ≤ k_+ < ∞`. For a gap window that - touches `k = 0` or `∞` (the tabulated `K = (0,∞)`), and for an unbounded `B` (`[0,∞)`, `(−∞,0]`, `R`), the tabulated values are - the coefficient integrals (1.1) on those sets only. Theorem B's asymptotic statement is not extended to them; the full window is - [LP] (15.2)'s `c_{4,L}`. +- **Windows outside [LP] Theorem B's hypothesis.** Theorem B assumes compact windows of positive length with a positive gap floor: + `−∞ < b_− < b_+ < ∞` and `0 < k_− < k_+ < ∞`. Three kinds of window fall outside it: + - a gap window that touches `k = 0` or `∞`, such as the tabulated `K = (0,∞)`; + - an unbounded `B`: `[0,∞)`, `(−∞,0]`, `R`; + - a singleton window, `b_− = b_+` or `k_− = k_+`. There (1.1) is zero and does not inherit Theorem B's positive coefficient. No + singleton window is tabulated. + + For these windows the values are the coefficient integrals (1.1) on those sets only. Theorem B's asymptotic statement is not + extended to them; the full window is [LP] (15.2)'s `c_{4,L}`. - It does not address `C`, `r_*` or `z_*`. C8 stays OPEN; no register surface is touched; `executed: false`. The replay workflow follows the repository's per-packet convention; the owner's open decision on such workflows (Math-#202/#204) applies here too. @@ -327,3 +333,8 @@ No external numerical library is used. `K = (0,∞)` and the unbounded `B`, are coefficient integrals only. Codex found the same defect on Math-#213 (thread 4151593177), and it is repaired in every packet of the series. §9 records the Codex review. The script, `RESULTS.json`, the rules and the mutants are byte-unchanged. +- **v1.2 (positive-length windows; NOTE only).** C43 found on Math-#205 (review 5377957341, finding C43-205-H-01) that + [LP] Theorem B also requires `B` and `K` to have positive length (line 37 of the pinned [LP]). The statement here allowed + singleton windows such as `K = [1, 1]`, where (1.1) is zero. §0 now states `−∞ < b_− < b_+ < ∞` and `0 < k_− < k_+ < ∞`, and + §7 classes singleton windows with the other windows outside the hypothesis. Every tabulated window has positive length, so no + value changes. The script, `RESULTS.json`, the rules and the mutants are byte-unchanged. diff --git a/frontiers/c8_window_coefficient_d4_20261001/SOURCE_FILES.json b/frontiers/c8_window_coefficient_d4_20261001/SOURCE_FILES.json index 007fa058a..4b1f16f2a 100644 --- a/frontiers/c8_window_coefficient_d4_20261001/SOURCE_FILES.json +++ b/frontiers/c8_window_coefficient_d4_20261001/SOURCE_FILES.json @@ -65,9 +65,9 @@ "files": [ { "path": "NOTE.md", - "bytes": 22477, - "sha256": "33ef38c1671b52da7b537fd4620abf8cc2856fb230b87445276fa18892a3dd8e", - "git_blob": "0c633a9e3470ee8b81e1d715da4ae9c7c88ef8e8" + "bytes": 23506, + "sha256": "bf79365f4416a74f23053b385eca8f6dbbe847db569c78a382d4926a777350fb", + "git_blob": "3bae7f1df2f16d28d8d0f27dda576bcbe12b02d4" }, { "path": "RESULTS.json", @@ -92,6 +92,16 @@ "window_coefficient_d4.py", "RESULTS.json" ] + }, + { + "version": "v1.2", + "finding": "C43-205-H-01 (positive lengths; found on Math-#205)", + "review": "https://github.com/d6g8k5htny-coder/Math-/pull/205#pullrequestreview-5377957341", + "change": "NOTE.md only: section 0 states [LP] Theorem B hypothesis as compact windows of positive length, -infinity < b_- < b_+ < infinity and 0 < k_- < k_+ < infinity (pinned [LP] lines 16 and 37); section 7 classes singleton windows (b_- = b_+ or k_- = k_+) outside the hypothesis", + "unchanged": [ + "window_coefficient_d4.py", + "RESULTS.json" + ] } ] } From c78dd10b25f24417d731f20b94f75ed4643d1c06 Mon Sep 17 00:00:00 2001 From: Claude Date: Thu, 1 Oct 2026 14:17:08 +0000 Subject: [PATCH 4/5] Window coefficient d = 4 v1.3: label the band-share column as the height-window share and add the C8 band's share of c_{d,ref} (NOTE only) The xAI lane found (Math-#222 comment 5932429158) that the section 5 table headed as the band's share of the birth mass shows F^(d)_[0,1], the share of birth heights in B = [0, 1] (the same for every K), while it read as the C8 band's share of the whole coefficient. Section 5 now labels that column and adds F^(d)_[0,1] G_[1/2,2] (3.25, 2.33, 1.04, 0.295, 0.0539, 0.00634 % for d = 2..7). The script, RESULTS.json, the rules, the mutants and the workflow are byte-unchanged; no certified value changes. Recorded in NOTE section 10 and SOURCE_FILES.json revisions. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_017Mi3hxjaxV45x6zo6o1ee3 --- .../c8_window_coefficient_d4_20261001/NOTE.md | 23 ++++++++++++------- .../SOURCE_FILES.json | 17 +++++++++++--- 2 files changed, 29 insertions(+), 11 deletions(-) diff --git a/frontiers/c8_window_coefficient_d4_20261001/NOTE.md b/frontiers/c8_window_coefficient_d4_20261001/NOTE.md index 3bae7f1df..157f7a1ae 100644 --- a/frontiers/c8_window_coefficient_d4_20261001/NOTE.md +++ b/frontiers/c8_window_coefficient_d4_20261001/NOTE.md @@ -210,16 +210,18 @@ prefix of a certified interval's endpoints (both checked mechanically before pub agrees with the reference to about 48 digits, and the full window contains Math-#199's `c_{4,ref}`, whose `c_{4,24}` equals it to `1.6e-108` (rule `C4_CONSISTENT`). -**How the birth mass moves with dimension.** The C8 band `B = [0, 1]` carries: +**How the band's share moves with dimension.** -| `d` | share of the birth mass | -|---|---| -| 2 | `48.3 %` | -| 3 | `34.6 %` | -| 4 | **`15.4 %`** | +| `d` | height-window share `F^(d)_{[0,1]}` (every `K`) | C8 band's share of `c_{d,ref}`, `F^(d)_{[0,1]} G_{[1/2,2]}` | +|---|---|---| +| 2 | `48.3 %` | `3.25 %` | +| 3 | `34.6 %` | `2.33 %` | +| 4 | **`15.4 %`** | **`1.04 %`** | -The negative half-line carries `0.64 %` in `d = 4`, against `4.6 %` in `d = 3`. The reason is that `f` must exceed the largest -eigenvalue of a larger GOE matrix. The gap factor is dimension-free (`6.74 %`). On the band, `c^(4)_{B,K}/c_{4,ref} = 1.04 %`. +The first column is the share of birth heights in `B = [0, 1]`; by the factorization `c_{B,K} = c_{d,ref} F_B G_K` it does +not depend on the gap window. The second is the C8 band's share of the whole coefficient, with the dimension-free gap factor +`G_{[1/2,2]} = 6.74 %`. Both are ratios of certified values from the separate packets, not a theorem about birth mass. The negative half-line carries `0.64 %` of the birth heights in `d = 4`, against `4.6 %` in `d = 3`. The reason is that `f` must +exceed the largest eigenvalue of a larger GOE matrix. ## 6. Rules, mutants, verification @@ -338,3 +340,8 @@ No external numerical library is used. singleton windows such as `K = [1, 1]`, where (1.1) is zero. §0 now states `−∞ < b_− < b_+ < ∞` and `0 < k_− < k_+ < ∞`, and §7 classes singleton windows with the other windows outside the hypothesis. Every tabulated window has positive length, so no value changes. The script, `RESULTS.json`, the rules and the mutants are byte-unchanged. +- **v1.3 (band-share wording; NOTE only).** The xAI lane found (on this PR, comment 5932367935) that the table of §5 headed as the band's share of the + birth mass shows `F^(d)_{[0,1]}`, the share of birth heights in `B = [0, 1]` (the same for every `K`), while it read as the C8 + band's share of the whole coefficient (Math-#222 comment 5932429158). §5 now labels that column as the height-window share and + adds the C8 band's share of `c_{d,ref}`, `F^(d)_{[0,1]} G_{[1/2,2]}`. The script, `RESULTS.json`, the rules and the mutants are + byte-unchanged; no certified value changes. diff --git a/frontiers/c8_window_coefficient_d4_20261001/SOURCE_FILES.json b/frontiers/c8_window_coefficient_d4_20261001/SOURCE_FILES.json index 4b1f16f2a..6d1a1431a 100644 --- a/frontiers/c8_window_coefficient_d4_20261001/SOURCE_FILES.json +++ b/frontiers/c8_window_coefficient_d4_20261001/SOURCE_FILES.json @@ -65,9 +65,9 @@ "files": [ { "path": "NOTE.md", - "bytes": 23506, - "sha256": "bf79365f4416a74f23053b385eca8f6dbbe847db569c78a382d4926a777350fb", - "git_blob": "3bae7f1df2f16d28d8d0f27dda576bcbe12b02d4" + "bytes": 24484, + "sha256": "f656644cbdcb9ac7aeaaa9c2ef680fad39715266942b776bad84d25103bebf7c", + "git_blob": "157f7a1ae17e7a8fa689f0f986349d4c405d5a7b" }, { "path": "RESULTS.json", @@ -102,6 +102,17 @@ "window_coefficient_d4.py", "RESULTS.json" ] + }, + { + "version": "v1.3", + "finding": "xAI band-share wording, Math-#222 comment 5932429158; on this PR comment 5932367935", + "review": "https://github.com/d6g8k5htny-coder/Math-/pull/222#issuecomment-5932429158", + "change": "NOTE.md section 5: the column F^(d)_[0,1] relabelled as the height-window share (the same for every K); the C8 band's share of c_{d,ref}, F^(d)_[0,1] G_[1/2,2], added; section 10", + "unchanged": [ + "window_coefficient_d4.py", + "RESULTS.json", + ".github/workflows/c8-window-coefficient-d4.yml" + ] } ] } From 5c425ce0221262294547f5de8732acd358891540 Mon Sep 17 00:00:00 2001 From: Claude Date: Thu, 1 Oct 2026 14:25:33 +0000 Subject: [PATCH 5/5] =?UTF-8?q?Window=20coefficient=20d=20=3D=204=20v1.3:?= =?UTF-8?q?=20state=20that=20the=20lane=20of=20caption=20check=20593236793?= =?UTF-8?q?5=20is=20not=20given=20(NOTE=20=C2=A710=20attribution=20only)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_017Mi3hxjaxV45x6zo6o1ee3 --- frontiers/c8_window_coefficient_d4_20261001/NOTE.md | 11 ++++++----- .../SOURCE_FILES.json | 8 ++++---- 2 files changed, 10 insertions(+), 9 deletions(-) diff --git a/frontiers/c8_window_coefficient_d4_20261001/NOTE.md b/frontiers/c8_window_coefficient_d4_20261001/NOTE.md index 157f7a1ae..d09612387 100644 --- a/frontiers/c8_window_coefficient_d4_20261001/NOTE.md +++ b/frontiers/c8_window_coefficient_d4_20261001/NOTE.md @@ -340,8 +340,9 @@ No external numerical library is used. singleton windows such as `K = [1, 1]`, where (1.1) is zero. §0 now states `−∞ < b_− < b_+ < ∞` and `0 < k_− < k_+ < ∞`, and §7 classes singleton windows with the other windows outside the hypothesis. Every tabulated window has positive length, so no value changes. The script, `RESULTS.json`, the rules and the mutants are byte-unchanged. -- **v1.3 (band-share wording; NOTE only).** The xAI lane found (on this PR, comment 5932367935) that the table of §5 headed as the band's share of the - birth mass shows `F^(d)_{[0,1]}`, the share of birth heights in `B = [0, 1]` (the same for every `K`), while it read as the C8 - band's share of the whole coefficient (Math-#222 comment 5932429158). §5 now labels that column as the height-window share and - adds the C8 band's share of `c_{d,ref}`, `F^(d)_{[0,1]} G_{[1/2,2]}`. The script, `RESULTS.json`, the rules and the mutants are - byte-unchanged; no certified value changes. +- **v1.3 (band-share wording; NOTE only).** A scoped caption check on this PR (comment 5932367935; its lane is not stated) + and the xAI lane (Harper, Math-#222 comment 5932429158) found that the table of §5, headed as the band's share of the birth + mass, shows `F^(d)_{[0,1]}`, the share of birth heights in `B = [0, 1]` (the same for every `K`), while it read as the C8 + band's share of the whole coefficient. §5 now labels that column as the height-window share and adds the C8 band's share of + `c_{d,ref}`, `F^(d)_{[0,1]} G_{[1/2,2]}`. The script, `RESULTS.json`, the rules and the mutants are byte-unchanged; no + certified value changes. diff --git a/frontiers/c8_window_coefficient_d4_20261001/SOURCE_FILES.json b/frontiers/c8_window_coefficient_d4_20261001/SOURCE_FILES.json index 6d1a1431a..ca337e7c1 100644 --- a/frontiers/c8_window_coefficient_d4_20261001/SOURCE_FILES.json +++ b/frontiers/c8_window_coefficient_d4_20261001/SOURCE_FILES.json @@ -65,9 +65,9 @@ "files": [ { "path": "NOTE.md", - "bytes": 24484, - "sha256": "f656644cbdcb9ac7aeaaa9c2ef680fad39715266942b776bad84d25103bebf7c", - "git_blob": "157f7a1ae17e7a8fa689f0f986349d4c405d5a7b" + "bytes": 24546, + "sha256": "50288f5fcf2676f32bad0ca7afb3ac7163d77ff1f958f8db5b86dacfd93d6924", + "git_blob": "d09612387e01866ea9d6fef7098aee26e226ed1a" }, { "path": "RESULTS.json", @@ -105,7 +105,7 @@ }, { "version": "v1.3", - "finding": "xAI band-share wording, Math-#222 comment 5932429158; on this PR comment 5932367935", + "finding": "band-share wording: xAI (Harper), Math-#222 comment 5932429158; a scoped caption check on this PR, comment 5932367935 (its lane is not stated)", "review": "https://github.com/d6g8k5htny-coder/Math-/pull/222#issuecomment-5932429158", "change": "NOTE.md section 5: the column F^(d)_[0,1] relabelled as the height-window share (the same for every K); the C8 band's share of c_{d,ref}, F^(d)_[0,1] G_[1/2,2], added; section 10", "unchanged": [