diff --git a/.github/workflows/equal-height-mass.yml b/.github/workflows/equal-height-mass.yml new file mode 100644 index 000000000..663324e70 --- /dev/null +++ b/.github/workflows/equal-height-mass.yml @@ -0,0 +1,76 @@ +name: Equal-height mass controls + +'on': + pull_request: + paths: + - 'frontiers/equal_height_mass_value_20261001/**' + - '.github/workflows/equal-height-mass.yml' + # bound merged sources (consumed and cited_only in SOURCES.json) + - 'frontiers/c7_zero_gap_limit_20260929/PROOF.md' + - 'frontiers/three_fronts_20260924/LIFETIME_REMAINDER.md' + - 'frontiers/c7_total_bounded_20260929/PROOF.md' + - 'imports/lifetime_parent_20260925/UNIFORM_MATRIX_CAP_AND_LIFETIME.md' + - 'coefficients/side24_v1/PROOF.md' + - 'frontiers/remainder_vanishing_20260930/PROOF.md' + - 'frontiers/cusp_second_order_20261001/PROOF.md' + - 'frontiers/candidate_third_order_20261001/PROOF.md' + - 'frontiers/third_order_rate_20261001/PROOF.md' + workflow_dispatch: + +permissions: + contents: read + +jobs: + exact-controls: + runs-on: ubuntu-latest + timeout-minutes: 20 + 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/equal_height_mass_value_20261001').resolve() + manifest = json.loads((root / 'SOURCES.json').read_text()) + present = sorted(p.name for p in root.iterdir()) + expected_names = sorted([e['path'] for e in manifest['files']] + ['SOURCES.json']) + if present != expected_names: + raise ValueError('packet tree differs from manifest: ' + repr(present)) + for entry in manifest['files']: + path = root / entry['path'] + if path.is_symlink(): + raise ValueError('symlink: ' + entry['path']) + data = path.read_bytes() + if len(data) != entry['bytes'] or hashlib.sha256(data).hexdigest() != entry['sha256']: + raise ValueError('packet file identity mismatch: ' + entry['path']) + for entry in manifest['consumed'] + manifest['cited_only']: + data = pathlib.Path(entry['path']).read_bytes() + framed = b'blob ' + str(len(data)).encode() + b'\0' + data + if len(data) != entry['bytes'] or hashlib.sha256(data).hexdigest() != entry['sha256'] or hashlib.sha1(framed).hexdigest() != entry['git_blob']: + raise ValueError('merged source drifted: ' + entry['path']) + if manifest.get('consumed_unmerged'): + raise ValueError('this packet declares no unmerged dependency') + script = str(root / 'equal_height_mass.py') + expected = (root / 'RESULTS.json').read_bytes() + for flags in (['-B', '-S'], ['-B', '-O', '-S']): + out = subprocess.run([sys.executable, *flags, script], check=True, capture_output=True, timeout=600).stdout + if out != expected: + raise RuntimeError('output differs from RESULTS.json under ' + ' '.join(flags)) + for m in manifest['mutants']: + rc = subprocess.run([sys.executable, *flags, script, '--mutant', m], capture_output=True, timeout=600).returncode + if rc != 1: + raise RuntimeError('mutant ' + m + ' not rejected') + rc = subprocess.run([sys.executable, *flags, script, '--mutant', 'M9'], capture_output=True, timeout=600).returncode + if rc != 2: + raise RuntimeError('unknown mutant label not rejected with exit 2') + print(json.dumps({'scientific_effect': 'NONE', 'mathematical_acceptance': False})) + PY + git diff --exit-code diff --git a/frontiers/equal_height_mass_value_20261001/GAMMA.json b/frontiers/equal_height_mass_value_20261001/GAMMA.json new file mode 100644 index 000000000..f2a929597 --- /dev/null +++ b/frontiers/equal_height_mass_value_20261001/GAMMA.json @@ -0,0 +1,30 @@ +{ + "B_3_24": 10.2097, + "I_of_s": { + "0.25": 6.719e-05, + "0.50": 0.0001348, + "0.75": 0.0001937, + "1.00": 0.0002535, + "1.25": 0.0003173, + "1.50": 0.0003809, + "1.75": 0.0004374, + "2.00": 0.0005175, + "2.25": 0.000584, + "2.50": 0.0006492, + "2.75": 0.0006933, + "3.00": 0.0006943, + "3.25": 0.000719, + "3.50": 0.0007273, + "3.75": 0.000735, + "4.00": 0.0007427, + "4.25": 0.0007512, + "4.50": 0.0007334 + }, + "beta_3": 0.0007400614572, + "gamma_3": -0.02095, + "gamma_3_se_batches": 0.0013, + "method": "two-point conditional Gaussian law (exact Hermite covariance derivatives), Monte Carlo over the Hessian residual with common random numbers in b, Gauss-Hermite (20) in b, trapezoid in s, step 0.25", + "not_a_control": true, + "object": "CL-EQUAL-HEIGHT-MASS-20261001-v1 exploration", + "samples_per_separation": 200000 +} diff --git a/frontiers/equal_height_mass_value_20261001/NOTE.md b/frontiers/equal_height_mass_value_20261001/NOTE.md new file mode 100644 index 000000000..95d622c88 --- /dev/null +++ b/frontiers/equal_height_mass_value_20261001/NOTE.md @@ -0,0 +1,259 @@ +# The equal-height mass `B_{d,L}`: a volume law and its value for the SIDE24 field + +Object: CL-EQUAL-HEIGHT-MASS-20261001-v1.2.1. +- v1.2.1 (4 October 2026) applies Grok Bot agent 15's read of the v1.2 status lines (5976336060; AMEND, wording only). + It changes no statement, proof, number or control. The changed bytes are listed at the end of §6. +- v1.2 (2 October 2026) is a status update. It changes no statement, proof, number or control. + - Math- #191 and #207 are now merged. + - The merged #218 (Theorem T) and #229 (Theorem T⁺) give the candidate density with this `B_{d,L}` as its constant + term, with rates, at their stated scope. Both are author-side proof candidates with scoped, conditional nonauthor + reviews. + - The merged #229, Proposition W⁺, proves the upper bound in the near-diagonal heuristic of §2, up to a factor + `log(2/r)`, for the torus kernel. It is an author-side proof candidate. Codex's PASS_TECHNICAL / ACCEPT_SCOPED + 5381412814 is conditional on its imported interfaces. + - Codex's Slice A review (5379568217) is a scoped analytic ACCEPT of Proposition V at v1.1, NOTE blob `ed0d3fa8`, + with the consumed [P], [R] and [Z] interfaces as hypotheses. v1.2 does not touch Proposition V or its proof. +- v1.1 (v1 → v1.1 after Codex P1 4151471466: the near part now has the same +quantified rate as the far part — Step 5 rewritten through a uniformly nondegenerate rescaled jet vector — and the SIDE24 +value is stated with its exact status; Codex P2 4151471472: the Monte Carlo sample count is validated). +Author: Anthropic Claude (claude.ai session `session_01NMeKEismAyeqgdB4sy2NJU`), 1 October 2026. +Disposition: AUTHOR-SIDE CANDIDATE (Proposition V) and EXPLORATION (the numbers); NONAUTHOR REVIEW REQUIRED. +Scientific effect: NONE — no register, graph, STATUS, PROOF_INDEX, prize or Boolean change. Same GitHub account as every +lane; zero organizational independence. Consumes merged sources only ([Z], [R], [P]). [C7-K] is cited only since v1.1 +(§4: v1's Lemma N, superseded by Step 5). Math- #191 and #207 (merged since; v1.2) are cited for interpretation, not +used. v1 incorporated a clean-context referee pass (one gap — the uniformity +in `L` of the near-diagonal majorant — closed in v1 by a majorant, Lemma N, and in v1.1 by the quantitative Step 5; +minor points applied; `β_2`, `β_3` and `γ_3` independently recomputed). + +## 0. Statement + +**Setting.** [Z] (`frontiers/c7_zero_gap_limit_20260929/PROOF.md`, blob `5b6328ea`) for the [P] field on +`X_L = R^d/(LZ^d)`, whose covariance is the normalized periodized Gaussian kernel +`K_L(z) = Σ_{n∈Z^d} e^{−|z+Ln|²/2} / Σ_{n∈Z^d} e^{−|Ln|²/2}` (unit variance). Its equal-height mass is + + B_{d,L} = ∫_{X_L∖{0}} ∫_R Ψ_0^{(L)}(b, y) db dy, Ψ_0(b, y) = p_y(v_{b,0}) E_{Q_{y,b,0}}[W], ((Z2)–(Z3)) + +`W = |det H_0 det H_y|1{H_0 < 0, index H_y = d − 1}`. By Theorem Z (Z4), `B_{d,L}` is the limit of the rejected density, +`ρ_rej(ℓ) → B_{d,L}`; by Math- #191 (R+.1) (merged), it is the constant term of the candidate density, +`ν_cand(ℓ) = cℓ^{−1/3} + B_{d,L} + o(1)`. (v1.2: the merged #218 (Theorem T) and #229 (Theorem T⁺) give +`ν_cand = cℓ^{−1/3} + B_{d,L} + I^{cand}ℓ^{1/4} + c₂ℓ^{1/3} + O(ℓ^{3/7})`, at their stated scope.) [Z] states that it gives "No numerical value for B_(d,L)". + +Let `f_∞` be the stationary Gaussian field on `R^d` with covariance `e^{−|z|²/2}`, `ρ_j(b)` its height density of critical +points of index `j` (per unit volume and unit height) and `Ψ_0^∞(b, y)` its equal-height kernel ((Z2) on `R^d`). + +**Proposition V (volume law).** There are `C, N, L₀` such that for `L ≥ L₀` + + B_{d,L} = β_d L^d + γ_d + ε_L, |ε_L| ≤ C L^N e^{−L²/8}, β_d := ∫_R ρ_d(b) ρ_{d−1}(b) db, + γ_d := ∫_{R^d}∫_R (Ψ_0^∞(b, y) − ρ_d(b)ρ_{d−1}(b)) db dy, (V.1) + +the last integral converging absolutely. (`C`, `N` are existential, as everywhere in the chain; they are not computed.) + +**Values (exploration; not certified).** For the Gaussian kernel, + + β_2 = 3.122769186·10⁻³, β_3 = 7.400614572·10⁻⁴ (deterministic quadrature; controls Q1–Q4 of equal_height_mass.py), + γ_3 = −0.020 ± 0.002 (two Monte Carlo explorations, §2), + +so `24³β_3 + γ_3 = 10.231 − 0.020 ≈ 10.21`, and **`B_{3,24} = 10.21 ± 0.002 + ε_{24}`** with `|ε_{24}| ≤ C·24^N e^{−72}` +(`e^{−72} ≈ 5·10⁻³²`; `C`, `N` not computed). That is about `244` times `c_{3,24} = 0.0417759318…` (the enclosure of +`coefficients/side24_v1`). **Status of this value:** exploration. `β_3` is deterministic (to `10⁻⁸`) and `γ_3` is Monte +Carlo; the remainder is proved exponentially small in `L²` but with unquantified constants. So `B_{3,24} ≈ 10.21` is the +value of the asymptotic formula at `L = 24`, not a certified enclosure. + +**What is not claimed.** No numerical `C`, `N` in (V.1); no certified value of `γ_3` or `B_{3,24}`; nothing about +`B_{d,L}` for covariances other than the periodized Gaussian kernel; no change to Theorem Z. + +## 1. Proof of Proposition V + +For `y` in the fundamental cell `C_L = [−L/2, L/2)^d ∖ {0}` (the torus point identified with its representative), let +`Σ_L(y)` be the covariance matrix of the jet vector `J(y) = (O_y, H_0, H_y)` of `f_L` (`O_y = (f, ∇f)(0), (f, ∇f)(y)`, the +two Hessians), and `Σ_∞(y)` that of `f_∞`. Gaussian regression ([Z] §2, (Z10)) writes the kernel as a function of the +covariance: + + Ψ_0(b, y) = F(Σ(y); b), F(Σ; b) := φ_{Σ_OO}(v_b) E[W(b m_Σ + S_Σ^{1/2}ζ)], ζ ~ N(0, I), + +`m_Σ = Σ_HOΣ_OO^{−1}e`, `S_Σ = Σ_HH − Σ_HOΣ_OO^{−1}Σ_OH`, `e = (1, 0, …, 0, 1, 0, …, 0)` (so `v_b = be`). + +*Step 1 (Lipschitz dependence).* Let `𝒦_c` be the set of covariance matrices with eigenvalues in `[c, 1/c]`. On `𝒦_c`, the +maps `Σ ↦ m_Σ, S_Σ, S_Σ^{1/2}` are Lipschitz, and `|∂_Σ φ_{Σ_OO}(v_b)| ≤ C_c(1 + b²)e^{−c'b²}`. The function `W` is continuous and +piecewise polynomial of degree `2d` in the two Hessians, vanishing where an index changes, so +`|W(H) − W(H')| ≤ C(1 + |H| + |H'|)^{2d−1}|H − H'|` (on each factor this is [R] Lemma R3.1 (R6): along the segment from `H` to +`H'` an index change passes through a singular matrix). Hence `|F(Σ; b) − F(Σ'; b)| ≤ C_c‖Σ − Σ'‖(1 + |b|)^Ne^{−c'b²}` on `𝒦_c`. + +*Step 2 (nondegeneracy away from the diagonal).* `Σ_∞(y)` is continuous in `y`, nondegenerate for every `y ≠ 0` (the +distinct-site jet rank of [P] §2 and [Z] §2 on `R^d`: a zero-variance combination of jets at `0` and `y` is a distribution +`T` with `∫|T̂(ξ)|²e^{−|ξ|²/2}dξ = 0`, so `T̂ ≡ 0` and `T = 0`), and tends to the +block-diagonal `diag(Σ₁, Σ₁)` as `|y| → ∞`, `Σ₁` the nondegenerate one-point jet covariance. So `Σ_∞(y) ∈ 𝒦_c` for +`|y| ≥ r₀`, with `c = c(r₀) > 0`. + +*Step 3 (image terms).* Up to the normalization factor `(Σ_n e^{−|Ln|²/2})^{−1} = 1 + O(e^{−L²/2})`, every entry of +`Σ_L(y) − Σ_∞(y)` is a sum over `n ≠ 0` of derivatives of order at most four of `e^{−|z|²/2}` at points `z ∈ {Ln, ±y + Ln}`, +and `|±y + Ln| ≥ L|n|_∞ − |y|_∞ ≥ L|n|_∞/2` for `y ∈ C_L`. Hence +`‖Σ_L(y) − Σ_∞(y)‖ ≤ CL^Ne^{−L²/8}`, uniformly in `y ∈ C_L`. In particular `Σ_L(y) ∈ 𝒦_{c/2}` for `|y| ≥ r₀` and `L ≥ L₀`, and +the one-point densities satisfy `ρ_j^{(L)} = ρ_j + O(L^Ne^{−L²/2})`. + +*Step 4 (far part).* For `y ∈ C_L`, `|y| ≥ r₀`, Steps 1–3 give `|Ψ_0^{(L)}(b, y) − Ψ_0^∞(b, y)| ≤ CL^Ne^{−L²/8}(1 + |b|)^Ne^{−c'b²}`. +The cross block of `Σ_∞(y)` consists of derivatives of `e^{−|y|²/2}` of order at most four, so +`‖Σ_∞(y) − diag(Σ₁, Σ₁)‖ ≤ C(1 + |y|)⁴e^{−|y|²/2}`. At the block-diagonal covariance the two sites are independent and +`F(diag(Σ₁, Σ₁); b) = ρ_d(b)ρ_{d−1}(b)`. Hence `|Ψ_0^∞(b, y) − ρ_dρ_{d−1}(b)| ≤ C(1 + |y|)⁴e^{−|y|²/2}(1 + |b|)^Ne^{−c'b²}`, which +is integrable over `{|y| ≥ r₀} × R`. Integrating over `C_L ∖ B_{r₀}` gives the far statement of Proposition V; the tail +`∫_{R^d∖C_L}` of the last integrand is `O(L^Ne^{−L²/8})`. + +*Step 5 (near part, quantitative).* For `|y| < r₀` the jets at `0` and `y` degenerate as `y → 0`, so Step 1 does not +apply to `Σ(y)` directly. Rescale instead. + +Write `y = ru` with `M = −ru/2`, `S = ru/2` after the translation of [R] §2. Form the vector `J̃(r, u)` of: +- the observation rows `U_r` of [R] §2: the averages and divided differences of `f` and `∇f` at the pins, ending in + `U_3 = (6/r²)[f_x(M) + f_x(S) − 2(f(S) − f(M))/r]`; +- the rescaled Hessian combinations + `[(f_xx(S) + f_xx(M))/2 − (f_x(S) − f_x(M))/r]/r²`, `[(f_xx(S) − f_xx(M))/r − U_3]/r²`, + `[(f_xy_j(S) + f_xy_j(M))/2 − (f_y_j(S) − f_y_j(M))/r]/r²`, `(f_xy_j(S) − f_xy_j(M))/r`, `(A_S + A_M)/2`, `(A_S − A_M)/r`. + +By Taylor's formula with integral remainder (centred rules), `J̃(r, u)` converges in `L²` as `r → 0`. Its limit is a +list of *distinct* partial derivatives at `0`, with nonzero coefficients: +- from the rows: `f, f_x, f_xx, f_xxx, f_y_j, f_xy_j`; +- from the Hessian combinations: `f_xxxx/12, f_xxxxx/60, f_xxxy_j/12, f_xxy_j, f_y_jy_l, f_xy_jy_l`. + +That list is nondegenerate by the finite-jet rank of [P] §2 (on `R^d` by Step 2's Fourier argument). By continuity and +compactness, the covariance `Σ̃_L(r, u)` of `J̃` has eigenvalues in `[c, 1/c]` for `r ≤ r₀`, all frames and +`L ∈ [L₀, ∞]`. Its entries are divided differences of `K_L`, i.e. averages of derivatives of `K_L` over the segment, so +`‖Σ̃_L(r, u) − Σ̃_∞(r, u)‖ ≤ C‖K_L − K_∞‖_{C^q(B_{2r₀})} ≤ CL^Ne^{−L²/8}`. + +**The kernel in rescaled variables.** On the event `U_r = v_r(b, 0)` (equal heights, `k = 0`), the scaled Hessians of +[R] §4 are affine in `J̃` with coefficients polynomial in `r`: +- `α_{M,S} = r(Ũ_a ∓ (r/2)Ũ_b)` (cf. #191 (1.1) at `k = 0`); +- `β_{M,S} = rŨ_c ∓ Ũ_d/2`; +- `A_{M,S} = Ũ_e ∓ (r/2)Ũ_f`. + +So `det K_i = α_i det A_i − r β_iᵀadj(A_i)β_i` is `r` times a polynomial in `(J̃, r)`. Hence +`W̃ := W_r/r⁴ = |(det K_M/r)(det K_S/r)|1{typed}` is continuous and piecewise polynomial in `(J̃, r)`, and vanishes where +an index changes. By the separation-variable form of the kernel ([Z] (Z14); #191 (2.1)), + + r^{d−1}Ψ_0(b, ru) = r^{−2}A_r(b, 0, u) = 12 π_r(v_r(b, 0)) E_Q[W̃] = F̃(Σ̃(r, u); b), + +with `F̃` of the same form as `F` in Step 1. Step 1's argument applies verbatim on the uniformly nondegenerate set and gives: +- `|r^{d−1}(Ψ_0^{(L)} − Ψ_0^∞)(b, ru)| ≤ CL^Ne^{−L²/8}(1 + |b|)^Ne^{−c'b²}`; +- `r^{d−1}Ψ_0^∞(b, ru) ≤ C(1 + |b|)^Ne^{−c'b²}`. + +Integrating over `r < r₀`, `u` and `b`, the near parts for `L` and `∞` differ by `O(L^Ne^{−L²/8})`, and the near part of +`γ_d` converges absolutely. This replaces any appeal to the uniformity in `L` of [Z] (Z15), whose proof uses +whole-torus norms. (v1's Lemma N — the pointwise bound behind [C7-K] (K1) at `k = 0` with local seminorms — gave only a +majorant and hence `o(1)`.) + +Adding the near and far parts, `B_{d,L} = β_dL^d + γ_d + O(L^Ne^{−L²/8})`. ∎ + +(The constants `C`, `N` come from compactness and continuity; quantifying them would turn `B_{3,24} ≈ 10.21` into an +enclosure, together with a certified `γ_3`.) + +## 2. The numbers + +*`β_d` (deterministic).* Given `f = b` and `∇f = 0`, the Hessian of `f_∞` is `−bI + G`. Here `G` has `Var G_ii = 2`, +`Cov(G_ii, G_jj) = 0` (`i ≠ j`), `Var G_ij = 1` (exact, Q1), i.e. a scaled GOE with density `∝ exp(−tr G²/4)`. Hence + + ρ_j(b) = φ(b)(2π)^{−d/2} E[|det(G − bI)|1{index(G − bI) = j}], + +computed by nested Gauss–Legendre quadrature over the ordered eigenvalues against `|Δ(λ)|e^{−Σλ²/4}`. The normalization +equals Mehta's closed form (Q2). The total densities reproduce the closed forms to `10⁻⁸`: +- `d = 2`: `n_max = 1/(2π√3)`, `n_sad = 1/(π√3)`; +- `d = 3`: Bardeen–Bond–Kaiser–Szalay (1986), `(29 ∓ 6√6)/(5^{3/2}8π²R_*³)` with `R_*³ = 27/(15√15)` (Q3). + +Two resolutions agree to `10⁻⁸` (Q4): + + β_2 = 3.122769186·10⁻³, β_3 = 7.400614572·10⁻⁴, 24³β_3 = 10.230610. + +*`γ_3` (Monte Carlo, exploration).* Write `I(s) := ∫Ψ_0^∞(b, se₁) db`. Then `γ_3 = 4π∫_0^∞ s²(I(s) − β_3) ds`, where `I(s)` uses +the exact two-point conditional law (Hermite covariance derivatives), Monte Carlo over the Hessian residual, and +Gauss–Hermite quadrature in `b`. +- **Shipped stdlib exploration** (`python3 gamma_explore.py 200000`, 2·10⁵ residual samples per separation, step `0.25` + to `4.5`): `γ_3 = −0.0210 ± 0.0013` (batch standard error), `GAMMA.json`. +- **Independent check by the referee** (10⁶ samples per separation, a control variate tied to the decoupled law, + cutoff varied from `4.5` to `6.5`, not shipped): `γ_3 = −0.0200 ± 0.0001`. +- **Development run** (numpy, 2·10⁵ samples per separation, step `0.1`, not shipped): `γ_3 = −0.019 ± 0.001`. Its + plateau `I(s) = 7.436·10⁻⁴ ± 0.029·10⁻⁴` on `s ∈ [4.5, 6]` matches `β_3` to within 1.2 standard errors. + +*Shape of `I(s)`* (shipped `GAMMA.json`). `I(s)` rises roughly linearly from about `0.09β_3` at `s = 0.25`, through `0.34β_3` +(`s = 1`) and `0.70β_3` (`s = 2`), and reaches `β_3` by `s ≈ 3.5–4`. Equal-height maximum/index-2-saddle pairs are depleted +at short range, so `γ_3 < 0`. (The referee observed, heuristically, that at equal heights the two endpoint axial +curvatures agree to leading order. That suggests `r^{d−1}Ψ_0 = O(r³)` and `I(s) ∝ s^{4−d}` near `0`, consistent with the +linear rise in `d = 3`; the `O(1)` bound of Step 5 is far from sharp here.) +*v1.2.* The merged #229 (Proposition W⁺, (W⁺.2) at `k = 0` and (W⁺.3); an author-side proof candidate with Codex's +scoped, conditional review 5381412814) proves the upper half of this heuristic for the torus kernel, up to a factor +`log(2/r)`, conditional on #229's imported interfaces. Precisely, `r^{d−1}Ψ_0(b, ru) ≤ Cr³log(2/r)(1 + |b|)^Ne^{−cb²}` +for `0 < r ≤ r_0^*`, so the equal-height mass below separation `ρ` is `O(ρ⁴log(2/ρ))`. The mechanism is the typed +window `|Y| ≲ r`, of conditional probability `O(r log(2/r))`. No matching lower bound or exact power is proved. #229 +notes that the `d = 2` exploration suggests the logarithm may be an artifact. + +## 3. Consequences (with the values of §2; exploration-level numbers) + +- **Theorem Z's corollaries become quantitative for the SIDE24 field.** Per unit volume: + - the expected rejected count with gap in `(0, t]` is `B_{3,24}t + o(t) ≈ 10.2t` ((Z7)); + - `ρ_rej(ℓ)/ν_cand(ℓ) ~ (B/c)ℓ^{1/3} ≈ 244ℓ^{1/3}` ((Z8)); + - the cumulative ratio is `≈ 163t^{1/3}` ((Z9)). +- **Size of the candidate density.** In `ν_cand(ℓ) = cℓ^{−1/3} + B + o(1)` (#191, merged; with rates, #218 and #229), the constant exceeds the singular term once + `ℓ > (c/B)³ ≈ 6.8·10⁻⁸`. Unmarked max/index-2-saddle pairs with small height gap on the side-24 torus are therefore + overwhelmingly unrelated, far-apart pairs. By Theorem Z the elder rule removes all of them in the limit; the elder + density has no constant term (#191 (R+.2)). +- **With #207 (CU′.2)** (merged), `ρ_rej(ℓ) ≈ 10.21 + 0.072ℓ^{1/4}` for small `ℓ`. + +## 4. Sources + +| Tag | Path / reference | Role | +|---|---|---| +| [Z] | `frontiers/c7_zero_gap_limit_20260929/PROOF.md` (blob `5b6328ea`) | (Z2)–(Z4), §2 (nondegeneracy, (Z10)), §4 (Z15)–(Z17), (Z7)–(Z9) — consumed | +| [R] | `frontiers/three_fronts_20260924/LIFETIME_REMAINDER.md` (blob `247b3ecf`) | (R2) near-pair nondegeneracy, (R3) the regression form, Lemma R3.1 (R6) — consumed (Steps 1, 5) | +| [C7-K] | `frontiers/c7_total_bounded_20260929/PROOF.md` (blob `28748b08`) | §2, the pointwise bound behind (K1) — cited (v1's Lemma N, superseded by Step 5) | +| [P] | `imports/lifetime_parent_20260925/UNIFORM_MATRIX_CAP_AND_LIFETIME.md` (blob `dfed3b8d`) | §2 distinct-site jet rank, §3 near-pair nondegeneracy, (5.1)–(5.3), the field — consumed | +| side24_v1 | `coefficients/side24_v1/PROOF.md` (blob `44b66f04`) | the value `c_{3,24} = 0.0417759318…` in §§0, 3 — cited only | +| #191, #207 | `frontiers/remainder_vanishing_20260930/PROOF.md` (`441152df`), `frontiers/cusp_second_order_20261001/PROOF.md` (`f6df5a73`); merged since v1.1 | interpretation of `B_{d,L}` as `ν_cand`'s constant term; `ρ_rej`'s `ℓ^{1/4}` term — cited only | +| #218, #229 | `frontiers/candidate_third_order_20261001/PROOF.md` (`70ca57ef`), `frontiers/third_order_rate_20261001/PROOF.md` (`110ed33a`); merged | Theorems T and T⁺ (`B_{d,L}` with rates); Proposition W⁺ (§2's heuristic) — cited only (v1.2) | +| [BBKS] | J. M. Bardeen, J. R. Bond, N. Kaiser, A. S. Szalay, *The statistics of peaks of Gaussian random fields*, Astrophys. J. 304 (1986) 15–61 | closed-form densities of maxima and saddles in `d = 3` (control Q3) — external | +| [Mehta] | M. L. Mehta, *Random Matrices*, 3rd ed., Elsevier (2004), the Selberg/Mehta integral | GOE normalization (control Q2) — external | + +## 5. Controls and exploration + +`equal_height_mass.py` (stdlib; `RESULTS.json` its output, byte-identical under `-O`): +- **Q1:** the conditional Hessian law, in exact rationals. +- **Q2:** the scaled-GOE normalization against Mehta. +- **Q3:** the total densities against the closed forms (`d = 2`; BBKS for `d = 3`). +- **Q4:** `β_2`, `β_3` at two resolutions. +- **Mutants:** M1 (the unconditioned diagonal variance `3`), M2 (no Vandermonde factor) and M3 (index-`d` points counted as + saddles) exit 1; an unknown label exits 2. + +The controls test the one-point densities and `β_d` only. Proposition V is proved in prose. `gamma_explore.py` +(stdlib, Monte Carlo, fixed seed, not replayed by the workflow; output `GAMMA.json`) is exploration. + +## 6. Review slices + +A: Proposition V. This covers: +- the Lipschitz dependence of the Kac–Rice kernel on the covariance (Step 1); +- far-field nondegeneracy (Step 2); +- the image bound (Step 3); +- the far integration (Step 4); +- the uniformity in `L` of (Z15)'s constants, and the dominated convergence (Step 5). + +B: The numbers. This covers: +- the conditional Hessian law; +- the reduction to scaled-GOE eigenvalue integrals and the quadrature; +- the agreement with the BBKS densities; +- `β_3`, the Monte Carlo design for `γ_3`, and `B_{3,24} ≈ 10.21`. + +**Changed bytes in v1.2** (status update, against v1.1 at `8e89fe8`, NOTE blob `ed0d3fa8`): +- *Header:* the object label and version list, and the sentence on #191 and #207. +- *§0:* "(merged)" for #191, and the parenthetical on #218 and #229. +- *§2:* the v1.2 paragraph after the `γ_3` heuristic. +- *§3:* "merged" for #191 and #207. +- *§4:* the #191/#207 row and the new #218/#229 row. +- *§6:* this list. + +Proposition V, its proof (Steps 1–5), §1, every number, `equal_height_mass.py`, `RESULTS.json`, `gamma_explore.py` and +`GAMMA.json` are unchanged. + +**Changed bytes in v1.2.1** (wording only, against v1.2 at `f35b28b`, NOTE blob `1d265140`; Grok Bot agent 15, +5976336060): +- *Header:* the object label; the v1.2.1 line; the three v1.2 sub-bullets on #218, #229 and Slice A, replaced by the + verdict's text (findings 4–6); and the consumed-sources sentence, which now lists [C7-K] as cited only, as §4 does + (finding 7, third bullet). +- *§2:* the first sentence of the v1.2 paragraph, replaced by the verdict's text (finding 4). +- *§6:* this list. + +§0, §1, §§3–5, Proposition V and its proof (Steps 1–5), every number, `equal_height_mass.py`, `RESULTS.json`, +`gamma_explore.py` and `GAMMA.json` are unchanged. diff --git a/frontiers/equal_height_mass_value_20261001/README.md b/frontiers/equal_height_mass_value_20261001/README.md new file mode 100644 index 000000000..1288b1dc3 --- /dev/null +++ b/frontiers/equal_height_mass_value_20261001/README.md @@ -0,0 +1,43 @@ +# The equal-height mass `B_{d,L}`: volume law and value (CL-EQUAL-HEIGHT-MASS-20261001-v1.2.1) + +Author-side candidate and exploration, Anthropic Claude, 1 October 2026. Scientific effect NONE. Nonauthor review +required. It consumes merged sources only: [Z], [R] and [P]. [C7-K] is cited only since v1.1 (v1's Lemma N, superseded +by Step 5). + +**v1.2.1 (4 October 2026; wording only).** This applies Grok Bot agent 15's read of the v1.2 status lines (5976336060): +the review status of #218 and #229, the upper-bound reading of Proposition W⁺, the scope of the Slice A ACCEPT, and +[C7-K] as cited only. + +**v1.2 (2 October 2026; status update, no statement or number changes).** Math- #191 and #207 are now merged. The merged +#218 (Theorem T) and #229 (Theorem T⁺) give the candidate density with this `B_{d,L}` as its constant term, with rates, +at their stated scope. Both are author-side proof candidates with scoped, conditional nonauthor reviews. The merged #229 +(Proposition W⁺; an author-side proof candidate with Codex's scoped, conditional review 5381412814) proves the upper +bound in the near-diagonal heuristic of NOTE §2, up to `log(2/r)`: the equal-height mass below separation `ρ` is +`O(ρ⁴log(2/ρ))`. Codex's Slice A review (5379568217) is a scoped analytic ACCEPT of Proposition V at v1.1. v1.2 does +not touch it. + +**Proposition V.** Let `B_{d,L}` be Theorem Z's equal-height mass for the periodized Gaussian kernel. It is the limit +of the rejected density and the constant term of the candidate density. For `L ≥ L₀`, + + B_{d,L} = β_d L^d + γ_d + ε_L, |ε_L| ≤ CL^Ne^{−L²/8}, β_d = ∫ρ_d(b)ρ_{d−1}(b) db, γ_d = ∫_{R^d}∫(Ψ_0^∞ − ρ_dρ_{d−1}) db dy. + +Here `β_d` pairs the height densities of maxima and of index-`(d−1)` saddles of the field on `R^d`, and `γ_d` is a +near-field correction. The constants `C`, `N` exist but are not computed. In v1.1, after Codex P1 4151471466, the near +part has the same rate as the far part: it is proved through a uniformly nondegenerate rescaled jet vector. + +**Values (exploration).** +- `β_2 = 3.122769186·10⁻³` and `β_3 = 7.400614572·10⁻⁴`, by deterministic quadrature over scaled-GOE eigenvalues. Checked against the Bardeen–Bond–Kaiser–Szalay closed forms to `10⁻⁸`. +- `γ_3 = −0.020 ± 0.002`, by two Monte Carlo explorations. +- Hence **`B_{3,24} ≈ 10.21 ≈ 244 c_{3,24}`**. This is the value of the asymptotic formula at `L = 24`, with an exponentially small remainder whose constants are not computed. It is exploration, not an enclosure. +- Consequence: on the SIDE24 torus the candidate density's constant term (by #191, merged) exceeds `cℓ^{−1/3}` for `ℓ > 6.8·10⁻⁸`. Unrelated far-apart equal-height pairs dominate the unmarked small-gap density, and the elder rule removes them. + +**Files.** +- `NOTE.md` — the proposition, its proof and the numbers. A clean-context referee pass found that v1's near-part uniformity was asserted rather than proved; v1 answered with a majorant, and v1.1 replaces it with the quantitative Step 5. The same pass recomputed `β_2`, `β_3` and `γ_3 = −0.0200 ± 0.0001` independently. +- `equal_height_mass.py` — stdlib controls: Q1 conditional Hessian law (exact), Q2 GOE normalisation, Q3 densities against closed forms, Q4 `β_d` at two resolutions. `RESULTS.json` is its output, byte-identical under `-O`. Mutants M1–M3 exit 1; an unknown label exits 2. +- `gamma_explore.py` — stdlib Monte Carlo for `γ_3`. Exploration only, not replayed; `python3 gamma_explore.py` (2·10⁵ samples per separation, about two minutes) reproduces `GAMMA.json`, which is unchanged from v1. The sample count must be a positive multiple of 5. +- `SOURCES.json`. + +**Not claimed.** +- Numerical `C`, `N`. +- Certified values. +- Other covariances. diff --git a/frontiers/equal_height_mass_value_20261001/RESULTS.json b/frontiers/equal_height_mass_value_20261001/RESULTS.json new file mode 100644 index 000000000..98001bf93 --- /dev/null +++ b/frontiers/equal_height_mass_value_20261001/RESULTS.json @@ -0,0 +1,44 @@ +{ + "checks": { + "Q1_conditional_hessian_law": { + "info": "scaled GOE: Var f_ii = 2, Var f_ij = 1, all other pairs 0; E[f_ii | f = b] = -b", + "passed": true + }, + "Q2_scaled_GOE_normalisation": { + "info": { + "2": 20.0530262, + "3": 213.258381 + }, + "passed": true + }, + "Q3_total_densities_closed_forms": { + "info": { + "2": { + "n_max": 0.09188814923, + "n_max_closed": 0.09188814924, + "n_sad": 0.1837762985, + "n_sad_closed": 0.1837762985 + }, + "3": { + "n_max": 0.03486240891, + "n_max_closed": 0.03486240894, + "n_sad": 0.106507305, + "n_sad_closed": 0.106507305 + } + }, + "passed": true + }, + "Q4_beta_two_resolutions": { + "info": { + "24^3 beta_3": 10.23061, + "beta_2": 0.003122769186, + "beta_3": 0.0007400614572 + }, + "passed": true + } + }, + "mutant": null, + "object": "CL-EQUAL-HEIGHT-MASS-20261001-v1", + "passed": true, + "scientific_effect": "NONE" +} diff --git a/frontiers/equal_height_mass_value_20261001/SOURCES.json b/frontiers/equal_height_mass_value_20261001/SOURCES.json new file mode 100644 index 000000000..c01216b37 --- /dev/null +++ b/frontiers/equal_height_mass_value_20261001/SOURCES.json @@ -0,0 +1,249 @@ +{ + "schema": 1, + "scientific_effect": "NONE", + "object": "CL-EQUAL-HEIGHT-MASS-20261001-v1.2.1", + "kind": "author-side candidate (Proposition V: B_{d,L} = beta_d L^d + gamma_d + O(L^N e^{-L^2/8}) for the periodized Gaussian kernel) and exploration (beta_2, beta_3 by deterministic quadrature with controls; gamma_3 by Monte Carlo; B_{3,24} ~ 10.21); consumes merged sources only; nonauthor review required. gamma_explore.py / GAMMA.json are exploration, not controls.; v1.2: status update (#191, #207 merged; #218/#229 cited; #229 Proposition W+ proves the upper bound in the section 2 heuristic up to log, an author-side candidate with a scoped, conditional review); no statement, proof, number or control changes; v1.2.1: wording only, after Grok Bot agent 15 (5976336060): the review status of #218/#229, the upper-bound reading of Proposition W+, the scope of the Slice A ACCEPT, and [C7-K] cited only (as NOTE section 4 says since v1.1); no statement, proof, number or control changes", + "author": "Anthropic Claude", + "session": "https://claude.ai/code/session_01NMeKEismAyeqgdB4sy2NJU", + "read_at": { + "branch_base": "3e0a91b69892b9717564c592e7a966492a81566a", + "main_merged_in_v1_2": "2d8616ef1b45c4d5bb0970dcc20453bb4126114d" + }, + "consumed": [ + { + "path": "frontiers/c7_zero_gap_limit_20260929/PROOF.md", + "bytes": 17592, + "sha256": "f0e563c45c41333f2bb6e5bf5cb98f0d3b592e2abf2af1c1b098c21ad77cb777", + "git_blob": "5b6328ea3d6afcbeb731698b3834e536f72d1bcb", + "tag": "Z", + "use": "(Z2)-(Z4) definition of B_{d,L}; section 2 nondegeneracy and the regression form (Z10); section 4 (Z15)-(Z17) near-diagonal majorant; corollaries (Z7)-(Z9)" + }, + { + "path": "frontiers/three_fronts_20260924/LIFETIME_REMAINDER.md", + "bytes": 17734, + "sha256": "380b7d0abdb0fe2de5a6564565af9560d3f1b1ce22fd5538927db0c52f4f3a4a", + "git_blob": "247b3ecf80bfbe896948d5d489b2d5842a81c481", + "tag": "R", + "use": "(R2) uniform nondegeneracy of the rescaled near-pair rows, (R3) regression form, Lemma R3.1 (R6) (Steps 1, 5)" + }, + { + "path": "imports/lifetime_parent_20260925/UNIFORM_MATRIX_CAP_AND_LIFETIME.md", + "bytes": 40261, + "sha256": "9350ad6eaba6626b93c3dedeef9e2ff816e5cdf1c8318e85fb27499141c84bc7", + "git_blob": "dfed3b8d318a3ab1950957f393307733a4bef3f2", + "tag": "P", + "use": "section 2 distinct-site jet rank; section 3 near-pair nondegeneracy; (5.1)-(5.3); the periodized Gaussian field" + } + ], + "cited_only": [ + { + "path": "frontiers/c7_total_bounded_20260929/PROOF.md", + "bytes": 14982, + "sha256": "16c0efe372c1b1f26460aaa109287fed78e6fbd2dd00a0530998db296278dd01", + "git_blob": "28748b086ec6761ef467dc67cba475fbdf8b7455", + "tag": "C7-K", + "use": "cited only since v1.1: section 2, the pointwise bound behind (K1), used by v1's Lemma N, which Step 5 superseded in v1.1 (moved from consumed in v1.2.1; identity binding unchanged)" + }, + { + "path": "coefficients/side24_v1/PROOF.md", + "bytes": 10272, + "sha256": "c06daccc4ba4b9168522b9888b76a7d599934fc3b91bd753ee5d492262917769", + "git_blob": "44b66f04f89fcd87383b3603fa69f1feb64cdddd", + "tag": "side24_v1", + "use": "the value c_{3,24} = 0.0417759318... quoted in sections 0 and 3" + }, + { + "path": "frontiers/remainder_vanishing_20260930/PROOF.md", + "bytes": 25353, + "sha256": "0cb5b949261476f10e539677e2744e3288752474393af25ba787e67b1350f32a", + "git_blob": "441152dfc1d8d00cb268cebdb0394212a5bfacdb", + "tag": "191", + "use": "interpretation: (R+.1)-(R+.2), B_{d,L} is the constant term of nu_cand; the elder density has none (merged since v1.1)" + }, + { + "path": "frontiers/cusp_second_order_20261001/PROOF.md", + "bytes": 52605, + "sha256": "cffc1b83ac364da58bd650c3c301ea1babd38e19af54f74010bdc120edce38a8", + "git_blob": "f6df5a7356a54771b0052e42a864a140709903ad", + "tag": "207", + "use": "(CU-prime.2), the ell^(1/4) term of rho_rej, quoted in section 3 (merged since v1.1)" + }, + { + "path": "frontiers/candidate_third_order_20261001/PROOF.md", + "bytes": 37220, + "sha256": "6c1279164499d4fe2fbeee244b40dafa2159758d20f04826cd67d7602ea97fe4", + "git_blob": "70ca57ef05199e75417d7d57928c1e1c93bf944e", + "tag": "218", + "use": "Theorem T: nu_cand with B_{d,L} and the next terms (v1.2, section 0)" + }, + { + "path": "frontiers/third_order_rate_20261001/PROOF.md", + "bytes": 37626, + "sha256": "5de5a6c7b942a71675c812000ade30c16766f02ee388e8dc3e1c51dde5297f7d", + "git_blob": "110ed33a57902bef11873807e722fde3888b59fb", + "tag": "229", + "use": "Theorem T+; Proposition W+ ((W+.2) at k = 0, (W+.3)): the upper bound in the section 2 heuristic up to log(2/r) (v1.2; upper-bound wording v1.2.1)" + } + ], + "cited_external": [ + { + "tag": "BBKS", + "reference": "J. M. Bardeen, J. R. Bond, N. Kaiser, A. S. Szalay, The statistics of peaks of Gaussian random fields, Astrophys. J. 304 (1986) 15-61", + "use": "closed-form densities of maxima and saddles in d = 3 (control Q3)" + }, + { + "tag": "Mehta", + "reference": "M. L. Mehta, Random Matrices, 3rd ed., Elsevier (2004), Selberg/Mehta integral", + "use": "GOE normalisation (control Q2)" + } + ], + "mutants": [ + "M1", + "M2", + "M3" + ], + "replayed": [ + "equal_height_mass.py" + ], + "not_replayed": [ + "gamma_explore.py" + ], + "referee": { + "kind": "pre-submission clean-context referee pass, same author family (Anthropic Claude subagent); NOT acceptance, NOT independent", + "result": "no error; one gap (Step 5 asserted the uniformity in L of the near-diagonal majorant (Z15), whose proof uses whole-torus norms) closed by Lemma N (the pointwise (K1) bound at k = 0 with local seminorms; moments through the covariance on a ball); minor points applied (normalized periodized kernel; c_{3,24} source; [C7-K] in the header; the (Z15) chain; the I(s) shape 0.70 at s = 2; the 200000 invocation; full scaled-GOE covariance in Q1; [R] (R6) citation; jet rank on R^d; e defined; the L^N prefactor; #191 marked unmerged); beta_2, beta_3 recomputed independently to 10 digits; gamma_3 = -0.0200 +- 0.0001 independently (10^6 samples per separation, control variate)" + }, + "automated_nonauthor": [ + { + "source": "Codex review comment 4151471466 on Math- #211 (P1, v1 NOTE.md line 42)", + "finding": "the SIDE24 value does not follow from an unquantified near-part o(1)", + "disposition": "v1.1: Step 5 rewritten through a uniformly nondegenerate rescaled jet vector, giving the same O(L^N e^{-L^2/8}) rate for the near part; the value B_{3,24} ~ 10.21 is stated as the asymptotic formula at L = 24 with an exponentially small remainder of uncomputed constants (exploration, not an enclosure)" + }, + { + "source": "Codex review comment 4151471472 on Math- #211 (P2, gamma_explore.py)", + "finding": "sample counts not divisible by five were silently truncated", + "disposition": "v1.1: the count must be a positive multiple of five (exit 2 otherwise); GAMMA.json (200000) unchanged" + } + ], + "files": [ + { + "path": "NOTE.md", + "bytes": 19894, + "sha256": "fb9c56d7da5ead43fbd30860c38a17431609ad1808dbeba4f0489fdeb8e743b5" + }, + { + "path": "README.md", + "bytes": 3812, + "sha256": "578e55725288e047f7b6037ca8b73be576ae6d84bc40e18662329e1545c33d1d" + }, + { + "path": "equal_height_mass.py", + "bytes": 10792, + "sha256": "88a00dafb5710009bd1eeb6267a6b9a197e2cca304ce2f90df5cd138951d1ace" + }, + { + "path": "RESULTS.json", + "bytes": 929, + "sha256": "9054e435878a57a6bea42b8af08c0bd51770474503990334687559f7260b06c3" + }, + { + "path": "gamma_explore.py", + "bytes": 7591, + "sha256": "fb07dc5efea1def170ea14a6c7e4aa1afe391645f42a9f30d21ee6e4810b01d8" + }, + { + "path": "GAMMA.json", + "bytes": 824, + "sha256": "60f512e83517b4aa37da4d4fbeeb45857ea1fed45dfd9346f60236a72fa6805a" + } + ], + "supersedes": { + "object": "CL-EQUAL-HEIGHT-MASS-20261001-v1.2", + "head": "f35b28b1b0415e68c54e41b5265ba95fe81ebc60", + "note_blob": "1d2651406b52dd322b222eb97c2daed196b156e7" + }, + "nonauthor_reviews": [ + { + "slice": "A (Proposition V)", + "reviewer": "OpenAI Codex /root with /root/volume_far_review (delegated AI review; same GitHub account; organizational independence 0)", + "review": "pullrequestreview-5379568217", + "pickup": "5931994043", + "at": "8e89fe8 (NOTE blob ed0d3fa8)", + "verdict": "scoped analytic ACCEPT; no blocking finding; Slice B numerics not reviewed", + "findings": [] + }, + { + "slice": "arithmetic note", + "reviewer": "xAI / Grok team (same GitHub account; organizational independence 0)", + "review": "pullrequestreview-5379852902", + "at": "8e89fe8", + "verdict": "NOT READY (arithmetic closes; not a proof acceptance; behind main)", + "findings": [], + "status_at_f35b28b": "arithmetic still stands at f35b28b (Grok Bot agent 15, 5976336060); the NOT READY rested on branch currency and is not a proof vote; currency is re-checked at integration" + }, + { + "slice": "B (the numerical-control/exploration layer)", + "reviewer": "OpenAI / GPT-5.6 Sol (delegated AI review; same GitHub account; organizational independence 0)", + "review": "pullrequestreview-5402347121", + "pickup": "5972573004", + "at": "f35b28b (v1.2)", + "verdict": "PASS_TECHNICAL_SCOPED / ACCEPT_SCOPED, as numerical controls and exploration; no rigorous enclosure of beta_2/beta_3; no certified gamma_3 or B_{3,24}; no explicit finite-L constants", + "findings": [] + }, + { + "slice": "v1.2 status lines", + "reviewer": "Grok Bot agent 15 (xAI lane; delegated AI review; same GitHub account; organizational independence 0)", + "review": "issuecomment-5976336060", + "pickup": "5976315783", + "at": "f35b28b (v1.2; NOTE blob 1d265140)", + "verdict": "AMEND, wording only; no mathematical defect; Proposition V carry-forward to 1d265140 holds", + "findings": [ + "4: conditional sources stated as flat results (#218, #229)", + "5: \"upper half\" dropped in header and README", + "6: Slice A described without its scope", + "7: PR-body disposition stale; [C7-K] consumed vs cited" + ], + "disposition": "v1.2.1 applies the replacement texts of findings 4-6 (and the README sentence on #218/#229 in the same wording); for finding 7 the PR body is updated, and [C7-K] is aligned the other way: cited only in the header, README and SOURCES.json, as NOTE section 4 and Step 5 show" + } + ], + "status_updates": [ + { + "version": "v1.2", + "files_changed": [ + "NOTE.md", + "README.md", + "SOURCES.json", + ".github/workflows/equal-height-mass.yml" + ], + "unchanged": [ + "equal_height_mass.py", + "RESULTS.json", + "gamma_explore.py", + "GAMMA.json" + ], + "proposition_v_and_proof": "unchanged" + }, + { + "version": "v1.2.1", + "files_changed": [ + "NOTE.md", + "README.md", + "SOURCES.json" + ], + "unchanged": [ + "equal_height_mass.py", + "RESULTS.json", + "gamma_explore.py", + "GAMMA.json", + ".github/workflows/equal-height-mass.yml" + ], + "proposition_v_and_proof": "unchanged" + } + ], + "supersedes_history": [ + { + "object": "CL-EQUAL-HEIGHT-MASS-20261001-v1.1", + "head": "8e89fe886368ae048e125c26f3ac51aa9bec83f6", + "note_blob": "ed0d3fa8e4c28d181fa7d21efcde74933cc6f03c" + } + ] +} diff --git a/frontiers/equal_height_mass_value_20261001/equal_height_mass.py b/frontiers/equal_height_mass_value_20261001/equal_height_mass.py new file mode 100644 index 000000000..92ba3cdec --- /dev/null +++ b/frontiers/equal_height_mass_value_20261001/equal_height_mass.py @@ -0,0 +1,257 @@ +#!/usr/bin/env python3 +"""Controls and the far-field coefficient of Theorem Z's equal-height mass (CL-EQUAL-HEIGHT-MASS-20261001-v1). +Standard library only; deterministic (exact rationals where exact, fixed Gauss-Legendre quadrature otherwise). + +For the stationary field on R^d with covariance exp(-|z|^2/2) and d = 2, 3, the height densities (per unit volume +and unit height) of critical points of index j are + + rho_j(b) = phi(b) (2 pi)^(-d/2) E[ |det(G - b I)| 1{index(G - b I) = j} ], + +where, given f = b and grad f = 0, the Hessian is H = -b I + G with G centred, Var G_ii = 2, Cov(G_ii, G_jj) = 0 +(i != j), Var G_ij = 1, i.e. G has density proportional to exp(-tr G^2 / 4) (a scaled GOE). The far-field +coefficient of the equal-height mass B_{d,L} of [Z] (Z3) is + + beta_d = int rho_d(b) rho_{d-1}(b) db (maxima against index-(d-1) saddles). + + Q1 the conditional law of the Hessian (exact rationals, Hermite moments of the Gaussian kernel): given f and + grad f, the full covariance of the Hessian entries is the scaled-GOE pattern (Var f_ii = 2, Var f_ij = 1, every + other pair 0) and E[f_ii | f = b] = -b, E[f_ij | f = b] = 0, in d = 2 and d = 3; + Q2 the scaled-GOE normalisation: the quadrature of int |Vandermonde| exp(-sum lambda^2/4) over ordered eigenvalues, + times d!, equals Mehta's closed form 8 sqrt(2 pi) (d = 2) and 8 (2 pi)^(3/2) 3/sqrt(pi) = 48 sqrt(2) pi (d = 3); + Q3 the total densities against closed forms: d = 2, n_max = 1/(2 pi sqrt 3), n_sad = 1/(pi sqrt 3); d = 3 (Bardeen, + Bond, Kaiser and Szalay 1986, with R*^3 = 27/(15 sqrt 15)), n_max = (29 - 6 sqrt 6)/(5^(3/2) 8 pi^2 R*^3) and + n_sad = (29 + 6 sqrt 6)/(5^(3/2) 8 pi^2 R*^3), to 1e-8 relative; + Q4 beta_2 and beta_3 at two quadrature resolutions (agreement to 1e-8 relative), and 24^3 beta_3. + M mutants (--mutant M1|M2|M3) exit 1: M1 uses the unconditioned diagonal variance 3 (weight exp(-lambda^2/6)), + M2 drops the Vandermonde factor, M3 counts index-d points as the saddles; an unknown label exits 2. + Scope: these are numerical controls of the one-point densities and of beta_d. They do not test Proposition V + (the volume law), the near-field correction gamma_d (see gamma_explore.py, exploration only) or Theorem Z. +""" +import argparse +import json +import math +import sys +from fractions import Fraction as F + +# ------------------------------------------------------------------------------------------ Q1: exact moments + +def kap(n): + """E-moment structure of exp(-z^2/2): d^n/dz^n at 0 is 0 (n odd) or (-1)^(n/2) (n-1)!! (n even).""" + if n % 2: + return F(0) + out = 1 + for t in range(n - 1, 0, -2): + out *= t + return F((-1) ** (n // 2) * out) + + +def cov(a, b): + out = F((-1) ** sum(b)) + for x, y in zip(a, b): + out *= kap(x + y) + return out + + +def solve(M, v): + n = len(M) + A = [row[:] + [v[i]] for i, row in enumerate(M)] + for i in range(n): + p = next(r for r in range(i, n) if A[r][i] != 0) + A[i], A[p] = A[p], A[i] + for r in range(n): + if r != i and A[r][i] != 0: + fct = A[r][i] / A[i][i] + A[r] = [x - fct * y for x, y in zip(A[r], A[i])] + return [A[i][n] / A[i][i] for i in range(n)] + + +def check_Q1(d): + e = lambda *ks: tuple(sum(1 for k in ks if k == t) for t in range(d)) + obs = [tuple([0] * d)] + [e(t) for t in range(d)] + hes = [e(i, j) for i in range(d) for j in range(i, d)] + C = [[cov(a, b) for b in obs] for a in obs] + out = {} + for h in hes: + for g in hes: + x = solve(C, [cov(o, g) for o in obs]) + out[(h, g)] = cov(h, g) - sum(xi * cov(h, o) for xi, o in zip(x, obs)) + reg = {h: solve(C, [cov(o, h) for o in obs])[0] for h in hes} + # the full conditional covariance must be the scaled-GOE pattern: Var f_ii = 2, Var f_ij = 1 (i < j), all other + # pairs 0 (this is what makes the density proportional to exp(-tr G^2/4)); regression on f: -1 on f_ii, 0 on f_ij + for h in hes: + for g in hes: + if h == g: + want = F(2) if max(h) == 2 else F(1) + else: + want = F(0) + if out[(h, g)] != want: + return False + if reg[h] != (F(-1) if max(h) == 2 else F(0)): + return False + return True + +# ------------------------------------------------------------------------- quadrature over ordered eigenvalues + +def gauss_legendre(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-16: + break + xs.append(x) + ws.append(2 / ((1 - x * x) * dp * dp)) + return xs, ws + + +class Quad: + def __init__(self, n, mutant): + self.gx, self.gw = gauss_legendre(n) + self.var = 3.0 if mutant == 'M1' else 2.0 # diagonal variance of G (M1: unconditioned) + self.vdm = mutant != 'M2' + self.A = 12.0 + + def nodes(self, a, b): + h, c = (b - a) / 2, (a + b) / 2 + return [(c + h * x, h * w) for x, w in zip(self.gx, self.gw)] + + def wt(self, x): + return math.exp(-x * x / (2 * self.var)) + + def vd(self, *ls): + if not self.vdm: + return 1.0 + out = 1.0 + for i in range(len(ls)): + for j in range(i + 1, len(ls)): + out *= ls[j] - ls[i] + return out + + def ordered_integral(self, d, region, integrand): + """int over lambda_1 < ... < lambda_d with the per-coordinate ranges given by region(level, previous).""" + A = self.A + if d == 2: + tot = 0.0 + lo2, hi2 = region['top'] + for l2, w2 in self.nodes(lo2, hi2): + lo1, hi1 = region['low'](l2) + s = 0.0 + for l1, w1 in self.nodes(lo1, hi1): + s += w1 * integrand(l1, l2) * self.vd(l1, l2) * self.wt(l1) + tot += w2 * s * self.wt(l2) + return tot + tot = 0.0 + lo3, hi3 = region['top'] + for l3, w3 in self.nodes(lo3, hi3): + lo2, hi2 = region['mid'](l3) + s2 = 0.0 + for l2, w2 in self.nodes(lo2, hi2): + lo1, hi1 = region['low'](l2) + s1 = 0.0 + for l1, w1 in self.nodes(lo1, hi1): + s1 += w1 * integrand(l1, l2, l3) * self.vd(l1, l2, l3) * self.wt(l1) + s2 += w2 * s1 * self.wt(l2) + tot += w3 * s2 * self.wt(l3) + return tot + + def normaliser(self, d): + A = self.A + if d == 2: + reg = {'top': (-A, A), 'low': lambda l2: (-A, l2)} + else: + reg = {'top': (-A, A), 'mid': lambda l3: (-A, l3), 'low': lambda l2: (-A, l2)} + return math.factorial(d) * self.ordered_integral(d, reg, lambda *ls: 1.0) + + def expectations(self, d, b, Z, mutant): + """E|det(G - b)| 1{index d} and 1{index d-1} (M3: index d counted for both).""" + A = self.A + prod = lambda *ls: abs(math.prod(l - b for l in ls)) + if d == 2: + rmax = {'top': (-A, b), 'low': lambda l2: (-A, l2)} + rsad = {'top': (b, A), 'low': lambda l2: (-A, b)} + else: + rmax = {'top': (-A, b), 'mid': lambda l3: (-A, l3), 'low': lambda l2: (-A, l2)} + rsad = {'top': (b, A), 'mid': lambda l3: (-A, b), 'low': lambda l2: (-A, l2)} + emax = math.factorial(d) * self.ordered_integral(d, rmax, prod) / Z + esad = emax if mutant == 'M3' else math.factorial(d) * self.ordered_integral(d, rsad, prod) / Z + return emax, esad + + +def mehta(d): + return 8 * math.sqrt(2 * math.pi) if d == 2 else 8 * (2 * math.pi) ** 1.5 * 3 / math.sqrt(math.pi) + + +def closed_densities(d): + if d == 2: + return 1 / (2 * math.pi * math.sqrt(3)), 1 / (math.pi * math.sqrt(3)) + rs3 = 27 / (15 * math.sqrt(15)) + den = 5 ** 1.5 * 8 * math.pi ** 2 * rs3 + return (29 - 6 * math.sqrt(6)) / den, (29 + 6 * math.sqrt(6)) / den + + +def densities_and_beta(d, n, nb, mutant): + q = Quad(n, mutant) + Z = q.normaliser(d) # quadrature-consistent; Q2 compares it with Mehta + bx, bw = gauss_legendre(nb) + nm = ns = beta = 0.0 + for x, w in zip(bx, bw): + b, wb = 7.0 * x, 7.0 * w + em, es = q.expectations(d, b, Z, mutant) + pref = math.exp(-b * b / 2) / math.sqrt(2 * math.pi) * (2 * math.pi) ** (-d / 2) + nm += wb * pref * em + ns += wb * pref * es + beta += wb * pref * em * pref * es + return nm, ns, beta, Z + + +def sig(x, k=10): + return float('%.*g' % (k, x)) + + +def main(): + ap = argparse.ArgumentParser() + ap.add_argument('--mutant', default=None) + args = ap.parse_args() + if args.mutant is not None and args.mutant not in ('M1', 'M2', 'M3'): + sys.stderr.write('unknown mutant label\n') + return 2 + mut = args.mutant + checks, ok_all = {}, True + q1 = check_Q1(2) and check_Q1(3) + checks['Q1_conditional_hessian_law'] = {'passed': q1, 'info': 'scaled GOE: Var f_ii = 2, Var f_ij = 1, all other pairs 0; E[f_ii | f = b] = -b'} + ok_all &= q1 + vals = {} + for d in (2, 3): + hi = densities_and_beta(d, 48, 56, mut) + lo = densities_and_beta(d, 40, 48, mut) + vals[d] = (hi, lo) + q2 = all(abs(vals[d][0][3] - mehta(d)) <= 1e-8 * mehta(d) for d in (2, 3)) + checks['Q2_scaled_GOE_normalisation'] = {'passed': q2, 'info': {str(d): sig(vals[d][0][3]) for d in (2, 3)}} + ok_all &= q2 + q3 = True + info3 = {} + for d in (2, 3): + cm, cs = closed_densities(d) + nm, ns = vals[d][0][0], vals[d][0][1] + info3[str(d)] = {'n_max': sig(nm), 'n_max_closed': sig(cm), 'n_sad': sig(ns), 'n_sad_closed': sig(cs)} + q3 &= abs(nm - cm) <= 1e-8 * cm and abs(ns - cs) <= 1e-8 * cs + checks['Q3_total_densities_closed_forms'] = {'passed': q3, 'info': info3} + ok_all &= q3 + q4 = all(abs(vals[d][0][2] - vals[d][1][2]) <= 1e-8 * abs(vals[d][0][2]) for d in (2, 3)) + checks['Q4_beta_two_resolutions'] = {'passed': q4, 'info': {'beta_2': sig(vals[2][0][2]), 'beta_3': sig(vals[3][0][2]), + '24^3 beta_3': sig(24 ** 3 * vals[3][0][2], 8)}} + ok_all &= q4 + out = {'object': 'CL-EQUAL-HEIGHT-MASS-20261001-v1', 'scientific_effect': 'NONE', 'passed': bool(ok_all), + 'mutant': mut, 'checks': checks} + sys.stdout.write(json.dumps(out, indent=1, sort_keys=True) + '\n') + return 0 if ok_all else 1 + + +if __name__ == '__main__': + sys.exit(main()) diff --git a/frontiers/equal_height_mass_value_20261001/gamma_explore.py b/frontiers/equal_height_mass_value_20261001/gamma_explore.py new file mode 100644 index 000000000..4152953da --- /dev/null +++ b/frontiers/equal_height_mass_value_20261001/gamma_explore.py @@ -0,0 +1,201 @@ +#!/usr/bin/env python3 +"""EXPLORATION for NOTE.md (CL-EQUAL-HEIGHT-MASS-20261001-v1). Standard library only, floating point, fixed seed. +NOT a control, NOT replayed by the workflow (a few minutes). + +The near-field correction of Proposition V in d = 3 for the Gaussian kernel exp(-|z|^2/2): + + gamma_3 = 4 pi int_0^oo s^2 [ I(s) - beta_3 ] ds, I(s) := int_R Psi_0(b, s e_1) db, + +Psi_0 the equal-height kernel (Z2) of the stationary field on R^3: Psi_0(b, y) = p_y(v_b) E[|det H_0 det H_y| +1{H_0 < 0, index H_y = 2} | O_y = v_b], O_y = (f, grad f)(0), (f, grad f)(y), v_b = (b, 0, b, 0). The conditional law of +the two Hessians is Gaussian with mean b m(s) and a covariance S(s) independent of b (exact covariance derivatives of +the kernel through probabilists' Hermite polynomials); E[. | b] is estimated by Monte Carlo over the residual with +common random numbers across b, and the b-integral uses Gauss-Hermite nodes for the weight exp(-q b^2/2). +beta_3 is taken from equal_height_mass.py (deterministic). Output: GAMMA.json. +""" +import json +import math +import random +import sys + +BETA3 = 7.400614572e-4 # equal_height_mass.py, Q4 (24^3 beta_3 = 10.23061) + + +def He(n, x): + if n == 0: + return 1.0 + h0, h1 = 1.0, x + for k in range(1, n): + h0, h1 = h1, x * h1 - k * h0 + return h1 + + +def dK(g, z): + out = 1.0 + for gk, zk in zip(g, z): + out *= (-1) ** gk * He(gk, zk) * math.exp(-zk * zk / 2) + return out + + +def cov(a, Pa, b, Pb): + return (-1) ** sum(b) * dK(tuple(x + y for x, y in zip(a, b)), tuple(p - q for p, q in zip(Pa, Pb))) + + +OBS = [(0, 0, 0), (1, 0, 0), (0, 1, 0), (0, 0, 1)] +HES = [(2, 0, 0), (0, 2, 0), (0, 0, 2), (1, 1, 0), (1, 0, 1), (0, 1, 1)] + + +def solve_many(M, cols): + """M^{-1} [cols] by Gauss-Jordan with partial pivoting.""" + n = len(M) + A = [M[i][:] + [c[i] for c in cols] for i in range(n)] + k = len(cols) + for i in range(n): + p = max(range(i, n), key=lambda r: abs(A[r][i])) + A[i], A[p] = A[p], A[i] + piv = A[i][i] + A[i] = [x / piv for x in A[i]] + for r in range(n): + if r != i and A[r][i] != 0.0: + f = A[r][i] + A[r] = [x - f * y for x, y in zip(A[r], A[i])] + return [[A[i][n + j] for i in range(n)] for j in range(k)] + + +def logdet(M): + n = len(M) + A = [row[:] for row in M] + s = 0.0 + for i in range(n): + p = max(range(i, n), key=lambda r: abs(A[r][i])) + A[i], A[p] = A[p], A[i] + piv = A[i][i] + s += math.log(abs(piv)) + for r in range(i + 1, n): + f = A[r][i] / piv + A[r] = [x - f * y for x, y in zip(A[r], A[i])] + return s + + +def cholesky(S): + n = len(S) + L = [[0.0] * n for _ in range(n)] + for i in range(n): + for j in range(i + 1): + v = S[i][j] - sum(L[i][k] * L[j][k] for k in range(j)) + if i == j: + L[i][i] = math.sqrt(max(v, 1e-14)) + else: + L[i][j] = v / L[j][j] + return L + + +def hermite_nodes(n): + """Gauss-Hermite nodes/weights for exp(-x^2).""" + xs, ws = [], [] + for i in range(n): + if i == 0: + x = math.sqrt(2 * n + 1) - 1.85575 * (2 * n + 1) ** (-1 / 6) + elif i == 1: + x = xs[0] - 1.14 * n ** 0.426 / xs[0] + elif i == 2: + x = 1.86 * xs[1] - 0.86 * xs[0] + elif i == 3: + x = 1.91 * xs[2] - 0.91 * xs[1] + else: + x = 2 * xs[i - 1] - xs[i - 2] + for _ in range(200): + p1, p2 = math.pi ** -0.25, 0.0 + for j in range(1, n + 1): + p3 = p2 + p2 = p1 + p1 = x * math.sqrt(2 / j) * p2 - math.sqrt((j - 1) / j) * p3 + pp = math.sqrt(2 * n) * p2 + dx = p1 / pp + x -= dx + if abs(dx) < 1e-15: + break + xs.append(x) + ws.append(2 / (pp * pp)) + return xs, ws + + +def det3(a, b, c, d, e, f): + return a * (b * c - f * f) - d * (d * c - f * e) + e * (d * f - b * e) + + +def I_of_s(s, NS, rng, hx, hw): + P0, P1 = (0.0, 0.0, 0.0), (s, 0.0, 0.0) + O = [(a, P0) for a in OBS] + [(a, P1) for a in OBS] + H = [(a, P0) for a in HES] + [(a, P1) for a in HES] + COO = [[cov(a, Pa, b, Pb) for (b, Pb) in O] for (a, Pa) in O] + CHO = [[cov(a, Pa, b, Pb) for (b, Pb) in O] for (a, Pa) in H] + CHH = [[cov(a, Pa, b, Pb) for (b, Pb) in H] for (a, Pa) in H] + e = [1.0, 0, 0, 0, 1.0, 0, 0, 0] + sol = solve_many(COO, [e] + [row for row in CHO]) + ce, X = sol[0], sol[1:] # C_OO^-1 e and C_OO^-1 C_OH (columns) + q = sum(ei * ci for ei, ci in zip(e, ce)) + m = [sum(CHO[i][k] * ce[k] for k in range(8)) for i in range(12)] + S = [[CHH[i][j] - sum(CHO[i][k] * X[j][k] for k in range(8)) for j in range(12)] for i in range(12)] + L = cholesky(S) + pref = math.exp(-0.5 * logdet(COO) - 4 * math.log(2 * math.pi)) + scale = math.sqrt(2 / q) + bs = [x * scale for x in hx] + NB = 5 + per = NS // NB + batches = [] + acc = [0.0] * len(bs) + for it in range(per * NB): + z = [rng.gauss(0.0, 1.0) for _ in range(12)] + R = [sum(L[i][k] * z[k] for k in range(i + 1)) for i in range(12)] + for t, b in enumerate(bs): + h = [R[i] + b * m[i] for i in range(12)] + if not (h[0] < 0 and h[0] * h[1] - h[3] * h[3] > 0): + continue + d0 = det3(h[0], h[1], h[2], h[3], h[4], h[5]) + if d0 >= 0: + continue + d1 = det3(h[6], h[7], h[8], h[9], h[10], h[11]) + if d1 <= 0 or (h[6] > 0 and h[6] * h[7] - h[9] * h[9] > 0): + continue + acc[t] += -d0 * d1 + if (it + 1) % per == 0: + batches.append(pref * scale * sum(w * a / per for w, a in zip(hw, acc))) + acc = [0.0] * len(bs) + return batches + + +def main(): + NS = int(sys.argv[1]) if len(sys.argv) > 1 else 200000 # GAMMA.json: the default (about two minutes) + if NS < 5 or NS % 5: + sys.stderr.write('the sample count must be a positive multiple of 5 (five batches)\n') + return 2 + rng = random.Random(20261001) + hx, hw = hermite_nodes(20) + ss = [0.25 * j for j in range(1, 19)] # 0.25 .. 4.5 + per_s = [I_of_s(s, NS, rng, hx, hw) for s in ss] + vals = [sum(b) / len(b) for b in per_s] + + def gamma(v): + # trapezoid in s on [0, 4.5] (the s^2 weight vanishes at 0); the integrand is negligible beyond 4.5 + g, prev_s, prev_f = 0.0, 0.0, 0.0 + for s, x in zip(ss, v): + f = 4 * math.pi * s * s * (x - BETA3) + g += 0.5 * (s - prev_s) * (f + prev_f) + prev_s, prev_f = s, f + return g + gb = [gamma([b[k] for b in per_s]) for k in range(len(per_s[0]))] + g = sum(gb) / len(gb) + se = math.sqrt(sum((x - g) ** 2 for x in gb) / (len(gb) - 1) / len(gb)) + out = {'object': 'CL-EQUAL-HEIGHT-MASS-20261001-v1 exploration', 'not_a_control': True, + 'samples_per_separation': NS, 'beta_3': BETA3, + 'I_of_s': {('%.2f' % s): float('%.4g' % v) for s, v in zip(ss, vals)}, + 'gamma_3': float('%.4g' % g), 'gamma_3_se_batches': float('%.2g' % se), + 'B_3_24': float('%.6g' % (24 ** 3 * BETA3 + g)), + 'method': 'two-point conditional Gaussian law (exact Hermite covariance derivatives), Monte Carlo over the ' + 'Hessian residual with common random numbers in b, Gauss-Hermite (20) in b, trapezoid in s, step 0.25'} + sys.stdout.write(json.dumps(out, indent=1, sort_keys=True) + '\n') + + +if __name__ == '__main__': + sys.exit(main())