From eee00170b8dc7403f75886aa554940dc9d20c951 Mon Sep 17 00:00:00 2001 From: Claude Date: Sat, 3 Oct 2026 20:14:26 +0000 Subject: [PATCH 1/2] Cap first exit in Lean v1.6: L3-L4 and the cap from SP's hypothesis (H1) Stacked on v1.5 (Math-#253). Adds six declarations (standard axioms only): - strongConcaveOn_of_hessian: H y v v <= -delta |v|^2 for the second derivative on a convex set gives delta-strong concavity (segment restriction + concaveOn_of_hasDerivWithinAt2_nonpos); - transverse_hessian_le: H(M) <= -lambda and increments of H from M = (-r/2, 0) bounded by m (|dx| + |dy|) give H <= -(lambda - 5 r m) on the cap (SP L3-L4); - slices_strongConcave: each slice is (lambda - 5 r m)-strongly concave; - ridge_capHyp_H1: ridge_capHyp_normalized with hconc and delta derived from the Hessian data and (H1) 8 r m^2 < lambda; - h1ToyF, h1Toy_capHyp: x^3/3 - x/4 - 20 y^2 (lambda = 40 > 32) meets every hypothesis. The 74 v1.5 declarations are unchanged. Interface I3 shrinks to L6, the existence and regularity of h, and L9-L12. Source gate, unit tests (both modes) and --execute (80 declarations, three negative controls) pass locally. Scientific effect NONE. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_017Mi3hxjaxV45x6zo6o1ee3 --- .../cap_first_exit_lean_20261002/ALIGNMENT.md | 12 +- .../CapFirstExit.lean | 247 +++++++++++++++++- .../MANIFEST.json | 52 +++- .../cap_first_exit_lean_20261002/README.md | 18 +- .../cap_first_exit_lean_20261002/test_gate.py | 2 +- 5 files changed, 307 insertions(+), 24 deletions(-) diff --git a/frontiers/cap_first_exit_lean_20261002/ALIGNMENT.md b/frontiers/cap_first_exit_lean_20261002/ALIGNMENT.md index a190fdd82..51242ab48 100644 --- a/frontiers/cap_first_exit_lean_20261002/ALIGNMENT.md +++ b/frontiers/cap_first_exit_lean_20261002/ALIGNMENT.md @@ -4,7 +4,7 @@ | Source | Path | Role | |---|---|---| -| SP | `reviews/d1_cap_elder_partner_second_pass_claude_20260930/REVIEW.md` | the line-numbered reconstruction of CAP §§2–5. L13, L16, L17 and L19–L22 are proved here. Since v1.5, L1, L2, L5, L7 (maximum and uniqueness), L8, L11's chain rule and L18 are also proved, from SP's normalization and L4's output (`ridge_capHyp_normalized`, `ridge_capHyp_sp`, `ridge_capHyp_of_slices`). Inputs that remain: L3–L4's derivation of `δ`, L7's existence and regularity of `h`, and L12. | +| SP | `reviews/d1_cap_elder_partner_second_pass_claude_20260930/REVIEW.md` | the line-numbered reconstruction of CAP §§2–5. L13, L16, L17 and L19–L22 are proved here. Since v1.5, L1, L2, L5, L7 (maximum and uniqueness), L8, L11's chain rule and L18 are also proved, from SP's normalization and L4's output (`ridge_capHyp_normalized`, `ridge_capHyp_sp`, `ridge_capHyp_of_slices`). Since v1.6, L3–L4 are proved from SP's (H1) and the Hessian increments (`ridge_capHyp_H1`). Inputs that remain: L6, L7's existence and regularity of `h`, and L9–L12. | | CAP | `imports/lifetime_parent_20260925/MARKED_CYLINDER_CAP_PROOF.md` | the deterministic theorem that SP reconstructs | The source setting (SP §2) is as follows: @@ -64,6 +64,10 @@ The source setting (SP §2) is as follows: | `hermite_gap_le` | `g' = G` on `[a, c]`, `G(a) = G(c) = 0`, the convexity pair for `G` at modulus `m` ⇒ `g(a) − g(c) ≤ m(c − a)³/12` | SP L1 (`g_0(c) − g_0(a) = −(1/2)∫ φ g_0'''`, `∫ φ = r³/6`) | No integral: `two_node_bound` gives `G ≥ −(m/2)(t − a)(c − t)`, so `g + (m/2)Φ` with `Φ' = (t − a)(c − t)` is monotone, and `Φ(c) = (c − a)³/6`. The pair is the weak form of `|g_0'''| ≤ m`. | | `hermite_m_ge_two` | on `[−r/2, r/2]`, `g(−r/2) − g(r/2) = r³/6` ⇒ `2 ≤ m` | SP L2 (`m ≥ 2`) | SP's `φ`-weighted average of `f_xxx` is exactly 2, so `m ≥ 2`. Lean proves this inequality, not the average identity, and does not need L2's second statement (a point with `f_xxx = 2`). | | `ridge_capHyp_normalized` | the conclusions of `ridge_capHyp_sp`, with `hm` replaced by: `g_0 = f(·, 0)` has derivative `G0` on `[−r/2, r/2]`, `G0(∓r/2) = 0`, the convexity pair for `G0` at modulus `m`, and the gap exactly `r³/6` | SP §2 normalization, L1, L2, then as `ridge_capHyp_sp` | `G0(∓r/2) = 0` are the critical pins along `y = 0`. `h(∓r/2) = 0` identifies `b − s` with `g_0(−r/2) − g_0(r/2)`. | +| `strongConcaveOn_of_hessian` | `HasFDerivAt φ (Dφ y) y`, `HasFDerivAt Dφ (H y) y` and `H y v v ≤ −δ‖v‖²` on convex `K` ⇒ `StrongConcaveOn K δ φ` | SP L7's first sentence ("`δ`-strongly concave … (L4)") | The quadratic-form bound `D_y² f ≤ −δI` is SP's form. The proof restricts to segments and uses Mathlib's `concaveOn_of_hasDerivWithinAt2_nonpos`. | +| `transverse_hessian_le` | `H(M) v v ≤ −λ‖v‖²`, `‖H(p) − H(M)‖ ≤ m(|p.1 + r/2| + ‖p.2‖)` on the cap ⇒ `H(p) v v ≤ −(λ − 5rm)‖v‖²` there | SP L3 (increments, `|Δx| + ‖Δy‖ < 5r`) and L4 (`D_y² f(p) ≤ D_y² f(M) + 5rm · I`) | The increment hypothesis is L3's output for `u = D_y² f`, whose `x`- and `y`-derivatives are third-derivative blocks bounded by `m`. It is stated as an operator-norm bound on the difference. | +| `slices_strongConcave` | under the same data on the cap, each slice `y ↦ f(x, y)`, `x ∈ [−2r, r/2]`, is `(λ − 5rm)`-strongly concave on `B̄(0, 2r)` | SP L4 (`δ = λ − 5rm`) | SP proves it on `D`; the cap's range of `x` suffices. | +| `ridge_capHyp_H1` | the conclusions of `ridge_capHyp_normalized`, with `hconc` and `hδ` replaced by the slice derivatives `Dφ` and Hessians `H` on the cap, the increment bound, `H(M) ≤ −λ` and (H1) `8rm² < λ` | SP §2 (H1), L1–L5, L7, L8, L11, L12, L16–L20 | `δ := λ − 5rm`, and `rm(8m − 5) < λ − 5rm` is (H1). SP's (H2) `rn ≤ 1/20` feeds only L4's `f_xxx ≥ 7/4` and L12, so it is not needed here. | | `sp_curved_side_constants` | `r > 0`, `m ≥ 2`, `δ > r m (8m - 5)`, `0 ≤ ω ≤ 2 m r²` ⇒ `ω ≤ 2rδ` and `2δ · r³/6 < (2rδ - ω)²` | SP L2 (`m ≥ 2`), L4 (`δ > rmk`, `k = 8m - 5`), L5 (`‖w‖ ≤ (15/8) m r² < 2 m r²`), L18 (`4400r³/121 > r³/6`) | So SP's own constants meet `hωr` and `hcurv` at SP's gap `b - s = r³/6`. | | `CapHyp.congr` | from `g = f` on `closure C` and along one ridge `γ₀`, `CapHyp g C M z b s` | the audit's exterior-invariance corollary (Math-#193 deliverable 2) | `closure C ⊇ C ∪ frontier C`. In SP, `C` is closed. | @@ -96,6 +100,8 @@ Each necessity theorem is one conjunction, so it certifies its own premises, not The ridge toy has `δ = 2`, below SP's `δ > rm(8m − 5) = 22`. So `spToyF (x, y) = x³/3 − x/4 − 12y²` is added: there `m = 2` (`f_xxx = 2`), `δ = 24`, `w = 0` and the gap is exactly `r³/6`. `spToy_capHyp` shows that every hypothesis of `ridge_capHyp_sp` holds there, so SP's normalized hypotheses are jointly satisfiable. `spToy_normalized` does the same for `ridge_capHyp_normalized`, with `G0 = x² − 1/4`, `|G0''| = 2 = m` and gap exactly `1/6`. +`spToyF` has `λ = 24 < 8rm² = 32`, so it does not meet (H1). `h1ToyF (x, y) = x³/3 − x/4 − 20y²` (v1.6) has a constant transverse Hessian `−40`, so `λ = 40 > 32`, its Hessian increments vanish and the gap is exactly `1/6`. `h1Toy_capHyp` shows that every hypothesis of `ridge_capHyp_H1` holds there. + The toy lives on `ℝ`, which is not compact. So the older-peak theorems (`older_peak`, `elder_death_level_peak`) have no concrete instance exhibited in Lean. Their extra hypotheses (compact, locally connected, continuous `f`) hold on the torus. @@ -109,7 +115,7 @@ illustrates the hypotheses; it is not a model of the planar cap. |---|---|---|---| | I1 | Coordinates: SP's cap is `[-2r, r/2] × B̄(0, 2r)` in a frame `φ` of the periodic lift, and SP's "boundary" is the topological frontier. The transport to the torus (`CapHyp.toTorus`) and the face list (`frontier_cylinder`) are proved; the transport needs no embedding radius | SP §2 | Only the identification of SP's objects with these Lean objects remains. | | I2 | Persistence bookkeeping: in H0 superlevel persistence with distinct critical values, the class born at a local maximum `M` dies at the largest level at which its component contains a strictly higher local maximum (the elder rule) | SP L22, P §8 | This is the definition of the elder pairing. On a compact, locally connected space, Lean proves that this level is `s` (`elder_death_level_peak`). Only the identification of the persistence module's pairing with that definition is informal. | -| I3 | The analytic steps that produce the inputs of `ridge_capHyp_normalized` from `G_r`: L3–L4 (increments, and the transverse Hessian bound giving `δ > rmk` in `hconc`); `m` as a bound on the third derivatives, which gives the convexity pairs for `G0 = ∂_x f(·, 0)` (L1's input `|g_0'''| ≤ m`) and for `w` (L5's input `‖w''‖ ≤ m`); the critical pins `G0(∓r/2) = 0` and `h(∓r/2) = 0`; L6 (the `w'` bound); L7's existence of the transverse maximizer `h(x)` in the ball and the implicit-function regularity of `h`; and L9–L12 (`‖h'‖` and the `F''` bound giving `hconv`) | SP L3, L4, L6, L7, L9–L12; CAP §§2–5 | These are checked with exact constants by SP's script, not in Lean. Since v1.5, Lean proves L1, L2, L5, L7's maximum and uniqueness, L8, L11's chain rule and L18 from those outputs, and checks SP's constants in the curvature step. L13, L16, L17, L19 and L20 were already proved in v1.4. | +| I3 | The analytic steps that produce the inputs of `ridge_capHyp_H1` from `G_r`: (H1) `λ > 8rm²` and the Hessian data at and around `M` (L3's input: the third-derivative blocks of `f` bounded by `m`, giving the increment bound on `H`); `m` as a bound on the third derivatives, which gives the convexity pairs for `G0 = ∂_x f(·, 0)` (L1's input `|g_0'''| ≤ m`) and for `w` (L5's input `‖w''‖ ≤ m`); the critical pins `G0(∓r/2) = 0` and `h(∓r/2) = 0`; L6 (the `w'` bound); L7's existence of the transverse maximizer `h(x)` in the ball and the implicit-function regularity of `h`; and L9–L12 (`‖h'‖` and the `F''` bound giving `hconv`) | SP §2 (H1), L6, L7, L9–L12; CAP §§2–5 | These are checked with exact constants by SP's script, not in Lean. Since v1.6, Lean proves L3–L4 (from (H1) and the increment bound). Since v1.5, Lean proves L1, L2, L5, L7's maximum and uniqueness, L8, L11's chain rule and L18 from those outputs, and checks SP's constants in the curvature step. L13, L16, L17, L19 and L20 were already proved in v1.4. | | I4 | Theorem A, measurability, `Q^W(G_r^c) ≤ C r³` | P §§7–8, C1, G1 | probability | ## 5. Review contract @@ -126,5 +132,5 @@ row of §4, it says whether the interface is stated correctly. A changed Lean source, toolchain or pin makes an earlier review stale. -v1.5 is additive: it inserts the sections `Slice` and the slice-route toy, and updates the file's header comment. The 53 v1.4 declarations and their statements are unchanged, as the diff against v1.4 shows. The v1.4 alignment review ([5396110365](https://github.com/d6g8k5htny-coder/Math-/pull/246#pullrequestreview-5396110365), `ALIGNED_SCOPED`) therefore still covers the v1.4 rows once a reviewer confirms by diff that they are unchanged. A delta review assesses the new rows: the fourteen slice rows of §2, the v1.5 toy paragraphs of §3 and the revised I3. A same-provider read, including any Claude +v1.5 is additive: it inserts the sections `Slice` and the slice-route toy, and updates the file's header comment. The 53 v1.4 declarations and their statements are unchanged, as the diff against v1.4 shows. The v1.4 alignment review ([5396110365](https://github.com/d6g8k5htny-coder/Math-/pull/246#pullrequestreview-5396110365), `ALIGNED_SCOPED`) therefore still covers the v1.4 rows once a reviewer confirms by diff that they are unchanged. A delta review assesses the new rows: the fourteen slice rows of §2, the v1.5 toy paragraphs of §3 and the revised I3. v1.6 adds four further §2 rows (`strongConcaveOn_of_hessian` to `ridge_capHyp_H1`), the `h1ToyF` paragraph of §3 and a further revision of I3; its 74 v1.5 declarations are unchanged. A same-provider read, including any Claude read, gives zero independence credit. A build or merge is not an alignment review. diff --git a/frontiers/cap_first_exit_lean_20261002/CapFirstExit.lean b/frontiers/cap_first_exit_lean_20261002/CapFirstExit.lean index 9d3453191..7b51a5d91 100644 --- a/frontiers/cap_first_exit_lean_20261002/CapFirstExit.lean +++ b/frontiers/cap_first_exit_lean_20261002/CapFirstExit.lean @@ -16,11 +16,10 @@ is one instance. Only the older-peak theorems add compactness, local connectedness and continuity of `f`, all of which hold on the torus. - What this file does NOT formalize: the analytic steps L3, L4 and L6, the existence and - implicit-function regularity of the transverse maximizer `h`, and L9–L12 (they enter - `ridge_capHyp_normalized`, `ridge_capHyp_of_slices` and `ridge_inputs_of_joint` as hypotheses; - L1, L2, L5, L7's maximum and uniqueness, L8, L11's chain rule, L13 and L16–L20 are proved from - them); the identification of the H0 persistence pairing with the elder rule (L22, P §8); the + What this file does NOT formalize: the analytic step L6, the existence and implicit-function + regularity of the transverse maximizer `h`, and L9–L12 (they enter `ridge_capHyp_H1`, + `ridge_capHyp_of_slices` and `ridge_inputs_of_joint` as hypotheses; L1–L5, L7's maximum and + uniqueness, L8, L11's chain rule, L13 and L16–L20 are proved from them); the identification of the H0 persistence pairing with the elder rule (L22, P §8); the unstable-branch analysis (L23); and every probabilistic statement. -/ import Mathlib @@ -1079,6 +1078,155 @@ theorem ridge_capHyp_normalized {f : ℝ × E → ℝ} {h : ℝ → E} {F G0 : exact ridge_capHyp_sp hr hm hδ hh hg hFa hFc hconv hconc hball hcrit hha hhc hw hwcv hwcc hnorm.le +/-- **Second-order condition for strong concavity.** If `φ` has derivative `Dφ` and `Dφ` has +derivative `H` at every point of the convex set `K`, and `H y v v ≤ -δ ‖v‖²` there, then `φ` is +`δ`-strongly concave on `K`. Along each segment, `φ(x + t v) + (δ/2)‖v‖² t²` has a nonpositive +second derivative, so it is concave on `[0, 1]`. -/ +theorem strongConcaveOn_of_hessian {K : Set E} {φ : E → ℝ} {Dφ : E → E →L[ℝ] ℝ} + {H : E → E →L[ℝ] E →L[ℝ] ℝ} {δ : ℝ} (hK : Convex ℝ K) + (hD : ∀ y ∈ K, HasFDerivAt φ (Dφ y) y) (hH : ∀ y ∈ K, HasFDerivAt Dφ (H y) y) + (hneg : ∀ y ∈ K, ∀ v : E, H y v v ≤ -δ * ‖v‖ ^ 2) : StrongConcaveOn K δ φ := by + refine ⟨hK, fun x hx y hy a b ha hb hab => ?_⟩ + set v := y - x with hv + have hmem : ∀ t ∈ Icc (0 : ℝ) 1, x + t • v ∈ K := fun t ht => hK.add_smul_sub_mem hx hy ht + set ψ : ℝ → ℝ := fun t => φ (x + t • v) + δ / 2 * ‖v‖ ^ 2 * t ^ 2 with hψ + set ψ' : ℝ → ℝ := fun t => Dφ (x + t • v) v + δ * ‖v‖ ^ 2 * t with hψ' + set ψ'' : ℝ → ℝ := fun t => H (x + t • v) v v + δ * ‖v‖ ^ 2 with hψ'' + have hline : ∀ t : ℝ, HasDerivAt (fun s : ℝ => x + s • v) v t := fun t => by + simpa using ((hasDerivAt_id t).smul_const v).const_add x + have hd1 : ∀ t ∈ Icc (0 : ℝ) 1, HasDerivAt ψ (ψ' t) t := by + intro t ht + have h1 : HasDerivAt (fun s => φ (x + s • v)) (Dφ (x + t • v) v) t := + (hD _ (hmem t ht)).comp_hasDerivAt t (hline t) + have h2 : HasDerivAt (fun s : ℝ => δ / 2 * ‖v‖ ^ 2 * s ^ 2) (δ * ‖v‖ ^ 2 * t) t := by + convert (hasDerivAt_pow 2 t).const_mul (δ / 2 * ‖v‖ ^ 2) using 1 + push_cast + ring + exact h1.add h2 + have hd2 : ∀ t ∈ Icc (0 : ℝ) 1, HasDerivAt ψ' (ψ'' t) t := by + intro t ht + have h1 : HasDerivAt (fun s => Dφ (x + s • v)) (H (x + t • v) v) t := + (hH _ (hmem t ht)).comp_hasDerivAt t (hline t) + have h1' : HasDerivAt (fun s => Dφ (x + s • v) v) (H (x + t • v) v v) t := by + simpa using h1.clm_apply (hasDerivAt_const t v) + have h2 : HasDerivAt (fun s : ℝ => δ * ‖v‖ ^ 2 * s) (δ * ‖v‖ ^ 2) t := by + simpa using (hasDerivAt_id t).const_mul (δ * ‖v‖ ^ 2) + exact h1'.add h2 + have hcc : ConcaveOn ℝ (Icc (0 : ℝ) 1) ψ := by + refine concaveOn_of_hasDerivWithinAt2_nonpos (convex_Icc 0 1) + (fun t ht => (hd1 t ht).continuousAt.continuousWithinAt) + (fun t ht => (hd1 t (interior_subset ht)).hasDerivWithinAt) + (fun t ht => (hd2 t (interior_subset ht)).hasDerivWithinAt) (fun t ht => ?_) + have := hneg _ (hmem t (interior_subset ht)) v + simp only [hψ''] + linarith + have key := hcc.2 (left_mem_Icc.mpr zero_le_one) (right_mem_Icc.mpr zero_le_one) ha hb hab + simp only [hψ, smul_eq_mul, mul_zero, zero_smul, add_zero, mul_one, one_smul, zero_add] at key + have hab' : a = 1 - b := by linarith + have hpt : a • x + b • y = x + b • v := by + rw [hab', hv, smul_sub, sub_smul, one_smul]; abel + have hn : ‖x - y‖ = ‖v‖ := by rw [hv, norm_sub_rev] + rw [hpt, hn, smul_eq_mul, smul_eq_mul] + have hxv : x + v = y := by rw [hv]; abel + rw [hxv] at key + show a * φ x + b * φ y + a * b * (δ / 2 * ‖v‖ ^ 2) ≤ φ (x + b • v) + rw [hab'] at key ⊢ + linear_combination key + +/-- **L3–L4 (the transverse Hessian bound).** If the transverse Hessian `H` satisfies +`H(M) ≤ -λ` (SP's `λ = λ_min(-D_y² f(M))`) and its increments from `M = (-r/2, 0)` are bounded by +`m (|Δx| + ‖Δy‖)` (L3, with `m` bounding the third-derivative blocks), then `H(p) ≤ -(λ - 5rm)` +on the cap. The increment is at most `3r/2 + 2r ≤ 5r` there; SP bounds it on all of `D` by +`9r/2 < 5r`. -/ +theorem transverse_hessian_le {H : ℝ × E → E →L[ℝ] E →L[ℝ] ℝ} {r m lam : ℝ} (hr : 0 < r) + (hm : 0 ≤ m) + (hlip : ∀ p ∈ Icc (-2 * r) (r / 2) ×ˢ Metric.closedBall (0 : E) (2 * r), + ‖H p - H (-r / 2, 0)‖ ≤ m * (|p.1 - -r / 2| + ‖p.2‖)) + (hlam : ∀ v : E, H (-r / 2, 0) v v ≤ -lam * ‖v‖ ^ 2) : + ∀ p ∈ Icc (-2 * r) (r / 2) ×ˢ Metric.closedBall (0 : E) (2 * r), ∀ v : E, + H p v v ≤ -(lam - 5 * r * m) * ‖v‖ ^ 2 := by + rintro ⟨x, y⟩ ⟨hx, hy⟩ v + have hy' : ‖y‖ ≤ 2 * r := by simpa using hy + have hdx : |x - -r / 2| ≤ 3 * r / 2 := by + rw [abs_le]; constructor <;> linarith [hx.1, hx.2] + have hinc : ‖H (x, y) - H (-r / 2, 0)‖ ≤ 5 * r * m := by + have := hlip (x, y) ⟨hx, hy⟩ + calc ‖H (x, y) - H (-r / 2, 0)‖ ≤ m * (|x - -r / 2| + ‖y‖) := this + _ ≤ m * (3 * r / 2 + 2 * r) := by gcongr + _ ≤ 5 * r * m := by nlinarith + have hsplit : H (x, y) v v = H (-r / 2, 0) v v + (H (x, y) - H (-r / 2, 0)) v v := by + simp + have hb := (H (x, y) - H (-r / 2, 0)).le_opNorm₂ v v + have hb' : (H (x, y) - H (-r / 2, 0)) v v ≤ 5 * r * m * ‖v‖ ^ 2 := by + have h1 := (le_abs_self _).trans (by simpa [Real.norm_eq_abs] using hb) + calc (H (x, y) - H (-r / 2, 0)) v v ≤ ‖H (x, y) - H (-r / 2, 0)‖ * ‖v‖ * ‖v‖ := h1 + _ ≤ 5 * r * m * ‖v‖ * ‖v‖ := by gcongr + _ = 5 * r * m * ‖v‖ ^ 2 := by ring + rw [hsplit] + have := hlam v + nlinarith + +/-- **L4 (strong concavity of the slices).** Under `transverse_hessian_le`'s hypotheses, with the +slice derivatives `Dφ` and Hessians `H` given on the cap, every slice `y ↦ f (x, y)`, +`x ∈ [-2r, r/2]`, is `(λ - 5rm)`-strongly concave on `B̄(0, 2r)`. -/ +theorem slices_strongConcave {f : ℝ × E → ℝ} {Dφ : ℝ × E → E →L[ℝ] ℝ} + {H : ℝ × E → E →L[ℝ] E →L[ℝ] ℝ} {r m lam : ℝ} (hr : 0 < r) (hm : 0 ≤ m) + (hD : ∀ p ∈ Icc (-2 * r) (r / 2) ×ˢ Metric.closedBall (0 : E) (2 * r), + HasFDerivAt (fun y => f (p.1, y)) (Dφ p) p.2) + (hH : ∀ p ∈ Icc (-2 * r) (r / 2) ×ˢ Metric.closedBall (0 : E) (2 * r), + HasFDerivAt (fun y => Dφ (p.1, y)) (H p) p.2) + (hlip : ∀ p ∈ Icc (-2 * r) (r / 2) ×ˢ Metric.closedBall (0 : E) (2 * r), + ‖H p - H (-r / 2, 0)‖ ≤ m * (|p.1 - -r / 2| + ‖p.2‖)) + (hlam : ∀ v : E, H (-r / 2, 0) v v ≤ -lam * ‖v‖ ^ 2) : + ∀ x ∈ Icc (-2 * r) (r / 2), + StrongConcaveOn (Metric.closedBall (0 : E) (2 * r)) (lam - 5 * r * m) (fun y => f (x, y)) := by + intro x hx + have hbd := transverse_hessian_le hr hm hlip hlam + exact strongConcaveOn_of_hessian (Dφ := fun y => Dφ (x, y)) (H := fun y => H (x, y)) + (convex_closedBall _ _) (fun y hy => hD (x, y) ⟨hx, hy⟩) (fun y hy => hH (x, y) ⟨hx, hy⟩) + (fun y hy v => hbd (x, y) ⟨hx, hy⟩ v) + +/-- **The cap from SP's hypothesis (H1) (L1–L5, L7, L8, L11, L18).** As `ridge_capHyp_normalized`, +with the slice strong concavity and `δ > rm(8m - 5)` derived from Hessian data: the slice +derivatives and Hessians on the cap, the increment bound of `H` from `M` with constant `m`, +`H(M) ≤ -λ`, and (H1) `8 r m² < λ`. Then `δ = λ - 5rm > rm(8m - 5)`. -/ +theorem ridge_capHyp_H1 {f : ℝ × E → ℝ} {h : ℝ → E} {F G0 : ℝ → ℝ} + {w : ℝ → E →L[ℝ] ℝ} {Dφ : ℝ × E → E →L[ℝ] ℝ} {H : ℝ × E → E →L[ℝ] E →L[ℝ] ℝ} + {r m lam : ℝ} (hr : 0 < r) + (hg0 : ∀ x ∈ Icc (-r / 2) (r / 2), HasDerivAt (fun x => f (x, 0)) (G0 x) x) + (hG0cv : ConvexOn ℝ (Icc (-r / 2) (r / 2)) (fun t => G0 t + m / 2 * t ^ 2)) + (hG0cc : ConcaveOn ℝ (Icc (-r / 2) (r / 2)) (fun t => G0 t - m / 2 * t ^ 2)) + (hG0a : G0 (-r / 2) = 0) (hG0c : G0 (r / 2) = 0) + (hD : ∀ p ∈ Icc (-2 * r) (r / 2) ×ˢ Metric.closedBall (0 : E) (2 * r), + HasFDerivAt (fun y => f (p.1, y)) (Dφ p) p.2) + (hH : ∀ p ∈ Icc (-2 * r) (r / 2) ×ˢ Metric.closedBall (0 : E) (2 * r), + HasFDerivAt (fun y => Dφ (p.1, y)) (H p) p.2) + (hlip : ∀ p ∈ Icc (-2 * r) (r / 2) ×ˢ Metric.closedBall (0 : E) (2 * r), + ‖H p - H (-r / 2, 0)‖ ≤ m * (|p.1 - -r / 2| + ‖p.2‖)) + (hlam : ∀ v : E, H (-r / 2, 0) v v ≤ -lam * ‖v‖ ^ 2) (hH1 : 8 * r * m ^ 2 < lam) + (hh : ContinuousOn h (Icc (-r / 2) (2 * r))) + (hg : ∀ x ∈ Icc (-2 * r) (2 * r), HasDerivAt (fun x => f (x, h x)) (F x) x) + (hFa : F (-r / 2) = 0) (hFc : F (r / 2) = 0) + (hconv : ConvexOn ℝ (Icc (-2 * r) (2 * r)) (fun x => F x - (x + r / 2) * (x - r / 2) / 8)) + (hball : ∀ x ∈ Icc (-2 * r) (r / 2), h x ∈ Metric.closedBall (0 : E) (2 * r)) + (hcrit : ∀ x ∈ Icc (-2 * r) (r / 2), + HasFDerivAt (fun y => f (x, y)) (0 : E →L[ℝ] ℝ) (h x)) + (hha : h (-r / 2) = 0) (hhc : h (r / 2) = 0) + (hw : ∀ x ∈ Icc (-2 * r) (r / 2), HasFDerivAt (fun y => f (x, y)) (w x) (0 : E)) + (hwcv : ∀ v : E, ConvexOn ℝ (Icc (-2 * r) (r / 2)) (fun t => w t v + m * ‖v‖ / 2 * t ^ 2)) + (hwcc : ∀ v : E, ConcaveOn ℝ (Icc (-2 * r) (r / 2)) (fun t => w t v - m * ‖v‖ / 2 * t ^ 2)) + (hnorm : f (-r / 2, h (-r / 2)) - f (r / 2, h (r / 2)) = r ^ 3 / 6) : + CapHyp f (Icc (-2 * r) (r / 2) ×ˢ Metric.closedBall (0 : E) (2 * r)) (-r / 2, h (-r / 2)) + (2 * r, h (2 * r)) (f (-r / 2, h (-r / 2))) (f (r / 2, h (r / 2))) ∧ + ∀ x ∈ frontier (Icc (-2 * r) (r / 2) ×ˢ Metric.closedBall (0 : E) (2 * r)), + x ≠ (r / 2, h (r / 2)) → f x < f (r / 2, h (r / 2)) := by + have hm : 2 ≤ m := + hermite_m_ge_two hr hg0 hG0cv hG0cc hG0a hG0c (by simpa [hha, hhc] using hnorm) + have hconc := slices_strongConcave hr (by linarith) hD hH hlip hlam + have hδ : r * m * (8 * m - 5) < lam - 5 * r * m := by nlinarith + exact ridge_capHyp_normalized hr hg0 hG0cv hG0cc hG0a hG0c hδ hh hg hFa hFc hconv hconc hball + hcrit hha hhc hw hwcv hwcc hnorm + end Slice /-! ### A concrete instance and the necessity of each hypothesis @@ -1488,4 +1636,93 @@ theorem spToy_normalized : · simp only [spToyF] norm_num + +/-- A field meeting (H1): `f (x, y) = x³/3 - x/4 - 20 y²`, so `λ = 40 > 8 r m² = 32` at `r = 1`, +`m = 2`, and gap exactly `r³/6`. -/ +noncomputable def h1ToyF (p : ℝ × ℝ) : ℝ := p.1 ^ 3 / 3 - p.1 / 4 - 20 * p.2 ^ 2 + +/-- **`ridge_capHyp_H1` is not vacuous.** `h1ToyF` meets every hypothesis, with a constant +transverse Hessian `-40`, `h = 0`, `w = 0`, `G0 = F = x² - 1/4`, `m = 2` and `λ = 40`. -/ +theorem h1Toy_capHyp : + CapHyp h1ToyF (Icc (-2 * 1) (1 / 2) ×ˢ Metric.closedBall (0 : ℝ) (2 * 1)) (-1 / 2, 0) + (2 * 1, 0) (h1ToyF (-1 / 2, 0)) (h1ToyF (1 / 2, 0)) ∧ + ∀ x ∈ frontier (Icc (-2 * 1) (1 / 2) ×ˢ Metric.closedBall (0 : ℝ) (2 * 1)), + x ≠ (1 / 2, 0) → h1ToyF x < h1ToyF (1 / 2, 0) := by + have hslope : ∀ x y : ℝ, HasFDerivAt (fun y : ℝ => h1ToyF (x, y)) + (ContinuousLinearMap.mul ℝ ℝ (-40 * y)) y := by + intro x y + rw [hasFDerivAt_iff_hasDerivAt] + have h1 := ((hasDerivAt_pow 2 y).const_mul 20).const_sub (x ^ 3 / 3 - x / 4) + convert h1 using 1 + · funext t + simp only [h1ToyF] + · simp + ring + have hslice : ∀ x : ℝ, HasFDerivAt (fun y : ℝ => h1ToyF (x, y)) (0 : ℝ →L[ℝ] ℝ) 0 := by + intro x + simpa using hslope x 0 + have hhess : ∀ y : ℝ, HasFDerivAt (fun y : ℝ => ContinuousLinearMap.mul ℝ ℝ (-40 * y)) + ((-40 : ℝ) • ContinuousLinearMap.mul ℝ ℝ) y := by + intro y + convert ((-40 : ℝ) • ContinuousLinearMap.mul ℝ ℝ).hasFDerivAt (x := y) using 1 + funext t + ext + simp + have hgx : ∀ x : ℝ, HasDerivAt (fun x => h1ToyF (x, 0)) (x ^ 2 - 1 / 4) x := by + intro x + have h1 := ((hasDerivAt_pow 3 x).div_const 3).sub ((hasDerivAt_id x).div_const 4) + convert h1 using 1 + · funext y + simp only [h1ToyF, id, Pi.sub_apply] + ring + · push_cast + ring + have hq : ConvexOn ℝ univ (fun x : ℝ => (7 / 8 : ℝ) • x ^ 2 + (-7 / 32 : ℝ)) := + ((even_two.convexOn_pow).smul (by norm_num)).add (convexOn_const _ convex_univ) + refine ridge_capHyp_H1 (E := ℝ) (f := h1ToyF) (h := fun _ => (0 : ℝ)) + (F := fun x => x ^ 2 - 1 / 4) (G0 := fun x => x ^ 2 - 1 / 4) (w := fun _ => 0) + (Dφ := fun p => ContinuousLinearMap.mul ℝ ℝ (-40 * p.2)) + (H := fun _ => (-40 : ℝ) • ContinuousLinearMap.mul ℝ ℝ) (r := 1) (m := 2) (lam := 40) + one_pos (fun x _ => hgx x) ?_ ?_ (by norm_num) (by norm_num) + (fun p _ => hslope p.1 p.2) (fun p _ => hhess p.2) ?_ ?_ (by norm_num) + continuousOn_const (fun x _ => hgx x) (by norm_num) (by norm_num) ?_ + (fun x _ => by simp) (fun x _ => hslice x) rfl rfl (fun x _ => hslice x) ?_ ?_ ?_ + · have hc : ConvexOn ℝ univ (fun x : ℝ => (2 : ℝ) • x ^ 2 + (-1 / 4 : ℝ)) := + ((even_two.convexOn_pow).smul (by norm_num)).add (convexOn_const _ convex_univ) + refine (hc.subset (subset_univ _) (convex_Icc _ _)).congr ?_ + intro x _ + simp only [smul_eq_mul] + ring + · refine (concaveOn_const (-1 / 4 : ℝ) (convex_Icc _ _)).congr ?_ + intro x _ + ring + · intro p hp + have hp2 : 0 ≤ |p.1 - -1 / 2| + ‖p.2‖ := by positivity + simp only [sub_self, ContinuousLinearMap.opNorm_zero] + linarith + · intro v + simp only [smul_apply, ContinuousLinearMap.mul_apply', smul_eq_mul, + Real.norm_eq_abs, sq_abs] + nlinarith [sq_nonneg v] + · refine (hq.subset (subset_univ _) (convex_Icc _ _)).congr ?_ + intro x _ + simp only [smul_eq_mul] + ring + · intro v + have hc : ConvexOn ℝ univ (fun t : ℝ => ‖v‖ • t ^ 2) := + (even_two.convexOn_pow).smul (norm_nonneg v) + refine (hc.subset (subset_univ _) (convex_Icc _ _)).congr ?_ + intro t _ + simp only [smul_eq_mul, zero_apply] + ring + · intro v + have hc : ConcaveOn ℝ univ (fun t : ℝ => -(‖v‖ • t ^ 2)) := + ((even_two.convexOn_pow).smul (norm_nonneg v)).neg + refine (hc.subset (subset_univ _) (convex_Icc _ _)).congr ?_ + intro t _ + simp only [smul_eq_mul, zero_apply] + ring + · simp only [h1ToyF] + norm_num + end CapFirstExit diff --git a/frontiers/cap_first_exit_lean_20261002/MANIFEST.json b/frontiers/cap_first_exit_lean_20261002/MANIFEST.json index 9d3557406..667eee7b9 100644 --- a/frontiers/cap_first_exit_lean_20261002/MANIFEST.json +++ b/frontiers/cap_first_exit_lean_20261002/MANIFEST.json @@ -86,6 +86,10 @@ "CapFirstExit.hermite_gap_le", "CapFirstExit.hermite_m_ge_two", "CapFirstExit.ridge_capHyp_normalized", + "CapFirstExit.strongConcaveOn_of_hessian", + "CapFirstExit.transverse_hessian_le", + "CapFirstExit.slices_strongConcave", + "CapFirstExit.ridge_capHyp_H1", "CapFirstExit.toyF", "CapFirstExit.toyRidge", "CapFirstExit.toy_ridge_ge", @@ -106,7 +110,9 @@ "CapFirstExit.ridgeToy_slices", "CapFirstExit.spToyF", "CapFirstExit.spToy_capHyp", - "CapFirstExit.spToy_normalized" + "CapFirstExit.spToy_normalized", + "CapFirstExit.h1ToyF", + "CapFirstExit.h1Toy_capHyp" ], "expected_axioms": { "CapFirstExit.path_meets_frontier": [ @@ -374,6 +380,26 @@ "Quot.sound", "propext" ], + "CapFirstExit.strongConcaveOn_of_hessian": [ + "Classical.choice", + "Quot.sound", + "propext" + ], + "CapFirstExit.transverse_hessian_le": [ + "Classical.choice", + "Quot.sound", + "propext" + ], + "CapFirstExit.slices_strongConcave": [ + "Classical.choice", + "Quot.sound", + "propext" + ], + "CapFirstExit.ridge_capHyp_H1": [ + "Classical.choice", + "Quot.sound", + "propext" + ], "CapFirstExit.toyF": [ "Classical.choice", "Quot.sound", @@ -478,6 +504,16 @@ "Classical.choice", "Quot.sound", "propext" + ], + "CapFirstExit.h1ToyF": [ + "Classical.choice", + "Quot.sound", + "propext" + ], + "CapFirstExit.h1Toy_capHyp": [ + "Classical.choice", + "Quot.sound", + "propext" ] }, "files": [ @@ -488,18 +524,18 @@ }, { "path": "ALIGNMENT.md", - "bytes": 19924, - "sha256": "57b992a292ba73f841ad41d9051fa29bba6238a3aad567193249443e18fded58" + "bytes": 22147, + "sha256": "fe801adba43a2e40f24a22b39ef8b379b7dc58dbe35dcdee19a2dbbcca4cc765" }, { "path": "CapFirstExit.lean", - "bytes": 77018, - "sha256": "4b84c4e1b06ade5d1581b47a24e8905a5c1715773de5e73f539fdb98c07a1fad" + "bytes": 90646, + "sha256": "20e82fc57695b7a5cd83be1125796a46abba5e3ebe4676359a275eddf3b6127e" }, { "path": "README.md", - "bytes": 12711, - "sha256": "a6d235c69b8d7d5d129214043acbd1450f5231bffea27dd15762e9011613c260" + "bytes": 13532, + "sha256": "af375f1331d97031e91d1206d8bb724a0f7e94d95ac2f1ecb11753496cdcf43e" }, { "path": "gate.py", @@ -524,7 +560,7 @@ { "path": "test_gate.py", "bytes": 6274, - "sha256": "7fe701b2fb9b790d089a107064140d140fedaec93936c08851475c02895528eb" + "sha256": "880a075aee91c10a16d7d1ad3628624b522d040437f3fb9f327be63c3724555e" } ] } diff --git a/frontiers/cap_first_exit_lean_20261002/README.md b/frontiers/cap_first_exit_lean_20261002/README.md index 080aa8ac7..e552c2321 100644 --- a/frontiers/cap_first_exit_lean_20261002/README.md +++ b/frontiers/cap_first_exit_lean_20261002/README.md @@ -24,15 +24,16 @@ This packet kernel-checks three things: - the one-variable and assembly steps of the analytic part (L13, L16, L17, L19, L20, in `ridge_capHyp`); - since v1.5, L1–L2 and the slice steps: - L1–L2, the Hermite bound `g(a) − g(c) ≤ m(c − a)³/12`, which under the normalization `b − s = r³/6` forces `m ≥ 2`; + - since v1.6, L3–L4, the slice strong concavity `δ = λ − 5rm` from SP's transverse Hessian at `M` and the third-derivative increment bound; - L5, the transverse-gradient bound, from the third-derivative bound `m`; - L7, the transverse maximum and its uniqueness; - L8, the ridge bound; - L11's chain rule; - L18, the curved side. - These are derived from L4's output, the strong concavity of each transverse slice. `ridge_capHyp_sp` takes SP's hypotheses with `m ≥ 2` assumed. `ridge_capHyp_normalized` derives `m ≥ 2` from SP's normalization (gap exactly `r³/6`, pins critical, third derivatives bounded by `m`). + These are derived from L4's output, the strong concavity of each transverse slice. `ridge_capHyp_sp` takes SP's hypotheses with `m ≥ 2` assumed. `ridge_capHyp_normalized` derives `m ≥ 2` from SP's normalization (gap exactly `r³/6`, pins critical, third derivatives bounded by `m`). `ridge_capHyp_H1` (v1.6) also derives `hconc` and `δ > rm(8m − 5)` from SP's hypothesis (H1) `λ > 8rm²`. -The estimates L3, L4 and L6, L7's existence and regularity of `h`, and L9–L12 remain hypotheses. +The estimate L6, L7's existence and regularity of `h`, and L9–L12 remain hypotheses. In the topological theorems, `X` is any topological space, and nothing is assumed about `f` outside `C` except along the single ridge path. @@ -69,6 +70,9 @@ single ridge path. | `spToyF`, `spToy_capHyp` | `x³/3 − x/4 − 12y²` (`m = 2`, `δ = 24 > 22`, gap `r³/6`) meets every hypothesis of `ridge_capHyp_sp` | | `hermite_gap_le`, `hermite_m_ge_two` | L1–L2: if `g' = G` vanishes at `a < c` and `|G''| ≤ m` (weak form), then `g(a) − g(c) ≤ m(c − a)³/12`. At the gap `r³/6` on `[−r/2, r/2]`, this forces `m ≥ 2` | | `ridge_capHyp_normalized`, `spToy_normalized` | the cap with `m ≥ 2` derived from the normalization (L1–L2) instead of assumed; `spToyF` meets every hypothesis | +| `strongConcaveOn_of_hessian` | second-order condition: `H y v v ≤ −δ‖v‖²` for the second derivative on a convex set gives `δ`-strong concavity | +| `transverse_hessian_le`, `slices_strongConcave` | L3–L4: `H(M) ≤ −λ` and increments of `H` from `M` bounded by `m(|Δx| + ‖Δy‖)` give `H ≤ −(λ − 5rm)` on the cap, so each slice is `(λ − 5rm)`-strongly concave | +| `ridge_capHyp_H1`, `h1ToyF`, `h1Toy_capHyp` | the cap from SP's (H1) `λ > 8rm²` with Hessian data in place of `hconc`; `x³/3 − x/4 − 20y²` (`λ = 40 > 32`) meets every hypothesis | | `sp_curved_side_constants` | SP's constants (`m ≥ 2`, `δ > rm(8m − 5)`, `ω ≤ 2mr²`, gap `r³/6`) satisfy `ω ≤ 2rδ` and the curvature condition | | `ridgeToy_joint`, `ridgeToy_slices` | the ridge toy (`δ = 2`, `ω = 0`) meets every input of the slice route, which re-derives (C1)–(C3) and (C2⁺) | | `ridgeToy_capHyp`, `ridgeToy_saddle_strict` | SP's normalization at `r = 1` (`f = x³/3 − x/4 − y²`, gap exactly `r³/6`) satisfies every ridge hypothesis, so they are jointly satisfiable | @@ -91,10 +95,10 @@ that step. This packet does not formalize: -- the analytic steps L3, L4 and L6 (the increments, the transverse Hessian bound that produces `δ`, and the `w'` - bound), the existence and implicit-function regularity of the transverse maximizer `h`, and L9–L12 (the `‖h'‖` and - `F''` bounds). These enter `ridge_capHyp_normalized`, `ridge_capHyp_of_slices` and `ridge_inputs_of_joint` as - hypotheses. L1, L2, L5, L7's maximum and uniqueness, L8, L11's chain rule, L13 and L16–L20 are proved from them; +- the analytic step L6 (the `w'` bound), the existence and implicit-function regularity of the transverse maximizer + `h`, and L9–L12 (the `‖h'‖` and `F''` bounds). These enter `ridge_capHyp_H1`, `ridge_capHyp_of_slices` and + `ridge_inputs_of_joint` as hypotheses, together with the Hessian data and third-derivative bounds that L3 and L4 + consume. L1–L5, L7's maximum and uniqueness, L8, L11's chain rule, L13 and L16–L20 are proved from them; - the match between the source's coordinates and the Lean objects: that SP's cap is `[-2r, r/2] × B̄(0, 2r)` in a frame `φ` and that SP analyses the periodic lift. The transport to the torus and the face list are themselves proved (`CapHyp.toTorus`, `frontier_cylinder`); @@ -133,7 +137,7 @@ The source gate checks: bound); - rebuilds the package fresh; - replays the module with `leanchecker`; -- prints the axioms of all 74 declarations, requiring exactly the manifest's report: each uses only `propext`, +- prints the axioms of all 80 declarations, requiring exactly the manifest's report: each uses only `propext`, `Classical.choice`, `Quot.sound`; - runs three negative controls (an injected `sorry`, a custom axiom, and `native_decide`). The audit must reject each. diff --git a/frontiers/cap_first_exit_lean_20261002/test_gate.py b/frontiers/cap_first_exit_lean_20261002/test_gate.py index f8e6a79ff..dceeb6188 100644 --- a/frontiers/cap_first_exit_lean_20261002/test_gate.py +++ b/frontiers/cap_first_exit_lean_20261002/test_gate.py @@ -16,7 +16,7 @@ class SourceGate(unittest.TestCase): def test_tree_passes(self): m = gate.source_check() - self.assertEqual(len(m["targets"]), 74) + self.assertEqual(len(m["targets"]), 80) self.assertEqual(m['scientific_effect'], 'NONE') def copy(self): From 1cbbbf9dbe7c7319f4431e4a4daf6879a49d48fd Mon Sep 17 00:00:00 2001 From: Claude Date: Sat, 3 Oct 2026 20:25:05 +0000 Subject: [PATCH 2/2] Cap first exit in Lean v1.6: prove L3's increment step (Codex 4174695678) ridge_capHyp_H1 assumed the transverse-Hessian increment estimate, which is L3's output, so "L3-L4 proved" overstated the kernel-checked scope. Adds hessian_increment: derivative bounds m on x -> H(x, 0) over [-2r, r/2] and on s -> H(x, s . y) over [0, 1] (norm <= m |y|) give |H(p) - H(M)| <= m (|dx| + |dy|), by the mean value inequality along y = 0 and then along the ray. ridge_capHyp_H1 now takes those derivative bounds instead of the increment estimate; the toy supplies zero derivatives. The y-bound is stated along rays because the pinned Mathlib does not synthesize the norm on the triple-nested operator space. ALIGNMENT, README and the test count (81) are updated; the third-derivative bounds themselves stay listed in I3. Source gate, unit tests (both modes) and --execute (81 declarations, three negative controls) pass locally. Scientific effect NONE. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_017Mi3hxjaxV45x6zo6o1ee3 --- .../cap_first_exit_lean_20261002/ALIGNMENT.md | 11 ++-- .../CapFirstExit.lean | 57 ++++++++++++++++--- .../MANIFEST.json | 20 ++++--- .../cap_first_exit_lean_20261002/README.md | 11 ++-- .../cap_first_exit_lean_20261002/test_gate.py | 2 +- 5 files changed, 74 insertions(+), 27 deletions(-) diff --git a/frontiers/cap_first_exit_lean_20261002/ALIGNMENT.md b/frontiers/cap_first_exit_lean_20261002/ALIGNMENT.md index 51242ab48..1228d4461 100644 --- a/frontiers/cap_first_exit_lean_20261002/ALIGNMENT.md +++ b/frontiers/cap_first_exit_lean_20261002/ALIGNMENT.md @@ -4,7 +4,7 @@ | Source | Path | Role | |---|---|---| -| SP | `reviews/d1_cap_elder_partner_second_pass_claude_20260930/REVIEW.md` | the line-numbered reconstruction of CAP §§2–5. L13, L16, L17 and L19–L22 are proved here. Since v1.5, L1, L2, L5, L7 (maximum and uniqueness), L8, L11's chain rule and L18 are also proved, from SP's normalization and L4's output (`ridge_capHyp_normalized`, `ridge_capHyp_sp`, `ridge_capHyp_of_slices`). Since v1.6, L3–L4 are proved from SP's (H1) and the Hessian increments (`ridge_capHyp_H1`). Inputs that remain: L6, L7's existence and regularity of `h`, and L9–L12. | +| SP | `reviews/d1_cap_elder_partner_second_pass_claude_20260930/REVIEW.md` | the line-numbered reconstruction of CAP §§2–5. L13, L16, L17 and L19–L22 are proved here. Since v1.5, L1, L2, L5, L7 (maximum and uniqueness), L8, L11's chain rule and L18 are also proved, from SP's normalization and L4's output (`ridge_capHyp_normalized`, `ridge_capHyp_sp`, `ridge_capHyp_of_slices`). Since v1.6, L3–L4 are proved from SP's (H1) and the third-derivative bounds on the transverse Hessian (`ridge_capHyp_H1`). Inputs that remain: L6, L7's existence and regularity of `h`, and L9–L12. | | CAP | `imports/lifetime_parent_20260925/MARKED_CYLINDER_CAP_PROOF.md` | the deterministic theorem that SP reconstructs | The source setting (SP §2) is as follows: @@ -65,9 +65,10 @@ The source setting (SP §2) is as follows: | `hermite_m_ge_two` | on `[−r/2, r/2]`, `g(−r/2) − g(r/2) = r³/6` ⇒ `2 ≤ m` | SP L2 (`m ≥ 2`) | SP's `φ`-weighted average of `f_xxx` is exactly 2, so `m ≥ 2`. Lean proves this inequality, not the average identity, and does not need L2's second statement (a point with `f_xxx = 2`). | | `ridge_capHyp_normalized` | the conclusions of `ridge_capHyp_sp`, with `hm` replaced by: `g_0 = f(·, 0)` has derivative `G0` on `[−r/2, r/2]`, `G0(∓r/2) = 0`, the convexity pair for `G0` at modulus `m`, and the gap exactly `r³/6` | SP §2 normalization, L1, L2, then as `ridge_capHyp_sp` | `G0(∓r/2) = 0` are the critical pins along `y = 0`. `h(∓r/2) = 0` identifies `b − s` with `g_0(−r/2) − g_0(r/2)`. | | `strongConcaveOn_of_hessian` | `HasFDerivAt φ (Dφ y) y`, `HasFDerivAt Dφ (H y) y` and `H y v v ≤ −δ‖v‖²` on convex `K` ⇒ `StrongConcaveOn K δ φ` | SP L7's first sentence ("`δ`-strongly concave … (L4)") | The quadratic-form bound `D_y² f ≤ −δI` is SP's form. The proof restricts to segments and uses Mathlib's `concaveOn_of_hasDerivWithinAt2_nonpos`. | -| `transverse_hessian_le` | `H(M) v v ≤ −λ‖v‖²`, `‖H(p) − H(M)‖ ≤ m(|p.1 + r/2| + ‖p.2‖)` on the cap ⇒ `H(p) v v ≤ −(λ − 5rm)‖v‖²` there | SP L3 (increments, `|Δx| + ‖Δy‖ < 5r`) and L4 (`D_y² f(p) ≤ D_y² f(M) + 5rm · I`) | The increment hypothesis is L3's output for `u = D_y² f`, whose `x`- and `y`-derivatives are third-derivative blocks bounded by `m`. It is stated as an operator-norm bound on the difference. | +| `hessian_increment` | `x ↦ H(x, 0)` with derivative of norm `≤ m` on `[−2r, r/2]`, and `s ↦ H(x, s • y)` with derivative of norm `≤ m‖y‖` on `[0, 1]` for each cap point ⇒ `‖H(p) − H(M)‖ ≤ m(|p.1 + r/2| + ‖p.2‖)` on the cap | SP L3 ("moving first in `x` then in `y` … `sup‖∂_x u‖ |Δx| + sup‖D_y u‖ ‖Δy‖`", for `u = D_y² f`) | Mean value inequality twice: along `y = 0`, then along the ray from `(x, 0)` to `(x, y)`. The `y`-bound is stated along rays, i.e. `‖D_y³ f[y]‖ ≤ m‖y‖`, which is what L3 uses and is implied by `‖D_y³ f‖ ≤ m`. (Lean at the pinned Mathlib does not synthesize the norm on the triple-nested operator space, so the bound is not stated as `‖D_y H‖ ≤ m`.) | +| `transverse_hessian_le` | `H(M) v v ≤ −λ‖v‖²`, `‖H(p) − H(M)‖ ≤ m(|p.1 + r/2| + ‖p.2‖)` on the cap ⇒ `H(p) v v ≤ −(λ − 5rm)‖v‖²` there | SP L4 (`D_y² f(p) ≤ D_y² f(M) + 5rm · I`), with L3's increment `|Δx| + ‖Δy‖ < 5r` | The increment hypothesis is `hessian_increment`'s conclusion. | | `slices_strongConcave` | under the same data on the cap, each slice `y ↦ f(x, y)`, `x ∈ [−2r, r/2]`, is `(λ − 5rm)`-strongly concave on `B̄(0, 2r)` | SP L4 (`δ = λ − 5rm`) | SP proves it on `D`; the cap's range of `x` suffices. | -| `ridge_capHyp_H1` | the conclusions of `ridge_capHyp_normalized`, with `hconc` and `hδ` replaced by the slice derivatives `Dφ` and Hessians `H` on the cap, the increment bound, `H(M) ≤ −λ` and (H1) `8rm² < λ` | SP §2 (H1), L1–L5, L7, L8, L11, L12, L16–L20 | `δ := λ − 5rm`, and `rm(8m − 5) < λ − 5rm` is (H1). SP's (H2) `rn ≤ 1/20` feeds only L4's `f_xxx ≥ 7/4` and L12, so it is not needed here. | +| `ridge_capHyp_H1` | the conclusions of `ridge_capHyp_normalized`, with `hconc` and `hδ` replaced by the slice derivatives `Dφ` and Hessians `H` on the cap, the third-derivative bounds of `hessian_increment` (`∂_x H` along `y = 0` and `D_y H` along rays, both at `m`), `H(M) ≤ −λ` and (H1) `8rm² < λ` | SP §2 (H1), L1–L5, L7, L8, L11, L12, L16–L20 | `δ := λ − 5rm`, and `rm(8m − 5) < λ − 5rm` is (H1). SP's (H2) `rn ≤ 1/20` feeds only L4's `f_xxx ≥ 7/4` and L12, so it is not needed here. | | `sp_curved_side_constants` | `r > 0`, `m ≥ 2`, `δ > r m (8m - 5)`, `0 ≤ ω ≤ 2 m r²` ⇒ `ω ≤ 2rδ` and `2δ · r³/6 < (2rδ - ω)²` | SP L2 (`m ≥ 2`), L4 (`δ > rmk`, `k = 8m - 5`), L5 (`‖w‖ ≤ (15/8) m r² < 2 m r²`), L18 (`4400r³/121 > r³/6`) | So SP's own constants meet `hωr` and `hcurv` at SP's gap `b - s = r³/6`. | | `CapHyp.congr` | from `g = f` on `closure C` and along one ridge `γ₀`, `CapHyp g C M z b s` | the audit's exterior-invariance corollary (Math-#193 deliverable 2) | `closure C ⊇ C ∪ frontier C`. In SP, `C` is closed. | @@ -115,7 +116,7 @@ illustrates the hypotheses; it is not a model of the planar cap. |---|---|---|---| | I1 | Coordinates: SP's cap is `[-2r, r/2] × B̄(0, 2r)` in a frame `φ` of the periodic lift, and SP's "boundary" is the topological frontier. The transport to the torus (`CapHyp.toTorus`) and the face list (`frontier_cylinder`) are proved; the transport needs no embedding radius | SP §2 | Only the identification of SP's objects with these Lean objects remains. | | I2 | Persistence bookkeeping: in H0 superlevel persistence with distinct critical values, the class born at a local maximum `M` dies at the largest level at which its component contains a strictly higher local maximum (the elder rule) | SP L22, P §8 | This is the definition of the elder pairing. On a compact, locally connected space, Lean proves that this level is `s` (`elder_death_level_peak`). Only the identification of the persistence module's pairing with that definition is informal. | -| I3 | The analytic steps that produce the inputs of `ridge_capHyp_H1` from `G_r`: (H1) `λ > 8rm²` and the Hessian data at and around `M` (L3's input: the third-derivative blocks of `f` bounded by `m`, giving the increment bound on `H`); `m` as a bound on the third derivatives, which gives the convexity pairs for `G0 = ∂_x f(·, 0)` (L1's input `|g_0'''| ≤ m`) and for `w` (L5's input `‖w''‖ ≤ m`); the critical pins `G0(∓r/2) = 0` and `h(∓r/2) = 0`; L6 (the `w'` bound); L7's existence of the transverse maximizer `h(x)` in the ball and the implicit-function regularity of `h`; and L9–L12 (`‖h'‖` and the `F''` bound giving `hconv`) | SP §2 (H1), L6, L7, L9–L12; CAP §§2–5 | These are checked with exact constants by SP's script, not in Lean. Since v1.6, Lean proves L3–L4 (from (H1) and the increment bound). Since v1.5, Lean proves L1, L2, L5, L7's maximum and uniqueness, L8, L11's chain rule and L18 from those outputs, and checks SP's constants in the curvature step. L13, L16, L17, L19 and L20 were already proved in v1.4. | +| I3 | The analytic steps that produce the inputs of `ridge_capHyp_H1` from `G_r`: (H1) `λ > 8rm²`; the slice derivatives and Hessians on the cap, with the third-derivative blocks `∂_x D_y² f` (along `y = 0`) and `D_y³ f` (along rays) bounded by `m`. These bounds are L3's input; L3's increment step itself is proved (`hessian_increment`); `m` as a bound on the third derivatives, which gives the convexity pairs for `G0 = ∂_x f(·, 0)` (L1's input `|g_0'''| ≤ m`) and for `w` (L5's input `‖w''‖ ≤ m`); the critical pins `G0(∓r/2) = 0` and `h(∓r/2) = 0`; L6 (the `w'` bound); L7's existence of the transverse maximizer `h(x)` in the ball and the implicit-function regularity of `h`; and L9–L12 (`‖h'‖` and the `F''` bound giving `hconv`) | SP §2 (H1), L6, L7, L9–L12; CAP §§2–5 | These are checked with exact constants by SP's script, not in Lean. Since v1.6, Lean proves L3–L4 (from (H1) and the increment bound). Since v1.5, Lean proves L1, L2, L5, L7's maximum and uniqueness, L8, L11's chain rule and L18 from those outputs, and checks SP's constants in the curvature step. L13, L16, L17, L19 and L20 were already proved in v1.4. | | I4 | Theorem A, measurability, `Q^W(G_r^c) ≤ C r³` | P §§7–8, C1, G1 | probability | ## 5. Review contract @@ -132,5 +133,5 @@ row of §4, it says whether the interface is stated correctly. A changed Lean source, toolchain or pin makes an earlier review stale. -v1.5 is additive: it inserts the sections `Slice` and the slice-route toy, and updates the file's header comment. The 53 v1.4 declarations and their statements are unchanged, as the diff against v1.4 shows. The v1.4 alignment review ([5396110365](https://github.com/d6g8k5htny-coder/Math-/pull/246#pullrequestreview-5396110365), `ALIGNED_SCOPED`) therefore still covers the v1.4 rows once a reviewer confirms by diff that they are unchanged. A delta review assesses the new rows: the fourteen slice rows of §2, the v1.5 toy paragraphs of §3 and the revised I3. v1.6 adds four further §2 rows (`strongConcaveOn_of_hessian` to `ridge_capHyp_H1`), the `h1ToyF` paragraph of §3 and a further revision of I3; its 74 v1.5 declarations are unchanged. A same-provider read, including any Claude +v1.5 is additive: it inserts the sections `Slice` and the slice-route toy, and updates the file's header comment. The 53 v1.4 declarations and their statements are unchanged, as the diff against v1.4 shows. The v1.4 alignment review ([5396110365](https://github.com/d6g8k5htny-coder/Math-/pull/246#pullrequestreview-5396110365), `ALIGNED_SCOPED`) therefore still covers the v1.4 rows once a reviewer confirms by diff that they are unchanged. A delta review assesses the new rows: the fourteen slice rows of §2, the v1.5 toy paragraphs of §3 and the revised I3. v1.6 adds five further §2 rows (`strongConcaveOn_of_hessian` to `ridge_capHyp_H1`), the `h1ToyF` paragraph of §3 and a further revision of I3; its 74 v1.5 declarations are unchanged. A same-provider read, including any Claude read, gives zero independence credit. A build or merge is not an alignment review. diff --git a/frontiers/cap_first_exit_lean_20261002/CapFirstExit.lean b/frontiers/cap_first_exit_lean_20261002/CapFirstExit.lean index 7b51a5d91..df7f5d2b6 100644 --- a/frontiers/cap_first_exit_lean_20261002/CapFirstExit.lean +++ b/frontiers/cap_first_exit_lean_20261002/CapFirstExit.lean @@ -1166,6 +1166,39 @@ theorem transverse_hessian_le {H : ℝ × E → E →L[ℝ] E →L[ℝ] ℝ} {r have := hlam v nlinarith +/-- **L3 (increments of the transverse Hessian).** If `x ↦ H (x, 0)` has derivative `Hx x` with +`‖Hx x‖ ≤ m` on `[-2r, r/2]` (the block `∂_x D_y² f`), and along each ray `s ↦ H (x, s • y)`, +`s ∈ [0, 1]`, the derivative `Hr p s` has `‖Hr p s‖ ≤ m ‖y‖` (the block `D_y³ f` applied to `y`), +then moving first in `x` along `y = 0` and then along the ray gives `‖H p - H M‖ ≤ m (|Δx| + ‖Δy‖)` +from `M = (-r/2, 0)`, by the mean value inequality. -/ +theorem hessian_increment {H : ℝ × E → E →L[ℝ] E →L[ℝ] ℝ} {Hx : ℝ → E →L[ℝ] E →L[ℝ] ℝ} + {Hr : ℝ × E → ℝ → E →L[ℝ] E →L[ℝ] ℝ} {r m : ℝ} (hr : 0 < r) + (hHx : ∀ x ∈ Icc (-2 * r) (r / 2), HasDerivAt (fun t => H (t, 0)) (Hx x) x) + (hHxb : ∀ x ∈ Icc (-2 * r) (r / 2), ‖Hx x‖ ≤ m) + (hHr : ∀ p ∈ Icc (-2 * r) (r / 2) ×ˢ Metric.closedBall (0 : E) (2 * r), ∀ s ∈ Icc (0 : ℝ) 1, + HasDerivAt (fun s : ℝ => H (p.1, s • p.2)) (Hr p s) s) + (hHrb : ∀ p ∈ Icc (-2 * r) (r / 2) ×ˢ Metric.closedBall (0 : E) (2 * r), ∀ s ∈ Icc (0 : ℝ) 1, + ‖Hr p s‖ ≤ m * ‖p.2‖) : + ∀ p ∈ Icc (-2 * r) (r / 2) ×ˢ Metric.closedBall (0 : E) (2 * r), + ‖H p - H (-r / 2, 0)‖ ≤ m * (|p.1 - -r / 2| + ‖p.2‖) := by + rintro ⟨x, y⟩ hp + have hx := hp.1 + have h1 : ‖H (x, (1 : ℝ) • y) - H (x, (0 : ℝ) • y)‖ ≤ m * ‖y‖ * ‖(1 : ℝ) - 0‖ := + (convex_Icc (0 : ℝ) 1).norm_image_sub_le_of_norm_hasDerivWithin_le + (f := fun s : ℝ => H (x, s • y)) (fun s hs => (hHr (x, y) hp s hs).hasDerivWithinAt) + (fun s hs => hHrb (x, y) hp s hs) (left_mem_Icc.mpr zero_le_one) + (right_mem_Icc.mpr zero_le_one) + have ha : -r / 2 ∈ Icc (-2 * r) (r / 2) := ⟨by linarith, by linarith⟩ + have h2 : ‖H (x, 0) - H (-r / 2, 0)‖ ≤ m * ‖x - -r / 2‖ := + (convex_Icc (-2 * r) (r / 2)).norm_image_sub_le_of_norm_hasDerivWithin_le + (f := fun t => H (t, 0)) (fun t ht => (hHx t ht).hasDerivWithinAt) hHxb ha hx + simp only [one_smul, zero_smul, sub_zero, norm_one, mul_one] at h1 + rw [Real.norm_eq_abs] at h2 + calc ‖H (x, y) - H (-r / 2, 0)‖ ≤ ‖H (x, y) - H (x, 0)‖ + ‖H (x, 0) - H (-r / 2, 0)‖ := + norm_sub_le_norm_sub_add_norm_sub (H (x, y)) (H (x, 0)) (H (-r / 2, 0)) + _ ≤ m * ‖y‖ + m * |x - -r / 2| := add_le_add h1 h2 + _ = m * (|(x, y).1 - -r / 2| + ‖(x, y).2‖) := by simp only; ring + /-- **L4 (strong concavity of the slices).** Under `transverse_hessian_le`'s hypotheses, with the slice derivatives `Dφ` and Hessians `H` given on the cap, every slice `y ↦ f (x, y)`, `x ∈ [-2r, r/2]`, is `(λ - 5rm)`-strongly concave on `B̄(0, 2r)`. -/ @@ -1192,7 +1225,7 @@ derivatives and Hessians on the cap, the increment bound of `H` from `M` with co `H(M) ≤ -λ`, and (H1) `8 r m² < λ`. Then `δ = λ - 5rm > rm(8m - 5)`. -/ theorem ridge_capHyp_H1 {f : ℝ × E → ℝ} {h : ℝ → E} {F G0 : ℝ → ℝ} {w : ℝ → E →L[ℝ] ℝ} {Dφ : ℝ × E → E →L[ℝ] ℝ} {H : ℝ × E → E →L[ℝ] E →L[ℝ] ℝ} - {r m lam : ℝ} (hr : 0 < r) + {Hx : ℝ → E →L[ℝ] E →L[ℝ] ℝ} {Hr : ℝ × E → ℝ → E →L[ℝ] E →L[ℝ] ℝ} {r m lam : ℝ} (hr : 0 < r) (hg0 : ∀ x ∈ Icc (-r / 2) (r / 2), HasDerivAt (fun x => f (x, 0)) (G0 x) x) (hG0cv : ConvexOn ℝ (Icc (-r / 2) (r / 2)) (fun t => G0 t + m / 2 * t ^ 2)) (hG0cc : ConcaveOn ℝ (Icc (-r / 2) (r / 2)) (fun t => G0 t - m / 2 * t ^ 2)) @@ -1201,8 +1234,12 @@ theorem ridge_capHyp_H1 {f : ℝ × E → ℝ} {h : ℝ → E} {F G0 : ℝ → HasFDerivAt (fun y => f (p.1, y)) (Dφ p) p.2) (hH : ∀ p ∈ Icc (-2 * r) (r / 2) ×ˢ Metric.closedBall (0 : E) (2 * r), HasFDerivAt (fun y => Dφ (p.1, y)) (H p) p.2) - (hlip : ∀ p ∈ Icc (-2 * r) (r / 2) ×ˢ Metric.closedBall (0 : E) (2 * r), - ‖H p - H (-r / 2, 0)‖ ≤ m * (|p.1 - -r / 2| + ‖p.2‖)) + (hHx : ∀ x ∈ Icc (-2 * r) (r / 2), HasDerivAt (fun t => H (t, 0)) (Hx x) x) + (hHxb : ∀ x ∈ Icc (-2 * r) (r / 2), ‖Hx x‖ ≤ m) + (hHr : ∀ p ∈ Icc (-2 * r) (r / 2) ×ˢ Metric.closedBall (0 : E) (2 * r), ∀ s ∈ Icc (0 : ℝ) 1, + HasDerivAt (fun s : ℝ => H (p.1, s • p.2)) (Hr p s) s) + (hHrb : ∀ p ∈ Icc (-2 * r) (r / 2) ×ˢ Metric.closedBall (0 : E) (2 * r), ∀ s ∈ Icc (0 : ℝ) 1, + ‖Hr p s‖ ≤ m * ‖p.2‖) (hlam : ∀ v : E, H (-r / 2, 0) v v ≤ -lam * ‖v‖ ^ 2) (hH1 : 8 * r * m ^ 2 < lam) (hh : ContinuousOn h (Icc (-r / 2) (2 * r))) (hg : ∀ x ∈ Icc (-2 * r) (2 * r), HasDerivAt (fun x => f (x, h x)) (F x) x) @@ -1222,6 +1259,7 @@ theorem ridge_capHyp_H1 {f : ℝ × E → ℝ} {h : ℝ → E} {F G0 : ℝ → x ≠ (r / 2, h (r / 2)) → f x < f (r / 2, h (r / 2)) := by have hm : 2 ≤ m := hermite_m_ge_two hr hg0 hG0cv hG0cc hG0a hG0c (by simpa [hha, hhc] using hnorm) + have hlip := hessian_increment hr hHx hHxb hHr hHrb have hconc := slices_strongConcave hr (by linarith) hD hH hlip hlam have hδ : r * m * (8 * m - 5) < lam - 5 * r * m := by nlinarith exact ridge_capHyp_normalized hr hg0 hG0cv hG0cc hG0a hG0c hδ hh hg hFa hFc hconv hconc hball @@ -1682,9 +1720,14 @@ theorem h1Toy_capHyp : refine ridge_capHyp_H1 (E := ℝ) (f := h1ToyF) (h := fun _ => (0 : ℝ)) (F := fun x => x ^ 2 - 1 / 4) (G0 := fun x => x ^ 2 - 1 / 4) (w := fun _ => 0) (Dφ := fun p => ContinuousLinearMap.mul ℝ ℝ (-40 * p.2)) - (H := fun _ => (-40 : ℝ) • ContinuousLinearMap.mul ℝ ℝ) (r := 1) (m := 2) (lam := 40) + (H := fun _ => (-40 : ℝ) • ContinuousLinearMap.mul ℝ ℝ) (Hx := fun _ => 0) (Hr := fun _ _ => 0) + (r := 1) (m := 2) (lam := 40) one_pos (fun x _ => hgx x) ?_ ?_ (by norm_num) (by norm_num) - (fun p _ => hslope p.1 p.2) (fun p _ => hhess p.2) ?_ ?_ (by norm_num) + (fun p _ => hslope p.1 p.2) (fun p _ => hhess p.2) + (fun x _ => hasDerivAt_const x ((-40 : ℝ) • ContinuousLinearMap.mul ℝ ℝ)) + (fun x _ => by simp only [ContinuousLinearMap.opNorm_zero]; norm_num) + (fun p _ s _ => hasDerivAt_const s ((-40 : ℝ) • ContinuousLinearMap.mul ℝ ℝ)) + (fun p _ s _ => by simp only [ContinuousLinearMap.opNorm_zero]; positivity) ?_ (by norm_num) continuousOn_const (fun x _ => hgx x) (by norm_num) (by norm_num) ?_ (fun x _ => by simp) (fun x _ => hslice x) rfl rfl (fun x _ => hslice x) ?_ ?_ ?_ · have hc : ConvexOn ℝ univ (fun x : ℝ => (2 : ℝ) • x ^ 2 + (-1 / 4 : ℝ)) := @@ -1696,10 +1739,6 @@ theorem h1Toy_capHyp : · refine (concaveOn_const (-1 / 4 : ℝ) (convex_Icc _ _)).congr ?_ intro x _ ring - · intro p hp - have hp2 : 0 ≤ |p.1 - -1 / 2| + ‖p.2‖ := by positivity - simp only [sub_self, ContinuousLinearMap.opNorm_zero] - linarith · intro v simp only [smul_apply, ContinuousLinearMap.mul_apply', smul_eq_mul, Real.norm_eq_abs, sq_abs] diff --git a/frontiers/cap_first_exit_lean_20261002/MANIFEST.json b/frontiers/cap_first_exit_lean_20261002/MANIFEST.json index 667eee7b9..17e016736 100644 --- a/frontiers/cap_first_exit_lean_20261002/MANIFEST.json +++ b/frontiers/cap_first_exit_lean_20261002/MANIFEST.json @@ -88,6 +88,7 @@ "CapFirstExit.ridge_capHyp_normalized", "CapFirstExit.strongConcaveOn_of_hessian", "CapFirstExit.transverse_hessian_le", + "CapFirstExit.hessian_increment", "CapFirstExit.slices_strongConcave", "CapFirstExit.ridge_capHyp_H1", "CapFirstExit.toyF", @@ -390,6 +391,11 @@ "Quot.sound", "propext" ], + "CapFirstExit.hessian_increment": [ + "Classical.choice", + "Quot.sound", + "propext" + ], "CapFirstExit.slices_strongConcave": [ "Classical.choice", "Quot.sound", @@ -524,18 +530,18 @@ }, { "path": "ALIGNMENT.md", - "bytes": 22147, - "sha256": "fe801adba43a2e40f24a22b39ef8b379b7dc58dbe35dcdee19a2dbbcca4cc765" + "bytes": 22998, + "sha256": "73fc8bff14c9eb42650228f905fb229bec6a67725bec166fe1e9738fab84596d" }, { "path": "CapFirstExit.lean", - "bytes": 90646, - "sha256": "20e82fc57695b7a5cd83be1125796a46abba5e3ebe4676359a275eddf3b6127e" + "bytes": 93791, + "sha256": "6d4dc00f7d20e2268b39f9b37fbd3fa4326d843678cab6727e73c714b7a25955" }, { "path": "README.md", - "bytes": 13532, - "sha256": "af375f1331d97031e91d1206d8bb724a0f7e94d95ac2f1ecb11753496cdcf43e" + "bytes": 13713, + "sha256": "0ef7a243688759c71e4b4f2bc6848bbd932440c7fce65c67f0f8453338cd3d71" }, { "path": "gate.py", @@ -560,7 +566,7 @@ { "path": "test_gate.py", "bytes": 6274, - "sha256": "880a075aee91c10a16d7d1ad3628624b522d040437f3fb9f327be63c3724555e" + "sha256": "04249947dc69b95b37b7ca5ec8e496e195947983ead8b5e3380dcf0d4265dc46" } ] } diff --git a/frontiers/cap_first_exit_lean_20261002/README.md b/frontiers/cap_first_exit_lean_20261002/README.md index e552c2321..e62ccfd4c 100644 --- a/frontiers/cap_first_exit_lean_20261002/README.md +++ b/frontiers/cap_first_exit_lean_20261002/README.md @@ -24,7 +24,7 @@ This packet kernel-checks three things: - the one-variable and assembly steps of the analytic part (L13, L16, L17, L19, L20, in `ridge_capHyp`); - since v1.5, L1–L2 and the slice steps: - L1–L2, the Hermite bound `g(a) − g(c) ≤ m(c − a)³/12`, which under the normalization `b − s = r³/6` forces `m ≥ 2`; - - since v1.6, L3–L4, the slice strong concavity `δ = λ − 5rm` from SP's transverse Hessian at `M` and the third-derivative increment bound; + - since v1.6, L3–L4: the transverse Hessian's increments from its third-derivative bounds `m` (mean value inequality), then the slice strong concavity `δ = λ − 5rm` from SP's Hessian bound at `M`; - L5, the transverse-gradient bound, from the third-derivative bound `m`; - L7, the transverse maximum and its uniqueness; - L8, the ridge bound; @@ -71,7 +71,8 @@ single ridge path. | `hermite_gap_le`, `hermite_m_ge_two` | L1–L2: if `g' = G` vanishes at `a < c` and `|G''| ≤ m` (weak form), then `g(a) − g(c) ≤ m(c − a)³/12`. At the gap `r³/6` on `[−r/2, r/2]`, this forces `m ≥ 2` | | `ridge_capHyp_normalized`, `spToy_normalized` | the cap with `m ≥ 2` derived from the normalization (L1–L2) instead of assumed; `spToyF` meets every hypothesis | | `strongConcaveOn_of_hessian` | second-order condition: `H y v v ≤ −δ‖v‖²` for the second derivative on a convex set gives `δ`-strong concavity | -| `transverse_hessian_le`, `slices_strongConcave` | L3–L4: `H(M) ≤ −λ` and increments of `H` from `M` bounded by `m(|Δx| + ‖Δy‖)` give `H ≤ −(λ − 5rm)` on the cap, so each slice is `(λ − 5rm)`-strongly concave | +| `hessian_increment` | L3: derivative bounds `m` on `∂_x H` (along `y = 0`) and on `D_y H` (along rays) give `‖H(p) − H(M)‖ ≤ m(|Δx| + ‖Δy‖)` | +| `transverse_hessian_le`, `slices_strongConcave` | L4: `H(M) ≤ −λ` and those increments give `H ≤ −(λ − 5rm)` on the cap, so each slice is `(λ − 5rm)`-strongly concave | | `ridge_capHyp_H1`, `h1ToyF`, `h1Toy_capHyp` | the cap from SP's (H1) `λ > 8rm²` with Hessian data in place of `hconc`; `x³/3 − x/4 − 20y²` (`λ = 40 > 32`) meets every hypothesis | | `sp_curved_side_constants` | SP's constants (`m ≥ 2`, `δ > rm(8m − 5)`, `ω ≤ 2mr²`, gap `r³/6`) satisfy `ω ≤ 2rδ` and the curvature condition | | `ridgeToy_joint`, `ridgeToy_slices` | the ridge toy (`δ = 2`, `ω = 0`) meets every input of the slice route, which re-derives (C1)–(C3) and (C2⁺) | @@ -97,8 +98,8 @@ This packet does not formalize: - the analytic step L6 (the `w'` bound), the existence and implicit-function regularity of the transverse maximizer `h`, and L9–L12 (the `‖h'‖` and `F''` bounds). These enter `ridge_capHyp_H1`, `ridge_capHyp_of_slices` and - `ridge_inputs_of_joint` as hypotheses, together with the Hessian data and third-derivative bounds that L3 and L4 - consume. L1–L5, L7's maximum and uniqueness, L8, L11's chain rule, L13 and L16–L20 are proved from them; + `ridge_inputs_of_joint` as hypotheses, together with the Hessian data and the third-derivative bounds `m` that L1, + L3 and L5 consume. L1–L5, L7's maximum and uniqueness, L8, L11's chain rule, L13 and L16–L20 are proved from them; - the match between the source's coordinates and the Lean objects: that SP's cap is `[-2r, r/2] × B̄(0, 2r)` in a frame `φ` and that SP analyses the periodic lift. The transport to the torus and the face list are themselves proved (`CapHyp.toTorus`, `frontier_cylinder`); @@ -137,7 +138,7 @@ The source gate checks: bound); - rebuilds the package fresh; - replays the module with `leanchecker`; -- prints the axioms of all 80 declarations, requiring exactly the manifest's report: each uses only `propext`, +- prints the axioms of all 81 declarations, requiring exactly the manifest's report: each uses only `propext`, `Classical.choice`, `Quot.sound`; - runs three negative controls (an injected `sorry`, a custom axiom, and `native_decide`). The audit must reject each. diff --git a/frontiers/cap_first_exit_lean_20261002/test_gate.py b/frontiers/cap_first_exit_lean_20261002/test_gate.py index dceeb6188..c44063a23 100644 --- a/frontiers/cap_first_exit_lean_20261002/test_gate.py +++ b/frontiers/cap_first_exit_lean_20261002/test_gate.py @@ -16,7 +16,7 @@ class SourceGate(unittest.TestCase): def test_tree_passes(self): m = gate.source_check() - self.assertEqual(len(m["targets"]), 80) + self.assertEqual(len(m["targets"]), 81) self.assertEqual(m['scientific_effect'], 'NONE') def copy(self):