diff --git a/.github/workflows/side24-periodization-firstvar.yml b/.github/workflows/side24-periodization-firstvar.yml new file mode 100644 index 000000000..d3e96a4ba --- /dev/null +++ b/.github/workflows/side24-periodization-firstvar.yml @@ -0,0 +1,59 @@ +name: SIDE24 periodization first-variation checks + +'on': + pull_request: + paths: + - 'frontiers/side24_periodization_20260929/**' + - '.github/workflows/side24-periodization-firstvar.yml' + workflow_dispatch: + +permissions: + contents: read + +jobs: + exact-and-probe: + runs-on: ubuntu-latest + timeout-minutes: 10 + steps: + - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 + with: + persist-credentials: false + - uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 + with: + python-version: '3.11.16' + - name: Verify sources, replay both modes, reject mutants + env: + PYTHONDONTWRITEBYTECODE: '1' + run: | + set -euo pipefail + python -B -S - <<'PY' + import hashlib, json, pathlib, subprocess, sys + root = pathlib.Path('frontiers/side24_periodization_20260929').resolve() + manifest = json.loads((root / 'SOURCE_FILES.json').read_text())['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']) + script = str(root / 'first_variation_check.py') + expected = (root / 'RESULTS.json').read_bytes() + mutants = ['M1', 'M2', 'M3'] + for flags in (['-B', '-S'], ['-B', '-O', '-S']): + out = subprocess.run([sys.executable, *flags, script], + check=True, capture_output=True, timeout=300).stdout + if out != expected: + raise RuntimeError('output differs from RESULTS.json under ' + ' '.join(flags)) + for m in mutants: + rc = subprocess.run([sys.executable, *flags, script, '--mutant', m], + capture_output=True, timeout=300).returncode + if rc != 1: + raise RuntimeError('mutant ' + m + ' not rejected') + print(json.dumps({'scientific_effect': 'NONE', 'scientific_acceptance': False})) + PY + git diff --exit-code diff --git a/frontiers/side24_periodization_20260929/PROOF.md b/frontiers/side24_periodization_20260929/PROOF.md new file mode 100644 index 000000000..1a84f215c --- /dev/null +++ b/frontiers/side24_periodization_20260929/PROOF.md @@ -0,0 +1,181 @@ +# SIDE24 periodization first-variation: the exact nearest-image correction + +**Object:** CL-SIDE24-PFV-20260929-v1. **Author:** Anthropic Claude (session `session_01NMeKEismAyeqgdB4sy2NJU`). +**Disposition:** author-side candidate; **nonauthor review open**. No register, prize, `lemma_closed` flag or scientific +status is changed by this note. Scientific effect: NONE until a nonauthor lane reviews it. + +## Scope and exact parent + +This note evaluates the **leading finite-size correction** to the SIDE24 lifetime-density coefficient defined by the +reconciled parent chain: `imports/lifetime_parent_20260925/UNIFORM_MATRIX_CAP_AND_LIFETIME.md` eq. (15.2) +(blob `dfed3b8d…`, SHA256 `9350ad6e…`), read with the reading rule of +`reviews/d1_chain_reconciliation_20260928/RECONCILIATION.md`, and its `d=3` reference specialization in +`coefficients/side24_v1/PROOF.md` (blob `44b66f04…`). It does **not** re-derive, re-accept, or modify that parent +or that coefficient; it derives one additional scalar, the first image-shell variation, at the parent's own +existential scope. It asserts no numerical enclosure of the coefficient itself. + +Let `Φ(J)` be the `O(3)`-invariant coefficient functional on the full even covariance-jet tensors through order +six, defined by the parent's §15 angular integral. The moments `(a, m4, χ)` parametrize its restriction to the +isotropic jet family used in §4; the side-`L` periodized jet `J_L` need not be isotropic. In the reference +normalization, `c_{3,L} = Φ(J_L)`. Write `J_∞` for the isotropic nonperiodic Euclidean jet +(`a=1, m4=3, χ=15`, `Ω = aχ − m4² = 6`), which is fixed by rotations. Poisson summation gives +`J_L = J_∞ + J^{(1)}_L + R_L`, where `J^{(1)}_L` is the term linear in `q = e^{−L²/2}` from the six nearest +images `±L e_i` after normalization. The remaining normalized jet `R_L` includes normalization/product terms +as well as higher image shells. + +## Theorem (candidate) + +With `P_3(L) = −L²(10L⁴ − 147L² + 315)/105` (equivalently `−(2/21)L⁶ + (7/5)L⁴ − 3L²`), + + DΦ(J_∞)[J^{(1)}_L] / Φ(J_∞) = P_3(L) · e^{−L²/2}, + +and hence the relative side-`L` correction is + + c_{3,L}/c_{3,∞} − 1 = P_3(L) e^{−L²/2} + ε_L, + +where `ε_L` consists of the nonlinear functional and remaining normalized-jet terms described in §5; no new +sharp bound on `ε_L` is asserted here. + +At `L = 24`: `P_3(24) = −620813376/35`, so the leading relative correction is +`−(620813376/35) e^{−288} ≈ −1.4862 × 10^{−118}`, and it sits strictly inside the coarse periodization band +`|c_{3,24}/c_{3,∞} − 1| < 10^{−106}` proved (outward-rational) in `coefficients/side24_v1/PROOF.md` §§2–4. The +present note sharpens the *leading term* of that already-reviewed band; it does not weaken or replace the band. + +## 1. Rotational projection is exact because Φ is O(3)-invariant + +The full coefficient functional is `O(3)`-invariant because rotating a covariance jet rotates the angular +integration variable in the parent's §15 integral. Since `J_∞` is fixed by rotations, its derivative satisfies +`DΦ(J_∞)[U·H] = DΦ(J_∞)[H]` for every rotation `U` and jet perturbation `H`. By linearity, + + DΦ(J_∞)[H] = DΦ(J_∞)[∫_{O(3)} U·H dU], + +where Haar measure is normalized to mass one. Consequently only the Haar projection of `H` onto the isotropic +three-moment subspace contributes to this first variation; no such reduction is asserted for `Φ` at a general +anisotropic jet. The relevant projection onto `(a, m4, χ)` uses the directional-derivative averages + + ⟨∂²_v⟩ = (1/3) Σ_i d_ii, + ⟨∂⁴_v⟩ = (1/5) Σ_i d_iiii + (2/5) Σ_{i (-13/6, 1/2, 2/3); dlogc = dOmega/9 + dm4/6 - (13/6) da at (1,3,15)", + "H7_P3": { + "P3(24)": "-620813376/35", + "P3(L)": "-L^2(10L^4-147L^2+315)/105" + }, + "H8_bounds": { + "coarse_band": "1e-106 (side24_v1 (4)); linear term inside", + "e^-288": "<1e-125 (exact rational)", + "|P3(24)|e^-288": "<1e-117 (exact); ~1.4862e-118 (float)" + } + }, + "scope": "finite exact controls for the nearest-image first-variation candidate; not the Gaussian/analytic proof" +} diff --git a/frontiers/side24_periodization_20260929/SOURCE_FILES.json b/frontiers/side24_periodization_20260929/SOURCE_FILES.json new file mode 100644 index 000000000..302a6f7bf --- /dev/null +++ b/frontiers/side24_periodization_20260929/SOURCE_FILES.json @@ -0,0 +1,50 @@ +{ + "author": "Anthropic Claude", + "consumes": [ + { + "path": "imports/lifetime_parent_20260925/UNIFORM_MATRIX_CAP_AND_LIFETIME.md", + "role": "parent (15.2) exponent structure", + "sha256": "9350ad6eaba6626b93c3dedeef9e2ff816e5cdf1c8318e85fb27499141c84bc7" + }, + { + "blob": "44b66f04f89fcd87383b3603fa69f1feb64cdddd", + "path": "coefficients/side24_v1/PROOF.md", + "role": "reference specialization + coarse band" + } + ], + "delivered_under": "owner instruction in claude.ai session 2026-09-29; OWNER_STOP left in place; no self-merge; scientific effect NONE", + "files": [ + { + "bytes": 12391, + "path": "PROOF.md", + "sha256": "f540b9b9907ba3e7fa21a9aff03c2af9c7c26c8af63589a79fe72f9f0a62ec50" + }, + { + "bytes": 13368, + "path": "first_variation_check.py", + "sha256": "57d0cac78975ee6c1a23321d8aa44cff92681fb2a42aff8fe820f727c975d6f3" + }, + { + "bytes": 1307, + "path": "RESULTS.json", + "sha256": "b9a28da8aa4332fcf67fc6a1a61d0c8c5caead4de6f15d653a8aafa0426c268c" + } + ], + "mutants": [ + "M1", + "M2", + "M3" + ], + "object": "CL-SIDE24-PFV-20260929-v1.1", + "result": { + "P3(24)": "-620813376/35", + "P3(L)": "-L^2(10L^4-147L^2+315)/105", + "coarse_band": "< 1e-106 (side24_v1, reviewed)", + "leading_relative_correction_L24": "-(620813376/35) e^-288 ~ -1.4862e-118" + }, + "reviewer_session": "https://claude.ai/code/session_01NMeKEismAyeqgdB4sy2NJU", + "scientific_acceptance": false, + "scientific_effect": "NONE", + "scope": "leading nearest-image first-variation of the reference SIDE24 coefficient; author-side; nonauthor review open", + "v1_1_change": "\u00a74 rewritten: the three exponents are derived from finite Gaussian conditioning of the isotropic jet (general d), not read off; checker H6 extended (conditional-covariance scaling, tau^2 Schur complement, general-d exponent sums). \u00a71-3, \u00a75 and the closed forms unchanged." +} diff --git a/frontiers/side24_periodization_20260929/first_variation_check.py b/frontiers/side24_periodization_20260929/first_variation_check.py new file mode 100644 index 000000000..c9ae70c5d --- /dev/null +++ b/frontiers/side24_periodization_20260929/first_variation_check.py @@ -0,0 +1,281 @@ +#!/usr/bin/env python3 +# first_variation_check.py — exact finite controls for the SIDE24 nearest-image +# first-variation candidate (object CL-SIDE24-PFV-20260929-v1). +# +# Python standard library only. Fail-closed via SystemExit (no `assert`, so +# `-O` output is byte-identical). Mutants: --mutant M1|M2|M3 -> exit 1. +# +# What this program proves is finite algebra: Hermite values, sphere-moment +# weights, the rotational projection of the six-image jet perturbation, the +# chain rule through the isotropic coefficient functional, the closed form +# P3(L), its value at L=24, and rigorous magnitude bounds. It does NOT prove +# the continuum Gaussian statements; those live in PROOF.md. + +import json +import math +import sys +from fractions import Fraction as F + +FAILURES = [] + + +def check(name, cond): + if not cond: + FAILURES.append(name) + print("FAIL " + name) + raise SystemExit(1) + + +# ---------- exact polynomials in L (coefficient dict: degree -> Fraction) ---- +def pzero(): + return {} + + +def padd(p, r): + out = dict(p) + for d, c in r.items(): + out[d] = out.get(d, F(0)) + c + if out[d] == 0: + del out[d] + return out + + +def pscale(p, s): + return {d: c * F(s) for d, c in p.items() if c * F(s) != 0} + + +def pmul(p, r): + out = {} + for d1, c1 in p.items(): + for d2, c2 in r.items(): + out[d1 + d2] = out.get(d1 + d2, F(0)) + c1 * c2 + return {d: c for d, c in out.items() if c != 0} + + +def peval(p, x): + return sum(c * F(x) ** d for d, c in p.items()) + + +def peq(p, r): + return padd(p, pscale(r, -1)) == {} + + +# ---------- probabilists' Hermite polynomials He_k, exact ---------- +def hermite(k): + # He_0 = 1, He_1 = x, He_{n+1} = x He_n - n He_{n-1} + hs = [{0: F(1)}, {1: F(1)}] + while len(hs) <= k: + n = len(hs) - 1 + hs.append(padd(pmul({1: F(1)}, hs[n]), pscale(hs[n - 1], -n))) + return hs[k] + + +def dfact(n): # double factorial of odd n (n!!), n >= -1 + out = 1 + while n > 1: + out *= n + n -= 2 + return out + + +def main(argv): + mutant = None + if len(argv) == 3 and argv[1] == "--mutant": + mutant = argv[2] + elif len(argv) != 1: + print("usage: first_variation_check.py [--mutant M1|M2|M3]") + raise SystemExit(2) + + results = {} + + # ---- H1: Hermite seeds and values --------------------------------------- + seed = F(2) if mutant == "M3" else F(1) # M3 corrupts He_1 + He = {k: hermite(k) for k in (0, 1, 2, 3, 4, 5, 6)} + if mutant == "M3": + He[1] = {1: seed} + # rebuild upward with the corrupted seed + hs = [He[0], He[1]] + for n in range(1, 6): + hs.append(padd(pmul({1: F(1)}, hs[n]), pscale(hs[n - 1], -n))) + for k in range(7): + He[k] = hs[k] + he0 = {k: peval(He[k], 0) for k in (0, 2, 4, 6)} + check("H1_he0", [he0[0], he0[2], he0[4], he0[6]] == [F(1), F(-1), F(3), F(-15)]) + check("H1_He2", peq(He[2], {2: F(1), 0: F(-1)})) + check("H1_He4", peq(He[4], {4: F(1), 2: F(-6), 0: F(3)})) + check("H1_He6", peq(He[6], {6: F(1), 4: F(-15), 2: F(45), 0: F(-15)})) + # derivative identity spot check: (d/dz)^k e^{-z^2/2} = (-1)^k He_k(z) e^{-z^2/2} + # verified structurally by the recurrence used; record the three values used + results["H1_hermite"] = {"He2": "L^2-1", "He4": "L^4-6L^2+3", + "He6": "L^6-15L^4+45L^2-15", "at_zero": [1, -1, 3, -15]} + + # ---- H2: sphere moments on S^2 via the Gaussian factorization ----------- + # E[v1^{2a} v2^{2b} v3^{2c}] = (2a-1)!!(2b-1)!!(2c-1)!! / (2n+1)!!, n=a+b+c + # (g = R v with R^2 ~ chi^2_3 independent of v; E chi^2_3-moments = (2n+1)!!/1) + def smom(a, b, c): + n = a + b + c + return F(dfact(2 * a - 1) * dfact(2 * b - 1) * dfact(2 * c - 1), + dfact(2 * n + 1)) + + # chi^2_3 moment recursion cross-check: E R^{2n} = prod_{j 3*smom6 + 18*smom42/... keep the + # direct expansion: multinomial coefficients 1 (aaa), 3 (a^2b), 6 (abc): + # 3*E v1^6 + 3*perm... expansion above verified: 3*(1/7) + 18*(1/35) + 6*(1/105) = 15/35+18/35+2/35 = 1 + results["H2_sphere_moments"] = {"v1^2": "1/3", "v1^4": "1/5", "v1^2v2^2": "1/15", + "v1^6": "1/7", "v1^4v2^2": "1/35", + "v1^2v2^2v3^2": "1/105"} + + # ---- H3: projection weights (directional-derivative averages) ----------- + # = sum E[v_i v_j v_k v_l] d_ijkl: d_iiii weight 1/5; + # d_iijj (i weight 6/15 = 2/5. + w_iijj = F(1, 5) if mutant == "M1" else 6 * smom(1, 1, 0) + check("H3_w4_iiii", smom(2, 0, 0) == F(1, 5)) + check("H3_w4_iijj", w_iijj == F(2, 5)) + # : d_iiiiii weight 1/7; d_iiiijj (i!=j ordered) 6!/(4!2!) = 15 orderings, + # each E = 1/35 -> 15/35 = 3/7; d_iijjkk 6!/(2!2!2!) = 90 orderings, E = 1/105 -> 6/7. + check("H3_w6_i6", smom(3, 0, 0) == F(1, 7)) + check("H3_w6_i4j2", 15 * smom(2, 1, 0) == F(3, 7)) + check("H3_w6_112233", 90 * smom(1, 1, 1) == F(6, 7)) + results["H3_projection_weights"] = {"d4": ["1/5", "2/5"], "d6": ["1/7", "3/7", "6/7"]} + + # ---- H4: per-q first-order normalized 1-D moment perturbations ---------- + # dm_{2j}(L) = 2 (He_{2j}(L) - He_{2j}(0)) [coefficient of q; Z_L division included] + dm = {2 * j: pscale(padd(He[2 * j] if 2 * j else {0: F(1)}, + {0: -he0.get(2 * j, F(1))}), 2) for j in (1, 2, 3)} + # ---- H5: assemble the projected radial-moment variations (per q) -------- + # per-axis / per-pair structure (six images +/- L e_i; only the matching + # 1-D factor is perturbed at first order): + # Per-axis perturbations of the summed (unnormalized-by-count) radial moments. + # There are 3 axes i and, for the mixed terms, 3 unordered pairs {i,j}. + # = (1/3) sum_i d_ii ; only the axis-i image family perturbs d_ii. + d_ii = dm[2] # per axis i + # = (1/5) sum_i d_iiii + (2/5) sum_{i = (1/7) sum_i d_i^6 + (3/7) sum_{i 27182818284/10^10, so e^288 > (27182818284/10^10)^288; compare 10^125. + e_lo = F(27182818284, 10 ** 10) + lhs = e_lo ** 288 + check("H8_exp_bound", lhs > F(10) ** 125) + # hence e^{-288} < 10^{-125} and |P3(24)| e^{-288} < 1.8e7 * 1e-125 < 1e-117 + check("H8_linear_term_band", abs(P324) * F(10) ** -125 < F(1, 10 ** 117)) + check("H8_inside_coarse_band", F(1, 10 ** 117) < F(1, 10 ** 106)) + # informational float value of the linear term + lin = abs(float(P324)) * math.exp(-288.0) + check("H8_float_scale", 1.0e-118 < lin < 2.0e-118) + results["H8_bounds"] = {"e^-288": "<1e-125 (exact rational)", + "|P3(24)|e^-288": "<1e-117 (exact); ~%.4e (float)" % lin, + "coarse_band": "1e-106 (side24_v1 (4)); linear term inside"} + + out = { + "object": "CL-SIDE24-PFV-20260929-v1-CHECKS", + "scope": ("finite exact controls for the nearest-image first-variation " + "candidate; not the Gaussian/analytic proof"), + "results": results, + "passed": True, + } + print(json.dumps(out, indent=2, sort_keys=True)) + + +if __name__ == "__main__": + main(sys.argv)