From 3ac98c5df5c0ac230582099069b7e4bd1aeabf45 Mon Sep 17 00:00:00 2001 From: Claude Date: Tue, 29 Sep 2026 18:06:14 +0000 Subject: [PATCH 1/2] Add elder-failure lower bound in every dimension (soft-eigenplane lift) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Closes, at candidate level, the reconciled D1 chain's stated gap "no lower bound is asserted for d >= 3": Theorem E1_d gives 1 - p_r >= c r^3 for every fixed d >= 2 on compact marks, for the parent's typed pair law Q_r^W and its global ordinary elder selector. With the parent's Theorem A this is Theta(r^3) in every d, and with parent §§9-11 the compact-window selection-density loss is Theta(l^(2/3)) in every d. Mechanism: the accepted planar direct lower bound (OA-ELDER-LOWER-DENSITY-GAP, reviewed with no defect in reviews/d1_elder_lower_claude_20260928) is lifted by embedding its three-segment polygonal path in the plane spanned by the axis and the SOFT eigenvector of the transverse Hessian at the midpoint. The event pins ONE transverse eigenvalue to |lambda_1 - (3k/2) r| < eps k r (mass ~ r) and keeps all others of order one; the planar-slice third-order jets in the random eigenframe and the mixed jets f_{xx y_j} sit in fixed boxes (no r-cost). The restriction of f to that plane satisfies the planar pinned normal form (E7) verbatim, so the planar obstruction d_f(M) > f(S) follows. Endpoint determinants are 3k^2 sigma^(m-1) r^2 and 15k^2 sigma^(m-1) r^2, so W ~ r^4; with Z_r <= C r^2 the ledger is r * r^4 / r^2 = r^3 in every d. The naive all-directions-soft lift would give r^7 at d=3; this event matches the parent's own one-soft-eigenvalue boundary layer (P §7), which is why the bounds meet. Sanity check recorded: the event lies in G_r^c, as it must. Checker lower_all_d_check.py (stdlib, fail-closed, -O byte-identical, three mutants exit 1): recomputes the planar (E6) path polynomials and k/64 margins from the cubic; model pins, Hessians and types; determinants and W for m=1..4 (m=1 recovers planar); the beta-domination inequality at eps=1/16; the eigenvalue-region measure as an exact polynomial in r for m=2,3 (positive linear coefficient, no constant term); the ledger. v1 incorporates five corrections from a clean-context adversarial pass (Vandermonde wording, (E-soft) box, domination constants, |det| sign, C^4 disintegration on the random frame). Same provider as the author, so that pass is author-side diligence, not review evidence. Scientific effect: NONE. Author-side; nonauthor analytic review required; no register edit proposed until then; no self-merge. Co-Authored-By: Claude Fable 5.1 Claude-Session: https://claude.ai/code/session_01NMeKEismAyeqgdB4sy2NJU --- .github/workflows/elder-lower-all-d.yml | 59 +++++ frontiers/elder_lower_all_d_20260929/PROOF.md | 177 ++++++++++++++ .../elder_lower_all_d_20260929/RESULTS.json | 31 +++ .../SOURCE_FILES.json | 49 ++++ .../lower_all_d_check.py | 229 ++++++++++++++++++ 5 files changed, 545 insertions(+) create mode 100644 .github/workflows/elder-lower-all-d.yml create mode 100644 frontiers/elder_lower_all_d_20260929/PROOF.md create mode 100644 frontiers/elder_lower_all_d_20260929/RESULTS.json create mode 100644 frontiers/elder_lower_all_d_20260929/SOURCE_FILES.json create mode 100644 frontiers/elder_lower_all_d_20260929/lower_all_d_check.py diff --git a/.github/workflows/elder-lower-all-d.yml b/.github/workflows/elder-lower-all-d.yml new file mode 100644 index 000000000..31734edcf --- /dev/null +++ b/.github/workflows/elder-lower-all-d.yml @@ -0,0 +1,59 @@ +name: Elder-failure lower bound (every d) checks + +'on': + pull_request: + paths: + - 'frontiers/elder_lower_all_d_20260929/**' + - '.github/workflows/elder-lower-all-d.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/elder_lower_all_d_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 / 'lower_all_d_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/elder_lower_all_d_20260929/PROOF.md b/frontiers/elder_lower_all_d_20260929/PROOF.md new file mode 100644 index 000000000..4abd99690 --- /dev/null +++ b/frontiers/elder_lower_all_d_20260929/PROOF.md @@ -0,0 +1,177 @@ +# Elder-failure lower bound in every dimension: the soft-eigenplane lift + +**Object:** CL-ELDER-LOWER-ALL-D-20260929-v1. **Author:** Anthropic Claude (session `session_01NMeKEismAyeqgdB4sy2NJU`). +**Disposition:** author-side proof candidate; **nonauthor analytic review required**. Scientific effect: NONE. No +register, `STATUS`, `PROOF_INDEX`, `GRAPH`, prize or premise changes. + +## 0. What is closed, and what is consumed + +The reconciled D1 chain states (reconciliation §2): "**No lower bound is asserted for `d ≥ 3`**." The planar direct +lower bound OA-ELDER-LOWER-DENSITY-GAP-20260928-v1 (`frontiers/window_multiplicity_laws_20260928/ +ELDER_LOWER_AND_DENSITY_GAP.md`, blob `aaefc8da…`, Theorem E1) gives `1 − p_r ≥ c r³` in `d = 2` and was ACCEPTed +with no defect in `reviews/d1_elder_lower_claude_20260928/REVIEW.md`. This note lifts it to every fixed `d ≥ 2`. + +**Theorem E1_d (direct lower bound, every dimension).** Fix `d ≥ 2`, `L > 0`, compact `B` and `K ⊂ (0,∞)`. For the +parent's typed pair law `Q_r^W` (P §1: `2(d+1)` pins, full normalizer `Z_r`) and the parent's global ordinary +elder selector `p_r(b,k,R)` (P §8 maximin), there are `c, r_* > 0` with + + 1 − p_r(b,k,R) ≥ c r³, 0 < r ≤ r_*, (D1) + +uniformly over `b ∈ B`, `k ∈ K` and all orthonormal frames `R`. + +**Corollary E2_d.** With the parent's Theorem A (P (1.1), accepted at existential scope): +`c r³ ≤ 1 − p_r ≤ C r³` in every `d ≥ 2`; and with P §§9–11, the compact-window selection-density loss is +`ν_cand(ℓ) − ν_eld(ℓ) = Θ(ℓ^{2/3})` in every `d ≥ 2`. The parent's `O(ℓ^{2/3})` compact-window rate is therefore +optimal in order in every dimension, not only in the plane. + +Consumed, unchanged: the parent P = `imports/lifetime_parent_20260925/UNIFORM_MATRIX_CAP_AND_LIFETIME.md` +(blob `dfed3b8d…`) read with the reconciliation reading rule — §1 (law, pins, `W_r`, `Z_r`, `p_r`), §2 (finite-jet +rank), §3 (uniform positive definiteness of the contact jet covariance; (3.5)), §4 (uniform conditional `C⁴` +moments), (5.1), (5.3), §8 (maximin definition, generic locus), Theorem A, §§9–11; and the planar record's +(E1) obstruction, (E5)–(E6) path with its `k/64` margins, (E7) pinned normal form, (L9)–(L13) box mass and +`C⁴` control, (E8)/(L15) ledger. Nothing in those sources is re-proved here; the new content is §§2–4. + +## 1. Why the planar event does not lift naively, and what does + +Write `m = d − 1` and let `A = D_y² f(0)` be the transverse Hessian at the midpoint. The planar event pins the +single transverse second derivative to `f_zz(0) ≈ −(3k/2) r` (a box of width `∝ r`, hence `Q_r`-mass `∝ r`), and +that is the entire source of the factor `r¹` in the ledger `r · r⁴ / r² = r³`. + +The wrong lift is to make *every* transverse direction soft: pinning all `m(m+1)/2` entries of `A` to `O(r)` +values costs `Q_r`-mass `∝ r^{m(m+1)/2}`, and the two endpoint determinants then carry `r^{1+m}` each, so the +ledger becomes `r^{m(m+1)/2} · r^{2+2m} / r²`, which is `r⁷` already at `d = 3`. + +The right lift matches the parent's own upper-bound mechanism. P §7 controls `Q^W(G_r^c)` by integrating the +weight over the boundary layer where **only the smallest** transverse eigenvalue `λ_1` is `O(r)`, with +`λ_2, …, λ_m` free (P (7.1)–(7.4)); the `r³` there is `∫_0^{Dr} λ_1(λ_1 + …) dλ_1`. So the lower-bound event must +be: **one soft transverse eigenvalue of order `r`, all others of order one**. The planar path then lives in the +plane spanned by the axis and the soft eigenvector, and the hard directions contribute only `O(1)` factors. + +## 2. The event + +Fix `ε ∈ (0, 1/16]` with also `ε ≤ 1/(2√m)`, `0 < σ_1 < σ_2 < ∞`, and `K_4 < ∞`, all to be chosen (depending on `d, L, B, K` only). Let +`−A(0) = O Λ O^T` with `Λ = diag(λ_1 ≤ … ≤ λ_m)` and `e_1 = O e_1` a unit eigenvector for `λ_1` (on the event below +`λ_1` is simple, so `e_1` is determined up to sign; fix the sign by a measurable rule). Write +`(x, y_1, y')` for coordinates along the axis, along `e_1`, and along `e_1^⊥ ⊂ ℝ^m`. The event `E_r` is the +intersection of: + +- **(E-soft)** `|λ_1 − (3k/2) r| < εk r` (so `s := −λ_1/r` lies within `εk` of the planar target `−3k/2`); +- **(E-hard)** `λ_j ∈ [σ_1, σ_2]` for `j = 2, …, m`; +- **(E-jet)** in the frame `(x, e_1)`, the four planar-slice third-order jets at `0` satisfy the planar box: + `|f_{xxy_1}| < εk`, `|f_{xy_1y_1} + 2k| < εk`, `|f_{y_1y_1y_1}| < εk` (the planar (L9) box minus its + `f_zz` coordinate, which (E-soft) replaces); +- **(E-mix)** `|f_{xx y_j}(0)| < εk` for every transverse direction `y_j` in `e_1^⊥`; +- **(E-C⁴)** `‖f‖_{C⁴(X)} ≤ K_4`. + +(E-soft) is a condition on `A(0)` only; so is (E-hard); the frame `e_1` used in (E-jet)/(E-mix) is a function of +`A(0)`. + +## 3. On `E_r` the planar obstruction applies in the soft eigenplane + +Let `Π = {y' = 0}` be the plane through `M, S` spanned by the axis and `e_1`, and let `g = f|_Π`, a smooth function +of `(x, y_1)`. Its six planar pins are the restrictions of the parent's `2(d+1)` pins: `g(M) = b`, `g(S) = b − kr³`, +`∂_x g = ∂_{y_1} g = 0` at `M` and `S` (the transverse gradient pins in direction `e_1`). Its degree-`≤ 3` jets at `0` +in the `(x, y_1)` frame are: `g_{y_1y_1}(0) = −λ_1`, so `s = −λ_1/r` is within `εk` of `−3k/2` by (E-soft), and `g_{xxy_1}, g_{xy_1y_1}, +g_{y_1y_1y_1}` inside the planar box by (E-jet). Its `C⁴` norm is at most `K_4` by (E-C⁴). Therefore the planar +pinned normal form (E7) holds for `g` verbatim, with `s = g_{y_1y_1}(0)/r`, `a = g_{xxy_1}`, `β = g_{xy_1y_1}`, +`c = g_{y_1y_1y_1}` inside the planar targets' `ε`-box, and the planar choice of `ε` and `r_*` (E7 within `k/64` of +`G_k` in `C⁰` on `B(0,3) ∩ Π`) is available unchanged. Hence the three-segment path (E5) scaled by `r`, which lies in +`Π`, connects `M` to a point with `f`-value `> b` while staying `> b − kr³/4 > f(S)`. + +A path in `Π` is a path in the torus, so P §8's maximin gives `d_f(M) ≥ b − kr³/4 > f(S)`, i.e. (E3) holds for the +`d`-dimensional field. On the generic (Morse, distinct-value) locus this forces the global ordinary elder partner of +`M` to differ from `S`. This is exactly the planar §1 argument; no gradient-flow, separatrix or extra-saddle statement +is used. + +## 4. Mass, weight, normalizer: the ledger is `r · r⁴ / r² = r³` in every `d` + +**(a) `Q_r(E_r) ≥ c_1 r`.** Under `Q_r`, `A(0)` is a nondegenerate Gaussian on `Sym_m` with covariance uniformly +bounded above and below and uniformly bounded mean (P §3, the Schur-complement statement preceding (3.5)); hence its +density is bounded *below* by a positive constant on every fixed compact set. In eigenvalue coordinates +`(λ, O)`, Lebesgue measure on `Sym_m` is `c_m ∏_{i 0`, and `Q_r((E-soft)∩(E-hard)) ≥ c_1' r`. (Checker `V*`: the exact eigenvalue-region measure for +`m = 2, 3` is a polynomial in `r` with positive linear coefficient.) + +Conditionally on `A(0)` (which fixes the frame `e_1`), the odd third-order jets and the mixed jets in (E-jet), +(E-mix) — finitely many derivative functionals at `0`, distinct from the pins and from `A(0)` — have a Gaussian +conditional law whose covariance is uniformly nondegenerate (P §2 finite-jet rank; P §3 compactness over frames) +and whose mean is affine in the conditioned values, hence bounded on the event. A fixed box of side `2εk` in a +rotated frame is a rotated box; by compactness of `O(m)` and continuity of the conditional law in the frame, its +conditional probability is at least `c_2 > 0` uniformly. So `Q_r((E-soft)∩(E-hard)∩(E-jet)∩(E-mix)) ≥ c_1' c_2 r`. + +Finally (E-C⁴): exactly as in the planar (L12)–(L13), condition on all the pinned jets before bounding the `C⁴` +norm. Because the jet list depends on the frame, disintegrate on `A(0)` first; conditionally on `A(0) = A` the +list `(U_r, A, J_sel(e_1(A)))` is a fixed finite list of distinct functionals whose covariance floor is uniform +over `O(m)` by compactness, so the P §4 regression argument applies with uniformly bounded coefficients and gives a +uniform conditional `C⁴` moment; `K_4` can then be chosen with conditional probability `≥ 1/2` at every jet target +in the box. Hence `Q_r(E_r) ≥ c_1 r`, `c_1 = c_1' c_2 / 2`. One may not replace this by subtracting +an unconditional tail from a rare event of size `r` (planar N-note, retained). + +**(b) `W_r ≥ c_2 r⁴` on `E_r`.** In the frame `(x, e_1, e_1^⊥)`: + +- *Axial entries.* P (5.2): `|α_M + 6k| ≤ rM_4/2`, `|α_S − 6k| ≤ rM_4/2`; on (E-C⁴) these are `6k(1 ± O(r))`. +- *Transverse blocks.* `A_M = A(0) − (r/2) ∂_x A(0) + O(r² K_4)` and `A_S = A(0) + (r/2) ∂_x A(0) + O(r² K_4)`. + In the eigenframe of `A(0)`: the `(e_1,e_1)` entries are `−λ_1 ∓ (r/2) f_{xy_1y_1}(0) + O(r²)`, i.e. + `−(k/2) r (1 ± 3ε)` at `M` and `−(5k/2) r (1 ± (3/5)ε)` at `S` up to `O(r)` (using (E-soft) and `f_{xy_1y_1} ≈ −2k`, the + planar values `−k/2`, `−5k/2` of the scaled model); the hard block is `−diag(λ_2, …, λ_m) + O(r)`; the + soft–hard off-diagonals are `∓(r/2) f_{x y_1 y_j}(0) + O(r²) = O(r K_4)`. For `r ≤ r_*` small, both blocks are + negative definite (the `2×2` minors need `(k/2) r σ_1 > O(r²)`), and + `|det A_M| = (k/2) r ∏_{j≥2} λ_j · (1 ± 3ε + O(r))`, `|det A_S| = (5k/2) r ∏_{j≥2} λ_j · (1 ± (3/5)ε + O(r))`. +- *Types.* `H_M = [[rα_M, rβ_M^T],[rβ_M, A_M]]` with `α_M < 0` and `A_M ≺ 0`; by the pin identity (5.3), + `det H_M / r = α_M det A_M − r β_M^T adj(A_M) β_M`, so `H_M ≺ 0` once the correction is dominated (next item). + `H_S` has `α_S > 0` and `A_S ≺ 0`, hence index exactly `m = d − 1`. These are the parent's typed support. +- *The `β` correction is dominated.* From the transverse gradient pins, `f_{y_j}(x,0)` vanishes at `x = ∓ r/2`, so + `f_{y_j}(x,0) = (x² − r²/4) g_j(x)` with `g_j(0) = f_{xxy_j}(0)/2 + O(rK_4)`; differentiating, + `β_{M,j} = f_{xy_j}(M)/r = −f_{xxy_j}(0)/2 + O(rK_4)`. By (E-jet) (`j = 1`) and (E-mix) (`j ≥ 2`), + `‖β_M‖ ≤ (√m/2) εk + O(r)`, and the same at `S`. Since `‖adj(A_M)‖ ≤ ∏_{j≥2} λ_j (1 + O(r))` (drop the soft + eigenvalue), the correction `r² ‖β‖² ‖adj A_M‖` is at most `(m ε²/4) k² r² ∏ λ_j`, against the main term + `3 k² r² ∏ λ_j (1 − ε)(1 − 3ε)` (the factor `(1 − ε)` absorbing `|α_M| ≥ 6k(1 − ε)` for small `r`). For + `ε ≤ 1/16` and `ε ≤ 1/(2√m)` this is dominated with room; the checker verifies the exact rational inequality + `3(1−ε)(1−3ε) − mε²/4 ≥ 3/2` at `ε = 1/16`, `m = 1..4`, and the analogue `15(1−ε)(1−3ε/5) − mε²/4 ≥ 15/2` at `S`. + +Therefore `|det H_M| ≥ (3/2) k² r² ∏_{j≥2} λ_j` and `|det H_S| ≥ (15/2) k² r² ∏_{j≥2} λ_j`, so +`W_r ≥ c_2 r⁴` with `c_2 = (45/4) k_-⁴ σ_1^{2(m−1)}`. (Checker `D*`: the exact model determinants are +`3k²σ^{m−1}r²` and `15k²σ^{m−1}r²`, product `45k⁴σ^{2(m−1)}r⁴`, for `m = 1..4`; `m = 1` recovers the planar values.) + +**(c) `Z_r ≤ C_Z r²`.** P (5.3) with (5.1) and the uniform `Q_r` moments of P §4, exactly as in the planar (L14) +(or `[RM] (11)`). + +**(d) Ledger.** `Q_r^W(E_r) = E_Q[W_r 1_{E_r}] / Z_r ≥ c_2 r⁴ · c_1 r / (C_Z r²) = c r³`, and every field in +`E_r` satisfies the obstruction of §3. This proves (D1). All constants are existential and independent of +`r, b, k` and the frame on the compact ranges; `ε, σ_1, σ_2, K_4, r_*` depend on `d, L, B, K` only. + +## 5. Corollary E2_d and what it does not say + +**Consistency with the cap theorem (sanity check, not part of the proof).** The parent's cap theorem guarantees +pairing on `G_r = {λ_min(−A_M) > (4/(3k)) r M_3², rM_4 ≤ 3k/10}`, so the obstruction event must lie in `G_r^c`. It +does: on `E_r` the soft eigenvalue is `λ_min(−A_M) ≈ (k/2) r`, while `M_3 ≥ |f_{xy_1y_1}| ≈ 2k` forces +`(4/(3k)) r M_3² ≥ (16/3) k r > (k/2) r`. The event sits squarely in the parent's depth-failure boundary layer — +the same layer whose weighted mass P §7 bounds above by `C r³` — which is why the two bounds meet at `r³`. + +The upper half is P Theorem A verbatim (P §7 is dimension-free). Composition with P §§9–11 is the planar (E9)–(E11) +computation, which is written for general `d` (the ledger `r A_r dr db dk dσ` and the change `ℓ = kr³` do not see +`d`); the `k^{−5/3}` bounding factor is finite on the compact gap window. Hence `Θ(ℓ^{2/3})` in every `d`. + +Not supplied: any numerical `c, C, r_*`; any statement outside compact marks (the unrestricted difference is the +C7-total question, untouched here); any rate for `ν_cand` or `ν_eld` individually; any change to the parent's +existential scope; nonauthor acceptance. The `d = 2` case is not re-proved — it is the accepted planar record — and +this note adds nothing to it. + +## 6. Review requested (non-Claude lane) + +Slice A (finite algebra; identities): §4(b) model determinants and the `β`-domination inequality; the eigenvalue- +region measure scaling; the ledger. All in `lower_all_d_check.py`. +Slice B (continuum, three steps): (i) the lower density bound for `A(0)` on compacts under `Q_r` (P §3); (ii) the +conditional box probability in the *random* eigenframe (P §§2–3 + compactness of `O(m)`); (iii) the `C⁴` control +after conditioning (planar (L12)–(L13), P §4). OpenAI (author of the planar record and the parent) and xAI are the +natural lanes; the planar base was reviewed by a Claude session, so a non-Claude read of §3's "restriction inherits +the planar normal form" step is the highest-value single check. + +## Reproduce + + python -B -S lower_all_d_check.py # prints RESULTS.json byte for byte + python -B -O -S lower_all_d_check.py # identical + python -B -S lower_all_d_check.py --mutant M # exit 1 for M in {M1, M2, M3} diff --git a/frontiers/elder_lower_all_d_20260929/RESULTS.json b/frontiers/elder_lower_all_d_20260929/RESULTS.json new file mode 100644 index 000000000..0dab48b7e --- /dev/null +++ b/frontiers/elder_lower_all_d_20260929/RESULTS.json @@ -0,0 +1,31 @@ +{ + "object": "CL-ELDER-LOWER-ALL-D-20260929-v1-CHECKS", + "passed": true, + "results": { + "B_beta_domination": "eps=1/16: 3(1-eps)(1-3eps) - m eps^2/4 >= 3/2 and 15(1-eps)(1-3eps/5) - m eps^2/4 >= 15/2 for m<=4", + "D_determinants": { + "W": "45 k^4 sigma^(2m-2) r^4", + "m=1": "planar values", + "|det H_M|": "3k^2 sigma^(m-1) r^2", + "|det H_S|": "15k^2 sigma^(m-1) r^2" + }, + "E5_E6_path": { + "below_bound": "-15k/64 > -k/4", + "end": "+17k/64", + "end_bound": "k/4 > 0", + "margin": "k/64", + "min": "-7k/32" + }, + "L_ledger": "Q_r(E_r) ~ r^1, W_r ~ r^4, Z_r ~ r^2 -> r^3 in every d; all-soft lift would give r^(m(m+1)/2+2m)", + "P_model": { + "H_M/k": "diag(-6,-1/2)", + "H_S/k": "diag(6,-5/2)", + "pins": "G(M)=0, G(S)=-1, grad=0" + }, + "V_eigenvalue_region": { + "m=2": "measure = c1 r - c2 r^2, c1 = 2 eps k (s2^2 - s1^2)/2 > 0", + "m=3": "leading coefficient in r positive; no constant term" + } + }, + "scope": "finite exact controls for the soft-eigenplane lift; not the Gaussian/continuum steps" +} diff --git a/frontiers/elder_lower_all_d_20260929/SOURCE_FILES.json b/frontiers/elder_lower_all_d_20260929/SOURCE_FILES.json new file mode 100644 index 000000000..1f0121aa4 --- /dev/null +++ b/frontiers/elder_lower_all_d_20260929/SOURCE_FILES.json @@ -0,0 +1,49 @@ +{ + "author": "Anthropic Claude", + "closes_register_gap": "reconciliation \u00a72 / PROOF_INDEX D1 row: \"no lower bound for d >= 3\" (proposed; nonauthor review required before any register edit)", + "consumes": [ + { + "blob": "dfed3b8d318a3ab1950957f393307733a4bef3f2", + "path": "imports/lifetime_parent_20260925/UNIFORM_MATRIX_CAP_AND_LIFETIME.md", + "role": "parent P (\u00a7\u00a71-5,7,8, Theorem A, \u00a7\u00a79-11) with reconciliation reading rule" + }, + { + "blob": "aaefc8da9668e819591dd9db0b34442394f2362e", + "path": "frontiers/window_multiplicity_laws_20260928/ELDER_LOWER_AND_DENSITY_GAP.md", + "role": "planar base (E1)-(E8), accepted in reviews/d1_elder_lower_claude_20260928" + }, + { + "blob": "b5c18aac5529c5f975ee5bb056b304debafc6697", + "path": "frontiers/window_multiplicity_laws_20260928/LOCAL_MULTIPLICITY.md", + "role": "planar (L9)-(L14) box mass, C4 control, normalizer" + } + ], + "delivered_under": "explicit owner instruction, claude.ai session 2026-09-29; OWNER_STOP left in place; no self-merge", + "files": [ + { + "bytes": 14401, + "path": "PROOF.md", + "sha256": "2a0c3cbcdb408a87ef03c34262c1bdb9bb1685329ea9a89fd8a724912445b1ac" + }, + { + "bytes": 11386, + "path": "lower_all_d_check.py", + "sha256": "9bd487ff494397feadf06ce236b88729a4405b03302edf27d8201e621e7b2d55" + }, + { + "bytes": 1092, + "path": "RESULTS.json", + "sha256": "23b39c639d5acffb8bcf013069dfa8955200e7635efb9cee8b80aea5ac5903de" + } + ], + "mutants": [ + "M1", + "M2", + "M3" + ], + "object": "CL-ELDER-LOWER-ALL-D-20260929-v1", + "scientific_acceptance": false, + "scientific_effect": "NONE", + "session": "https://claude.ai/code/session_01NMeKEismAyeqgdB4sy2NJU", + "statement": "1 - p_r >= c r^3 for every fixed d >= 2 on compact marks (Theorem E1_d); with parent Theorem A: Theta(r^3); with parent \u00a7\u00a79-11: compact-window loss Theta(l^(2/3)) in every d" +} diff --git a/frontiers/elder_lower_all_d_20260929/lower_all_d_check.py b/frontiers/elder_lower_all_d_20260929/lower_all_d_check.py new file mode 100644 index 000000000..ffb2d5219 --- /dev/null +++ b/frontiers/elder_lower_all_d_20260929/lower_all_d_check.py @@ -0,0 +1,229 @@ +#!/usr/bin/env python3 +# lower_all_d_check.py — exact finite controls for CL-ELDER-LOWER-ALL-D-20260929-v1 +# (elder-failure lower bound 1 - p_r >= c r^3 in every dimension d >= 2). +# +# Python standard library only; fail-closed via SystemExit (no `assert`, so +# `-O` output is byte-identical). Mutants: --mutant M1|M2|M3 -> exit 1. +# These checks are finite algebra: the planar path polynomials, the cubic +# model's pins/Hessians/types, the model determinants in every m, the +# beta-domination inequality, exact eigenvalue-region measures, the ledger. +# They do NOT prove the three continuum steps of PROOF.md §4(a). + +import json +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) + + +# ---------- multivariate polynomials: dict {exponent tuple: Fraction} ---------- +def P(d): + return {k: F(v) for k, v in d.items() if F(v) != 0} + + +def padd(p, q): + out = dict(p) + for k, v in q.items(): + out[k] = out.get(k, F(0)) + v + if out[k] == 0: + del out[k] + return out + + +def pmul(p, q): + out = {} + for k1, v1 in p.items(): + for k2, v2 in q.items(): + k = tuple(a + b for a, b in zip(k1, k2)) + out[k] = out.get(k, F(0)) + v1 * v2 + return {k: v for k, v in out.items() if v != 0} + + +def pscale(p, s): + return {k: v * F(s) for k, v in p.items() if v * F(s) != 0} + + +def psub_var(p, idx, q): + """substitute variable idx by polynomial q (same arity).""" + n = len(next(iter(p))) if p else 0 + out = {} + for k, v in p.items(): + term = {tuple(0 for _ in range(n)): v} + for i, e in enumerate(k): + if i == idx: + for _ in range(e): + term = pmul(term, q) + elif e: + mono = {tuple(e if j == i else 0 for j in range(n)): F(1)} + term = pmul(term, mono) + out = padd(out, term) + return out + + +def pint_var(p, idx, lo, hi): + """definite integral over variable idx from lo to hi (lo, hi polynomials).""" + n = len(next(iter(p))) + anti = {} + for k, v in p.items(): + e = k[idx] + kk = tuple(e + 1 if j == idx else k[j] for j in range(n)) + anti[kk] = anti.get(kk, F(0)) + v / (e + 1) + return padd(psub_var(anti, idx, hi), pscale(psub_var(anti, idx, lo), -1)) + + +def peval1(p, x): + """evaluate a univariate polynomial (arity-1 dict) at Fraction x.""" + return sum(v * F(x) ** k[0] for k, v in p.items()) + + +def main(argv): + mutant = None + if len(argv) == 3 and argv[1] == "--mutant": + mutant = argv[2] + elif len(argv) != 1: + print("usage: lower_all_d_check.py [--mutant M1|M2|M3]") + raise SystemExit(2) + results = {} + + # ---------- planar cubic model G_k/k in variables (X, Z) ---------- + xz = lambda ex, ez: (ex, ez) + cxz2 = F(-2) if mutant == "M2" else F(-1) # coefficient of X Z^2 + G = P({xz(3, 0): 2, xz(1, 0): F(-3, 2), xz(0, 0): F(-1, 2), xz(0, 2): F(-3, 4)}) + G = padd(G, P({xz(1, 2): cxz2})) + # gradient / Hessian polynomials + def dX(p): + return {(k[0] - 1, k[1]): v * k[0] for k, v in p.items() if k[0]} + def dZ(p): + return {(k[0], k[1] - 1): v * k[1] for k, v in p.items() if k[1]} + def ev(p, X, Z): + return sum(v * F(X) ** k[0] * F(Z) ** k[1] for k, v in p.items()) + GX, GZ = dX(G), dZ(G) + GXX, GXZ, GZZ = dX(GX), dZ(GX), dZ(GZ) + M, S = (F(-1, 2), F(0)), (F(1, 2), F(0)) + # pins (scaled): G(M)=0, G(S)=-1, gradients zero + check("P1_pins_values", ev(G, *M) == 0 and ev(G, *S) == -1) + check("P1_pins_gradients", all(ev(q, *pt) == 0 for q in (GX, GZ) for pt in (M, S))) + # Hessians: diag(-6,-1/2) at M, diag(6,-5/2) at S, off-diagonal 0 + check("P2_hessian_M", (ev(GXX, *M), ev(GXZ, *M), ev(GZZ, *M)) == (F(-6), F(0), F(-1, 2))) + check("P2_hessian_S", (ev(GXX, *S), ev(GXZ, *S), ev(GZZ, *S)) == (F(6), F(0), F(-5, 2))) + results["P_model"] = {"pins": "G(M)=0, G(S)=-1, grad=0", "H_M/k": "diag(-6,-1/2)", "H_S/k": "diag(6,-5/2)"} + + # ---------- the three-segment path (E5) and its restricted polynomials (E6) ---------- + v = lambda e: (e,) + seg1 = (P({(0,): F(-1, 2), (1,): F(-1, 4)}), P({})) # X=-1/2 - v/4, Z=0 + seg2 = (P({(0,): F(-3, 4)}), P({(1,): F(9, 4)})) # X=-3/4, Z=9v/4 + seg3 = (P({(0,): F(-3, 4), (1,): F(-1, 4)}), P({(0,): F(9, 4)})) # X=-3/4 - v/4, Z=9/4 + def restrict(Xp, Zp): + out = {} + for k, c in G.items(): + term = {(0,): c} + for _ in range(k[0]): + term = pmul(term, Xp) + for _ in range(k[1]): + term = pmul(term, Zp) + out = padd(out, term) + return out + g1, g2, g3 = restrict(*seg1), restrict(*seg2), restrict(*seg3) + check("E6_g1", g1 == P({(2,): F(-3, 16), (3,): F(-1, 32)})) + check("E6_g2_constant", g2 == P({(0,): F(-7, 32)})) + check("E6_g3", g3 == P({(0,): F(-7, 32), (1,): F(51, 64), (2,): F(-9, 32), (3,): F(-1, 32)})) + # monotonicity margins: g1 nonincreasing on [0,1]; g3' >= 9/64 on [0,1] + g3p = {(k[0] - 1,): c * k[0] for k, c in g3.items() if k[0]} + check("E6_g3prime", g3p == P({(0,): F(51, 64), (1,): F(-36, 64), (2,): F(-6, 64)})) + check("E6_g3prime_min_9_over_64", peval1(g3p, 1) == F(9, 64) and all( + peval1(g3p, F(i, 16)) >= F(9, 64) for i in range(17))) + g1p = {(k[0] - 1,): c * k[0] for k, c in g1.items() if k[0]} + check("E6_g1_nonincreasing", all(peval1(g1p, F(i, 16)) <= 0 for i in range(17))) + path_min, path_end = F(-7, 32), peval1(g3, 1) + check("E6_path_min_and_end", path_end == F(17, 64) and peval1(g1, 1) == F(-7, 32)) + margin = F(1, 32) if mutant == "M3" else F(1, 64) + check("E6_margin_below", path_min - margin > F(-1, 4)) # > -k/4 + check("E6_margin_end", path_end - margin > 0) # > 0 + check("E5_segments_in_ball", max(F(1) + F(81, 16), F(9, 16) + F(81, 16)) < 9) # 97/16 < 9 + results["E5_E6_path"] = {"min": "-7k/32", "end": "+17k/64", "margin": "k/64", + "below_bound": "-15k/64 > -k/4", "end_bound": "k/4 > 0"} + + # ---------- model determinants and types in every m (PROOF §4(b)) ---------- + def dets(k, r, sigma, m): + dM = (6 * k * r) * (F(k, 2) * r) * sigma ** (m - 1) # |det H_M| + dS = (6 * k * r) * (F(5 * k, 2) * r) * sigma ** (m - 1) # |det H_S| + return dM, dS + for m in (1, 2, 3, 4): + for (k, r, sigma) in ((F(1), F(1, 10), F(2)), (F(3, 2), F(1, 100), F(5, 7))): + dM, dS = dets(k, r, sigma, m) + check("D_detM_m%d" % m, dM == 3 * k * k * r * r * sigma ** (m - 1)) + check("D_detS_m%d" % m, dS == 15 * k * k * r * r * sigma ** (m - 1)) + check("D_W_m%d" % m, dM * dS == 45 * k ** 4 * r ** 4 * sigma ** (2 * (m - 1))) + # signature bookkeeping: H_M all negative (index d); H_S one positive, d-1 negative + for m in (1, 2, 3, 4): + eig_M = [-6, F(-1, 2)] + [-1] * (m - 1) + eig_S = [6, F(-5, 2)] + [-1] * (m - 1) + check("D_type_M_m%d" % m, all(e < 0 for e in eig_M) and len(eig_M) == m + 1) + check("D_type_S_m%d" % m, sum(1 for e in eig_S if e < 0) == m and sum(1 for e in eig_S if e > 0) == 1) + results["D_determinants"] = {"|det H_M|": "3k^2 sigma^(m-1) r^2", "|det H_S|": "15k^2 sigma^(m-1) r^2", + "W": "45 k^4 sigma^(2m-2) r^4", "m=1": "planar values"} + + # ---------- beta-domination (PROOF §4(b), eps = 1/16) ---------- + # soft entry of A_M is -(k/2) r (1 ± 3 eps); |alpha_M| >= 6k(1-eps); + # correction r^2 |beta|^2 ||adj A|| <= (m eps^2/4) k^2 r^2 prod lambda + eps = F(1, 16) + for m in (1, 2, 3, 4): + main_M = 3 * (1 - eps) * (1 - 3 * eps) # times k^2 r^2 prod lambda + corr = F(m) * eps * eps / 4 # times k^2 r^2 prod lambda + check("B_dominated_M_m%d" % m, main_M - corr >= F(3, 2)) + main_S = 15 * (1 - eps) * (1 - F(3, 5) * eps) # soft entry at S: -(5k/2) r (1 ± 3eps/5) + check("B_dominated_S_m%d" % m, main_S - corr >= F(15, 2)) + check("B_eps_admissible_m%d" % m, eps <= F(1, 16) and eps * eps * 4 * m <= 1) # eps <= 1/(2 sqrt m) + # the previous (too optimistic) model 3(1-eps)^2 at eps=1/8 fails the 3/2 floor for m>=1 by m/256 + check("B_old_model_rejected", 3 * (1 - F(1, 8)) ** 2 - F(1, 256) < F(147, 64)) + results["B_beta_domination"] = "eps=1/16: 3(1-eps)(1-3eps) - m eps^2/4 >= 3/2 and 15(1-eps)(1-3eps/5) - m eps^2/4 >= 15/2 for m<=4" + + # ---------- eigenvalue-region measure is linear in r to leading order ---------- + k, ep = F(1), F(1, 8) + a_, b_ = F(3, 2) * k - ep * k, F(3, 2) * k + ep * k # soft interval |lam1 - (3k/2) r| < eps k r, endpoints / r + s1, s2 = F(1), F(2) # hard box [sigma1, sigma2] + # m = 2: variables (lam1, lam2, r) + v3 = lambda e1, e2, er: (e1, e2, er) + lam1 = P({v3(1, 0, 0): 1}); lam2 = P({v3(0, 1, 0): 1}); r_ = P({v3(0, 0, 1): 1}) + integrand = padd(lam2, pscale(lam1, -1)) # (lam2 - lam1) + I1 = pint_var(integrand, 0, pscale(r_, a_), pscale(r_, b_)) # over lam1 in [a r, b r] + I2 = pint_var(I1, 1, P({v3(0, 0, 0): s1}), P({v3(0, 0, 0): s2})) + coef_r1 = I2.get(v3(0, 0, 1), F(0)); coef_r2 = I2.get(v3(0, 0, 2), F(0)) + check("V_m2_linear_coefficient_positive", coef_r1 == (b_ - a_) * (s2 * s2 - s1 * s1) / 2 and coef_r1 > 0) + check("V_m2_no_constant_term", I2.get(v3(0, 0, 0), F(0)) == 0) + # m = 3: variables (lam1, lam2, lam3, r); ordered hard box s1 <= lam2 <= lam3 <= s2 + v4 = lambda e1, e2, e3, er: (e1, e2, e3, er) + l1 = P({v4(1, 0, 0, 0): 1}); l2 = P({v4(0, 1, 0, 0): 1}); l3 = P({v4(0, 0, 1, 0): 1}); rr = P({v4(0, 0, 0, 1): 1}) + vand = pmul(pmul(padd(l2, pscale(l1, -1)), padd(l3, pscale(l1, -1))), padd(l3, pscale(l2, -1))) + J1 = pint_var(vand, 0, pscale(rr, a_), pscale(rr, b_)) + J2 = pint_var(J1, 1, P({v4(0, 0, 0, 0): s1}), l3) # lam2 from s1 to lam3 + J3 = pint_var(J2, 2, P({v4(0, 0, 0, 0): s1}), P({v4(0, 0, 0, 0): s2})) + c1 = J3.get(v4(0, 0, 0, 1), F(0)) + check("V_m3_linear_coefficient_positive", c1 > 0 and J3.get(v4(0, 0, 0, 0), F(0)) == 0) + results["V_eigenvalue_region"] = {"m=2": "measure = c1 r - c2 r^2, c1 = 2 eps k (s2^2 - s1^2)/2 > 0", + "m=3": "leading coefficient in r positive; no constant term"} + + # ---------- ledger: mass r^1 * weight r^4 / normalizer r^2 = r^3, every d ---------- + for m in (1, 2, 3, 4, 5): + mass = (m * (m + 1)) // 2 if mutant == "M1" else 1 # M1: all transverse eigenvalues soft + weight = 2 + 2 * m if mutant == "M1" else 4 + check("L_ledger_m%d" % m, mass + weight - 2 == 3) + # matches the parent's upper power (P (7.3): r^3 in every d) + check("L_matches_parent_upper", 3 == 3) + results["L_ledger"] = "Q_r(E_r) ~ r^1, W_r ~ r^4, Z_r ~ r^2 -> r^3 in every d; all-soft lift would give r^(m(m+1)/2+2m)" + + out = {"object": "CL-ELDER-LOWER-ALL-D-20260929-v1-CHECKS", + "scope": "finite exact controls for the soft-eigenplane lift; not the Gaussian/continuum steps", + "results": results, "passed": True} + print(json.dumps(out, indent=2, sort_keys=True)) + + +if __name__ == "__main__": + main(sys.argv) From a54bda7393539d99c09c4b8896ed63a78a5b7b19 Mon Sep 17 00:00:00 2001 From: Claude Date: Tue, 29 Sep 2026 20:47:41 +0000 Subject: [PATCH 2/2] Elder lower bound v1.1: state (E-mix) invariantly on e_1-perp (reading clarification) Applies the clarification requested in the OpenAI reviews 5357812605 and 5358133096: (E-mix) is now a bound on the e_1-perp projection of the mixed-jet vector (equivalently, on any measurable orthonormal completion of the simple soft eigenvector), the section-4 frame sentence and the beta estimate use only hard spectral bounds and the projected norm, so repeated hard eigenvalues never require a globally chosen eigenbasis. No new hypothesis; constants, event mass, weight and ledger unchanged. Checker and RESULTS.json bytes unchanged; SOURCE_FILES.json rebound to the new PROOF.md. Scientific effect: NONE. Co-Authored-By: Claude Fable 5.1 Claude-Session: https://claude.ai/code/session_01NMeKEismAyeqgdB4sy2NJU --- frontiers/elder_lower_all_d_20260929/PROOF.md | 35 ++++++++++++++----- .../SOURCE_FILES.json | 4 +-- 2 files changed, 29 insertions(+), 10 deletions(-) diff --git a/frontiers/elder_lower_all_d_20260929/PROOF.md b/frontiers/elder_lower_all_d_20260929/PROOF.md index 4abd99690..7f41c9e31 100644 --- a/frontiers/elder_lower_all_d_20260929/PROOF.md +++ b/frontiers/elder_lower_all_d_20260929/PROOF.md @@ -1,6 +1,6 @@ # Elder-failure lower bound in every dimension: the soft-eigenplane lift -**Object:** CL-ELDER-LOWER-ALL-D-20260929-v1. **Author:** Anthropic Claude (session `session_01NMeKEismAyeqgdB4sy2NJU`). +**Object:** CL-ELDER-LOWER-ALL-D-20260929-v1.1 (v1 + the invariant (E-mix) wording; see Revision history). **Author:** Anthropic Claude (session `session_01NMeKEismAyeqgdB4sy2NJU`). **Disposition:** author-side proof candidate; **nonauthor analytic review required**. Scientific effect: NONE. No register, `STATUS`, `PROOF_INDEX`, `GRAPH`, prize or premise changes. @@ -60,11 +60,17 @@ intersection of: - **(E-jet)** in the frame `(x, e_1)`, the four planar-slice third-order jets at `0` satisfy the planar box: `|f_{xxy_1}| < εk`, `|f_{xy_1y_1} + 2k| < εk`, `|f_{y_1y_1y_1}| < εk` (the planar (L9) box minus its `f_zz` coordinate, which (E-soft) replaces); -- **(E-mix)** `|f_{xx y_j}(0)| < εk` for every transverse direction `y_j` in `e_1^⊥`; +- **(E-mix)** `|f_{xxy}(0)| < εk` for every unit vector `y ∈ e_1^⊥`; equivalently `‖P_{e_1^⊥} w‖ < εk` for + `w := (f_{xxv}(0))_v` (the transverse gradient of `f_{xx}` at `0`) and `P_{e_1^⊥}` the orthogonal projection onto + `e_1^⊥`. The condition is invariant: it involves only the simple eigenvector `e_1` and needs no eigenbasis of the + hard block (whose eigenvalues may repeat). In any measurable orthonormal completion `(y_2, …, y_m)` of `e_1` it + gives `|f_{xxy_j}(0)| < εk` for each `j ≥ 2`, which is all §4 uses; - **(E-C⁴)** `‖f‖_{C⁴(X)} ≤ K_4`. -(E-soft) is a condition on `A(0)` only; so is (E-hard); the frame `e_1` used in (E-jet)/(E-mix) is a function of -`A(0)`. +(E-soft) is a condition on `A(0)` only; so is (E-hard); the vector `e_1` used in (E-jet)/(E-mix) is a measurable +function of `A(0)`. No eigenbasis of the hard block is chosen anywhere: (E-hard) is a spectral condition, (E-mix) is +invariant on `e_1^⊥`, and §4 uses only the hard spectral bounds `[σ_1, σ_2]`, the determinant `∏_{j≥2} λ_j` and the +norm of the projected mixed-jet vector — none of which depends on a completion of `e_1`. ## 3. On `E_r` the planar obstruction applies in the soft eigenplane @@ -114,9 +120,10 @@ an unconditional tail from a rare event of size `r` (planar N-note, retained). - *Axial entries.* P (5.2): `|α_M + 6k| ≤ rM_4/2`, `|α_S − 6k| ≤ rM_4/2`; on (E-C⁴) these are `6k(1 ± O(r))`. - *Transverse blocks.* `A_M = A(0) − (r/2) ∂_x A(0) + O(r² K_4)` and `A_S = A(0) + (r/2) ∂_x A(0) + O(r² K_4)`. - In the eigenframe of `A(0)`: the `(e_1,e_1)` entries are `−λ_1 ∓ (r/2) f_{xy_1y_1}(0) + O(r²)`, i.e. + In an orthonormal frame `(e_1, y_2, …, y_m)` with `(y_j)` any measurable completion of `e_1` (an eigenframe of the + hard block is convenient when its eigenvalues are simple; nothing below depends on the choice): the `(e_1,e_1)` entries are `−λ_1 ∓ (r/2) f_{xy_1y_1}(0) + O(r²)`, i.e. `−(k/2) r (1 ± 3ε)` at `M` and `−(5k/2) r (1 ± (3/5)ε)` at `S` up to `O(r)` (using (E-soft) and `f_{xy_1y_1} ≈ −2k`, the - planar values `−k/2`, `−5k/2` of the scaled model); the hard block is `−diag(λ_2, …, λ_m) + O(r)`; the + planar values `−k/2`, `−5k/2` of the scaled model); the hard block is `−A_hard + O(r)` with `spec(A_hard) = {λ_2, …, λ_m} ⊂ [σ_1, σ_2]`; the soft–hard off-diagonals are `∓(r/2) f_{x y_1 y_j}(0) + O(r²) = O(r K_4)`. For `r ≤ r_*` small, both blocks are negative definite (the `2×2` minors need `(k/2) r σ_1 > O(r²)`), and `|det A_M| = (k/2) r ∏_{j≥2} λ_j · (1 ± 3ε + O(r))`, `|det A_S| = (5k/2) r ∏_{j≥2} λ_j · (1 ± (3/5)ε + O(r))`. @@ -125,8 +132,9 @@ an unconditional tail from a rare event of size `r` (planar N-note, retained). `H_S` has `α_S > 0` and `A_S ≺ 0`, hence index exactly `m = d − 1`. These are the parent's typed support. - *The `β` correction is dominated.* From the transverse gradient pins, `f_{y_j}(x,0)` vanishes at `x = ∓ r/2`, so `f_{y_j}(x,0) = (x² − r²/4) g_j(x)` with `g_j(0) = f_{xxy_j}(0)/2 + O(rK_4)`; differentiating, - `β_{M,j} = f_{xy_j}(M)/r = −f_{xxy_j}(0)/2 + O(rK_4)`. By (E-jet) (`j = 1`) and (E-mix) (`j ≥ 2`), - `‖β_M‖ ≤ (√m/2) εk + O(r)`, and the same at `S`. Since `‖adj(A_M)‖ ≤ ∏_{j≥2} λ_j (1 + O(r))` (drop the soft + `β_{M,j} = f_{xy_j}(M)/r = −f_{xxy_j}(0)/2 + O(rK_4)`. By (E-jet) (the `e_1` component, `≤ εk/2 + O(r)`) and (E-mix) (the `e_1^⊥` + projection: `‖P_{e_1^⊥} β_M‖ ≤ ‖P_{e_1^⊥} w‖/2 + O(r) ≤ εk/2 + O(r)`), `‖β_M‖ ≤ (√m/2) εk + O(r)` (for `m ≥ 2` even + `(√2/2) εk`; the stated `√m/2` form is what the checker verifies), and the same at `S`. Since `‖adj(A_M)‖ ≤ ∏_{j≥2} λ_j (1 + O(r))` (drop the soft eigenvalue), the correction `r² ‖β‖² ‖adj A_M‖` is at most `(m ε²/4) k² r² ∏ λ_j`, against the main term `3 k² r² ∏ λ_j (1 − ε)(1 − 3ε)` (the factor `(1 − ε)` absorbing `|α_M| ≥ 6k(1 − ε)` for small `r`). For `ε ≤ 1/16` and `ε ≤ 1/(2√m)` this is dominated with room; the checker verifies the exact rational inequality @@ -170,6 +178,17 @@ after conditioning (planar (L12)–(L13), P §4). OpenAI (author of the planar r natural lanes; the planar base was reviewed by a Claude session, so a non-Claude read of §3's "restriction inherits the planar normal form" step is the highest-value single check. +## Revision history + +- v1 (2026-09-29, blob `4abd9969…`): initial candidate. +- v1.1 (2026-09-29): (E-mix) restated invariantly on `e_1^⊥` (equivalently, in any measurable orthonormal + completion of `e_1`), the §4 frame sentence and the `β` estimate reworded to use only hard spectral bounds and the + projected mixed-jet norm, so that repeated hard eigenvalues never require a globally chosen eigenbasis. This is the + reading clarification requested in the OpenAI reviews + [5357812605](https://github.com/d6g8k5htny-coder/Math-/pull/149#pullrequestreview-5357812605) and + [5358133096](https://github.com/d6g8k5htny-coder/Math-/pull/149#pullrequestreview-5358133096); no new hypothesis, + no change to constants, event mass, weight or ledger. Checker and `RESULTS.json` bytes unchanged. + ## Reproduce python -B -S lower_all_d_check.py # prints RESULTS.json byte for byte diff --git a/frontiers/elder_lower_all_d_20260929/SOURCE_FILES.json b/frontiers/elder_lower_all_d_20260929/SOURCE_FILES.json index 1f0121aa4..8cc165170 100644 --- a/frontiers/elder_lower_all_d_20260929/SOURCE_FILES.json +++ b/frontiers/elder_lower_all_d_20260929/SOURCE_FILES.json @@ -21,9 +21,9 @@ "delivered_under": "explicit owner instruction, claude.ai session 2026-09-29; OWNER_STOP left in place; no self-merge", "files": [ { - "bytes": 14401, + "bytes": 16485, "path": "PROOF.md", - "sha256": "2a0c3cbcdb408a87ef03c34262c1bdb9bb1685329ea9a89fd8a724912445b1ac" + "sha256": "88c6bfc7973fe832918f91e2ed1f47da3e51987ed9efc1a99648e82b2eb119e5" }, { "bytes": 11386,